agent

type AgentExpectResponse = agenttypes.AgentExpectResponse

type AgentExtensionsOutput = agenttypes.AgentExtensionsOutput

type AgentExtractRule = agenttypes.AgentExtractRule

type AgentFinding = agenttypes.AgentFinding

type AgentFindingsOutput = agenttypes.AgentFindingsOutput

type AgentHTTPRecord = agenttypes.AgentHTTPRecord

type AgentHTTPRecordsOutput = agenttypes.AgentHTTPRecordsOutput

type AgentLoginFlow = agenttypes.AgentLoginFlow

type AgentRuntime interface {
	// RunPrompt runs one prompt on a fresh session. When sourcePath is set it is
	// appended to the system prompt so the agent knows it has filesystem access
	// to local source. Text deltas mirror to streamWriter and reasoning deltas to
	// thinkingWriter when those are non-nil. When rec.SessionDir is set, the
	// fresh engine records a Pi-style JSONL transcript (flushed before return).
	RunPrompt(ctx context.Context, cfg *config.OliumConfig, prompt string, streamWriter, thinkingWriter io.Writer, sourcePath string, verbose bool, rec RecordSpec) (oliumRunOutput, error)

	// RunOnSession runs one prompt reusing an existing session's warm prefix.
	// Unlike RunPrompt it takes no RecordSpec: a reused session's transcript
	// recorder (if any) is attached once when the session is built
	// (NewSessionWithSpec with a RecordSpec) and spans all of its prompts, then
	// flushed by AgentSession.Close().
	RunOnSession(ctx context.Context, cfg *config.OliumConfig, sess AgentSession, prompt string, streamWriter, thinkingWriter io.Writer, verbose bool) (oliumRunOutput, error)

	// NewSession builds a reusable session without running anything. Equivalent
	// to NewSessionWithSpec with the standard tool-enabled spec.
	NewSession(cfg *config.OliumConfig, sourcePath string) (AgentSession, error)

	// NewSessionWithSpec builds a session from an explicit SessionSpec, for
	// specialized flows that need a custom system prompt, turn cap, or tool set.
	NewSessionWithSpec(cfg *config.OliumConfig, spec SessionSpec) (AgentSession, error)
}

type AgentSession interface {
	Fork() AgentSession
	Close() error
}

type AgentSessionConfig = agenttypes.AgentSessionConfig

type AgentSessionEntry = agenttypes.AgentSessionEntry

type AppIntent = agenttypes.AppIntent

type AttackPlan = agenttypes.AttackPlan

type AuditAgentConfig = agenttypes.AuditAgentConfig

type AuditAgentStatus = agenttypes.AuditAgentStatus

type AuditAgenticScanner struct {
	// contains filtered or unexported fields
}

type AuditDriverAgent = agenttypes.AuditDriverAgent

type AuditDriverAuthFlags = agenttypes.AuditDriverAuthFlags

type AuditDriverCfgInput struct {
	Mode                  string
	Modes                 []string
	SourcePath            string
	SessionDir            string
	ProjectUUID           string
	ScanUUID              string
	ParentAgenticScanUUID string
	Invocation            AuditDriverInvocation
	Stream                bool
	StreamWriter          io.Writer

	// ShowThinking opts into rendering agent thinking blocks (audit NDJSON
	// `thinking` events) in the live stream. Off by default; controlled by
	// `vigolium agent audit --show-thinking`.
	ShowThinking bool

	// KeepRaw maps to vigolium-audit's `--keep-raw`: opt out of the
	// deep/confirm auto-prune so raw scanner output, draft findings, and
	// intermediate workspaces stay on disk for manual review. Audit-only;
	// ignored for the piolium harness.
	KeepRaw bool

	// KeepSourceOutputDir suppresses the post-run cleanup of
	// <source>/vigolium-results/ from the source tree (a session copy is
	// always synced regardless). The CLI sets it from --keep-raw/--clean-raw
	// so the on-disk results can be reviewed or re-imported. Audit-only.
	KeepSourceOutputDir bool

	// AuthOverride carries the resolved BYOK bundle for this run. It is
	// already folded into Invocation.Auth by the caller (via
	// ResolveAuditDriverInvocation's variadic override or
	// ApplyAuthOverrideToAudit), so audit's argv reflects it. The
	// field is also stored on AuditAgentConfig so the launcher can match
	// audit's auth to whatever staging/env injection the piolium driver
	// would do (currently only piolium consumes it; audit stays argv-only).
	AuthOverride AuthOverride
}

type AuditDriverIntensityPreset = agenttypes.AuditDriverIntensityPreset

type AuditDriverInvocation = agenttypes.AuditDriverInvocation

type AuditRunner interface {
	Start(ctx context.Context) error
	Wait() error
	Done() <-chan struct{}
	Cancel()
	Status() *AuditAgentStatus
	FindingStats() FindingStats
	CostSummary() ScanCost
	AgenticScanUUID() string
}

type AuthOverride = agenttypes.AuthOverride

type AutopilotArtifactSpec struct {
	BriefPath            string `json:"brief_path"`
	ContextPath          string `json:"context_path"`
	PlanPath             string `json:"plan_path"`
	FindingsPath         string `json:"findings_path"`
	DismissedPath        string `json:"dismissed_path"`
	VisitedEndpointsPath string `json:"visited_endpoints_path"`
	ArtifactsPath        string `json:"artifacts_path"`
	SessionConfigPath    string `json:"session_config_path"`
	AuthStatePath        string `json:"auth_state_path"`
	AuthHeadersPath      string `json:"auth_headers_path"`
	BrowserSessionPath   string `json:"browser_session_path"`
	EvidenceDir          string `json:"evidence_dir"`
	VerificationPath     string `json:"verification_path"`
}

type AutopilotAuthFlow struct {
	Name      string   `json:"name"`
	LoginPath string   `json:"login_path,omitempty"`
	Tokens    []string `json:"tokens,omitempty"`
}

type AutopilotContextBundle struct {
	Version              string                    `json:"version"`
	Mode                 string                    `json:"mode"`
	TargetURL            string                    `json:"target,omitempty"`
	SourcePath           string                    `json:"source_path,omitempty"`
	DiffRef              string                    `json:"diff_ref,omitempty"`
	ChangedFiles         []string                  `json:"changed_files,omitempty"`
	Routes               []AutopilotRouteSummary   `json:"routes,omitempty"`
	AuthFlows            []AutopilotAuthFlow       `json:"auth_flows,omitempty"`
	Findings             []AutopilotFindingSummary `json:"findings,omitempty"`
	Priorities           []string                  `json:"priorities,omitempty"`
	AuditDriverAvailable bool                      `json:"audit_available"`
	AuditDriverStatus    string                    `json:"audit_status,omitempty"`
	PreparedAuth         *AutopilotPreparedAuth    `json:"prepared_auth,omitempty"`
	BrowserDecision      string                    `json:"browser_decision,omitempty"`
	BrowserReason        string                    `json:"browser_reason,omitempty"`
	Warnings             []string                  `json:"warnings,omitempty"`
}

type AutopilotExecutionPlan struct {
	AuthRequired   bool                  `json:"auth_required"`
	AuthPrepared   bool                  `json:"auth_prepared,omitempty"`
	BrowserMode    string                `json:"browser_mode,omitempty"`
	BrowserReason  string                `json:"browser_reason,omitempty"`
	Budgets        map[string]int        `json:"budgets,omitempty"`
	Tasks          []AutopilotPlanTask   `json:"tasks,omitempty"`
	StopCriteria   []string              `json:"stop_criteria,omitempty"`
	Warnings       []string              `json:"warnings,omitempty"`
	ArtifactPolicy AutopilotArtifactSpec `json:"artifact_policy"`
}

type AutopilotFindingSummary struct {
	ID         string   `json:"id,omitempty"`
	Title      string   `json:"title"`
	Severity   string   `json:"severity,omitempty"`
	Confidence string   `json:"confidence,omitempty"`
	Action     string   `json:"action,omitempty"`
	Kind       string   `json:"kind,omitempty"`
	Route      string   `json:"route,omitempty"`
	Locations  []string `json:"locations,omitempty"`
}

type AutopilotIntensityPreset = agenttypes.AutopilotIntensityPreset

type AutopilotPipelineConfig struct {
	TargetURL   string
	SourcePath  string
	Files       []string
	Instruction string
	Focus       string

	// Skill selection forwarded to the operator agent's planner-driven
	// loading. SkillNames/SkillTags force-include; NoSkillFilter loads the
	// full set; AlwaysOnSkills are kept regardless of selection.
	SkillNames     []string
	SkillTags      []string
	NoSkillFilter  bool
	AlwaysOnSkills []string

	// SystemPrompt, when non-empty, fully replaces the built-in autopilot
	// system prompt at the olium runtime layer. Empty falls back to
	// agent.olium.system_prompt in settings, then to the embedded persona.
	SystemPrompt string

	AgentName   string
	MaxCommands int

	DryRun     bool
	ShowPrompt bool

	// Triage, when true, runs an AI triage pass over the findings after the
	// operator loop completes — classifying each as confirmed (→ "triaged")
	// or "false_positive" and writing the verdict back, scoped to this run.
	// Pure classification: no native rescan.
	Triage bool

	SessionsDir string
	SessionDir  string

	ProjectUUID           string
	ScanUUID              string
	ParentAgenticScanUUID string

	StreamWriter     io.Writer
	ProgressCallback func(phase string, message string)

	// Audit is the audit-cfg slot — backed by either audit or piolium per
	// AuditHarness. Field name is legacy; the runtime is harness-agnostic.
	Audit *config.AuditAgentConfig

	// AuditHarness selects which harness backs the Audit cfg. Zero-valued
	// defaults to audit for backward compat.
	AuditHarness HarnessSpec

	// BrowserEnabled indicates whether agent-browser is available for the agent.
	BrowserEnabled bool
	// BrowserBinaryPath is agent.browser.binary_path for the typed browser_auth
	// adapter; empty resolves agent-browser on PATH.
	BrowserBinaryPath string
	// BrowserRequested preserves explicit user intent even when heuristics are weak.
	BrowserRequested bool
	// RequiresBrowser means auth/setup should prefer browser assistance over HTTP-only preparation.
	RequiresBrowser bool
	// KeepBrowserEnabled forces the browser tool to stay available even when the
	// browser-usage heuristic would deprioritize it (browser_unneeded). Unlike
	// BrowserRequested it does NOT signal explicit user intent, so it only guards
	// tool availability and never arms the browser-auth preflight or changes the
	// planning hint. Set by the CLI autopilot path (browser is always-on for
	// autopilot); the server leaves it false to keep its opt-in behavior.
	KeepBrowserEnabled bool
	// Credentials carries compact credentials extracted from the prompt or flag input.
	Credentials string
	// CredentialSets carries structured role/account pairs extracted from prompt input.
	CredentialSets []agenttypes.IntentCredentialSet
	// AuthRequired means auth should be prepared before operator launch.
	AuthRequired bool
	// BrowserStartURL is an explicit login/start URL for browser-based flows.
	BrowserStartURL string
	// FocusRoutes are protected or browser-focused routes named by the user.
	FocusRoutes []string
	// SessionConfig is the prepared session config for authenticated scanning.
	SessionConfig *AgentSessionConfig
	// AuthHeaders are hydrated headers ready for immediate use.
	AuthHeaders map[string]string
	// PreparedAuth summarizes the auth preparation outcome.
	PreparedAuth *AutopilotPreparedAuth

	// DiffContext holds parsed diff information for focused scanning.
	// When set, the agent prompt includes changed file list and patch content.
	DiffContext *agenttypes.DiffContext

	ContextBundle *AutopilotContextBundle
	Plan          *AutopilotExecutionPlan
	Artifacts     AutopilotArtifactSpec

	// PreflightDiscovery enables a discovery + Swagger/OpenAPI ingestion
	// pass before the operator agent starts. The records land in the
	// project DB so the agent's first turn can `list_findings` and
	// `query_records` against real attack surface instead of starting
	// blank. Skipped silently when TargetURL is empty. Default true via
	// the CLI/API wirers; explicitly settable to false to disable.
	PreflightDiscovery bool

	// PostHaltVerify enables the autopilot's post-halt coverage
	// verification loop. After the model calls halt_scan, the runner
	// runs another discovery + spec ingest pass, diffs new routes
	// against the pre-halt snapshot, and re-enters the agent once if
	// the gap meets PostHaltGapThreshold. Default true via the wirers.
	PostHaltVerify bool

	// PostHaltGapThreshold is the minimum number of new (method, URL)
	// signatures the post-halt probe must turn up before the agent is
	// re-entered. 0 = autopilot default (5).
	PostHaltGapThreshold int
}

type AutopilotPipelineResult = agenttypes.AutopilotPipelineResult

type AutopilotPipelineRunner struct {
	// contains filtered or unexported fields
}

type AutopilotPlanTask struct {
	ID       string `json:"id"`
	Type     string `json:"type"`
	Priority int    `json:"priority"`
	Reason   string `json:"reason"`
}

type AutopilotPreparedAuth struct {
	Requested       bool     `json:"requested"`
	Source          string   `json:"source,omitempty"`
	SessionConfig   string   `json:"session_config_path,omitempty"`
	SessionCount    int      `json:"session_count,omitempty"`
	Hydrated        bool     `json:"hydrated"`
	HeaderCount     int      `json:"header_count,omitempty"`
	AuthRequired    bool     `json:"auth_required"`
	RequiresBrowser bool     `json:"requires_browser,omitempty"`
	BrowserStartURL string   `json:"browser_start_url,omitempty"`
	FocusRoutes     []string `json:"focus_routes,omitempty"`
	ProtectedRoutes []string `json:"protected_routes,omitempty"`
	Notes           []string `json:"notes,omitempty"`
}

type AutopilotRouteSummary struct {
	Path   string `json:"path"`
	Method string `json:"method,omitempty"`
	Source string `json:"source,omitempty"`
}

type AutopilotTriageParams struct {
	TargetURL       string
	SourcePath      string
	ScanUUID        string
	ProjectUUID     string
	AgenticScanUUID string // verdicts are written back scoped to this run
	SessionDir      string
	StreamWriter    io.Writer
	Verbose         bool
}

type AutopilotVerificationReport struct {
	ConfirmedCount int      `json:"confirmed_count"`
	DismissedCount int      `json:"dismissed_count"`
	Warnings       []string `json:"warnings,omitempty"`
}

type BatchProvenance = agenttypes.BatchProvenance

type BurpBridgeToolSpec struct {
	ProjectUUID string
}

type CoverageProbe struct {
	// Target is the URL/hostname to probe. Required.
	Target string

	// ProjectUUID scopes the resulting http_records to the same project as
	// the autopilot run. Required.
	ProjectUUID string

	// AgenticScanUUID, when set, is recorded on the underlying Scan rows so
	// coverage-pass artifacts can be traced back to the parent autopilot
	// run.
	AgenticScanUUID string

	// ConfigPath optionally overrides the path to vigolium-configs.yaml so
	// the pass uses the same settings as the surrounding scan.
	ConfigPath string

	// Repo is the DB handle used for the snapshot diff. Required.
	Repo *database.Repository

	// Concurrency overrides the worker count. 0 = settings default.
	Concurrency int
}

type CoverageProbeResult struct {
	// DiscoveryScanUUID is the Scan row created by the discovery pass. Empty
	// on a probe that skipped discovery (e.g. snapshot-only call).
	DiscoveryScanUUID string

	// SpecIngestScanUUID is the Scan row created by the OpenAPI/Swagger
	// ingestion pass. Empty when ingestion was skipped or no spec was
	// found.
	SpecIngestScanUUID string

	// SignaturesBefore is the set of (method, URL) signatures present in
	// the project for Target's hostname when Run() started.
	SignaturesBefore []string

	// SignaturesAfter is the same set after both passes completed.
	SignaturesAfter []string

	// NewSignatures = SignaturesAfter - SignaturesBefore. Sorted for
	// stable output.
	NewSignatures []string
}

type CoverageReportInputs struct {
	AgenticScanUUID    string
	TargetURL          string
	Intensity          string
	Plan               *SwarmPlan
	Records            []*httpmsg.HttpRequestResponse
	TotalFindings      int
	FindingsByModule   map[string]int
	FindingsByEndpoint map[string]int
	Warnings           []string
}

type Engine struct {
	// contains filtered or unexported fields
}

type ExploitationEvidence = agenttypes.ExploitationEvidence

type ExtensionMergeResult struct {
	Extensions []GeneratedExtension
	Renames    map[string]string // original filename -> renamed filename
}

type FindingStats struct {
	Parsed     int            // total findings parsed from the session dir
	Saved      int            // findings successfully persisted to the database
	BySeverity map[string]int // count by normalized severity (critical/high/medium/low/info)

	// Reported is the count reported by the audit binary's own NDJSON
	// `result` event. It is only consulted when the on-disk findings tree
	// could not be parsed (Parsed == 0) and serves as a display-only
	// fallback so the CLI summary mirrors the streamer's `[result]` line
	// even when persistence didn't run. Severity keys are normalized to
	// lowercase to match BySeverity.
	Reported           int
	ReportedBySeverity map[string]int
}

type FollowUpScan = agenttypes.FollowUpScan

type GeneratedExtension = agenttypes.GeneratedExtension

type GuardrailVerdict struct {
	Allowed    bool     `json:"allowed"`
	Reason     string   `json:"reason"`
	Categories []string `json:"categories,omitempty"`
}

type HarnessSpec = agenttypes.HarnessSpec

type InputType = agenttypes.InputType

type Intensity = agenttypes.Intensity

type IntentCredentialSet = agenttypes.IntentCredentialSet

type IntentParseConfig = agenttypes.IntentParseConfig

type IntentParseOption = agenttypes.IntentParseOption

type InvalidExtension = agenttypes.InvalidExtension

type Options = agenttypes.Options

type PioliumChainScanner struct {
	// contains filtered or unexported fields
}

type PioliumSweepEntry struct {
	Dir        string
	LockPath   string
	BackupPath string
	Holder     pioliumLockBreadcrumb
}

type PioliumSweepResult struct {
	Swept    []PioliumSweepEntry // backup → target restored, lock removed
	Held     []PioliumSweepEntry // active run holds the lock; left alone
	Orphaned []string            // backup files without a matching restore target
}

type PlanCoverage struct {
	MissingPrefixes []string
	TotalPrefixes   int
	CoveredPrefixes int
}

type PlannedEndpoint = agenttypes.PlannedEndpoint

type PrefixCoverage struct {
	Prefix      string `json:"prefix"`
	RecordCount int    `json:"record_count"`
	InFocus     bool   `json:"in_focus"`
}

type ProbeConfig struct {
	Concurrency int                        // max parallel probe requests; 0 = default 10
	Timeout     time.Duration              // per-request probe timeout; 0 = default 10s
	MaxBodySize int                        // max response body bytes; 0 = default 2MB
	OnProgress  func(completed, total int) // optional progress callback
}

type ProgressEvent = agenttypes.ProgressEvent

type PromptTemplate = agenttypes.PromptTemplate

type QuickCheck = agenttypes.QuickCheck

type QuickCheckLintIssue = agenttypes.QuickCheckLintIssue

type QuickCheckMatch = agenttypes.QuickCheckMatch

type QuickCheckRequest = agenttypes.QuickCheckRequest

type RecordSpec struct {
	// SessionDir is the directory the transcript-*.jsonl file is written to.
	// Empty disables recording (the common one-off CLI case).
	SessionDir string
	// Template is the phase/template name; it seeds the per-phase filename
	// (transcript-<template>.jsonl) and the concurrency-dedup key so parallel
	// same-template calls (swarm plan batches) never share a file.
	Template string
	// SessionID is the transcript header's session id; empty falls back to the
	// SessionDir base name.
	SessionID string
}

type RepairConfig = agenttypes.RepairConfig

type Result = agenttypes.Result

type RetryConfig = agenttypes.RetryConfig

type RunPID struct {
	PID       int       `json:"pid"`
	PGID      int       `json:"pgid"`
	StartTime time.Time `json:"start_time"`
}

type ScanCost struct {
	Backend      string                 // "audit" | "pi"
	Model        string                 // model id reported by the harness
	InputTokens  int64                  // total input tokens across the run
	OutputTokens int64                  // total output tokens across the run
	CostUSD      float64                // priced total in USD
	Note         string                 // CLI-facing one-line annotation
	Blob         map[string]interface{} // payload for the TokenUsage JSONB column
}

type ScanFunc = agenttypes.ScanFunc

type ScanIntent = agenttypes.ScanIntent

type ScanRequest = agenttypes.ScanRequest

type SessionSpec struct {
	System            string // explicit system prompt; empty falls back to cfg/default
	SourcePath        string // appended to the system prompt when set
	MaxTurns          int    // 0 = engine default
	IncludeTools      bool   // register the builtin tool set
	EnablePromptCache bool
	// Skills, when non-nil and non-empty, injects an <available_skills> block
	// into the system prompt and registers the load_skill tool (requires
	// IncludeTools). Used by swarm plan/triage phases for planner-driven skill
	// loading; nil for phases that don't surface skills.
	Skills *skill.Registry
	// VigTools, when non-nil with a Repo (and IncludeTools), registers the
	// vigolium read+replay tool subset so a skill can actually confirm/escalate
	// against scan records. nil for phases that only reason over prompt context.
	VigTools *VigToolSpec
	// BurpBridgeTools, when non-nil (and IncludeTools), registers only
	// search_burp_items and inspect_burp_item. Both tools are read-only.
	BurpBridgeTools *BurpBridgeToolSpec
	// Record, when its SessionDir is set, attaches a Pi-style JSONL transcript
	// recorder to the built engine so the session's turns (including model
	// reasoning) persist for debugging. Zero value = no transcript.
	Record RecordSpec
}

type SetupCleanup = agenttypes.SetupCleanup

type Snippet = agenttypes.Snippet

type SourceAnalysisConfig = agenttypes.SourceAnalysisConfig

type SourceAnalysisResult = agenttypes.SourceAnalysisResult

type SwarmCheckpoint = agenttypes.SwarmCheckpoint

type SwarmConfig struct {
	// Inputs: raw input strings (URL, curl, raw HTTP, Burp XML, or record UUID)
	Inputs    []string  // raw input strings
	InputType InputType // explicit type (auto-detected if empty)

	// Source analysis
	SourcePath  string                  // path to application source code (triggers source analysis phase)
	Files       []string                // specific files to include (relative to SourcePath)
	DiffContext *agenttypes.DiffContext // non-nil when --diff or --last-commits was provided

	// Custom instruction
	Instruction string // user-provided custom instruction appended to agent prompts

	// ForceExtensions forces the Phase-2 extension agent to run even when the
	// plan agent decides built-in modules are sufficient. Bound to --with-extensions
	// on the CLI. Has no effect when DryRun is true (DryRun still skips Phase 2).
	ForceExtensions bool

	// Skill selection (planner-driven loading overrides)
	SkillNames    []string // --skill: force-include these skills, bypassing planner judgement
	SkillTags     []string // --skill-tag: force-include every skill carrying one of these tags
	NoSkillFilter bool     // --no-skill-filter: load the full skill set, ignore planner selection

	// Scanning parameters
	VulnType         string   // optional: focus on specific vulnerability type
	Focus            string   // optional: broad strategic hint (e.g. "API injection", "auth bypass")
	ModuleNames      []string // optional: explicit module IDs to use
	OnlyPhase        string   // isolate a single phase (empty = all phases)
	SkipPhases       []string // skip specific phases (empty = skip none)
	MaxIterations    int      // max triage-rescan loops (default 3)
	BatchConcurrency int      // max parallel master agent batches (0 = default 3)
	MaxMasterRetries int      // max master agent retries on parse failure (0 = default 3)
	SAMaxConcurrency int      // max parallel source analysis sub-agents (0 = default 3)

	// Agent
	AgentName          string
	DryRun             bool
	ShowPrompt         bool   // print rendered prompts to stderr before executing
	SourceAnalysisOnly bool   // run only source analysis phase and exit
	CodeAudit          bool   // enable AI security code audit phase (--code-audit)
	Browser            bool   // enable agent-browser integration (always on for swarm; no --browser flag)
	Auth               bool   // run browser-based auth phase before discovery (--browser-auth)
	Credentials        string // optional credentials for the browser auth phase (extracted from the prompt)
	CredentialSets     []agenttypes.IntentCredentialSet
	AuthRequired       bool
	RequiresBrowser    bool
	BrowserStartURL    string
	FocusRoutes        []string

	// Context truncation
	MaxResponseBodyBytes int // max response body size in context; 0 = default 4096
	MaxPlanRecords       int // max records sent to plan agent; 0 = no cap (ship the full surface)

	// Tuning: batching, probing, retries
	MasterBatchSize  int           // max records per master agent batch; 0 = default 5
	ProbeConcurrency int           // max parallel probe requests; 0 = default 10
	ProbeTimeout     time.Duration // per-request probe timeout; 0 = default 10s
	MaxProbeBodySize int           // max response body bytes during probing; 0 = default 2MB

	// ReconExtraHeaders, when set, is injected onto every recon probe
	// (and into the prompt-context's TechStack rendering). Populated by
	// the CLI from --cookie / --header / --auth-config so that recon
	// fingerprints authenticated pages instead of the public landing.
	ReconExtraHeaders map[string]string

	ProjectUUID string
	ScanUUID    string

	// Session directory base path for agent artifacts
	SessionsDir string

	// SessionDir is the pre-created session directory for this run.
	// When set, the swarm runner uses it directly instead of creating one.
	SessionDir string

	// AgenticScanUUID overrides the auto-generated agent run UUID.
	// When set (e.g. by CLI), the swarm runner uses this UUID for the DB record,
	// ensuring it matches the pre-created session directory name.
	AgenticScanUUID string

	// ResumeDir is the session directory of a previous run to resume from.
	// When set, the swarm runner loads the checkpoint and skips completed phases.
	ResumeDir string

	// Streaming
	StreamWriter     io.Writer
	Verbose          bool // when true, agent calls render a per-tool result preview alongside the standard one-liner
	ProgressCallback func(ProgressEvent)

	// ScanFunc runs the scan with the given module filters and extensions.
	ScanFunc ScanFunc

	// DiscoverFunc runs native discovery+spidering before master agent planning.
	// When set, the swarm runner executes discovery and feeds discovered records
	// into the master agent alongside the original inputs.
	DiscoverFunc func(ctx context.Context) error

	// SourceAnalysisCallback is called after source analysis completes to allow
	// the caller to process session config (e.g., convert to auth-config.yaml)
	// and extensions before the scan phase.
	SourceAnalysisCallback func(result *SourceAnalysisResult) error

	// BrowserAuthCallback is fired after the browser-based auth phase writes
	// an auth-config.yaml to the session dir. The CLI uses this to thread
	// the captured session into the discovery + scan funcs so the native
	// spider (and downstream scan) crawl post-login surface. Empty path =
	// auth phase ran but produced no config; the caller may treat that as
	// a soft failure.
	BrowserAuthCallback func(authConfigPath string) error

	// PhaseCallback is called when a swarm phase starts.
	PhaseCallback func(phase string)

	// Audit is the background-audit cfg slot — backed by either audit or
	// piolium per AuditHarness. Requires SourcePath to be non-empty. Field
	// name is legacy; the runtime is harness-agnostic.
	Audit *config.AuditAgentConfig

	// AuditHarness selects which harness backs the Audit cfg. Zero-valued
	// defaults to audit for backward compat.
	AuditHarness HarnessSpec
}

type SwarmCoveragePlan struct {
	ModuleTags []string `json:"module_tags,omitempty"`
	ModuleIDs  []string `json:"module_ids,omitempty"`
	// False when the scan ran against the full registry rather than a
	// plan-filtered subset — explicit so "no filter" isn't mistaken for
	// a misconfig.
	ModuleFilterApplied bool     `json:"module_filter_applied"`
	FocusAreas          []string `json:"focus_areas,omitempty"`
	Notes               string   `json:"notes,omitempty"`
	ExtensionsCount     int      `json:"extensions_count"`
	NeedsExtensions     bool     `json:"needs_extensions"`
	ExtensionAgentError string   `json:"extension_agent_error,omitempty"`
}

type SwarmCoverageReport struct {
	GeneratedAt     time.Time `json:"generated_at"`
	AgenticScanUUID string    `json:"agentic_scan_uuid,omitempty"`
	TargetURL       string    `json:"target_url,omitempty"`
	Intensity       string    `json:"intensity,omitempty"`

	TotalRecords int              `json:"total_records"`
	Prefixes     []PrefixCoverage `json:"prefixes,omitempty"`

	Plan SwarmCoveragePlan `json:"plan"`

	FindingsByModule   map[string]int `json:"findings_by_module,omitempty"`
	FindingsByEndpoint map[string]int `json:"findings_by_endpoint,omitempty"`
	TotalFindings      int            `json:"total_findings"`

	Warnings []string `json:"warnings,omitempty"`
}

type SwarmIntensityPreset = agenttypes.SwarmIntensityPreset

type SwarmPlan = agenttypes.SwarmPlan

type SwarmResult = agenttypes.SwarmResult

type SwarmRunner struct {
	// contains filtered or unexported fields
}

type TemplateData = agenttypes.TemplateData

type TokenUsage = agenttypes.TokenUsage

type TriageConfirmResult = agenttypes.TriageConfirmResult

type TriageLoopConfig struct {
	Engine     *Engine
	Repository *database.Repository // optional: used for early exit on high-confidence findings

	// Agent options for triage calls
	AgentName       string
	PromptTemplate  string // e.g. "pipeline-triage" or "agent-swarm-triage"
	TargetURL       string
	Hostname        string
	SourcePath      string
	Files           []string
	Instruction     string
	DryRun          bool
	ShowPrompt      bool
	ScanUUID        string
	ProjectUUID     string
	AgenticScanUUID string // when set, triage verdicts are written back to Finding.Status
	StreamWriter    io.Writer
	Verbose         bool // forwarded to agent.Options.Verbose for the per-tool result preview

	// Skills, when non-nil and non-empty, is the planner-filtered skill set the
	// triage agent loads (via load_skill) to confirm/escalate findings. Built
	// by the swarm triage step from the plan's recommended_skills + always-on
	// set. nil → triage runs without skills (e.g. the pipeline triage path).
	Skills *skill.Registry

	// Loop control
	MaxRounds                 int
	MaxFindingsPerTriageBatch int // if >0, split findings into batches of this size for triage
	BatchConcurrency          int // max triage batches run concurrently per round; 0 = default 3 (mirrors master-agent batches)
	MaxFindingsPerRound       int // max findings loaded per triage round; 0 = default 5000
	ResumeFromRound           int // skip triage rounds before this (0 = start from beginning)
	ProgressCallback          func(ProgressEvent)
	InitialFindingIDFloor     int64 // when >0, only findings newer than this ID are triaged in follow-up rounds

	// Scan callback for rescans
	ScanFunc ScanFunc

	// Session artifacts (optional)
	SessionDir   string
	ExtensionDir string // extension dir from the initial scan, carried into rescans

	// OnRescan is called before each rescan phase starts (optional).
	OnRescan func()

	// OnTriageRoundComplete is called after each triage round completes (optional).
	// The round number (0-indexed) is passed so callers can update checkpoints.
	OnTriageRoundComplete func(round int)
}

type TriageLoopResult struct {
	TriageResults  []*TriageResult
	Confirmed      int
	FalsePositives int
	RescanRounds   int
}

type TriageResult = agenttypes.TriageResult

type TriagedFinding = agenttypes.TriagedFinding

type VerifyCandidatesConfig struct {
	Repo            *database.Repository
	Provider        provider.Provider
	Model           string
	ProjectUUID     string
	ScanUUID        string
	AgenticScanUUID string
	Target          string
	SessionDir      string
	Mode            string // config.AutopilotMode{Shadow,Enforced}
	Concurrency     int    // 0 = defaultVerifyConcurrency
	StreamWriter    io.Writer
}

type VerifyCandidatesResult struct {
	Total         int
	Confirmed     int
	Rejected      int
	NeedsEvidence int
	Promoted      int // findings written (confirmed & promotion succeeded)
}

type VigToolSpec struct {
	Repo        *database.Repository
	ProjectUUID string
}