@oni.bot/core 1.0.0 → 1.0.1

package/dist/oni-code/conductor.js

@@ -1,1547 +0,0 @@
-/**
- * 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