@oni.bot/core 0.6.3 → 1.0.0

package/dist/oni-code/conductor.js

@@ -0,0 +1,1547 @@
+/**
+ * Conductor Agent — the core integration that wires ONIHarness with coding
+ * tools, dispatch tools, workspace awareness, and permissions.
+ *
+ * The Conductor is the main conversational agent for the `oni` CLI. It handles
+ * simple tasks directly and escalates to subagents/swarms for complex work.
+ *
+ * Unlike single-shot harness usage, the Conductor maintains conversation
+ * history across turns so the agent remembers prior context.
+ */
+import { agentLoop } from "../harness/agent-loop.js";
+import { ONIHarness } from "../harness/index.js";
+import { TodoModule } from "../harness/todo-module.js";
+import { HooksEngine } from "../harness/hooks-engine.js";
+import { ContextCompactor } from "../harness/context-compactor.js";
+import { defineTool } from "../tools/define.js";
+import { makeCodingTools } from "./tools/coding.js";
+import { LSPManager } from "../lsp/index.js";
+import { makeWebTools } from "./tools/web.js";
+import { makeSpawnAgentsTool } from "./tools/spawn-agents.js";
+import { makeSpawnSwarmTool, } from "./tools/spawn-swarm.js";
+import { makeCreateSkillTool } from "./tools/skill.js";
+import { ProjectMap } from "./workspace/project-map.js";
+import { ChangeTracker } from "./workspace/change-tracker.js";
+import { PermissionManager } from "./permissions.js";
+import { BackgroundScheduler } from "./scheduler.js";
+import { CronScheduler, persistJobs, loadPersistedJobs } from "./cron/index.js";
+import { makeCronTools } from "./tools/cron.js";
+import { LoopDetector } from "./loop-detector.js";
+import { AgentRegistry } from "./agent-registry.js";
+import { makeQuestionTool } from "./tools/question.js";
+import { makePlanTools } from "./tools/plan.js";
+import { makeBatchTool } from "./tools/batch.js";
+import { SessionTree } from "./session-fork.js";
+import { TaskEvaluator } from "./task-evaluator.js";
+import { SessionStats } from "./session-stats.js";
+import { EventBus } from "../events/bus.js";
+import { FileWatcher } from "./file-watcher.js";
+import { SessionTitleGenerator } from "./session-title.js";
+import { FileSnapshots } from "./workspace/file-snapshots.js";
+import { extractFileChange, extractPatchChanges, extractMultiEditChanges } from "./change-tracking.js";
+import { resolve as resolvePath, join as joinPath } from "node:path";
+import { homedir as osHomedir } from "node:os";
+import { SkillLoader } from "../harness/skill-loader.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { loadContextFiles } from "./context-files.js";
+import { buildAutoDispatchAgents } from "./topology-agent-builder.js";
+import { summarizeSwarmResult } from "./summarizer.js";
+import { ProgressTracker } from "./progress-tracker.js";
+import { DefaultSwarmRunner } from "./swarm-runner.js";
+// ── Constants ───────────────────────────────────────────────
+/** Tools that mutate files — used to trigger snapshots and agent-change markers. */
+const WRITE_TOOLS = new Set(["write_file", "edit_file", "apply_patch", "multi_edit"]);
+// ── System Prompt ───────────────────────────────────────────
+// Uses buildSystemPrompt() from system-prompt.ts (canonical) +
+// loadContextFiles() from context-files.ts (CLAUDE.md, AGENTS.md, .cursorrules)
+// ── Noop SwarmRunner ────────────────────────────────────────
+const NOOP_SWARM_RUNNER = {
+    run: async () => ({
+        outcome: "Swarm runner not configured",
+        agentSummaries: [],
+        filesModified: [],
+        duration: 0,
+    }),
+};
+// ── Conductor ───────────────────────────────────────────────
+export class Conductor {
+    config;
+    rootDir;
+    permissions;
+    changeTracker;
+    fileSnapshots;
+    swarmRunner;
+    swarmRunnerPublishesLifecycle;
+    tools;
+    todoModule;
+    hooksEngine;
+    compactor;
+    scheduler;
+    loopDetector;
+    lspManager;
+    cronScheduler;
+    agentRegistry;
+    taskEvaluator;
+    sessionStats;
+    eventBus;
+    fileWatcher;
+    titleGenerator;
+    skillLoader;
+    progressTracker;
+    autoCompactionEnabled;
+    /** Cached context files content (CLAUDE.md, AGENTS.md, .cursorrules) */
+    contextFilesBlock;
+    /** Prebuilt tool set for subagents — coding + web + custom, no orchestration tools */
+    subagentTools;
+    /** Accumulated conversation history across turns */
+    conversationHistory = [];
+    turnCount = 0;
+    /** Session tree for branch-based conversation management */
+    sessionTree;
+    /** Active agent name — determines system prompt and tool scoping */
+    activeAgent = "build";
+    /** Cached assembled system prompt (base + context files + skills). Invalidated on agent switch. */
+    _cachedSystemPrompt = null;
+    _cachedPromptAgent = null;
+    _cachedSkillVersion = -1;
+    _projectMapDirty = true;
+    /** Guard: true while chat() generator is executing. Prevents the background
+     *  scheduler from compacting conversationHistory while the agentLoop holds
+     *  a reference to it — otherwise the scheduler's compaction gets silently
+     *  overwritten when the agentLoop yields finalMessages. */
+    _chatActive = false;
+    _stopNudgeCount = 0;
+    /** Session-level circuit breaker: consecutive chat() calls that ended in inference error.
+     *  After 3 consecutive failures (9+ total retries), we stop attempting inference and
+     *  tell the user the provider appears down. Resets on any successful inference. */
+    _consecutiveInferenceFailures = 0;
+    static INFERENCE_FAILURE_THRESHOLD = 3;
+    permissionListener = null;
+    questionListener = null;
+    toolMetadataListener = null;
+    constructor(config) {
+        this.config = config;
+        this.rootDir = config.rootDir;
+        this.permissions = new PermissionManager(config.mode ?? "auto", config.rootDir);
+        this.changeTracker = new ChangeTracker();
+        this.fileSnapshots = new FileSnapshots();
+        this.eventBus = config.eventBus ?? new EventBus();
+        // ── LSP manager (shared across all agents) ──────────────
+        this.lspManager = new LSPManager(config.rootDir);
+        // Apply LSP config if present
+        if (config.oniConfig?.lsp === false) {
+            this.lspManager.disable();
+        }
+        else if (config.oniConfig?.lsp && typeof config.oniConfig.lsp === "object") {
+            const lspCfg = config.oniConfig.lsp;
+            const lspServers = Object.entries(lspCfg).map(([id, cfg]) => ({
+                id,
+                extensions: cfg.extensions,
+                command: cfg.command,
+                args: cfg.args,
+                languageId: cfg.languageId,
+            }));
+            this.lspManager.addServers(lspServers);
+        }
+        // ── Build tools ─────────────────────────────────────────
+        const codingTools = makeCodingTools(config.rootDir, {
+            lsp: this.lspManager,
+            changeTracker: this.changeTracker,
+            fileSnapshots: this.fileSnapshots,
+        });
+        const webTools = makeWebTools({
+            searchEndpoint: config.oniConfig?.searchEndpoint,
+            searchApiKey: config.oniConfig?.searchApiKey,
+        });
+        const spawnAgentsTool = makeSpawnAgentsTool({
+            runAgent: (task, _index, agentName) => this.runSubagent(task, agentName),
+        });
+        const shouldCreateDefaultSwarmRunner = !config.swarmRunner && !!config.eventBus;
+        const swarmRunner = config.swarmRunner ?? (shouldCreateDefaultSwarmRunner
+            ? new DefaultSwarmRunner({
+                model: config.model,
+                fastModel: config.fastModel,
+                rootDir: config.rootDir,
+                changeTracker: this.changeTracker,
+                maxConcurrency: config.oniConfig?.swarm?.maxConcurrency,
+                perAgentMaxTurns: config.oniConfig?.swarm?.perAgentMaxTurns,
+                agentTimeout: config.oniConfig?.swarm?.agentTimeout,
+                eventBus: this.eventBus,
+            })
+            : NOOP_SWARM_RUNNER);
+        this.swarmRunner = swarmRunner;
+        this.swarmRunnerPublishesLifecycle = shouldCreateDefaultSwarmRunner;
+        const spawnSwarmTool = makeSpawnSwarmTool(swarmRunner);
+        const projectMapTool = this.buildProjectMapTool();
+        const questionTool = makeQuestionTool();
+        const planTools = makePlanTools({
+            switchAgent: (name) => this.switchAgent(name),
+        });
+        // ── Skill loader — scan .oni/skills/, .claude/skills/, and global dirs ──
+        {
+            const homedir = osHomedir();
+            const skillDirs = [
+                joinPath(homedir, ".oni", "skills"),
+                joinPath(homedir, ".claude", "skills"),
+                joinPath(config.rootDir, ".oni", "skills"),
+                joinPath(config.rootDir, ".claude", "skills"),
+                joinPath(config.rootDir, ".agents", "skills"),
+            ];
+            this.skillLoader = SkillLoader.fromDirectories(skillDirs);
+        }
+        // ── Context files — load CLAUDE.md, AGENTS.md, .cursorrules ──
+        this.contextFilesBlock = loadContextFiles(config.rootDir);
+        // Build base tool list (batch tool wraps these)
+        const skillTool = this.skillLoader.getSkillTool();
+        const createSkillTool = makeCreateSkillTool(this.skillLoader);
+        const cronTools = makeCronTools(this.cronScheduler);
+        const baseTools = [
+            ...codingTools,
+            ...webTools,
+            spawnAgentsTool,
+            spawnSwarmTool,
+            projectMapTool,
+            questionTool,
+            ...planTools,
+            skillTool,
+            createSkillTool,
+            ...cronTools,
+            ...(config.customTools ?? []),
+        ];
+        const batchTool = makeBatchTool(baseTools);
+        this.tools = [...baseTools, batchTool];
+        // Cache subagent-eligible tools (coding + web + custom, no orchestration)
+        this.subagentTools = [...codingTools, ...webTools, ...(config.customTools ?? [])];
+        // ── Build harness modules ────────────────────────────────
+        this.todoModule = new TodoModule();
+        this.loopDetector = new LoopDetector();
+        this.agentRegistry = new AgentRegistry();
+        this.sessionStats = new SessionStats();
+        this.titleGenerator = new SessionTitleGenerator(config.fastModel ?? config.model);
+        this.progressTracker = new ProgressTracker(config.rootDir);
+        this.progressTracker.restoreInto((todos) => this.todoModule.write(todos), this.changeTracker);
+        this.todoModule.onChange((state) => {
+            if (this.progressTracker.syncTodoState(state)) {
+                this.persistProgressSnapshot();
+            }
+        });
+        // ── File watcher (reactive file change detection) ──────
+        this.fileWatcher = new FileWatcher({
+            rootDir: config.rootDir,
+            bus: this.eventBus,
+        });
+        this.fileWatcher.on(() => {
+            this._projectMapDirty = true;
+        });
+        this.fileWatcher.start();
+        // ── Cron scheduler (session-scoped recurring prompts) ──
+        this.cronScheduler = new CronScheduler({
+            onFire: (prompt, jobId) => {
+                // Emit event for the CLI to pick up and inject as a new chat turn
+                const event = {
+                    type: "cron.fired",
+                    prompt,
+                    jobId,
+                    timestamp: Date.now(),
+                };
+                this.eventBus.emit(event);
+            },
+            isBusy: () => this._chatActive,
+            onMutate: (jobs) => persistJobs(this.rootDir, jobs),
+        });
+        // ── Restore persisted cron jobs ───────────────────────────
+        const persistedJobs = loadPersistedJobs(this.rootDir);
+        if (persistedJobs.length > 0) {
+            this.cronScheduler.restore(persistedJobs);
+        }
+        // ── Apply ONICodeConfig (agents, permissions) ─────────
+        if (config.oniConfig) {
+            // Register custom agents from config
+            if (config.oniConfig.agents) {
+                for (const [name, agentCfg] of Object.entries(config.oniConfig.agents)) {
+                    this.agentRegistry.register({
+                        name,
+                        mode: agentCfg.mode ?? "subagent",
+                        description: agentCfg.description ?? name,
+                        tools: agentCfg.tools,
+                        systemPrompt: agentCfg.systemPrompt,
+                        maxTurns: agentCfg.maxTurns,
+                    });
+                }
+            }
+            // Apply permission rules from config
+            if (config.oniConfig.permissions) {
+                this.permissions.addRulesFromConfig(config.oniConfig.permissions);
+            }
+        }
+        const userEngine = new HooksEngine();
+        const permissionHooks = {
+            PreToolUse: [
+                {
+                    handler: async (payload) => {
+                        const { toolName, input } = payload;
+                        // Defensive wrapper: if ANY internal check throws (loopDetector,
+                        // permissionListener, etc.), deny the tool rather than letting
+                        // the hooks engine's catch treat the exception as "allow".
+                        try {
+                            // ── Doom loop detection → permission escalation ──────
+                            const loopResult = this.loopDetector.check(toolName, input);
+                            if (loopResult.blocked) {
+                                // In bypass/auto mode, tool spam (same tool, different args) is
+                                // normal — e.g., writing 10 different files. Skip escalation.
+                                const isAutoSpam = this.permissions.getMode() === "auto" &&
+                                    loopResult.type === "spam";
+                                if (isAutoSpam) {
+                                    // Fall through — allow the call without prompting
+                                }
+                                else if (this.permissionListener) {
+                                    const decision = await new Promise((resolve) => {
+                                        this.permissionListener(toolName, input, resolve);
+                                    });
+                                    if (decision === "deny") {
+                                        return {
+                                            decision: "deny",
+                                            reason: loopResult.reason ?? "Doom loop detected",
+                                        };
+                                    }
+                                    // User approved — reset count for this tool+args so execution continues
+                                    this.loopDetector.allowOnce(toolName, input);
+                                    if (decision === "always_allow") {
+                                        this.permissions.addAlwaysAllow(toolName);
+                                    }
+                                }
+                                else {
+                                    // No permission listener — block with reason
+                                    return {
+                                        decision: "deny",
+                                        reason: loopResult.reason ?? "Doom loop detected",
+                                    };
+                                }
+                            }
+                            // ── Plan mode enforcement ────────────────────────────
+                            if (this.activeAgent === "plan") {
+                                const planDef = this.agentRegistry.get("plan");
+                                const allowed = planDef?.tools ? new Set([...planDef.tools, "plan_exit"]) : null;
+                                if (allowed && !allowed.has(toolName)) {
+                                    return {
+                                        decision: "deny",
+                                        reason: `Tool "${toolName}" is not available in plan mode. Use plan_exit to switch back to build mode.`,
+                                    };
+                                }
+                                // Block plan_enter when already in plan mode
+                                if (toolName === "plan_enter") {
+                                    return {
+                                        decision: "deny",
+                                        reason: "Already in plan mode. Use plan_exit to switch to build mode.",
+                                    };
+                                }
+                            }
+                            else {
+                                // Block plan_exit when in build mode
+                                if (toolName === "plan_exit") {
+                                    return {
+                                        decision: "deny",
+                                        reason: "Not in plan mode. Use plan_enter to switch to plan mode first.",
+                                    };
+                                }
+                            }
+                            // ── Normal permission check ──────────────────────────
+                            if (this.permissions.needsApproval(toolName, input)) {
+                                if (this.permissionListener) {
+                                    this.eventBus.emit({
+                                        type: "permission.asked",
+                                        toolName,
+                                        input,
+                                        agentName: this.activeAgent,
+                                        timestamp: Date.now(),
+                                    });
+                                    const decision = await new Promise((resolve) => {
+                                        this.permissionListener(toolName, input, resolve);
+                                    });
+                                    const busDecision = decision === "always_allow" ? "always"
+                                        : decision === "allow" ? "allow"
+                                            : "deny";
+                                    this.eventBus.emit({
+                                        type: "permission.replied",
+                                        toolName,
+                                        decision: busDecision,
+                                        timestamp: Date.now(),
+                                    });
+                                    if (decision === "deny") {
+                                        return { decision: "deny", reason: "User denied" };
+                                    }
+                                    if (decision === "always_allow") {
+                                        this.permissions.addAlwaysAllow(toolName);
+                                    }
+                                }
+                            }
+                            // ── Snapshot files before mutation (for undo_edit) ──────
+                            // Also mark agent-initiated file changes so FileWatcher
+                            // tags the resulting change event as agentInitiated: true
+                            if (WRITE_TOOLS.has(toolName) && input) {
+                                const filePath = input.path ?? input.file_path;
+                                if (typeof filePath === "string") {
+                                    const abs = resolvePath(this.rootDir, filePath);
+                                    this.fileSnapshots.capture(abs);
+                                    this.fileWatcher.markAgentChange(abs);
+                                }
+                                // multi_edit has an edits array with individual file paths
+                                const edits = input.edits;
+                                if (Array.isArray(edits)) {
+                                    for (const edit of edits) {
+                                        const ep = edit?.path ?? edit?.file_path;
+                                        if (typeof ep === "string") {
+                                            const abs = resolvePath(this.rootDir, ep);
+                                            this.fileSnapshots.capture(abs);
+                                            this.fileWatcher.markAgentChange(abs);
+                                        }
+                                    }
+                                }
+                            }
+                            return { decision: "allow" };
+                        }
+                        catch {
+                            // Internal error in permission/loop/plan checking — deny to
+                            // prevent silent allow on handler crash.
+                            return {
+                                decision: "deny",
+                                reason: "Permission check failed (internal error)",
+                            };
+                        }
+                    },
+                },
+            ],
+        };
+        // ── Post-compaction state reinsertion ────────────────────
+        const postCompactHooks = {
+            PostCompact: [
+                {
+                    handler: (_payload) => {
+                        // Each state-gathering call is wrapped individually so a failure
+                        // in one (e.g. corrupted todo state) doesn't lose the others.
+                        const parts = [];
+                        // Reinject todo list so the agent doesn't lose track
+                        try {
+                            const todoState = this.todoModule.getState();
+                            if (todoState.todos.length > 0) {
+                                parts.push("Current task list:\n" + this.todoModule.toContextString());
+                            }
+                        }
+                        catch { /* partial state is better than no state */ }
+                        // Reinject change tracker summary
+                        try {
+                            const changes = this.changeTracker.getSummary();
+                            if (changes) {
+                                parts.push("Files modified this session:\n" + changes);
+                            }
+                        }
+                        catch { /* partial state is better than no state */ }
+                        // Reinject session stats for budget awareness
+                        try {
+                            const statsCtx = this.sessionStats.toContextString();
+                            if (statsCtx) {
+                                parts.push("Session so far: " + statsCtx);
+                            }
+                        }
+                        catch { /* partial state is better than no state */ }
+                        try {
+                            this.syncProgressSnapshot({ persist: false });
+                            const progressCtx = this.progressTracker.toContextString();
+                            if (progressCtx) {
+                                parts.push(progressCtx);
+                            }
+                        }
+                        catch { /* partial state is better than no state */ }
+                        if (parts.length === 0) {
+                            return { decision: "allow" };
+                        }
+                        return {
+                            decision: "allow",
+                            additionalContext: parts.join("\n\n"),
+                        };
+                    },
+                },
+            ],
+        };
+        // ── Session stats tracking hooks ─────────────────────────
+        const statsHooks = {
+            PostToolUse: [
+                {
+                    handler: (payload) => {
+                        const p = payload;
+                        this.sessionStats.recordToolCall(p.toolName, p.durationMs ?? 0);
+                        let changedWorkspace = false;
+                        // Record file changes in the ChangeTracker
+                        if (p.toolName === "apply_patch") {
+                            const changes = extractPatchChanges(p.output);
+                            for (const c of changes) {
+                                this.changeTracker.recordChange(c.file, c.type);
+                                changedWorkspace = true;
+                            }
+                        }
+                        else if (p.toolName === "multi_edit") {
+                            const changes = extractMultiEditChanges(p.output);
+                            for (const c of changes) {
+                                this.changeTracker.recordChange(c.file, c.type);
+                                changedWorkspace = true;
+                            }
+                        }
+                        else {
+                            const change = extractFileChange(p.toolName, (p.input ?? {}), p.output);
+                            if (change) {
+                                this.changeTracker.recordChange(change.file, change.type);
+                                changedWorkspace = true;
+                            }
+                        }
+                        if (changedWorkspace) {
+                            this._projectMapDirty = true;
+                        }
+                        this.progressTracker.recordVerification(p.toolName, (p.input ?? {}), p.output);
+                        this.syncProgressSnapshot();
+                        return { decision: "allow" };
+                    },
+                },
+            ],
+            PostToolUseFailure: [
+                {
+                    handler: (payload) => {
+                        const p = payload;
+                        const errMsg = p.error instanceof Error ? p.error.message : String(p.error);
+                        this.sessionStats.recordToolError(p.toolName, errMsg);
+                        this.syncProgressSnapshot();
+                        return { decision: "allow" };
+                    },
+                },
+            ],
+            PreCompact: [
+                {
+                    handler: () => {
+                        this.sessionStats.recordCompaction();
+                        return { decision: "allow" };
+                    },
+                },
+            ],
+        };
+        // ── Todo-aware Stop hook (blocks premature exit up to 2 times) ──
+        const todoStopHooks = {
+            Stop: [
+                {
+                    handler: () => {
+                        const state = this.todoModule.getState();
+                        const outstanding = state.todos.filter((t) => t.status === "in_progress" || t.status === "pending");
+                        if (outstanding.length > 0 && this._stopNudgeCount < 2) {
+                            this._stopNudgeCount++;
+                            const names = outstanding.map((t) => t.content).join(", ");
+                            const reason = this._stopNudgeCount === 1
+                                ? `Outstanding tasks remain: ${names}. Complete them or mark as completed before stopping.`
+                                : `You still have ${outstanding.length} uncompleted task(s). Continue working — do not stop until tasks are addressed.`;
+                            return { decision: "block", reason };
+                        }
+                        return { decision: "allow" };
+                    },
+                },
+            ],
+        };
+        userEngine.configure(permissionHooks);
+        userEngine.configure(postCompactHooks);
+        userEngine.configure(statsHooks);
+        userEngine.configure(todoStopHooks);
+        this.hooksEngine = HooksEngine.compose(HooksEngine.withSecurityGuardrails(), userEngine);
+        this.autoCompactionEnabled = config.oniConfig?.compaction?.auto !== false;
+        const summaryModel = config.fastModel ?? config.model;
+        this.compactor = new ContextCompactor({
+            summaryModel,
+            threshold: config.oniConfig?.compaction?.threshold,
+        });
+        // ── Background scheduler ─────────────────────────────────
+        this.scheduler = new BackgroundScheduler();
+        // Register proactive compaction check — runs every 30s.
+        // If conversation history exceeds compaction threshold between
+        // chat calls, compact proactively so the next chat starts clean.
+        if (this.autoCompactionEnabled) {
+            this.scheduler.register({
+                id: "token-budget-monitor",
+                intervalMs: 30_000,
+                runImmediately: false,
+                run: async () => {
+                    // Skip if chat() is in progress — the agentLoop handles its own
+                    // compaction internally, and compacting here would race with its
+                    // finalMessages capture (overwriting the scheduler's compaction).
+                    if (this._chatActive)
+                        return;
+                    if (this.conversationHistory.length < 4)
+                        return;
+                    const check = this.compactor.checkCompaction(this.conversationHistory);
+                    if (!check.needed)
+                        return;
+                    this.eventBus.emit({
+                        type: "session.compacting",
+                        sessionId: "",
+                        messageCount: this.conversationHistory.length,
+                        estimatedTokens: check.estimatedTokens,
+                        threshold: check.threshold,
+                        maxTokens: check.maxTokens,
+                        percentUsed: check.percentUsed,
+                        timestamp: Date.now(),
+                    });
+                    const before = this.conversationHistory.length;
+                    await this.hooksEngine.fire("PreCompact", {
+                        sessionId: "",
+                        messageCount: before,
+                        estimatedTokens: check.estimatedTokens,
+                    });
+                    try {
+                        const compacted = await this.compactor.compact(this.conversationHistory, { skipInitialCheck: true });
+                        const summarized = compacted.length <= 2 && before > 2;
+                        const estimatedTokensAfter = this.compactor.estimateTokens(compacted);
+                        const percentUsedAfter = check.maxTokens > 0
+                            ? estimatedTokensAfter / check.maxTokens
+                            : 0;
+                        this.conversationHistory = compacted;
+                        this.eventBus.emit({
+                            type: "session.compacted",
+                            sessionId: "",
+                            beforeCount: before,
+                            afterCount: compacted.length,
+                            summarized,
+                            estimatedTokensBefore: check.estimatedTokens,
+                            estimatedTokensAfter,
+                            threshold: check.threshold,
+                            maxTokens: check.maxTokens,
+                            percentUsedBefore: check.percentUsed,
+                            percentUsedAfter,
+                            timestamp: Date.now(),
+                        });
+                        // Fire PostCompact for state reinsertion
+                        const postResult = await this.hooksEngine.fire("PostCompact", {
+                            sessionId: "",
+                            beforeCount: before,
+                            afterCount: compacted.length,
+                            estimatedTokensAfter,
+                            summarized,
+                        });
+                        // Merge state reinsertion + continuation into a single user/assistant
+                        // pair. Two separate pairs would waste ~40-60 tokens per compaction on
+                        // dead "acknowledgment" turns ("State restored." / "Understood.").
+                        const focus = this.todoModule.getCurrentFocus();
+                        const continuationText = focus
+                            ? `Continue working. Current focus: ${focus.content}`
+                            : "Continue if you have next steps.";
+                        const userContent = postResult?.additionalContext
+                            ? `<system-reminder>\n${postResult.additionalContext}\n</system-reminder>\n\n${continuationText}`
+                            : continuationText;
+                        this.conversationHistory.push({ role: "user", content: userContent }, { role: "assistant", content: "Context loaded." });
+                    }
+                    catch (err) {
+                        const errorMsg = err instanceof Error ? err.message : String(err);
+                        this.eventBus.emit({
+                            type: "session.compacted",
+                            sessionId: "",
+                            beforeCount: before,
+                            afterCount: before,
+                            summarized: false,
+                            estimatedTokensBefore: check.estimatedTokens,
+                            threshold: check.threshold,
+                            maxTokens: check.maxTokens,
+                            percentUsedBefore: check.percentUsed,
+                            failed: true,
+                            error: errorMsg,
+                            timestamp: Date.now(),
+                        });
+                        this.eventBus.emit({
+                            type: "error",
+                            agent: this.activeAgent,
+                            error: new Error(`Context compaction failed: ${errorMsg}`),
+                            timestamp: Date.now(),
+                        });
+                    }
+                },
+            });
+        }
+        // ── Task evaluator (auto-dispatch) ──────────────────────
+        this.taskEvaluator = new TaskEvaluator();
+        // ── Session tree ──────────────────────────────────────────
+        this.sessionTree = new SessionTree();
+    }
+    // ── Public: chat (multi-turn with history) ─────────────────
+    async *chat(message, opts) {
+        this._chatActive = true;
+        this._stopNudgeCount = 0;
+        this.progressTracker.recordUserTask(message);
+        this.syncProgressSnapshot();
+        try {
+            // ── Resolve active agent config ──────────────────────────
+            const agentDef = this.agentRegistry.get(this.activeAgent);
+            const env = {
+                cwd: this.rootDir,
+                platform: process.platform,
+                date: new Date().toISOString().split("T")[0],
+            };
+            // Use cached prompt if agent hasn't changed (saves ~10ms/turn of string construction)
+            if (this._cachedSystemPrompt === null || this._cachedPromptAgent !== this.activeAgent || this._cachedSkillVersion !== this.skillLoader.version) {
+                let prompt = agentDef?.systemPrompt ?? buildSystemPrompt(env);
+                // Append project context files (CLAUDE.md, AGENTS.md, .cursorrules)
+                if (this.contextFilesBlock) {
+                    prompt += "\n\n" + this.contextFilesBlock;
+                }
+                // Append available skill descriptions (progressive disclosure — names only)
+                const skillBlock = this.skillLoader.getDescriptionsForContext();
+                if (skillBlock) {
+                    prompt += "\n\n" + skillBlock;
+                }
+                const progressBlock = this.progressTracker.toContextString();
+                if (progressBlock) {
+                    prompt += `\n\n# Persistent Progress\n\n${progressBlock}`;
+                }
+                this._cachedSystemPrompt = prompt;
+                this._cachedPromptAgent = this.activeAgent;
+                this._cachedSkillVersion = this.skillLoader.version;
+            }
+            const systemPrompt = this._cachedSystemPrompt;
+            const maxTurns = agentDef?.maxTurns ?? this.config.maxTurns ?? 50;
+            // Scope tools by active agent's allowed list (Set for O(1) lookup)
+            const allTools = [...this.todoModule.getTools(), ...this.tools];
+            const scopedTools = agentDef?.tools
+                ? (() => {
+                    const allowed = new Set([...agentDef.tools, "plan_exit"]);
+                    return allTools.filter((t) => allowed.has(t.name));
+                })()
+                : allTools;
+            const agentBefore = this.activeAgent;
+            // ── Emit session.created ──────────────────────────────────
+            this.eventBus.emit({
+                type: "session.created",
+                sessionId: "",
+                agentName: this.activeAgent,
+                timestamp: Date.now(),
+            });
+            // ── Auto-dispatch: evaluate for swarm before entering agent loop ──
+            const swarmRunner = this.swarmRunner;
+            const hasRealSwarmRunner = swarmRunner !== NOOP_SWARM_RUNNER;
+            const runnerPublishesSwarmLifecycle = this.swarmRunnerPublishesLifecycle;
+            const dispatch = this.taskEvaluator.evaluate(message, this.activeAgent, this.conversationHistory.length, hasRealSwarmRunner);
+            if (dispatch.shouldDispatch && dispatch.recommendation && hasRealSwarmRunner) {
+                // Hoist variables above try so the catch block can close lifecycle events
+                const rec = dispatch.recommendation;
+                const agentCount = rec.suggestedAgentCount;
+                const swarmId = `swarm_${Date.now().toString(36)}`;
+                const swarmStartMs = Date.now();
+                // Run swarm directly
+                try {
+                    // Yield step_start so the UI can show swarm progress in the spinner
+                    yield {
+                        type: "step_start",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: swarmStartMs,
+                        metadata: {
+                            swarmTopology: rec.topology,
+                            agentCount,
+                            agentName: "swarm",
+                        },
+                    };
+                    if (!runnerPublishesSwarmLifecycle) {
+                        this.eventBus.emit({
+                            type: "swarm.started",
+                            swarmId,
+                            topology: rec.topology,
+                            agentCount,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    // Build topology-aware agent definitions with distinct roles and prompts
+                    const autoAgents = buildAutoDispatchAgents(rec.topology, message, agentCount);
+                    const agents = autoAgents.map((a) => ({
+                        id: a.id,
+                        role: a.role,
+                        systemPrompt: a.systemPrompt,
+                    }));
+                    const result = await swarmRunner.run({
+                        topology: rec.topology,
+                        task: message,
+                        agents,
+                        tools: ["read_file", "edit_file", "write_file", "bash", "grep", "glob", "git", "list_dir", "apply_patch", "list_changes", "undo_edit", "multi_edit", "webfetch", "websearch"],
+                        maxTurns: 30,
+                    }, undefined, { signal: opts?.signal });
+                    if (!runnerPublishesSwarmLifecycle) {
+                        this.eventBus.emit({
+                            type: "swarm.completed",
+                            swarmId,
+                            topology: rec.topology,
+                            agentCount,
+                            duration: result.duration,
+                            durationMs: result.duration * 1000,
+                            agentResults: { outcome: result.outcome, filesModified: result.filesModified },
+                            timestamp: Date.now(),
+                        });
+                    }
+                    // Yield step_finish so the UI can clear swarm progress state
+                    yield {
+                        type: "step_finish",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: Date.now(),
+                        metadata: {
+                            stepDurationMs: Date.now() - swarmStartMs,
+                            swarmTopology: rec.topology,
+                            agentName: "swarm",
+                        },
+                    };
+                    // Record swarm in session stats so stats reflect auto-dispatched work
+                    this.sessionStats.recordToolCall("spawn_swarm", result.duration);
+                    for (const file of result.filesModified) {
+                        this.changeTracker.recordChange(file, "edit");
+                    }
+                    // Record in conversation history using the structured summarizer so
+                    // the model gets topology, per-agent summaries, files, and duration.
+                    const assistantContent = summarizeSwarmResult({
+                        topology: rec.topology,
+                        task: message,
+                        outcome: result.outcome,
+                        agentSummaries: result.agentSummaries,
+                        filesModified: result.filesModified,
+                        duration: result.duration,
+                    });
+                    this.progressTracker.recordAssistantSummary(assistantContent);
+                    this.syncProgressSnapshot();
+                    this.conversationHistory.push({ role: "user", content: message }, { role: "assistant", content: assistantContent });
+                    this.turnCount++;
+                    // Emit session.completed for the swarm path too
+                    this.eventBus.emit({
+                        type: "session.completed",
+                        sessionId: "",
+                        turns: this.turnCount,
+                        reason: "swarm_completed",
+                        timestamp: Date.now(),
+                    });
+                    // Yield assistant message so the UI renders the swarm outcome.
+                    // Without this, the outcome only appears in the "result" message
+                    // whose content is ignored by MessageBlock (returns null).
+                    yield {
+                        type: "assistant",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: Date.now(),
+                        content: assistantContent,
+                    };
+                    yield {
+                        type: "result",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: Date.now(),
+                        content: result.outcome,
+                        metadata: {
+                            swarmAutoDispatched: true,
+                            topology: dispatch.recommendation.topology,
+                            agentCount: dispatch.recommendation.suggestedAgentCount,
+                            filesModified: result.filesModified,
+                            duration: result.duration,
+                            finalMessages: this.conversationHistory,
+                        },
+                    };
+                    return;
+                }
+                catch (err) {
+                    // Swarm failed — close lifecycle events, then fall through to agent loop
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    // Close the step_start/step_finish pair so the UI clears swarm spinner
+                    yield {
+                        type: "step_finish",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: Date.now(),
+                        metadata: {
+                            stepDurationMs: Date.now() - swarmStartMs,
+                            swarmTopology: rec.topology,
+                            agentName: "swarm",
+                            error: errMsg,
+                        },
+                    };
+                    // Close the swarm.started EventBus event so subscribers see completion
+                    if (!runnerPublishesSwarmLifecycle) {
+                        this.eventBus.emit({
+                            type: "swarm.completed",
+                            swarmId,
+                            topology: rec.topology,
+                            agentCount,
+                            durationMs: Date.now() - swarmStartMs,
+                            agentResults: { error: errMsg },
+                            timestamp: Date.now(),
+                        });
+                    }
+                    yield {
+                        type: "error",
+                        sessionId: "",
+                        turn: this.turnCount,
+                        timestamp: Date.now(),
+                        content: `Swarm auto-dispatch failed, falling back to agent loop: ${errMsg}`,
+                    };
+                    // Continue to normal agentLoop below
+                }
+            }
+            const loopConfig = {
+                model: this.config.model,
+                tools: scopedTools,
+                agentName: this.activeAgent,
+                systemPrompt,
+                maxTurns,
+                maxTokens: this.config.maxTokens ?? 16384,
+                initialMessages: this.conversationHistory,
+                todoModule: this.todoModule,
+                hooksEngine: this.hooksEngine,
+                compactor: this.autoCompactionEnabled ? this.compactor : undefined,
+                skillLoader: this.skillLoader,
+                signal: opts?.signal,
+                inferenceTimeoutMs: this.config.inferenceTimeoutMs,
+                env,
+                onQuestion: this.questionListener
+                    ? (question, resolve) => this.questionListener(question, resolve)
+                    : undefined,
+                onToolMetadata: this.toolMetadataListener
+                    ? (toolCallId, toolName, update) => this.toolMetadataListener(toolCallId, toolName, update)
+                    : undefined,
+            };
+            // ── Session-level circuit breaker ─────────────────────────
+            // If inference has failed on the last N consecutive chat() calls,
+            // stop attempting and tell the user the provider appears down.
+            if (this._consecutiveInferenceFailures >= Conductor.INFERENCE_FAILURE_THRESHOLD) {
+                yield {
+                    type: "error",
+                    sessionId: "",
+                    turn: this.turnCount,
+                    timestamp: Date.now(),
+                    content: `Model provider appears down — inference has failed ${this._consecutiveInferenceFailures} consecutive times. Please wait and try again, or switch models.`,
+                    metadata: {
+                        circuitBreaker: true,
+                        consecutiveFailures: this._consecutiveInferenceFailures,
+                    },
+                };
+                return;
+            }
+            // Track last terminal message to derive session.completed reason
+            let lastTerminalType;
+            let lastBudgetExhausted = false;
+            for await (const msg of agentLoop(message, loopConfig)) {
+                // Track terminal messages (result/error) for session.completed reason
+                if (msg.type === "result") {
+                    lastTerminalType = "result";
+                    lastBudgetExhausted = !!msg.metadata?.budgetExhausted;
+                }
+                else if (msg.type === "error") {
+                    lastTerminalType = "error";
+                }
+                // Emit agent.start + llm.request for step_start messages
+                if (msg.type === "step_start" && msg.metadata) {
+                    const step = msg.turn ?? 0;
+                    this.eventBus.emit({
+                        type: "agent.start",
+                        agent: this.activeAgent,
+                        timestamp: Date.now(),
+                        step,
+                    });
+                    this.eventBus.emit({
+                        type: "llm.request",
+                        agent: this.activeAgent,
+                        model: this.config.model.modelId,
+                        timestamp: Date.now(),
+                        messageCount: this.conversationHistory.length,
+                        hasTools: scopedTools.length > 0,
+                    });
+                }
+                // Emit agent.end + llm.response for step_finish messages
+                if (msg.type === "step_finish" && msg.metadata) {
+                    const meta = msg.metadata;
+                    const step = msg.turn ?? 0;
+                    this.eventBus.emit({
+                        type: "agent.end",
+                        agent: this.activeAgent,
+                        timestamp: Date.now(),
+                        step,
+                        duration: meta.stepDurationMs ?? 0,
+                        usage: meta.usage,
+                    });
+                    this.eventBus.emit({
+                        type: "llm.response",
+                        agent: this.activeAgent,
+                        model: this.config.model.modelId,
+                        timestamp: Date.now(),
+                        duration: meta.stepDurationMs ?? 0,
+                        usage: meta.usage ?? { inputTokens: 0, outputTokens: 0 },
+                        stopReason: meta.stopReason ?? "end",
+                        hasToolCalls: (meta.toolCount ?? 0) > 0,
+                    });
+                }
+                // Emit session.compacting for in-chat compaction start
+                if (msg.type === "system" && msg.subtype === "compact_start" && msg.metadata) {
+                    const meta = msg.metadata;
+                    this.eventBus.emit({
+                        type: "session.compacting",
+                        sessionId: "",
+                        messageCount: meta.beforeCount ?? 0,
+                        estimatedTokens: meta.estimatedTokens,
+                        threshold: meta.threshold,
+                        maxTokens: meta.maxTokens,
+                        percentUsed: meta.percentUsed,
+                        timestamp: Date.now(),
+                    });
+                }
+                // Emit session.compacted for in-chat compaction boundary
+                if (msg.type === "system" && msg.subtype === "compact_boundary" && msg.metadata) {
+                    const meta = msg.metadata;
+                    this.eventBus.emit({
+                        type: "session.compacted",
+                        sessionId: "",
+                        beforeCount: meta.beforeCount ?? 0,
+                        afterCount: meta.afterCount ?? 0,
+                        summarized: meta.summarized ?? false,
+                        estimatedTokensBefore: meta.estimatedTokensBefore,
+                        estimatedTokensAfter: meta.estimatedTokensAfter,
+                        threshold: meta.threshold,
+                        maxTokens: meta.maxTokens,
+                        percentUsedBefore: meta.percentUsedBefore,
+                        percentUsedAfter: meta.percentUsedAfter,
+                        timestamp: Date.now(),
+                    });
+                }
+                // Emit error event for compaction failures so EventBus subscribers
+                // (analytics, UI) can react. The agent loop handles recovery internally
+                // (continues the loop, retries next turn), but consumers should know.
+                if (msg.type === "system" && msg.subtype === "compact_error") {
+                    const meta = msg.metadata;
+                    this.eventBus.emit({
+                        type: "session.compacted",
+                        sessionId: "",
+                        beforeCount: meta?.beforeCount ?? 0,
+                        afterCount: meta?.afterCount ?? meta?.beforeCount ?? 0,
+                        summarized: false,
+                        estimatedTokensBefore: meta?.estimatedTokensBefore,
+                        threshold: meta?.threshold,
+                        maxTokens: meta?.maxTokens,
+                        percentUsedBefore: meta?.percentUsedBefore,
+                        failed: true,
+                        error: meta?.error ?? msg.content ?? "Context compaction failed",
+                        timestamp: Date.now(),
+                    });
+                    this.eventBus.emit({
+                        type: "error",
+                        error: new Error(msg.content ?? "Context compaction failed"),
+                        timestamp: Date.now(),
+                    });
+                }
+                // Emit inference.retry for retry system messages
+                if (msg.type === "system" && msg.subtype === "inference_retry" && msg.metadata) {
+                    const meta = msg.metadata;
+                    this.eventBus.emit({
+                        type: "inference.retry",
+                        attempt: meta.attempt ?? 1,
+                        maxRetries: meta.maxRetries ?? 3,
+                        delayMs: meta.delayMs ?? 0,
+                        error: meta.error ?? msg.content ?? "Unknown error",
+                        timestamp: Date.now(),
+                    });
+                }
+                // Track token usage from inference calls
+                if (msg.type === "assistant" && msg.metadata?.usage) {
+                    const usage = msg.metadata.usage;
+                    this.sessionStats.recordInference(usage);
+                    this.eventBus.emit({
+                        type: "session.updated",
+                        sessionId: "",
+                        turn: this.turnCount + 1,
+                        tokenUsage: usage,
+                        timestamp: Date.now(),
+                    });
+                }
+                // Emit tool.call for tool_start messages
+                if (msg.type === "tool_start" && msg.metadata) {
+                    const toolName = msg.metadata.toolName;
+                    const toolArgs = msg.metadata.toolArgs;
+                    if (toolName) {
+                        this.eventBus.emit({
+                            type: "tool.call",
+                            agent: this.activeAgent,
+                            tool: toolName,
+                            timestamp: Date.now(),
+                            input: toolArgs ?? {},
+                        });
+                    }
+                }
+                // Emit tool.result for tool_result messages
+                if (msg.type === "tool_result" && msg.toolResults) {
+                    for (const tr of msg.toolResults) {
+                        if (tr.isError && tr.content?.startsWith("Tool use denied:")) {
+                            this.sessionStats.recordDenied(tr.toolName, tr.content);
+                        }
+                        this.eventBus.emit({
+                            type: "tool.result",
+                            agent: this.activeAgent,
+                            tool: tr.toolName,
+                            timestamp: Date.now(),
+                            duration: tr.durationMs ?? 0,
+                            status: tr.isError ? "error" : "success",
+                            output: tr.isError ? undefined : tr.content,
+                            error: tr.isError ? tr.content : undefined,
+                        });
+                    }
+                }
+                // Capture final messages from result or error to update history
+                if (msg.type === "result" || msg.type === "error") {
+                    const finalMessages = msg.metadata?.finalMessages;
+                    if (finalMessages) {
+                        this.conversationHistory = finalMessages;
+                        this.sessionTree.updateMessages(finalMessages);
+                    }
+                    if (msg.type === "result" && msg.content) {
+                        this.progressTracker.recordAssistantSummary(msg.content);
+                        this.syncProgressSnapshot();
+                    }
+                    if (msg.type === "error") {
+                        this.eventBus.emit({
+                            type: "error",
+                            agent: this.activeAgent,
+                            error: new Error(msg.content ?? "Unknown error"),
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+                yield msg;
+            }
+            this.turnCount++;
+            // ── Update session-level circuit breaker ─────────────────
+            if (lastTerminalType === "error") {
+                this._consecutiveInferenceFailures++;
+            }
+            else {
+                this._consecutiveInferenceFailures = 0;
+            }
+            // ── Fire-and-forget title generation on first turn ──────
+            if (this.turnCount === 1) {
+                void this.titleGenerator.generate(message).catch(() => { });
+            }
+            // Emit session.completed with reason derived from actual termination
+            const completedReason = lastTerminalType === "error"
+                ? "error"
+                : lastBudgetExhausted
+                    ? "budget_exhausted"
+                    : "completed";
+            this.eventBus.emit({
+                type: "session.completed",
+                sessionId: "",
+                turns: this.turnCount,
+                reason: completedReason,
+                timestamp: Date.now(),
+            });
+            // ── Yield agent_switch if agent changed during this turn ──
+            if (this.activeAgent !== agentBefore) {
+                yield {
+                    type: "agent_switch",
+                    sessionId: "",
+                    turn: this.turnCount,
+                    timestamp: Date.now(),
+                    content: `Agent switched from ${agentBefore} to ${this.activeAgent}`,
+                    metadata: {
+                        previousAgent: agentBefore,
+                        newAgent: this.activeAgent,
+                    },
+                };
+            }
+        }
+        finally {
+            this._chatActive = false;
+        }
+    }
+    // ── Public: chatToResult ────────────────────────────────────
+    async chatToResult(message) {
+        let finalResult = "";
+        for await (const msg of this.chat(message)) {
+            if (msg.type === "result") {
+                finalResult = msg.content ?? "";
+            }
+        }
+        return finalResult;
+    }
+    // ── Public: accessors ───────────────────────────────────────
+    getPermissions() {
+        return this.permissions;
+    }
+    setPermissionListener(listener) {
+        this.permissionListener = listener;
+    }
+    setQuestionListener(listener) {
+        this.questionListener = listener;
+    }
+    setToolMetadataListener(listener) {
+        this.toolMetadataListener = listener;
+    }
+    /** Get the active agent name */
+    getActiveAgent() {
+        return this.activeAgent;
+    }
+    /** Switch the active agent. Takes effect on the next chat() call. */
+    switchAgent(name) {
+        const def = this.agentRegistry.get(name);
+        if (!def) {
+            throw new Error(`Unknown agent "${name}". Available: ${this.agentRegistry.names().join(", ")}`);
+        }
+        this.activeAgent = name;
+        this._cachedSystemPrompt = null; // Invalidate prompt cache
+    }
+    /** Get the auto-generated session title (null if not yet generated). */
+    getSessionTitle() {
+        return this.titleGenerator.getTitle();
+    }
+    getChangeTracker() {
+        return this.changeTracker;
+    }
+    getFileSnapshots() {
+        return this.fileSnapshots;
+    }
+    getTurnCount() {
+        return this.turnCount;
+    }
+    /** Get loaded context files content (CLAUDE.md, AGENTS.md, .cursorrules). Empty string if none found. */
+    getContextFiles() {
+        return this.contextFilesBlock;
+    }
+    /** Get the durable session progress snapshot used across restarts/compaction. */
+    getProgressTracker() {
+        return this.progressTracker;
+    }
+    /** Get the skill loader for external skill registration and invocation */
+    getSkillLoader() {
+        return this.skillLoader;
+    }
+    /** Get the currently available tool names for UI display. */
+    getAvailableToolNames() {
+        const names = [...this.todoModule.getTools(), ...this.tools].map((tool) => tool.name);
+        return Array.from(new Set(names)).sort((a, b) => a.localeCompare(b));
+    }
+    /** Get the currently loaded skill names for UI display. */
+    getAvailableSkillNames() {
+        return this.skillLoader.getAll().map((skill) => skill.name).sort((a, b) => a.localeCompare(b));
+    }
+    /** Get configured MCP server names from ONI config. */
+    getConfiguredMCPServerNames() {
+        return Object.keys(this.config.oniConfig?.mcpServers ?? {}).sort((a, b) => a.localeCompare(b));
+    }
+    /** Invoke a skill by name with optional arguments — queues for next turn */
+    invokeSkill(name, args) {
+        return this.skillLoader.invoke(name, args);
+    }
+    getHistoryLength() {
+        return this.conversationHistory.length;
+    }
+    clearHistory() {
+        this.conversationHistory = [];
+        this.turnCount = 0;
+        this.sessionStats.reset();
+    }
+    // ── Session forking ──────────────────────────────────────────
+    /**
+     * Fork the current conversation at a specific message index.
+     * Creates a new branch with messages [0..atIndex-1].
+     * If atIndex is omitted, forks at the current end.
+     * Returns the new branch ID.
+     */
+    forkSession(atIndex, label) {
+        // Ensure tree is synced with current history
+        this.sessionTree.updateMessages(this.conversationHistory);
+        return this.sessionTree.fork(atIndex, label);
+    }
+    /**
+     * Switch to a different conversation branch.
+     * Updates the internal history to the branch's messages.
+     */
+    switchBranch(branchId) {
+        const msgs = this.sessionTree.switchBranch(branchId);
+        this.conversationHistory = msgs;
+    }
+    /**
+     * List all conversation branches with summary info.
+     */
+    listBranches() {
+        return this.sessionTree.listBranches();
+    }
+    /**
+     * Get the active branch ID.
+     */
+    getActiveBranchId() {
+        return this.sessionTree.getActiveBranchId();
+    }
+    /**
+     * Delete a branch. Cannot delete the root.
+     * If cascade is true, also deletes all children.
+     */
+    deleteBranch(branchId, cascade = false) {
+        const deleted = this.sessionTree.deleteBranch(branchId, cascade);
+        // If active branch was deleted, sync history to the new active (root)
+        if (deleted && this.sessionTree.getActiveBranchId() !== branchId) {
+            this.conversationHistory = this.sessionTree.getMessagesForLoop();
+        }
+        return deleted;
+    }
+    /**
+     * Get the session tree for advanced operations (serialization, etc.).
+     */
+    getSessionTree() {
+        return this.sessionTree;
+    }
+    /** Get session statistics (tool calls, tokens, compactions, errors). */
+    getSessionStats() {
+        return this.sessionStats;
+    }
+    /** Get the background scheduler for registering periodic tasks. */
+    getScheduler() {
+        return this.scheduler;
+    }
+    /** Get the loop detector for inspection or configuration. */
+    getLoopDetector() {
+        return this.loopDetector;
+    }
+    /** Get the event bus for subscribing to lifecycle events. */
+    getEventBus() {
+        return this.eventBus;
+    }
+    /** Get the file watcher for reactive file change detection. */
+    getFileWatcher() {
+        return this.fileWatcher;
+    }
+    /** Get the cron scheduler for managing recurring prompts. */
+    getCronScheduler() {
+        return this.cronScheduler;
+    }
+    /** Stop all background tasks and release resources.
+     *  Each cleanup step is isolated — a failure in one (e.g. corrupted
+     *  file handle, dead LSP process) must not prevent the others from
+     *  running, or resources leak (timers, child processes, listeners). */
+    dispose() {
+        try {
+            this.fileWatcher.stop();
+        }
+        catch { /* best-effort */ }
+        try {
+            this.scheduler.dispose();
+        }
+        catch { /* best-effort */ }
+        try {
+            this.cronScheduler.dispose();
+        }
+        catch { /* best-effort */ }
+        try {
+            this.lspManager.disposeAll();
+        }
+        catch { /* best-effort */ }
+        try {
+            this.eventBus.dispose();
+        }
+        catch { /* best-effort */ }
+    }
+    /** Get the LSP manager for inspection or external use. */
+    getLSPManager() {
+        return this.lspManager;
+    }
+    /** Get the task evaluator for inspection or testing. */
+    getTaskEvaluator() {
+        return this.taskEvaluator;
+    }
+    /** Manually trigger context compaction. Returns before/after message counts. */
+    async compactContext() {
+        if (this.conversationHistory.length < 4)
+            return null;
+        const before = this.conversationHistory.length;
+        const check = this.compactor.checkCompaction(this.conversationHistory);
+        this.eventBus.emit({
+            type: "session.compacting",
+            sessionId: "",
+            messageCount: before,
+            estimatedTokens: check.estimatedTokens,
+            threshold: check.threshold,
+            maxTokens: check.maxTokens,
+            percentUsed: check.percentUsed,
+            timestamp: Date.now(),
+        });
+        await this.hooksEngine.fire("PreCompact", {
+            sessionId: "",
+            messageCount: before,
+            estimatedTokens: check.estimatedTokens,
+        });
+        try {
+            const compacted = await this.compactor.compact(this.conversationHistory, { skipInitialCheck: true });
+            const summarized = compacted.length <= 2 && before > 2;
+            const estimatedTokensAfter = this.compactor.estimateTokens(compacted);
+            const percentUsedAfter = check.maxTokens > 0
+                ? estimatedTokensAfter / check.maxTokens
+                : 0;
+            this.conversationHistory = compacted;
+            this.eventBus.emit({
+                type: "session.compacted",
+                sessionId: "",
+                beforeCount: before,
+                afterCount: compacted.length,
+                summarized,
+                estimatedTokensBefore: check.estimatedTokens,
+                estimatedTokensAfter,
+                threshold: check.threshold,
+                maxTokens: check.maxTokens,
+                percentUsedBefore: check.percentUsed,
+                percentUsedAfter,
+                timestamp: Date.now(),
+            });
+            // Fire PostCompact hooks for state reinsertion (todo list, change tracker, stats)
+            const postResult = await this.hooksEngine.fire("PostCompact", {
+                sessionId: "",
+                beforeCount: before,
+                afterCount: compacted.length,
+                estimatedTokensAfter,
+                summarized,
+            });
+            // Inject state reinsertion + continuation prompt
+            const focus = this.todoModule.getCurrentFocus();
+            const continuationText = focus
+                ? `Continue working. Current focus: ${focus.content}`
+                : "Continue if you have next steps.";
+            const userContent = postResult?.additionalContext
+                ? `<system-reminder>\n${postResult.additionalContext}\n</system-reminder>\n\n${continuationText}`
+                : continuationText;
+            this.conversationHistory.push({ role: "user", content: userContent }, { role: "assistant", content: "Context loaded." });
+            return { before, after: compacted.length };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            // Compaction failed — close the lifecycle event and degrade gracefully.
+            // Conversation history is unchanged (compact() returns a new array).
+            this.eventBus.emit({
+                type: "session.compacted",
+                sessionId: "",
+                beforeCount: before,
+                afterCount: before,
+                summarized: false,
+                estimatedTokensBefore: check.estimatedTokens,
+                threshold: check.threshold,
+                maxTokens: check.maxTokens,
+                percentUsedBefore: check.percentUsed,
+                failed: true,
+                error: errorMsg,
+                timestamp: Date.now(),
+            });
+            this.eventBus.emit({
+                type: "error",
+                agent: this.activeAgent,
+                error: new Error(`Context compaction failed: ${errorMsg}`),
+                timestamp: Date.now(),
+            });
+            return null;
+        }
+    }
+    // ── Private: runSubagent ────────────────────────────────────
+    async runSubagent(task, agentName) {
+        try {
+            // Resolve agent definition from registry (if named)
+            const agentDef = agentName ? this.agentRegistry.get(agentName) : undefined;
+            // Reuse parent's prebuilt subagent tools (coding + web + custom).
+            // These already share LSPManager, ChangeTracker, and FileSnapshots
+            // so subagent edits are visible to list_changes and undo_edit.
+            const scopedTools = agentDef?.tools
+                ? (() => {
+                    const allowed = new Set(agentDef.tools);
+                    return this.subagentTools.filter((t) => allowed.has(t.name));
+                })()
+                : this.subagentTools;
+            // Use fastModel for lightweight agents (explore, compaction) to reduce
+            // latency and cost. Falls back to heavy model if no fastModel configured.
+            const agentModel = agentDef?.useFastModel && this.config.fastModel
+                ? this.config.fastModel
+                : this.config.model;
+            const subHarness = ONIHarness.create({
+                model: agentModel,
+                fastModel: this.config.fastModel,
+                sharedTools: scopedTools,
+                ...(agentDef?.systemPrompt ? { soul: agentDef.systemPrompt } : {}),
+            });
+            // Iterate run() manually instead of runToResult() so we can capture
+            // step_finish usage and merge it into the parent's sessionStats,
+            // and surface yielded error messages (e.g. inference failures) to
+            // the parent agent instead of silently discarding them.
+            let result = "";
+            const errors = [];
+            const agentConfig = {
+                name: agentName ?? "subagent",
+                ...(agentDef?.maxTurns ? { maxTurns: agentDef.maxTurns } : {}),
+            };
+            for await (const msg of subHarness.run(task, agentConfig)) {
+                if (msg.type === "result") {
+                    result = msg.content ?? "";
+                }
+                else if (msg.type === "error") {
+                    // Capture yielded errors so the parent agent knows the subagent failed
+                    if (msg.content)
+                        errors.push(msg.content);
+                }
+                else if (msg.type === "step_finish") {
+                    // Merge subagent inference usage into parent stats
+                    const meta = msg.metadata;
+                    if (meta?.usage) {
+                        this.sessionStats.recordInference(meta.usage);
+                    }
+                }
+            }
+            return {
+                result,
+                filesModified: [],
+                errors,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                result: "",
+                filesModified: [],
+                errors: [message],
+            };
+        }
+    }
+    // ── Private: project_map tool ───────────────────────────────
+    buildProjectMapTool() {
+        let cachedMap = null;
+        let cachedChangeVersion = -1;
+        return defineTool({
+            name: "project_map",
+            description: "Get a map of the project structure — lists all files with sizes. Useful for understanding the workspace layout.",
+            schema: {
+                type: "object",
+                properties: {
+                    refresh: {
+                        type: "boolean",
+                        description: "Force rebuild the project map (default false)",
+                    },
+                },
+            },
+            parallelSafe: true,
+            execute: (input) => {
+                const currentVersion = this.changeTracker.getVersion();
+                if (!cachedMap || input.refresh || this._projectMapDirty || cachedChangeVersion !== currentVersion) {
+                    cachedMap = ProjectMap.build(this.rootDir);
+                    cachedChangeVersion = currentVersion;
+                    this._projectMapDirty = false;
+                }
+                return {
+                    projectMap: cachedMap.toContextString(),
+                    fileCount: cachedMap.files.length,
+                };
+            },
+        });
+    }
+    syncProgressSnapshot(opts) {
+        this.progressTracker.syncTodoState(this.todoModule.getState());
+        this.progressTracker.syncChangeTracker(this.changeTracker);
+        if (opts?.persist !== false) {
+            this.persistProgressSnapshot();
+        }
+    }
+    persistProgressSnapshot() {
+        if (this.progressTracker.persist()) {
+            this._cachedSystemPrompt = null;
+        }
+    }
+}
+//# sourceMappingURL=conductor.js.map