repl

type ChitchatClassifier interface {
	Classify(ctx context.Context, userLine, priorTurnHint string) (isChitchat bool, err error)
}

type ChitchatResponder interface {
	Respond(ctx context.Context, userLine, priorContext string) (reply string, err error)
}

type CommandOperationAnswerer interface {
	AnswerCommandOperationResult(ctx context.Context, userLine string, plan operation.CommandOperationPlan, result operation.CommandOperationResult, lang string) (string, error)
}

type CommandOperationCLIConfig struct {
	Planner       CommandOperationPlanner
	Policy        operation.CommandPolicy
	RepoRoot      string
	RuntimeAnchor string
	Language      string
	Providers     []operation.ProviderInfo
	Progress      io.Writer
}

type CommandOperationContinuation struct {
	Complete bool
	Reason   string
	Request  operation.CommandOperationRequest
}

type CommandOperationContinuationPlanner interface {
	ContinueCommandOperation(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, snapshot operation.CapabilitySnapshot, records []commandOperationResultRecord) (CommandOperationContinuation, error)
}

type CommandOperationEvaluator interface {
	EvaluateCommandOperation(ctx context.Context, userLine string, records []commandOperationResultRecord, lang string) (operation.OperationEvaluation, error)
}

type CommandOperationPlanner interface {
	PlanCommandOperation(ctx context.Context, userLine, repoRoot string, policy TurnPolicy) (operation.CommandOperationRequest, error)
}

type CommandOperationPlannerWithHandoff interface {
	PlanCommandOperationWithHandoff(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, snapshot operation.CapabilitySnapshot, recentOperationContext string) (operation.CommandOperationRequest, error)
}

type CommandOperationPlannerWithSnapshot interface {
	PlanCommandOperationWithSnapshot(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, snapshot operation.CapabilitySnapshot) (operation.CommandOperationRequest, error)
}

type CommandOperationRecordsAnswerer interface {
	AnswerCommandOperationRecords(ctx context.Context, userLine string, records []commandOperationResultRecord, lang string) (string, error)
}

type CommandOperationReplanner interface {
	ReplanCommandOperation(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, snapshot operation.CapabilitySnapshot, previous operation.CommandOperationPlan, result operation.CommandOperationResult) (operation.CommandOperationRequest, error)
}

type Config struct {
	Runner   Runner
	Store    *memory.Store
	Render   ResultRenderer
	Renderer *render.Renderer
	RepoRoot string
	Branch   string
	In       io.Reader // nil → interactive (bubbletea); non-nil → line-oriented
	Out      io.Writer

	// ReadRunAutoResume arms the read-run snapshot auto-resume lane.
	// DEFAULT OFF (user ruling 2026-07-30: the feature is not stable
	// enough to be ambient — an interrupted session's snapshot must
	// never silently revive a run). codrax.yaml read_run_auto_resume.
	ReadRunAutoResume bool

	// UI customization (used by line-oriented mode).
	Prompt           string // primary prompt, e.g. ">"
	PromptCont       string // continuation prompt, e.g. "."
	Banner           string // printed once at start; empty → default badge
	HeaderPrinted    bool   // true when cmd already rendered the CODRAX startup header
	ModelListLine    string // optional model-list summary shown before model config
	ModelSummaryLine string // optional resolved model summary

	// PasteFoldMinChars is the rune-count threshold above which a
	// single-line paste gets folded into a placeholder. Multi-line
	// pastes always fold regardless of length. Zero or negative →
	// DefaultPasteFoldMinChars. Surfaces
	// codrax.yaml :: repl_paste_fold_min_chars.
	PasteFoldMinChars int

	// Version and BuildTime are the build-stamped identifiers passed
	// from cmd. Empty strings render as "dev" / "unknown" so a bare
	// `go run` still produces a coherent banner / /version line.
	Version   string
	BuildTime string

	// Language toggles banner hint text between zh and en. Mirrors
	// codrax.yaml `lang` / CLI `--lang`. Only "en" (case-insensitive)
	// flips to English; every other value — including empty, "zh",
	// "off", "fr" — renders zh (the codrax.yaml default).
	Language string

	// MarkdownPreview is optional REPL UX: when the final answer markdown
	// transcript is written, this registers the file and prints a browser
	// preview URL below the existing "Markdown saved" line. Nil disables
	// preview hints without affecting output dumping.
	MarkdownPreview MarkdownPreviewer

	// OutputDumpDir and OutputDumpMax mirror the orchestrator's final
	// answer transcript dump settings for REPL-local answer paths
	// (local transform / summarize / translate and /chat). Pipeline
	// runs still write via the orchestrator so BusContext can carry the
	// path; local paths write here because they bypass Runner.Run.
	OutputDumpDir string
	OutputDumpMax int

	// HitraceConvert optionally overrides the /htrace convert executor.
	// Nil uses hitraceconv.ConvertFile.
	HitraceConvert HitraceConvertFunc

	// ChitchatResponder handles the /chat slash command. When nil,
	// /chat prints a "not configured" warning and takes no LLM action
	// — the command is recognised but inert. cmd/root.go constructs
	// the default LLM-backed responder from providers.yaml when
	// codrax.yaml `chitchat_enabled: true` (the default). Exposing
	// this as an interface lets unit tests inject a deterministic stub
	// without needing an LLM.
	ChitchatResponder ChitchatResponder

	// Memory is the read-side handle into the conversation memory
	// store. cmd/root.go wires memory.NewAdapter(store) here so the
	// chitchat tool-use loop can call recall_memory directly. nil
	// disables the tool-use path (chitchat falls back to single-shot
	// Chat with the keyword-injected priorContext only).
	Memory types.MemoryReader

	// EnvSettings forwards codrax.yaml's env_recommend_* knobs into
	// the REPL so /env probe / explain / cache use the right
	// timeouts and strategy filters. Zero value falls through to
	// types.DefaultEnvRecommendSettings via ResolvedEnvRecommendSettings.
	EnvSettings types.EnvRecommendSettings

	// ColorMode controls ANSI escape emission for diff rendering
	// (and any other code blocks added later). Default ColorAuto:
	// on for TTY, off for pipes. NO_COLOR env wins over everything.
	// Surfaces --color={auto,always,never} on the CLI.
	ColorMode render.ColorMode

	// ChitchatClassifier optionally runs a single LLM call before each
	// normal dispatch to decide whether to reroute the turn to the
	// chit-chat path. nil disables the gate; the REPL falls back to
	// explicit /chat only. Requires ChitchatResponder to be non-nil;
	// cmd/root.go ties both wires together via codrax.yaml
	// `chitchat_classifier_enabled: true`. Fail-safe: any classifier
	// error routes to the pipeline unchanged.
	ChitchatClassifier ChitchatClassifier
	// UserMode is the explicit user-facing task lane. Auto preserves the
	// existing classifier-driven route; code/operation/data/write bypass
	// classification for users who know which lane they want.
	UserMode UserMode

	// OperationEnabled is the feature gate for the future independent
	// computer-operation / artifact-generation route. Batch 1 wires only
	// classification safety: when false, route=operation is refused at the
	// REPL surface instead of falling into the source-analysis pipeline.
	OperationEnabled bool
	// OperationProviders are optional side-effect capable providers for the
	// operation route. Empty means plan-only: REPL shows the typed operation
	// plan and stops before execution.
	OperationProviders []operation.ProviderInfo
	// OperationPlanner is an optional LLM-backed command planner for
	// route=operation + operation_kind=computer_operation.
	OperationPlanner CommandOperationPlanner
	// DataTaskPlanner is an optional LLM-backed planner for route=data. It is
	// intentionally independent from the source-analysis pipeline and the
	// command-operation approval loop.
	DataTaskPlanner DataTaskPlanner
	// DataMaterialExtractor is an optional multimodal extractor used only when
	// a data plan declares non-text materials as required and no text evidence
	// is available to the deterministic runner.
	DataMaterialExtractor DataMaterialExtractor
	// DataTaskMaxRepairRounds bounds script-failure repair attempts in the
	// read-only data lane. Zero uses DefaultDataTaskMaxRepairRounds.
	DataTaskMaxRepairRounds int
	// DataTaskMaxDataRounds bounds execute/evaluate/continue batches in the
	// read-only data lane. Zero uses DefaultDataTaskMaxDataRounds.
	DataTaskMaxDataRounds int
	// OperationCommandPolicy controls command-operation approval/execution.
	OperationCommandPolicy operation.CommandPolicy
	// MCPServers is used only for explicitly configured operation providers.
	// Explorer/read-mode MCP exposure continues to live in the agent layer.
	MCPServers *mcp.Registry
	// MCPServerConfigs lets explicitly lazy operation providers start only
	// after a user approves the operation plan. Eager MCP exposure remains
	// owned by cmd/root.go and the agent layer.
	MCPServerConfigs []types.MCPServerConfig
	// OperationSkillConfigs are local manifest-backed operation providers. They
	// are descriptors until typed operation routing plus approval reaches the
	// provider execution path.
	OperationSkillConfigs []types.OperationSkillConfig
	// OperationPendingStore persists one unresolved operation-lane decision so
	// restarts can surface pending approvals/clarifications. It is independent
	// from write-mode PlanStore.
	OperationPendingStore *OperationPendingStore

	// PlanStore persists B0 write-mode ChangePlans for the REPL
	// session. Nil disables the /plan slash command family —
	// useful for tests and for single-shot invocations that never
	// construct a REPL. cmd/root.go wires a real store under
	// <runtime-anchor>/plans when the REPL starts.
	PlanStore *PlanStore

	// PlanGroupStore persists stage II multi-phase PlanGroups
	// for the REPL's /phase slash command family. Nil disables
	// /phase entirely — single-phase plans remain fully usable
	// via /plan / /approve as before. cmd/root.go wires a real
	// store under <runtime-anchor>/plans/groups/ alongside
	// PlanStore.
	PlanGroupStore *PlanGroupStore

	// WriteWorkflowRunStore persists the controller-engine write
	// workflow DAG under <runtime-anchor>/plans/workflows/. Nil
	// disables the write half of /workflow while leaving operation
	// provider workflows unchanged.
	WriteWorkflowRunStore *WriteWorkflowRunStore

	// WriteWorkflowIdentityMint mints the current WFID-1 repo identity for
	// a repo root. cmd/root.go wires it to
	// orchestrator.MintWriteWorkflowRepoIdentityForRepo so the bare
	// /workflow resume form can run the same single-point identity gate
	// (types.MatchWriteWorkflowRepoIdentity) the write turn runs, and so
	// the one-shot resume token records the canonical repo root it was
	// minted in — the REPL never grows a second canonicaliser or git
	// probe. Nil (tests / partial wiring) skips the bare-resume identity
	// verdict and stamps the trimmed raw root.
	WriteWorkflowIdentityMint func(repoRoot string) types.WriteWorkflowRepoIdentity

	// ReadRunSnapshotStore persists typed read-mode execution snapshots
	// under <runtime-anchor>/plans/read_runs/. Nil disables the advanced
	// /read-runs audit command family.
	ReadRunSnapshotStore *ReadRunSnapshotStore

	// RuntimeArtifactStore persists one-shot runtime observations (auto-routed
	// pasted logs/traces) as durable refs under <runtime-anchor>/runtime_artifacts/.
	// The REPL may reattach those bytes on a later typed repo/hybrid continuation
	// without putting the raw payload into the classifier prompt.
	RuntimeArtifactStore *RuntimeArtifactStore

	// FailureTaxonomy is the stage-3 reader interface for
	// /pitfalls inspection. The REPL only reads (list / clear);
	// the orchestrator owns Append. Nil = /pitfalls reports
	// "feature disabled."
	FailureTaxonomy FailureTaxonomyReader

	// AttachedLogMaxBytes caps every REPL attach surface (`/log
	// <path>`, `/log` paste mode, splitPastedLog auto-route) so a
	// runaway paste cannot balloon the REPL process memory. Mirrors
	// cmd's maxAttachedLogBytes — both are driven by
	// codrax.yaml :: log_attach_max_bytes. Zero or negative →
	// DefaultAttachedLogMaxBytes (512 MiB), matching the CLI default.
	AttachedLogMaxBytes int

	// AttachedTraceMaxBytes caps the perf-channel attach surface
	// (`/htrace <path>` and the
	// `/atrace` aliases). Defaults to AttachedLogMaxBytes when zero
	// or negative — a user who only configures the log cap still
	// gets symmetric trace handling. Set independently to override.
	AttachedTraceMaxBytes int

	// SettingsPath is the resolved codrax.yaml the CLI loaded (or "" if
	// none was found). Surfaced verbatim by the L2 gate's reject
	// message so the user knows WHICH file to edit. Optional; empty
	// falls back to a generic "in codrax.yaml" phrasing.
	SettingsPath string

	// WriteEnabled mirrors codrax.yaml :: write_enabled. Gates every
	// REPL transition into a non-read mode (`/mode write|apply|verify`,
	// `/approve`). When false, the REPL refuses the transition with a
	// clear error pointing at the yaml knob — the alternative was the
	// pre-fix silent state where /mode write accepted, the planner
	// dispatched, the analyzer failed in a confusing way ("hypothesis
	// coverage" / "context canceled"), and the user had no idea
	// write_enabled was the cause. cmd/root.go forwards
	// runtime_settings.WriteEnabled.
	WriteEnabled bool

	// WriteApprovalPolicy controls /approve for write ChangePlans.
	// Defaults to auto_safe when empty. It is independent from command
	// operation approval and from write_enabled's capability gate.
	WriteApprovalPolicy writeflow.ApprovalPolicy

	// WriteAutoInitRepo mirrors the resolved auto-init authorization
	// (yaml `write_auto_init_repo` OR CLI `--auto-init-repo`). When
	// true, the REPL's /approve flow skips the interactive y/N
	// consent prompt for bare/headless repos and silently
	// authorizes the orchestrator to scaffold. When false (default),
	// /approve runs DetectRepoState before dispatching and prompts
	// for consent if the target needs init.
	WriteAutoInitRepo bool

	// WriteScaffoldEnabled mirrors the resolved scaffold authorization
	// (yaml `write_scaffold_enabled` OR CLI `--allow-scaffold`). When
	// true, the orchestrator's plan pre-hook tolerates an empty target
	// directory; without it, empty-dir plan/apply dispatches fail-loud
	// with a hint at the two authorization surfaces. Forwarded into
	// the orchestrator on REPL boot so REPL sessions inherit the
	// startup-time authorization without the user having to repeat
	// the flag.
	WriteScaffoldEnabled bool

	// RuntimeAnchor is <CWD>/.codrax/ — used by /worktree gc to
	// locate the worktree base under <RuntimeAnchor>/worktrees/.
	// Empty disables the gc subcommand (the slash dispatcher
	// surfaces a typed warning).
	RuntimeAnchor string

	// WorktreeKeepTTL + WorktreeKeepMaxCount mirror the resolved
	// codrax.yaml knobs so /worktree gc uses the same caps as
	// startup. Zero on either disables that gate.
	WorktreeKeepTTL      time.Duration
	WorktreeKeepMaxCount int

	// Topology is the multi-repo discovery snapshot for RepoRoot.
	// Populated by cmd/root.go::initApp; consumed by /repos. Nil
	// disables the slash command (handler surfaces a typed warning).
	Topology *topology.RepoTopology

	// MultiRepoEnabled mirrors codrax.yaml :: multi_repo_enabled.
	// When false, /repos still works (it shows a hint pointing at
	// the yaml gate) but Phase 4 multigraph routing is bypassed.
	MultiRepoEnabled bool

	// MultiRepoMaxActive mirrors codrax.yaml :: multi_repo_max_active.
	// /repos cap <N> overrides this value session-locally.
	MultiRepoMaxActive int

	// MultiRepoInactivePreviewCount mirrors codrax.yaml ::
	// multi_repo_inactive_preview_count. Threaded through to BusContext
	// so context/builder.go's L0 LLM advisory can decide how many
	// out-of-active sub-repos to surface in the prompt.
	MultiRepoInactivePreviewCount int

	// Multigraph is the cmd/root-supplied carrier handle the REPL
	// reads to render the /repos listing (auto-active row marker
	// + color). Stored as any so the REPL stays free of an
	// internal/tool/repomap/multigraph import. The REPL probes for
	// the ActiveSlugSnapshot() method via type-assert; nil disables
	// the auto-active marker so the listing falls back to the
	// 2-state pinned/inactive view.
	Multigraph any

	// InitialFocusSlugs pre-populates the session focus pin map at
	// REPL boot. Used by the --focus CLI flag (cmd/root.go); REPL
	// users who pin via /repos focus reach the same map through the
	// command handler. Empty / nil = no pin (default REPL boot).
	InitialFocusSlugs []string

	// OnMultiRepoFocusChange is invoked by the REPL when the user
	// runs /repos focus or /repos unfocus. cmd/root.go wires this to
	// app.multigraph.SetFocus so the next Run picks up the change.
	// Nil disables the propagation (focus state stays REPL-local).
	OnMultiRepoFocusChange func(slugs []string)

	// OnMultiRepoCapChange is invoked by /repos cap. cmd/root.go
	// wires this to app.multigraph.SetCap.
	OnMultiRepoCapChange func(n int)

	// OnMultiRepoRefresh is invoked by /repos refresh. cmd/root.go
	// rebuilds app.multigraph from the freshly-discovered topology
	// so the next Run sees the new sub-repo set.
	OnMultiRepoRefresh func(newTopology *topology.RepoTopology)
}

type DataMaterialExtractor interface {
	ExtractDataMaterials(ctx context.Context, repoRoot, outputRoot string, materials []dataquery.NonTextRequiredMaterial) ([]dataquery.MaterialExtraction, error)
}

type DataTaskCLIConfig struct {
	Planner         DataTaskPlanner
	RepoRoot        string
	RuntimeAnchor   string
	Language        string
	MaxRepairRounds int
	MaxDataRounds   int
	Progress        io.Writer
	ResumePath      string
}

type DataTaskContinuationPlanner interface {
	ContinueDataTask(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, candidates []dataquery.CandidateFile, records []dataTaskWorkflowRecord) (dataquery.TaskPlan, error)
}

type DataTaskContinuationPlannerWithDeferred interface {
	ContinueDataTaskWithDeferred(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, candidates []dataquery.CandidateFile, records []dataTaskWorkflowRecord, deferred dataquery.TaskPlan) (dataquery.TaskPlan, error)
}

type DataTaskEvaluator interface {
	EvaluateDataTask(ctx context.Context, userLine, repoRoot string, records []dataTaskWorkflowRecord, lang string) (dataquery.Evaluation, error)
}

type DataTaskEvaluatorWithDeferred interface {
	EvaluateDataTaskWithDeferred(ctx context.Context, userLine, repoRoot string, records []dataTaskWorkflowRecord, deferred dataquery.TaskPlan, lang string) (dataquery.Evaluation, error)
}

type DataTaskPlanner interface {
	PlanDataTask(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, candidates []dataquery.CandidateFile) (dataquery.TaskPlan, error)
}

type DataTaskRepairPlanner interface {
	RepairDataTask(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, candidates []dataquery.CandidateFile, previous dataquery.TaskPlan, executionError string) (dataquery.TaskPlan, error)
}

type DataTaskResultPatchPlanner interface {
	ProposeDataResultPatch(ctx context.Context, userLine, repoRoot string, previous dataquery.TaskPlan, partial dataquery.Result, violations []dataquery.DataTaskViolation, records []dataTaskWorkflowRecord, lang string) (dataquery.DataResultPatchPlan, error)
}

type DataTaskTypedRepairPlanner interface {
	RepairDataTaskWithViolation(ctx context.Context, userLine, repoRoot string, policy TurnPolicy, candidates []dataquery.CandidateFile, previous dataquery.TaskPlan, executionError string, violation dataquery.DataTaskViolation) (dataquery.TaskPlan, error)
}

type ErrUnsettledPlanExists struct {
	Existing PlanInfo
}

type FailureTaxonomyReader interface {
	// All returns a snapshot of every persisted pattern,
	// newest LastSeen first. Empty when the cache is fresh
	// or the feature is disabled.
	All() []types.FailurePattern

	// Clear wipes the cache file + zeroes the in-memory
	// copy. Idempotent — missing file is success.
	Clear() error
}

type GroupInfo struct {
	ID        string
	Path      string
	Status    string
	Decision  string
	Phases    int
	ActiveIdx int
	ModTime   int64
}

type HitraceConvertFunc func(context.Context, hitraceconv.Options) (hitraceconv.Result, error)

type LocalResponder interface {
	RespondLocal(ctx context.Context, userLine, priorContext, lastAnswer, presentationDirective string) (string, error)
}

type MarkdownPreviewer interface {
	RegisterMarkdown(path string) (string, error)
}

type MemoryReader = memoryReaderAlias

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

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

type PlanInfo struct {
	ID      string // plan-<nano>-<pid>
	Path    string // absolute file path
	SizeB   int64  // file size in bytes
	ModTime int64  // last modification unix-nano
	Status  string // PlanStatus* from types/change_plan.go; empty when JSON
	// was unreadable (List logs + continues so one corrupt file
	// doesn't break enumeration).
	UnvalidatedCount int    // number of static-check stages skipped
	HasCritique      bool   // plan_critic produced a non-empty review
	PhaseGroupID     string // non-empty when this plan is one phase of a multi-phase group
	PhaseIndex       int    // 0-based phase index within the group; meaningful only when PhaseGroupID != ""
	// WorktreeMissing fires when the plan's persisted
	// WorktreePath has been deleted out-of-band (e.g., user
	// rm -rf'd .codrax/worktrees/...). Populated by the
	// banner-detection path so unsettledBanner can tag the
	// plan as "(orphaned worktree)" instead of pretending it's
	// still fully actionable. Commit 42 P1.
	WorktreeMissing bool
}

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

type ProviderOperationAnswerer interface {
	AnswerProviderOperationResult(ctx context.Context, userLine string, records []providerOperationResultRecord, lang string) (string, error)
}

type ProviderOperationEvaluator interface {
	EvaluateProviderOperation(ctx context.Context, userLine string, records []providerOperationResultRecord, lang string) (operation.OperationEvaluation, error)
}

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

type ReadRunSnapshotInfo struct {
	ID               string
	Path             string
	Request          string
	TaskGraphHash    string
	TaskNodeCount    int
	NodeStatusCount  int
	ReadFileCount    int
	AcceptedEvidence int
	ModTime          int64
}

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

type ResultRenderer func(*types.BusContext) string

type Runner interface {
	Run(request, repoRoot, branch string) (*types.BusContext, error)
}

type RuntimeArtifactRef struct {
	SchemaVersion int       `json:"schema_version"`
	ID            string    `json:"id"`
	Kind          string    `json:"kind"`
	Path          string    `json:"path"`
	Bytes         int       `json:"bytes"`
	SHA256        string    `json:"sha256"`
	Source        string    `json:"source,omitempty"`
	CreatedAt     time.Time `json:"created_at"`
}

type RuntimeArtifactSnapshot struct {
	SchemaVersion int                `json:"schema_version"`
	Log           RuntimeArtifactRef `json:"log,omitempty"`
	Trace         RuntimeArtifactRef `json:"trace,omitempty"`
	UpdatedAt     time.Time          `json:"updated_at"`
}

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

type SingleShotTurnPolicyClassifier interface {
	ClassifyPolicySingleShot(ctx context.Context, userLine, priorTurnHint string, hasPriorAnswer bool) (TurnPolicy, error)
}

type TurnPolicy struct {
	Route                     TurnRoute
	NeedsRepoAccess           bool
	NeedsOperationAccess      bool
	NeedsDataAccess           bool
	Operation                 string // chat | transform | summarize | translate | elaborate | investigate | computer_operation | artifact_generation | ...
	OperationKind             string // optional more precise operation capability kind
	DataTaskKind              string // optional data lane kind, e.g. data_cleaning | data_join | data_aggregation
	WriteIntent               string // explicit_change | analysis_only | ambiguous
	Source                    string // current_message | last_answer | prior_context | repo | mixed
	CurrentSourceEvidenceMode types.TurnRouteCurrentSourceEvidenceMode
	RiskLevel                 string // none | low | medium | high
	SideEffects               []string
	TargetSurface             string // desktop | browser | file_artifact | office_doc | spreadsheet | slides | external_system | unknown
	RequiresConfirmation      bool
	Confidence                float64 // 0..1; <0.4 demotes to repo
	Reason                    string
	PresentationDirective     string // free-form, e.g. "mermaid", "markdown table", "brief 3-bullet"
	RequiresDiagram           bool   // precise current-turn hard visual authority; never inferred from directive text
}

type TurnPolicyClassifier interface {
	ClassifyPolicy(ctx context.Context, userLine, priorTurnHint string, hasPriorAnswer bool) (TurnPolicy, error)
}

type TurnRoute string

type UserMode string

type WorkflowRunInfo struct {
	ID                string
	Path              string
	Status            string
	ActiveBatchID     string
	ActiveBatchStatus string
	ActiveSliceID     string
	ActiveSliceStatus string
	CompletedSlices   int
	TotalSlices       int
	Batches           int
	ContextPacks      int
	NextState         string
	NextAction        string
	RequiresUser      bool
	ModTime           int64
}

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