wotann 0.5.0

package/dist/core/runtime.d.ts

@@ -0,0 +1,1425 @@
+/**
+ * WotannRuntime — the composition root that wires ALL systems together.
+ *
+ * Every module in the harness connects through this single point:
+ * - Provider discovery → registry → AgentBridge (with account pool)
+ * - Intelligence amplifier → reasoning sandwich → schema optimizer
+ * - Mode cycler → safety overrides → hook engine (with pause support)
+ * - Middleware pipeline (16 layers) wraps every query
+ * - Trace analyzer records every action for post-run analysis
+ * - Local context injects environment awareness
+ * - Memory store (8-layer + semantic search) captures observations
+ * - DoomLoop detector monitors for infinite loops
+ * - Cost tracker records spend per query
+ * - Session management tracks state
+ */
+import type { ProviderName, WotannQueryOptions, AgentMessage } from "./types.js";
+import { MessageQueue } from "./message-queue.js";
+import type { StreamChunk } from "../providers/types.js";
+import { HookEngine } from "../hooks/engine.js";
+import { Observer } from "../memory/observer.js";
+import { Reflector, type ReflectorJudge } from "../memory/reflector.js";
+import { CostTracker } from "../telemetry/cost-tracker.js";
+import { MemoryStore } from "../memory/store.js";
+import { SnippetStore } from "../snippets/snippet-store.js";
+import { type KnowledgeResult } from "../memory/unified-knowledge.js";
+import { type ContextEntry } from "../memory/context-tree-files.js";
+import { QuantizedVectorStore } from "../memory/quantized-vector-store.js";
+import { type WotannMode } from "./mode-cycling.js";
+import type { SessionState } from "./types.js";
+import { AccountPool } from "../providers/account-pool.js";
+import { PerFileEditTracker } from "../hooks/benchmark-engineering.js";
+import { SkillRegistry } from "../skills/loader.js";
+import { type PreCommitAnalysisResult } from "../verification/pre-commit.js";
+import { type ConversationCompactionResult } from "./runtime-intelligence.js";
+import type { ContextCapabilityProfile } from "../context/window-intelligence.js";
+import { FileFreezer } from "../security/file-freeze.js";
+import { SecretScanner } from "../security/secret-scanner.js";
+import { ProactiveMemoryEngine } from "../memory/proactive-memory.js";
+import { ConversationBranchManager } from "./conversation-branching.js";
+import { CrossSessionLearner } from "../learning/cross-session.js";
+import { CapabilityEqualizer } from "../providers/capability-equalizer.js";
+import { PluginLifecycle } from "../plugins/lifecycle.js";
+import { SessionRecorder } from "../telemetry/session-replay.js";
+import { ShadowGit } from "../utils/shadow-git.js";
+import { CanvasEditor } from "../ui/canvas.js";
+import * as DiffEngine from "../ui/diff-engine.js";
+import { CredentialPool } from "../providers/credential-pool.js";
+import { EpisodicMemory } from "../memory/episodic-memory.js";
+import { AutonomousExecutor } from "../orchestration/autonomous.js";
+import { NotificationManager } from "../desktop/notification-manager.js";
+import { ContextSourceInspector } from "../context/inspector.js";
+import { PersonaManager } from "../identity/persona.js";
+import { SelfHealingPipeline } from "../orchestration/self-healing-pipeline.js";
+import { LSPManager } from "../lsp/symbol-operations.js";
+import { type McpTier, type LoadToolsResult } from "../mcp/tool-loader.js";
+import { VisualDiffTheater } from "../testing/visual-diff-theater.js";
+import { type AgentId, type Handoff, type HandoffInputData, type HandoffResult } from "./handoff.js";
+import { ProviderBrain } from "../providers/provider-brain.js";
+import { type HashEditOperation, type HashEditResult } from "../tools/hashline-edit.js";
+import { ImageGenRouter } from "../tools/image-gen-router.js";
+import { type AmbientContext } from "../intelligence/ambient-awareness.js";
+import { UnifiedDispatchPlane } from "../channels/unified-dispatch.js";
+import type { AutonomousResult } from "../orchestration/autonomous.js";
+import { ArenaLeaderboard } from "../orchestration/arena.js";
+import type { ArenaContestant } from "../orchestration/arena.js";
+import { CouncilLeaderboard } from "../orchestration/council.js";
+import type { CouncilResult, SelfConsistencyResult } from "../orchestration/council.js";
+import { PIIRedactor } from "../security/pii-redactor.js";
+import { VectorStore, HybridMemorySearch } from "../memory/vector-store.js";
+import { RulesOfEngagement } from "../security/rules-of-engagement.js";
+import { TrainingPipeline } from "../training/pipeline.js";
+import { AutoresearchEngine } from "../training/autoresearch.js";
+import type { CompletionCriterion, VerificationEvidence } from "../autopilot/types.js";
+import { TaskDelegationManager } from "../orchestration/task-delegation.js";
+import { AutoClassifier } from "../security/auto-classifier.js";
+import { IntentVerifier } from "../security/intent-verifier.js";
+import { AutoVerifier } from "../intelligence/auto-verify.js";
+import { AutoReviewer } from "../intelligence/auto-reviewer.js";
+import { BugBot } from "../intelligence/bugbot.js";
+import { ProviderArbitrageEngine } from "../intelligence/provider-arbitrage.js";
+import { ErrorPatternLearner } from "../intelligence/error-pattern-learner.js";
+import { PredictiveContextLoader } from "../intelligence/predictive-context.js";
+import { AutoEnhancer } from "../intelligence/auto-enhance.js";
+import { CrossDeviceContextManager } from "../intelligence/cross-device-context.js";
+import { AITimeMachine } from "../intelligence/ai-time-machine.js";
+import { UserModelManager } from "../intelligence/user-model.js";
+import { VerificationCascade } from "../intelligence/verification-cascade.js";
+import { WallClockBudget } from "../intelligence/wall-clock-budget.js";
+import { PreCompletionVerifier } from "../intelligence/pre-completion-verifier.js";
+import { ProgressiveBudget } from "../intelligence/progressive-budget.js";
+import { GoalDriftDetector } from "../orchestration/goal-drift.js";
+import { type TodoProvider } from "../orchestration/todo-provider.js";
+import { type AgentRegistry } from "../orchestration/agent-registry.js";
+import { AutonomousContextManager } from "../orchestration/autonomous-context.js";
+import { type WaveTask } from "../orchestration/wave-executor.js";
+import { type StructuredPlan } from "../orchestration/ultraplan.js";
+import { ContextShardManager } from "../context/context-sharding.js";
+import { type ContextBudget as MaximizerContextBudget } from "../context/maximizer.js";
+import { type TaskContext, type ReplayBudget, type ReplayResult } from "../context/context-replay.js";
+import { TurboQuantEngine } from "../context/ollama-kv-compression.js";
+import { VirtualContextManager } from "../context/virtual-context.js";
+import { type PromptTestCase, type PromptTestResult, type RegressionReport } from "../testing/prompt-regression.js";
+import { ConversationTree, CommandHistory } from "./conversation-tree.js";
+import { type MonitorDigest } from "../monitoring/source-monitor.js";
+import { KnowledgeGraph } from "../memory/graph-rag.js";
+import { ContextTree } from "../memory/context-tree.js";
+import { CloudSyncEngine } from "../memory/cloud-sync.js";
+import { SkillForge } from "../learning/skill-forge.js";
+import { InstinctSystem } from "../learning/instinct-system.js";
+import { FlowTracker } from "../intelligence/flow-tracker.js";
+import { IdleDetector } from "../intelligence/away-summary.js";
+import { analyzeCodebaseHealth } from "../intelligence/codebase-health.js";
+import { DecisionLedger, type DecisionInput } from "../learning/decision-ledger.js";
+import { TaskSemanticRouter } from "../intelligence/task-semantic-router.js";
+import { ParallelSearchDispatcher } from "../intelligence/parallel-search.js";
+import { ConfirmActionGate } from "../security/confirm-action.js";
+import { AgentHierarchyManager } from "../orchestration/agent-hierarchy.js";
+import { AgentWorkspace } from "../orchestration/agent-workspace.js";
+import { ContextFence } from "../memory/context-fence.js";
+import { RetrievalQualityScorer } from "../memory/retrieval-quality.js";
+import { ContextLoader } from "../memory/context-loader.js";
+import { ObservationExtractor } from "../memory/observation-extractor.js";
+import { TunnelDetector } from "../memory/tunnel-detector.js";
+import { ConversationMiner } from "../memory/conversation-miner.js";
+import { AdaptivePromptGenerator } from "../intelligence/adaptive-prompts.js";
+import { NightlyConsolidator } from "../learning/nightly-consolidator.js";
+import { BenchmarkHarness } from "../intelligence/benchmark-harness.js";
+import { SkillsGuard } from "../security/skills-guard.js";
+import { VirtualPathResolver } from "./virtual-paths.js";
+import { ConfigDiscovery } from "./config-discovery.js";
+import { VibeVoiceBackend } from "../voice/vibevoice-backend.js";
+import { PromptEnhancer } from "../desktop/prompt-enhancer.js";
+import { type OmegaLayers } from "../memory/omega-layers.js";
+import { type ContextTier } from "../memory/progressive-context-loader.js";
+/**
+ * Thinking effort tiers passed to the reasoning sandwich / extended
+ * thinking layer. `xhigh` was added in V9 T14.1a (parity with Claude
+ * Code v2.1.111) as a finer granularity between `high` and `max` —
+ * Opus 4.7's extended-thinking sweet spot. Models that don't support
+ * extended thinking treat `xhigh` and `max` the same via
+ * `model-router.supportsXhighEffort`.
+ */
+export type ThinkingEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export interface RuntimeConfig {
+    readonly workingDir: string;
+    readonly hookProfile?: "minimal" | "standard" | "strict";
+    readonly enableMiddleware?: boolean;
+    readonly enableHooks?: boolean;
+    readonly enableWasmBypass?: boolean;
+    readonly enableMemory?: boolean;
+    readonly enableSemanticSearch?: boolean;
+    readonly enableTraceAnalysis?: boolean;
+    readonly enableTTSR?: boolean;
+    readonly skillsDir?: string;
+    readonly initialMode?: WotannMode;
+    readonly thinkingEffort?: ThinkingEffort;
+    readonly maxContextTokens?: number;
+    /**
+     * Provider to use when discovery hasn't run yet and the user hasn't
+     * picked one. Historically hardcoded to "anthropic" throughout the
+     * codebase; S1-16/17/18 make this configurable so free-tier users (who
+     * may only have Gemini or a local Ollama model) don't get error
+     * chunks attributed to a provider they haven't configured.
+     */
+    readonly defaultProvider?: ProviderName;
+    /**
+     * Default model paired with `defaultProvider`. When omitted, downstream
+     * code treats it as "auto" and lets the router choose.
+     */
+    readonly defaultModel?: string;
+    /**
+     * Phase H — LLM-as-judge auto-review after each query response. When
+     * true and a diff/response can be assembled, guardReview runs once with
+     * up to one retry on low-confidence failing verdicts. Defaults to
+     * `process.env.WOTANN_GUARDIAN === "1"` so it stays opt-in.
+     */
+    readonly enableGuardian?: boolean;
+    /**
+     * Round 63 — secondary AI VerifierEngine that audits primary responses
+     * via a strategy plugin set (safety / faithfulness / format /
+     * plan-action-match / hallucination / guardian-wrapper /
+     * four-perspective-wrapper / cove-wrapper). Defaults to
+     * `process.env.WOTANN_VERIFIER === "1"` (opt-in).
+     *
+     * When undefined, the engine is NOT instantiated. The legacy
+     * Guardian / CoVe blocks (gated by WOTANN_GUARDIAN / WOTANN_COVE)
+     * remain unchanged for backward compatibility — they coexist with
+     * the new engine path. Future rounds can fold them into wrapper
+     * strategies and remove the legacy code.
+     */
+    readonly enableVerifier?: boolean;
+    /**
+     * Round 63 — verifier engine config. Optional; defaults to "fast"
+     * mode + samplingRate 0.3 + riskGate "high-only" when enabled.
+     */
+    readonly verifierConfig?: import("../verification/types.js").VerifierConfig;
+    /**
+     * Phase H — emit honest "I don't know" on low-confidence retrievals
+     * instead of fabricating an answer from weak hits. Defaults to true.
+     */
+    readonly enableContextualAbstention?: boolean;
+    /**
+     * Phase H — which progressive context tier to prepare at initialize().
+     * L0 = identity only (~50 tokens), L1 = identity + critical facts
+     * (~170 tokens). L2/L3 are loaded lazily on topic/deep-search triggers.
+     */
+    readonly progressiveContextTier?: ContextTier;
+    /**
+     * Session-13 Serena-parity: when true, the runtime constructs a
+     * `LanguageServerRegistry` + 6-tool LSP agent surface (hover,
+     * definition, document_symbols beyond the legacy 3). Defaults to
+     * `process.env.WOTANN_LSP_TOOLS === "1"` so it stays opt-in until the
+     * multi-language LSP install-hint UX is validated against real users.
+     */
+    readonly enableLspAgentTools?: boolean;
+    /**
+     * Dual-terminal steering — GSD-inspired live state editing via
+     * `.wotann/steering/pending/*.json` command files. When true, the
+     * runtime allocates a SteeringServer and fs.watch()es for commands.
+     * Defaults to `process.env.WOTANN_STEERING === "1"` so short-lived
+     * queries don't hold an extra fd. Second-terminal writers use
+     * `SteeringServer#writeCommand` (or the forthcoming `wotann steer`
+     * CLI) to enqueue commands; autonomous phase boundaries drain
+     * `steeringCommands`.
+     */
+    readonly enableSteering?: boolean;
+    /**
+     * Session-13 Supermemory parity: route `searchMemory()` through the
+     * BM25+dense+RRF v2 hybrid retriever. Off by default — the existing
+     * `hybridSearch` path already covers most workloads; v2 adds SOTA
+     * re-ranking for retrieval evals. Opt-in via env `WOTANN_HYBRID_V2=1`
+     * or the config flag.
+     */
+    readonly useHybridV2?: boolean;
+    /**
+     * Session-13 deer-flow parity: scrub physical paths (`/Users/alice/...`)
+     * to virtual `/mnt/user-data/*` in tool-result transcripts before they
+     * reach the model. Defaults to true — agents should never see the
+     * user's home directory in transcripts.
+     */
+    readonly virtualPathsEnabled?: boolean;
+    /**
+     * P1-B1 Droid/Meta-Harness parity: capture an environment bootstrap
+     * snapshot (git HEAD/branch/dirty, tree, filtered env, services, log
+     * tail, lockfile shas) at session start and prepend it to the system
+     * prompt. Disable for benchmark runs where ~50ms of capture overhead
+     * matters. Defaults to ENABLED.
+     */
+    readonly skipBootstrapSnapshot?: boolean;
+    /**
+     * rc.2 follow-up: allocate a PreCompletionVerifier instance (B4 —
+     * ForgeCode 4-perspective self-review) so callers can run the
+     * 4-persona parallel review before declaring a task complete. The
+     * verifier is constructed lazily on first `getPreCompletionVerifier()`
+     * call with an LlmQuery bound to this runtime's query() method.
+     * Defaults to `process.env.WOTANN_PRE_COMPLETION_VERIFY === "1"` so it
+     * stays opt-in — 4 parallel LLM calls are expensive on free-tier.
+     */
+    readonly enablePreCompletionVerify?: boolean;
+    /**
+     * rc.2 follow-up: allocate a ProgressiveBudget instance (B12 —
+     * ForgeCode progressive-budget) so callers can wrap verify-loops
+     * with a LOW → MEDIUM → MAX escalation ladder. The scheduler is
+     * constructed lazily on first `getProgressiveBudget()` call with the
+     * default 3-tier config. Defaults to `process.env.WOTANN_PROGRESSIVE_BUDGET
+     * === "1"`. Allocation is cheap; leaving enabled everywhere would be
+     * safe, but we gate for symmetry with the other primitives.
+     */
+    readonly enableProgressiveBudget?: boolean;
+    /**
+     * M4 TEMPR opt-in: route active-memory recall through the 4-channel
+     * TEMPR search (vector + BM25 + entity + temporal) instead of the
+     * default FTS5 `store.search()`. TEMPR costs more per call but yields
+     * stronger retrieval on factual/entity-heavy prompts. Defaults to
+     * `process.env.WOTANN_USE_TEMPR === "1"` so the existing FTS path
+     * stays the free-tier default.
+     */
+    readonly useTempr?: boolean;
+    /**
+     * M6 Retrieval-mode opt-in: when set to a registered mode name
+     * (e.g. "time-decay", "fuzzy-match"), active-memory recall dispatches
+     * through `store.searchWithMode(mode, query)` instead of the default
+     * FTS search. `useTempr` takes precedence when both are set. Defaults
+     * to `process.env.WOTANN_RECALL_MODE` when unset; omit the env var
+     * to keep the default FTS path.
+     */
+    readonly recallMode?: string;
+    /**
+     * P1-B7 GoalDriftDetector opt-in (OpenHands port, part 3).
+     * Construction itself is cheap but the detector is only useful
+     * when callers wire it into a per-cycle checkpoint (see
+     * AutonomousExecutor.execute's `goalDrift` callback) AND provide
+     * a real `todoProvider`. Defaults to
+     * `process.env.WOTANN_GOAL_DRIFT === "1"` so the getter stays
+     * honest about its state — a caller that forgets to flip the
+     * flag gets `null` (feature off) instead of a detector with
+     * NullTodoProvider that always says "no drift".
+     */
+    readonly enableGoalDrift?: boolean;
+    /**
+     * V9 T1.5 — Prompt-cache warmup. When enabled, after `buildStablePrefix`
+     * rebuilds `this.systemPrompt`, the runtime fires a fire-and-forget
+     * call to `warmupCache()` (src/providers/prompt-cache-warmup.ts) so
+     * the active provider's server-side prompt cache is primed before
+     * the first real user query hits it. Mastra paper reports 4-10×
+     * cache savings when warmup lands before production traffic.
+     *
+     * Defaults: `enablePromptCacheWarmup === false` → off. Otherwise
+     * the env var `WOTANN_PROMPT_CACHE_WARMUP` controls: `"0"` disables,
+     * any other value (including unset) enables. This matches the
+     * "opt-in via env until proven safe" convention used by useTempr
+     * and enableGoalDrift.
+     */
+    readonly enablePromptCacheWarmup?: boolean;
+    /**
+     * P1-B7: optional provider the runtime hands back from
+     * `getTodoProvider()` when a caller wants a session-level default.
+     * When unset `getTodoProvider()` returns `NullTodoProvider` so
+     * default sessions pay zero FS cost.
+     */
+    readonly todoProvider?: TodoProvider;
+    /**
+     * Tier-A release hygiene (rc.2): flip the KG auto-populate gate for
+     * session-ingestion. When true, the SessionEnd hook passes
+     * `{ autoPopulateKG: true, populator: memoryStore }` to
+     * `ingestSession`, which then derives entities + heuristic
+     * relationships from observations and inserts them via
+     * `MemoryStore.recordEntity` / `recordHeuristicRelationship`. When
+     * false (default) the ingest pipeline returns zero KG counts and
+     * the flow is a no-op. Defaults to
+     * `process.env.WOTANN_AUTO_POPULATE_KG === "1"` so the existing
+     * free-tier behavior is unchanged — the flag is opt-in until the
+     * classifier's false-positive rate is characterized against the
+     * full MemoryStore corpus.
+     */
+    readonly autoPopulateKG?: boolean;
+    /**
+     * Tier-D1 (rc.2 follow-up): construct the OMEGA 3-layer memory
+     * facade on top of the existing MemoryStore. When enabled,
+     * `getOmegaLayers()` returns a lazily-built `OmegaLayers` instance
+     * whose `layer1/layer2/layer3` read/write the existing auto_capture,
+     * memory_entries/knowledge_nodes/knowledge_edges, and memory_summaries
+     * tables respectively. Composing this facade is zero-cost when off;
+     * the table DDL runs only on first construction. Defaults to
+     * `process.env.WOTANN_OMEGA_LAYERS === "1"` so the default code path
+     * stays unchanged — retrieval modes like summary-first can opt in
+     * when they need L3 compressed summaries, without forcing every
+     * session to run the L3 DDL.
+     */
+    readonly enableOmegaLayers?: boolean;
+}
+export interface RuntimeStatus {
+    readonly providers: readonly ProviderName[];
+    readonly activeProvider: ProviderName | null;
+    /** Last model id used by the active provider, when known. Empty
+     *  string when nothing has been routed through the runtime yet. */
+    readonly activeModel: string;
+    readonly hookCount: number;
+    readonly middlewareLayers: number;
+    readonly memoryEnabled: boolean;
+    readonly sessionId: string;
+    readonly totalTokens: number;
+    readonly totalCost: number;
+    readonly currentMode: WotannMode;
+    readonly traceEntries: number;
+    readonly semanticIndexSize: number;
+    readonly skillCount: number;
+    readonly contextPercent: number;
+    readonly messageCount: number;
+}
+export declare class WotannRuntime {
+    private infra;
+    /**
+     * Wave 4-W: per-provider billing model captured at discovery time so
+     * the cost-tracker `record()` call site can decide whether to skip
+     * the per-token charge for subscription-billed providers (Claude
+     * Pro/Max via OAuth, GitHub Copilot, etc.). Populated alongside
+     * `this.infra` from the discovered `ProviderAuth` array; left empty
+     * when no providers have been discovered yet (record() falls through
+     * to charge per-token, the safer default per QB #6).
+     *
+     * Map shape: ProviderName → "subscription" | "api-key" | "free".
+     * Read by the single call site at runtime.ts:~4212 via
+     * `shouldZeroForSubscription(provider, this.providerBilling.get(provider))`.
+     */
+    private readonly providerBilling;
+    private hookEngine;
+    private doomLoop;
+    private pipeline;
+    private costTracker;
+    /**
+     * Wave 4G: per-session tool-timing persistence. Every dispatched tool
+     * writes one JSONL row to `.wotann/tool-timing.jsonl` so post-session
+     * analysis can detect regressions and flag outliers. Baseline tracker
+     * is shared with the dispatcher so logged entries include the rolling
+     * median for context.
+     */
+    private toolTimingBaseline;
+    private toolTimingLogger;
+    private amplifier;
+    private reasoningSandwich;
+    private traceAnalyzer;
+    private modeCycler;
+    private accountPool;
+    private semanticIndex;
+    private quantizedVectorStore;
+    private contextIntelligence;
+    private editTracker;
+    private sessionAnalytics;
+    private skillRegistry;
+    private ttsrEngine;
+    private qmdContext;
+    private modelPerformanceStore;
+    private pluginPanels;
+    private memoryStore;
+    /**
+     * Round 8: cross-surface prompt library. Lives in the same .wotann
+     * state dir as memory.db so users can back up both with one tar.
+     * `null` until the SQLite handle opens — the daemon-side `snippet.*`
+     * RPCs return "SnippetStore not available" until then. Never throws
+     * at constructor time so a corrupt prior db doesn't kill the daemon.
+     */
+    private snippetStore;
+    private session;
+    /**
+     * F9: O(1) message lookup. Updated alongside `this.session.messages` so
+     * callers can retrieve by `id` without scanning the full history.
+     * Only messages that have an `id` field are indexed.
+     */
+    private readonly messageIndex;
+    private config;
+    private systemPrompt;
+    private localContextPrompt;
+    /**
+     * P1-B1 per-session bootstrap cache. One instance per runtime; the
+     * snapshot is captured lazily on the first session-start and frozen
+     * for the session lifetime. See src/core/bootstrap-snapshot.ts.
+     */
+    private readonly bootstrapCache;
+    private bootstrapPrompt;
+    private recentErrors;
+    private isFirstTurn;
+    /**
+     * Per-session message queue for user input typed while a model turn
+     * is mid-stream. The TUI input handler enqueues; we drain on every
+     * `query()` call and prepend the pending messages onto the next
+     * conversation context, so the model sees them as fresh user turns
+     * BEFORE the current prompt — matching open-swe's middleware ordering
+     * (queued = older, current = newer).
+     *
+     * Default-constructed so the runtime is always safe to drain from
+     * even if the embedder never wires a queue. When the TUI passes its
+     * own MessageQueue via {@link setMessageQueue}, we swap to that
+     * instance so the visual indicator and the runtime drain share state.
+     *
+     * Per-instance per QB#7 — never module-global.
+     */
+    private messageQueue;
+    private accuracyBooster;
+    private contextRelevanceScorer;
+    private responseValidator;
+    private responseCache;
+    private sessionStore;
+    private fileFreezer;
+    private secretScanner;
+    private proactiveMemory;
+    private activeMemory;
+    /**
+     * Observer — Mastra-style async per-turn fact extractor. Runs
+     * AFTER each turn completes, feeding observations into a
+     * per-session buffer. Drained by the Reflector or at session end.
+     * Never blocks the main query loop.
+     */
+    private observer;
+    /**
+     * Reflector — LLM-judge promotion/demotion of Observer's buffered
+     * observations. Nullable until `enableReflector(judge)` wires a
+     * provider-specific judge callback. Deliberately opt-in: the
+     * Reflector costs one LLM call per reflection cycle, so consumers
+     * must decide when the budget is worth it.
+     */
+    private reflector;
+    private branchManager;
+    private crossSessionLearner;
+    private capabilityEqualizer;
+    private pluginLifecycle;
+    private sessionRecorder;
+    private shadowGit;
+    private canvasEditor;
+    private currentEpisodeId;
+    private diffEngine;
+    private credentialPool;
+    private episodicMemory;
+    private autonomousExecutor;
+    private notificationManager;
+    private contextInspector;
+    private personaManager;
+    private selfHealingPipeline;
+    private lspManager;
+    private symbolOperations;
+    private dispatchPlane;
+    private arenaLeaderboard;
+    private councilLeaderboard;
+    private piiRedactor;
+    private vectorStore;
+    private hybridSearch;
+    private rulesOfEngagement;
+    private trainingPipeline;
+    private activeROESessionId;
+    private autonomousContextManager;
+    private contextShardManager;
+    private turboQuantEngine;
+    private virtualContextManager;
+    private conversationTree;
+    private commandHistory;
+    private knowledgeGraph;
+    private contextTree;
+    private cloudSyncEngine;
+    private skillForge;
+    private instinctSystem;
+    private skillsGuard;
+    private virtualPathResolver;
+    private configDiscovery;
+    private vibeVoiceBackend;
+    private promptEnhancerEngine;
+    private autoresearchEngine;
+    private taskDelegationManager;
+    private autoClassifier;
+    private intentVerifier;
+    private autoVerifier;
+    private imageGenRouter;
+    private readonly webFetchTool;
+    private planStore;
+    private autoReviewer;
+    private bugBot;
+    private providerArbitrage;
+    private errorPatternLearner;
+    private predictiveContext;
+    private deepResearch;
+    private autoModeDetector;
+    private codemapBuilder;
+    private trajectoryScorer;
+    private microEvalRunner;
+    private smartRetry;
+    private forgeDoomLoop;
+    private autoEnhancer;
+    private crossDeviceContext;
+    private aiTimeMachine;
+    private userModelManager;
+    private verificationCascade;
+    private wallClockBudget;
+    private agentRegistryInstance;
+    private preCompletionVerifier;
+    private progressiveBudget;
+    /**
+     * Tier-D1 OMEGA 3-layer memory facade. Lazily constructed on first
+     * getOmegaLayers() call when the gate is enabled AND memoryStore is
+     * present. The facade is a read/write view over the store; zero
+     * allocation when gated off.
+     */
+    private omegaLayers;
+    /**
+     * B7 goal-drift (OpenHands port, P1-B7). Lazily constructed on
+     * first getGoalDriftDetector() call when the gate is enabled.
+     * Null when the config flag + env var are both disabled —
+     * zero-overhead, zero-allocation when off.
+     */
+    private goalDriftDetector;
+    /**
+     * B4 recursion guard. The PreCompletionVerifier's LlmQuery is bound
+     * to `this.query()`, so if the post-turn verify-invoker calls
+     * verifier.verify() unguarded, each of the 4 perspective calls would
+     * recursively trigger another verify cycle → infinite loop. This
+     * flag is set inside finalizePreCompletionVerify and cleared in the
+     * finally; nested query() calls observe it as "verify already in
+     * progress, skip". Not module-global: per-runtime-instance.
+     */
+    private insidePreCompletionVerify;
+    private flowTracker;
+    private idleDetector;
+    private decisionLedger;
+    private taskRouter;
+    private parallelSearch;
+    private confirmAction;
+    private agentHierarchy;
+    private agentWorkspace;
+    private contextFence;
+    private retrievalQuality;
+    private contextLoader;
+    private observationExtractor;
+    private tunnelDetector;
+    private conversationMiner;
+    private adaptivePrompts;
+    private nightlyConsolidator;
+    private benchmarkHarness;
+    private progressiveLoader;
+    private runSessionIngestion;
+    private readonly guardianEnabled;
+    private readonly contextualAbstentionEnabled;
+    private readonly progressiveTier;
+    private verifierEngine;
+    private readonly verifierEnabled;
+    private readonly verifierHistory;
+    private static readonly VERIFIER_HISTORY_CAP;
+    private lspRegistry;
+    private lspAgentTools;
+    private readonly lspAgentToolsEnabled;
+    private mcpTools;
+    private mcpTier;
+    private diffTheater;
+    private readonly hybridV2Enabled;
+    private readonly virtualPathsEnabled;
+    private readonly sandboxVirtualPathConfig;
+    private providerBrain;
+    private readonly reflectionBuffer;
+    private readonly toolPatternDetector;
+    private searchProvider;
+    private claudeBridge;
+    /**
+     * Dual-terminal steering — when `WOTANN_STEERING=1` (or
+     * `config.enableSteering`), the runtime allocates a SteeringServer bound
+     * to `.wotann/steering/` and starts watching for commands from a second
+     * terminal. Commands (reprioritize / pause / resume / abort / change-model
+     * / add-constraint / add-context) are captured into `steeringCommands`
+     * for autonomous phases to consult. Null when disabled — opt-in by
+     * design so the file-watcher doesn't hold fds for short-lived queries.
+     */
+    private steeringServer;
+    private readonly steeringCommands;
+    /**
+     * Unified Knowledge Fabric — single-API search across MemoryStore +
+     * ContextTree + (future) graph-RAG / semantic / vector / FTS5 sources.
+     * Constructed eagerly in the constructor; retrievers register lazily
+     * once the subsystems they adapt are ready (post-initialize).
+     */
+    private readonly knowledgeFabric;
+    /**
+     * Context Tree (ByteRover-inspired): persistent markdown knowledge in
+     * `.wotann/context-tree/{resources,user,agent}/*.md`. Instance is
+     * allocated in initialize() once `workingDir` is validated; null until
+     * then so a pre-init close() doesn't touch the filesystem.
+     */
+    private contextTreeManager;
+    constructor(config: RuntimeConfig);
+    /** Get the image generation router for multi-provider image routing. */
+    getImageGenRouter(): ImageGenRouter;
+    /**
+     * Session-13: tiered MCP tool surface for the active runtime.
+     * Defaults to "core" (7 tools). Set `WOTANN_MCP_TIER=standard` for 14
+     * tools or `WOTANN_MCP_TIER=all` for the full 42+ surface (trades ~7k
+     * tokens for completeness). Empty array if the resolver failed.
+     */
+    getMcpTools(): readonly LoadToolsResult["tools"][number][];
+    /** Session-13: currently-resolved MCP tier, or null if resolver failed. */
+    getMcpTier(): McpTier | null;
+    /**
+     * Session-13: per-session Visual Diff Theater for hunk-level review.
+     * Consumers (CLI `wotann review`, iOS diff viewer) read sessions,
+     * accept/reject hunks, and apply.
+     */
+    getDiffTheater(): VisualDiffTheater | null;
+    /**
+     * Session-13 OpenAI agents-python parity: perform a full agent
+     * handoff. Runs the input filter (or default nested-history filter)
+     * and returns the HandoffResult — caller uses `downstreamInput` to
+     * start the next agent's turn. Called externally by
+     * `orchestration/agent-registry.ts`.
+     *
+     * Honest: throws on from===to per performHandoff() invariant; never
+     * fabricates a success.
+     */
+    performAgentHandoff(from: AgentId, to: AgentId, handoff: Handoff, data: HandoffInputData): Promise<HandoffResult>;
+    /**
+     * Session-13: access the ProviderBrain for learning-based routing.
+     * Returns null if the brain failed to initialise. Callers use
+     * `brain.route()` before dispatch and `recordProviderResponse()` after.
+     */
+    getProviderBrain(): ProviderBrain | null;
+    /**
+     * Session-13: record a provider response into the ProviderBrain so
+     * subsequent `route()` calls can favour healthier providers. No-op
+     * when the brain is unavailable.
+     */
+    recordProviderResponse(opts: {
+        readonly provider: ProviderName;
+        readonly durationMs: number;
+        readonly success: boolean;
+        readonly cost: number;
+    }): void;
+    /**
+     * Session-13: capture a file edit and push into a Visual Diff Theater
+     * session so the user can review hunks before a final merge. Reads
+     * current on-disk content for the `oldContent` side (empty string if
+     * the file is new). Honest: a missing file leaves `oldContent` empty
+     * rather than throwing. No-op when the theater is unavailable.
+     */
+    captureFileEditForDiff(filePath: string, newContent: string): void;
+    /** Get the cost tracker (daily/weekly/monthly aggregates + recording). */
+    getCostTracker(): CostTracker;
+    /**
+     * Read the current runtime mode name. Paired with the existing
+     * setMode() below — added so the daemon's mode.set RPC can echo the
+     * new mode back to the caller (S2-24).
+     */
+    getModeName(): WotannMode;
+    /**
+     * Initialize the runtime — discover providers, gather local context,
+     * assemble system prompt. Must be called before querying.
+     */
+    initialize(): Promise<void>;
+    /** Pending context to prepend to the next query()'s user prompt. */
+    private pendingContextPrefix;
+    /**
+     * Query the agent with full harness intelligence applied.
+     *
+     * EXECUTION ORDER:
+     * 1. Safety override check (guardrails-off mode?)
+     * 2. WASM bypass check (skip LLM for deterministic operations)
+     * 3. Hook engine: UserPromptSubmit
+     * 4. Middleware pipeline: before (all 16 layers)
+     * 5. DoomLoop check
+     * 6. Intelligence amplification (planning, verification, tool correction)
+     * 7. Reasoning sandwich (asymmetric budget: HIGH plan → LOW exec → HIGH verify)
+     * 8. Provider query via AgentBridge (with fallback chain)
+     * 9. Trace recording
+     * 10. Post-query hooks + middleware
+     * 11. Memory capture (SQLite + semantic index)
+     * 12. Cost tracking + session update
+     */
+    query(options: WotannQueryOptions): AsyncGenerator<StreamChunk>;
+    /**
+     * Enable the Reflector with a provider-specific LLM judge. Until
+     * this is called, the Observer still runs per-turn (feeding the
+     * `working` layer) but no promotion to `core_blocks` happens.
+     *
+     * The judge is intentionally caller-provided so the Reflector
+     * stays provider-agnostic. Use `buildJudgeFromLlm` from
+     * `src/memory/reflector.ts` for a default implementation.
+     */
+    enableReflector(judge: ReflectorJudge, reflectEveryNTurns?: number): void;
+    /**
+     * Disable the Reflector. The Observer continues to run.
+     * Idempotent.
+     */
+    disableReflector(): void;
+    /** Expose the Observer for tests and advanced consumers. */
+    getObserver(): Observer;
+    /** Expose the Reflector (nullable when not wired) for introspection. */
+    getReflector(): Reflector | null;
+    /**
+     * Switch to a different mode. Updates system prompt and safety overrides.
+     */
+    setMode(mode: WotannMode): void;
+    /**
+     * Cycle to the next mode.
+     */
+    cycleMode(): WotannMode;
+    /**
+     * Get the current mode name.
+     */
+    getCurrentMode(): WotannMode;
+    private updateSystemPromptForMode;
+    /**
+     * V9 T1.5 wire — fires the warmupCache() call against the active
+     * provider so the first real query lands on a warm server-side
+     * cache. Kept as a separate method so the hot `updateSystemPromptForMode`
+     * path stays readable and the warmup gate + sendFn construction live
+     * next to each other.
+     *
+     * Gate (opt-in): `RuntimeConfig.enablePromptCacheWarmup === true`
+     *   OR `process.env.WOTANN_PROMPT_CACHE_WARMUP` ∈ {"1", "true"}.
+     * A value of `"0"` or `"false"` always disables even if config says true.
+     *
+     * Non-fatal: returns immediately on any error. warmupCache() already
+     * has internal try/catch per-prefix; this wrapper adds a second layer
+     * so a missing provider bridge or transient network issue never
+     * surfaces as a mode-switch failure.
+     */
+    private maybeWarmupPromptCache;
+    private applySafetyOverrides;
+    private refreshContextTelemetry;
+    /**
+     * Session-13 Supermemory-parity: BM25+dense+RRF v2 retriever. Runs
+     * synchronously-like by blocking on a pure-BM25 retriever (no embed
+     * function) and merging with the legacy hybrid results. Returns []
+     * when the memory store is empty. Honest: caller sees empty instead
+     * of fabricated hits.
+     */
+    private searchMemoryHybridV2;
+    /**
+     * Session-13: async variant of searchMemory that routes through
+     * hybrid-v2 when enabled. Exposed for callers that can await (skills,
+     * iOS, desktop). The sync `searchMemory` stays on the legacy path for
+     * call sites like middleware that can't await.
+     */
+    searchMemoryV2Async(query: string): Promise<readonly {
+        id: string;
+        score: number;
+        text: string;
+        type: string;
+    }[]>;
+    /**
+     * Search memory using hybrid search (RRF fusion of FTS5 keyword + vector similarity).
+     */
+    searchMemory(query: string): readonly {
+        id: string;
+        score: number;
+        text: string;
+        type: string;
+    }[];
+    /**
+     * Get the trace analysis for the current session.
+     */
+    getTraceAnalysis(): import("../intelligence/trace-analyzer.js").TraceAnalysis;
+    getStatus(): RuntimeStatus;
+    /**
+     * Get context pressure and budget from the context window intelligence module.
+     */
+    getContextBudget(): import("../context/window-intelligence.js").ContextBudget;
+    getContextCapabilityProfile(): ContextCapabilityProfile;
+    /**
+     * Get session analytics summary.
+     */
+    getAnalyticsSummary(): string;
+    /**
+     * Get the skill registry (for querying available skills).
+     */
+    getSkillRegistry(): SkillRegistry;
+    /**
+     * Get the auto-classifier for tool call security classification.
+     */
+    getAutoClassifier(): AutoClassifier;
+    /**
+     * Get the intent verifier for drift detection.
+     */
+    getIntentVerifier(): IntentVerifier;
+    /**
+     * Get the auto-verifier for post-edit verification.
+     */
+    getAutoVerifier(): AutoVerifier;
+    /**
+     * rc.2 follow-up: get (or lazily construct) the PreCompletionVerifier
+     * instance (B4 — ForgeCode 4-persona review). Returns null when
+     * `enablePreCompletionVerify` is disabled (default). Callers should
+     * treat null as "feature off" rather than an error.
+     *
+     * Each call returns the SAME instance so runCount statistics
+     * accumulate within one session. Construction binds the verifier's
+     * LlmQuery to `runtime.query()` so reviews execute on whichever
+     * provider is currently active.
+     */
+    getPreCompletionVerifier(): PreCompletionVerifier | null;
+    /**
+     * rc.2 follow-up: get (or lazily construct) the ProgressiveBudget
+     * instance (B12 — escalating LOW→MEDIUM→MAX budget for verify-loops).
+     * Returns null when `enableProgressiveBudget` is disabled (default).
+     * Callers should treat null as "feature off" rather than an error.
+     *
+     * The returned scheduler is safe to share across sessions — per-
+     * session isolation is handled via the `sessionId` parameter on
+     * `nextPass()` / `wrap()` / `reset()`.
+     */
+    getProgressiveBudget(): ProgressiveBudget | null;
+    /**
+     * Tier-D1 OMEGA 3-layer memory facade. Lazily constructed on first
+     * `getOmegaLayers()` call when the gate is enabled AND a MemoryStore
+     * is present (the facade is a read/write view over the store, so it
+     * can't exist without one). Returns null when disabled, or when
+     * memoryStore is null (free-tier / memoryless mode).
+     *
+     * Composition is zero-cost when off. On first construction, the L3
+     * DDL (`memory_summaries` table creation) runs idempotently against
+     * the store's underlying sqlite handle.
+     *
+     * Gate chain:
+     *   config.enableOmegaLayers === true → always on
+     *   config.enableOmegaLayers === undefined → env WOTANN_OMEGA_LAYERS=1
+     *   config.enableOmegaLayers === false → always off (overrides env)
+     */
+    getOmegaLayers(): OmegaLayers | null;
+    /**
+     * P1-B7 goal-drift (OpenHands port, part 3).
+     *
+     * Returns a lazily-constructed GoalDriftDetector when the gate is
+     * enabled, or null when it's off. Gate chain:
+     *   - `config.enableGoalDrift === true` → enabled
+     *   - `process.env.WOTANN_GOAL_DRIFT === "1"` → enabled (when config
+     *      flag is undefined)
+     *   - otherwise → disabled, return null
+     *
+     * The detector is provider-agnostic: it takes a TodoState and a
+     * list of AgentActions and scores relevance. Callers wiring it into
+     * the autonomous loop supply their own `TodoProvider` via the
+     * `AutonomousExecutor.execute` `goalDrift` callback. The runtime
+     * does NOT couple the detector to a provider here — a single
+     * runtime may serve many tasks, each with its own provider.
+     *
+     * QB #14 real wiring: the getter returns a singleton per-runtime,
+     * not a module-global, so two runtimes never share drift state.
+     * QB #6 honest failure: returns `null` (not a no-op detector) when
+     * the feature is off so callers can detect the gate state.
+     */
+    getGoalDriftDetector(): GoalDriftDetector | null;
+    /**
+     * P1-B7 goal-drift: resolve the TodoProvider for drift-detector
+     * use. Defaults to NullTodoProvider (empty-todo stub) when no
+     * session-level provider has been configured. Callers that need
+     * a real FS-backed feed should either supply one on
+     * `RuntimeConfig.todoProvider` or build one at the call site via
+     * `createFsTodoProvider`.
+     */
+    getTodoProvider(): TodoProvider;
+    /**
+     * M4 + M6 wire: resolve the recall options used by active-memory
+     * pre-processing. Config overrides env vars; unset on both paths
+     * means default FTS5. TEMPR takes precedence over recallMode when
+     * both are set (gate symmetry — TEMPR is a heavier hybrid so its
+     * intent signal is stronger than a single retrieval mode).
+     */
+    private resolveRecallOptions;
+    /**
+     * B4 + B12 post-turn wire. Runs the 4-persona review after the turn
+     * finalizes the assistant message, with optional progressive-budget
+     * retry when B12 is also enabled.
+     *
+     * Returns:
+     *   - `null` when B4 is disabled (fast-path: no verifier allocated).
+     *   - A `VerificationReport` otherwise. The caller inspects `.status`
+     *     to decide whether to surface a blocking error.
+     *
+     * Recursion safety: this method sets `insidePreCompletionVerify` so
+     * nested `this.query()` calls inside perspective prompts observe the
+     * guard and skip re-verifying. The flag is cleared in the `finally`
+     * block even on exception.
+     */
+    private finalizePreCompletionVerify;
+    /**
+     * Get the per-file edit tracker (for benchmark engineering).
+     */
+    getEditTracker(): PerFileEditTracker;
+    private permissionMode;
+    getPermissionMode(): "auto-approve" | "ask-always" | "smart";
+    setPermissionMode(mode: "auto-approve" | "ask-always" | "smart"): void;
+    manualCompact(): ConversationCompactionResult;
+    private thinkingEffort;
+    setThinkingEffort(effort: ThinkingEffort): void;
+    getThinkingEffort(): ThinkingEffort;
+    /**
+     * Wire a TUI-owned MessageQueue into the runtime. Call this once on
+     * mount; the same instance is then used by the TUI's `enqueue` path
+     * (when the user types mid-stream) AND the runtime's `query()`
+     * drain — so the visual indicator stays in sync with the model
+     * input. See `src/core/message-queue.ts` for the schema.
+     *
+     * Inspired by langchain-ai/open-swe
+     * agent/middleware/check_message_queue.py — same pattern, but the
+     * queue is in-memory and per-runtime instead of a thread-keyed store.
+     */
+    setMessageQueue(queue: MessageQueue): void;
+    getMessageQueue(): MessageQueue;
+    setMaxContextTokens(tokens: number): void;
+    getMaxContextTokens(): number;
+    getAccountPool(): AccountPool;
+    restoreSession(session: SessionState): void;
+    saveCurrentSession(): string | null;
+    getSession(): SessionState;
+    getConversationHistory(): readonly AgentMessage[];
+    /**
+     * F9: O(1) lookup by message ID. Returns undefined when the ID is not
+     * in the index (either because the message has no ID or it has been
+     * compacted out of history).
+     */
+    getMessageById(id: string): AgentMessage | undefined;
+    /**
+     * Rebuild the message index from the current session messages. Called at
+     * every mutation point that replaces `this.session.messages` so the index
+     * never diverges from the array. Inexpensive for typical conversation
+     * sizes and avoids the need to reason about partial updates.
+     */
+    private syncMessageIndex;
+    getWorkingDir(): string;
+    getPluginPanels(): readonly string[];
+    getFileFreezer(): FileFreezer;
+    getSecretScanner(): SecretScanner;
+    getProactiveMemory(): ProactiveMemoryEngine;
+    getBranchManager(): ConversationBranchManager;
+    getCrossSessionLearner(): CrossSessionLearner;
+    getCapabilityEqualizer(): CapabilityEqualizer;
+    getPluginLifecycle(): PluginLifecycle;
+    getSessionRecorder(): SessionRecorder;
+    getShadowGit(): ShadowGit;
+    getMemoryStore(): MemoryStore | null;
+    /**
+     * Round 8: expose the runtime's SnippetStore over a public getter
+     * so the daemon RPC layer can drive the cross-surface prompt
+     * library. Returns null when the daemon failed to open the SQLite
+     * handle (e.g. on a corrupt prior db).
+     */
+    getSnippetStore(): SnippetStore | null;
+    /**
+     * Round 7: expose the runtime's HookEngine over a public getter
+     * so the daemon RPC layer (kairos-rpc.ts hooks.list / hooks.setEnabled)
+     * can drive the engine. Previously the field was private with no
+     * accessor, leaving `hooks.*` RPC unable to compile.
+     */
+    getHookEngine(): HookEngine;
+    /**
+     * Fire ToolResultReceived for a runtime-handled tool's raw output,
+     * BEFORE the result is yielded to the agent's next-turn context.
+     * Returns the (possibly sanitised) content; if the hook blocked,
+     * content is replaced with a sanitised error notice so callers can
+     * yield a safe placeholder instead of the injection-laced output.
+     *
+     * Session-5 architectural fix: the prior ResultInjectionScanner
+     * fired on PostToolUse with `content: fullContent` (the agent's
+     * response text). By then the injection had already entered the
+     * model's context. ToolResultReceived fires at the tool-dispatch
+     * level so the scanner gates the raw result before the model sees it.
+     */
+    private fireToolResultReceivedHook;
+    getCanvasEditor(): CanvasEditor;
+    getDiffEngine(): typeof DiffEngine;
+    getCredentialPool(): CredentialPool;
+    getEpisodicMemory(): EpisodicMemory;
+    getAutonomousExecutor(): AutonomousExecutor;
+    getNotificationManager(): NotificationManager;
+    getContextInspector(): ContextSourceInspector;
+    getPersonaManager(): PersonaManager;
+    getSelfHealingPipeline(): SelfHealingPipeline;
+    getLspManager(): LSPManager;
+    getDispatchPlane(): UnifiedDispatchPlane;
+    getArenaLeaderboard(): ArenaLeaderboard;
+    getPIIRedactor(): PIIRedactor;
+    getVectorStore(): VectorStore;
+    /**
+     * Round 63 turn-9: snapshot of recent verifier verdicts (FIFO order,
+     * oldest first). Empty when verifier is disabled or hasn't fired yet.
+     * Read-only; mutating the returned array doesn't affect the buffer.
+     */
+    getVerifierHistory(): readonly import("../verification/types.js").AggregateVerdict[];
+    /** Most-recent verifier verdict, or null when no verdict has fired. */
+    getLastVerifierVerdict(): import("../verification/types.js").AggregateVerdict | null;
+    /** True when the verifier engine is enabled (config or env). */
+    isVerifierEnabled(): boolean;
+    getHybridSearch(): HybridMemorySearch;
+    getRulesOfEngagement(): RulesOfEngagement;
+    getTrainingPipeline(): TrainingPipeline;
+    /**
+     * Session-6 (GAP-11): expose the optional QuantizedVectorStore so
+     * RPC handlers (memory.search-enhanced) and tests can reach it.
+     * Returns null when the opt-in env flag is off, signalling callers to
+     * fall back to semanticIndex.search().
+     */
+    getQuantizedVectorStore(): QuantizedVectorStore | null;
+    getActiveROESessionId(): string | undefined;
+    setActiveROESessionId(id: string | undefined): void;
+    getAutonomousContextManager(): AutonomousContextManager;
+    getContextShardManager(): ContextShardManager;
+    getTurboQuantEngine(): TurboQuantEngine;
+    getVirtualContextManager(): VirtualContextManager;
+    getConversationTree(): ConversationTree;
+    getCommandHistory(): CommandHistory;
+    getKnowledgeGraph(): KnowledgeGraph;
+    /**
+     * Path where the KG snapshot lives. Located under the workspace's wotann
+     * dir so per-project graphs stay isolated.
+     */
+    private knowledgeGraphPath;
+    /**
+     * Rehydrate the knowledge graph from disk on boot. Best-effort — missing
+     * or malformed file leaves the empty graph in place. Audit fix for the
+     * session 9 finding "KnowledgeGraph is RAM-only; SQLite knowledge_nodes
+     * tables are orphan; every restart loses the graph."
+     */
+    private rehydrateKnowledgeGraph;
+    /**
+     * Persist the knowledge graph to disk. Called on close() and any explicit
+     * checkpoint (e.g. before a destructive compaction). Idempotent; writes
+     * through a temp file + rename for atomicity.
+     *
+     * Phase B Bug #2 fix: the previous implementation leaked `.tmp.*` files
+     * into `.wotann/` every time the write failed mid-rename (crash, disk
+     * full, EACCES). We now wrap the write in try/finally and unlink the
+     * temp on ANY error so we don't accumulate dozens of orphan .tmp.*
+     * files across daemon restarts.
+     */
+    persistKnowledgeGraph(): Promise<void>;
+    getContextTreeView(): ContextTree;
+    getCloudSyncEngine(): CloudSyncEngine;
+    getSkillForge(): SkillForge;
+    getInstinctSystem(): InstinctSystem;
+    getSkillsGuard(): SkillsGuard;
+    getVirtualPathResolver(): VirtualPathResolver;
+    getConfigDiscovery(): ConfigDiscovery;
+    getVibeVoiceBackend(): VibeVoiceBackend;
+    getPromptEnhancerEngine(): PromptEnhancer;
+    getAutoresearchEngine(): AutoresearchEngine;
+    /**
+     * Verifier-gated task completion (Phase 4 Tier-1 unlock).
+     *
+     * Wraps the CompletionOracle with runtime-supplied callbacks:
+     *   - llmJudge routes through this.query so the judge runs on whatever
+     *     provider the runtime is currently bound to
+     *   - runCommand + captureScreenshot are left undefined so the oracle
+     *     falls back to its built-in sandboxed execFileSync and native
+     *     screencapture(1) paths
+     *
+     * Callers pass a task description and either explicit criteria or a
+     * taskType for sensible defaults (code|ui|docs|test). Returns the
+     * weighted completion score, a completed flag, and per-criterion
+     * evidence — ready to feed into autopilot loop control or
+     * benchmark-runner pass/fail gating.
+     */
+    verifyCompletion(task: string, options?: {
+        criteria?: readonly CompletionCriterion[];
+        taskType?: "code" | "ui" | "docs" | "test";
+        threshold?: number;
+        /**
+         * When supplied, verifyCompletion skips the expensive re-run path
+         * (tests, lint, typecheck) and delegates to
+         * `evaluateCompletionFromEvidence` which just scores the existing
+         * evidence. Use when the caller already ran the tests as part of
+         * task execution — avoids duplicate test runs.
+         */
+        preCollectedEvidence?: readonly VerificationEvidence[];
+    }): Promise<{
+        completed: boolean;
+        score: number;
+        evidence: readonly VerificationEvidence[];
+    }>;
+    getTaskDelegationManager(): TaskDelegationManager;
+    getAutoReviewer(): AutoReviewer;
+    getBugBot(): BugBot;
+    getProviderArbitrage(): ProviderArbitrageEngine;
+    getErrorPatternLearner(): ErrorPatternLearner;
+    getPredictiveContext(): PredictiveContextLoader;
+    getAutoEnhancer(): AutoEnhancer;
+    getCrossDeviceContext(): CrossDeviceContextManager;
+    getAITimeMachine(): AITimeMachine;
+    getUserModelManager(): UserModelManager;
+    getVerificationCascade(): VerificationCascade;
+    getWallClockBudget(): WallClockBudget;
+    getAgentRegistry(): AgentRegistry;
+    getFlowTracker(): FlowTracker;
+    getIdleDetector(): IdleDetector;
+    getDecisionLedger(): DecisionLedger;
+    /** Run codebase health analysis and return a 0-100 score with diagnostics. */
+    analyzeHealth(directory?: string): Promise<ReturnType<typeof analyzeCodebaseHealth>>;
+    /**
+     * Record an architectural or design decision with rationale.
+     * Persists to both the DecisionLedger (in-memory, serializable) and
+     * the MemoryStore decision_log table (SQLite, durable).
+     */
+    recordDecision(input: DecisionInput): string;
+    /** Get the FlowTracker's current insights about user intent. */
+    getFlowInsights(): readonly import("../intelligence/flow-tracker.js").FlowInsight[];
+    /** Check if user is idle and get away summary if so. */
+    getAwaySummary(): boolean;
+    getTaskRouter(): TaskSemanticRouter;
+    getParallelSearch(): ParallelSearchDispatcher;
+    getConfirmAction(): ConfirmActionGate;
+    getAgentHierarchy(): AgentHierarchyManager;
+    getAgentWorkspace(): AgentWorkspace;
+    getContextFence(): ContextFence;
+    getRetrievalQuality(): RetrievalQualityScorer;
+    getContextLoader(): ContextLoader;
+    getObservationExtractor(): ObservationExtractor;
+    /**
+     * Drive one consolidation pass over auto_capture. Intended to be called
+     * from the daemon heartbeat so structured memory_entries are produced
+     * even when no user queries are running. Phase B Bug #1 fix.
+     *
+     * Safe to call on an empty queue — returns a zero-valued report.
+     * @returns the consolidation report, or null if no memoryStore exists.
+     */
+    consolidateObservations(batchSize?: number): {
+        readonly read: number;
+        readonly routed: number;
+        readonly classificationFailed: number;
+        readonly decisionLogged: number;
+        readonly byBlock: Readonly<Record<string, number>>;
+    } | null;
+    /**
+     * Phase 13 Wave-3C — async companion to consolidateObservations.
+     * Runs relationship classification on newly extracted observations and
+     * persists the edges via the store's addRelationships method (when
+     * available). Honest logger.warn on failure; never silently swallows.
+     */
+    private classifyAndPersistRelationships;
+    getTunnelDetector(): TunnelDetector;
+    getConversationMiner(): ConversationMiner | null;
+    getAdaptivePrompts(): AdaptivePromptGenerator;
+    getNightlyConsolidator(): NightlyConsolidator;
+    getBenchmarkHarness(): BenchmarkHarness;
+    /**
+     * Classify a prompt and get the recommended model using task-semantic routing.
+     * This is an ACTIVE integration — called to optimize model selection.
+     */
+    classifyAndRoute(prompt: string): {
+        taskType: string;
+        complexity: string;
+        recommendedModel: string;
+    };
+    /**
+     * Run parallel search across all available sources.
+     * ACTIVE integration — used by research mode and agent tools.
+     */
+    searchAll(query: string): Promise<{
+        results: readonly {
+            source: string;
+            title: string;
+            content: string;
+            score: number;
+        }[];
+        durationMs: number;
+    }>;
+    /**
+     * Check if a tool action requires user confirmation before execution.
+     * ACTIVE integration — called from the tool execution pipeline.
+     */
+    checkActionApproval(toolName: string, args: Record<string, unknown>): {
+        requiresApproval: boolean;
+        risk: string;
+        category: string;
+    };
+    /**
+     * Generate an adaptive system prompt section based on the current model's capabilities.
+     * ACTIVE integration — called during system prompt assembly.
+     */
+    generateAdaptivePromptSection(modelId: string, basePrompt: string): string;
+    /**
+     * Get the progressive context wake-up payload (L0 + L1, ~170 tokens).
+     * ACTIVE integration — called at session start to minimize cold-start cost.
+     */
+    getWakeUpPayload(): {
+        content: string;
+        tokens: number;
+    };
+    /**
+     * Get a spawn configuration for an agent by ID, using the centralized
+     * registry. Returns undefined if the agent ID is not registered.
+     *
+     * Sync variant — delegates to `AgentRegistry#spawn` and does NOT
+     * resolve `required_reading` items. Callers that need the file
+     * contents prepended to the agent's system prompt should prefer
+     * `getAgentSpawnConfigWithContext` which awaits `spawnWithContext`
+     * (the requiredReadingHook path).
+     */
+    getAgentSpawnConfig(agentId: string, task: string): import("../orchestration/agent-registry.js").SpawnConfig | undefined;
+    /**
+     * Async spawn that resolves the agent's `required_reading` items into
+     * a prompt-block prepended to the system prompt via
+     * `AgentRegistry#spawnWithContext` + `requiredReadingHook`. Uses this
+     * runtime's workingDir as the workspace root — the hook honours the
+     * per-item size caps and the optional total budget.
+     *
+     * Closes the "spawnWithContext has 0 external callers" finding from
+     * docs/FINAL_VERIFICATION_AUDIT_2026-04-19.md; the sync `spawn` path
+     * stays available for callers that don't want the hook overhead.
+     */
+    getAgentSpawnConfigWithContext(agentId: string, task: string, options?: {
+        readonly defaultMaxCharsPerFile?: number;
+        readonly totalBudgetChars?: number;
+    }): Promise<import("../orchestration/agent-registry.js").SpawnConfig | undefined>;
+    /**
+     * Fold per-agent YAML overrides into the active registry. Reads
+     * `<workingDir>/.wotann/agents/*.yaml` by default. Specs that reference
+     * unknown agent IDs are silently skipped so a stale spec never blocks
+     * startup.
+     */
+    loadAgentOverrides(directory?: string): Promise<void>;
+    /**
+     * Run wave-based parallel execution: topological grouping by dependency.
+     * Tasks within each wave execute in parallel; waves run sequentially.
+     * Uses TaskDelegationManager to track ownership and results per task.
+     */
+    runWaveExecution(tasks: readonly WaveTask[], executor: (task: WaveTask) => Promise<string>): Promise<ReadonlyMap<string, string>>;
+    /**
+     * Generate a structured plan using ULTRAPLAN prompt engineering.
+     * Builds a planning prompt, parses the response into phases/risks/criteria.
+     */
+    generatePlan(task: string, context?: string): {
+        prompt: string;
+        parse: (response: string) => StructuredPlan;
+    };
+    /**
+     * Plan context budget using the maximizer for optimal allocation.
+     */
+    getMaximizerContextBudget(model: string, provider: string, systemPromptEstimate: number, bootstrapEstimate: number, memoryEstimate: number): MaximizerContextBudget;
+    /**
+     * Replay context: reconstruct the minimum effective context for a task.
+     * Used after compaction or session resume to rebuild focused context.
+     */
+    replayContext(task: TaskContext, budget: ReplayBudget): ReplayResult;
+    /**
+     * Optimize a tool schema for better model accuracy (flatten, sort, add descriptions).
+     */
+    optimizeToolSchema(schema: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Validate and coerce tool call arguments against a schema.
+     */
+    validateToolArgs(args: Record<string, unknown>, schema: Record<string, unknown>): {
+        valid: boolean;
+        corrected: Record<string, unknown>;
+        errors: readonly string[];
+    };
+    /**
+     * Run prompt regression test suite (CI/CD integration for system prompt validation).
+     */
+    runPromptRegressionTests(testCases?: readonly PromptTestCase[]): {
+        suite: readonly PromptTestCase[];
+        runTest: (tc: PromptTestCase, output: string, latencyMs: number) => PromptTestResult;
+        buildReport: (results: readonly PromptTestResult[], durationMs: number) => RegressionReport;
+    };
+    /**
+     * Check all tracked repos for changes since last sync.
+     * Used by both CLI `wotann repos` and TUI `/repos` command.
+     */
+    checkSourceRepos(): MonitorDigest;
+    /**
+     * Update sync state for all tracked repos.
+     */
+    syncSourceRepos(): void;
+    /**
+     * Generate an autonomous proof bundle capturing task, result, and runtime state.
+     */
+    generateProofBundle(task: string, result: AutonomousResult): string;
+    /**
+     * Run a blind arena contest across multiple providers.
+     * Uses the agent bridge to execute queries per provider and returns
+     * contestant results with hidden identities for blind voting.
+     */
+    runArena(prompt: string, providers: readonly ProviderName[]): Promise<readonly ArenaContestant[]>;
+    /**
+     * Run a council deliberation across multiple providers.
+     * Each model answers independently, then peer-reviews other responses,
+     * and a chairman synthesizes the final answer.
+     */
+    runCouncil(query: string, providers: readonly ProviderName[]): Promise<CouncilResult>;
+    /**
+     * Get the council leaderboard for tracking model performance in deliberations.
+     */
+    getCouncilLeaderboard(): CouncilLeaderboard;
+    /**
+     * Apply a hash-anchored edit (safe multi-agent editing).
+     * Unlike string-matching edits, hash edits are immune to whitespace/encoding drift.
+     */
+    applyHashEdit(filePath: string, operation: HashEditOperation): HashEditResult;
+    /**
+     * Compile ambient awareness context for the current workspace.
+     */
+    getAmbientContext(currentFile?: string, completedTask?: string): AmbientContext;
+    runPreCommitAnalysis(): PreCommitAnalysisResult | null;
+    /**
+     * Enhance a prompt using the most capable available model.
+     * Returns the enhanced prompt text and the model used.
+     */
+    enhancePrompt(prompt: string): Promise<{
+        enhancedPrompt: string;
+        model: string;
+    }>;
+    /**
+     * Run a council deliberation across multiple providers.
+     * 3-stage pipeline: individual responses → peer review → chairman synthesis.
+     */
+    runCouncilDeliberation(query: string, providerNames: readonly ProviderName[]): Promise<CouncilResult>;
+    /**
+     * Unified knowledge search — query across all registered retrievers
+     * (MemoryStore FTS5 + ContextTreeManager markdown files, plus whatever
+     * else gets registered in initialize()). Returns deduped, ranked results
+     * with provenance.
+     */
+    searchUnifiedKnowledge(query: string, maxResults?: number, minConfidence?: number): Promise<readonly KnowledgeResult[]>;
+    /**
+     * Write-through to the ContextTreeManager — upsert a markdown entry at
+     * `.wotann/context-tree/{category}/{slug}.md`. Returns null when the
+     * manager failed to initialize (e.g. unwritable workingDir). Used by
+     * agents that discover durable project knowledge during long sessions.
+     */
+    upsertContextTree(category: ContextEntry["category"], title: string, content: string): ContextEntry | null;
+    /**
+     * Run self-consistency voting — sample the SAME provider+model N times
+     * against the same prompt and return the mode of the distribution with
+     * a confidence score. Wang et al. 2022 (arXiv:2203.11171). Differs from
+     * `runCouncilDeliberation` which uses multiple providers; self-consistency
+     * is cheaper and probes a single model's answer stability. Use when the
+     * caller wants confidence calibration from one provider rather than
+     * cross-provider consensus.
+     *
+     * Fixes the session-4 false-claim (commit 2a9cf6c) where benchmark-harness
+     * was said to "wire selfConsistencyVote" but actually used majorityAnswer
+     * (votes on pre-collected responses, no query execution). This method is
+     * the real wiring — it executes fresh queries.
+     */
+    runSelfConsistency(query: string, options?: {
+        readonly numVotes?: number;
+        readonly systemPrompt?: string;
+        readonly normalizeAnswer?: (response: string) => string;
+    }): Promise<SelfConsistencyResult>;
+    close(): void;
+    /**
+     * Phase H — executes session-ingestion + supersession detection. Split
+     * out so close() stays sync while the async pipeline runs on the
+     * microtask queue. Honest warn on any failure; never silently swallows.
+     */
+    private runPhaseHSessionIngestion;
+    /**
+     * Run the autoDream consolidation pipeline if trigger conditions are met.
+     * Persists gotchas to .wotann/LESSONS.md and records to MemoryStore.
+     */
+    private runDreamConsolidation;
+    private getHoursSinceLastDream;
+    /**
+     * Build FileInfo descriptors from the directory tree string.
+     * Used by ContextRelevanceScorer to apply tiered context loading.
+     */
+    private buildFileInfoFromTree;
+    private captureLearningFeedback;
+    private resolveSecurityResearchProvider;
+}
+/**
+ * Create and initialize a runtime for the current working directory.
+ */
+export declare function createRuntime(workingDir?: string, initialMode?: WotannMode): Promise<WotannRuntime>;
+//# sourceMappingURL=runtime.d.ts.map