@kenkaiiii/gg-boss 4.3.140 → 4.3.142

package/dist/orchestrator.js

@@ -1,707 +0,0 @@
-import { Agent, isAbortError } from "@kenkaiiii/gg-agent";
-import { AuthStorage, compact, estimateConversationTokens, getContextWindow, shouldCompact, } from "@kenkaiiii/ggcoder";
-import { Worker } from "./worker.js";
-import { EventQueue } from "./event-queue.js";
-import { createBossTools, WORKER_PROMPT_BRIEF } from "./tools.js";
-import { createTaskTools } from "./task-tools.js";
-import { tasksStore } from "./tasks-store.js";
-import { saveSettings } from "./settings.js";
-import { playDoneAudio, playReadyAudio } from "./audio.js";
-import { log } from "./logger.js";
-import { buildBossSystemPrompt } from "./boss-system-prompt.js";
-import { bossStore } from "./boss-store.js";
-import { appendMessages, createSession, getMostRecent, getSessionById, loadSession, } from "./sessions.js";
-/**
- * The orchestrator. Owns N workers, a single shared event queue, and the boss Agent.
- * Each loop iteration: pop one event, format it as a user message, run the boss for
- * one full prompt (which may dispatch tool calls to workers), then await the next event.
- *
- * UI state is mirrored into bossStore — components subscribe via useBossState().
- */
-export class GGBoss {
-    workers = new Map();
-    lastSummaries = new Map();
-    queue = new EventQueue();
-    bossAgent;
-    ac = new AbortController();
-    /** Per-turn AbortController so ESC can cancel the current LLM call without killing workers. */
-    turnAc = null;
-    running = false;
-    pendingUserMessages = 0;
-    opts;
-    authStorage = new AuthStorage();
-    /** Path to the boss's per-session jsonl log under ~/.gg/boss/sessions/. */
-    sessionPath = "";
-    /** Last index in the boss's messages array we've persisted to disk. */
-    lastPersistedIndex = 0;
-    /** project → task id currently dispatched to that worker. Used to mark
-     *  the right task done/blocked when the worker_turn_complete event arrives. */
-    inFlightTaskByProject = new Map();
-    /**
-     * Auto-chain notices waiting to be delivered to the boss. When the
-     * orchestrator deterministically dispatches the next pending task for a
-     * project (because the boss didn't), the boss has no other way to know it
-     * happened — it'd see "X(working)" in the next event's other_workers
-     * trailer and dismiss it as stale because it remembers receiving X's prior
-     * completion event. We attach an explicit note to the next event so the
-     * boss's mental model stays in sync with reality.
-     */
-    pendingAutoChainNotices = [];
-    /**
-     * "Had any worker activity since the last all-clear chime?" Set true when
-     * a worker_turn_complete or worker_error event arrives, cleared when we
-     * detect the orchestrator has fully wound down (all workers idle, queue
-     * empty, boss turn finished). Drives playReadyAudio so the chime fires
-     * once per workflow instead of every time the boss replies to a chat
-     * message that didn't dispatch any workers.
-     */
-    hadWorkerActivitySinceReady = false;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    async initialize() {
-        await this.authStorage.load();
-        await tasksStore.load();
-        const loggedInProviders = (await this.authStorage.listProviders());
-        bossStore.init({
-            bossProvider: this.opts.bossProvider,
-            bossModel: this.opts.bossModel,
-            bossThinkingLevel: this.opts.bossThinkingLevel,
-            workerProvider: this.opts.workerProvider,
-            workerModel: this.opts.workerModel,
-            loggedInProviders,
-            workers: this.opts.projects.map((p) => ({ name: p.name, cwd: p.cwd })),
-        });
-        await Promise.all(this.opts.projects.map(async (p) => {
-            const worker = new Worker({
-                name: p.name,
-                cwd: p.cwd,
-                provider: this.opts.workerProvider,
-                model: this.opts.workerModel,
-                thinkingLevel: this.opts.workerThinkingLevel,
-                signal: this.ac.signal,
-                queue: this.queue,
-            });
-            await worker.initialize();
-            this.workers.set(p.name, worker);
-        }));
-        const creds = await this.authStorage.resolveCredentials(this.opts.bossProvider);
-        const tools = this.buildToolSet();
-        // Either resume a prior session (load messages from jsonl), or create a
-        // new one. Either way we end up with `sessionPath` to persist into.
-        let priorMessages;
-        if (this.opts.resumeSessionId) {
-            const info = await getSessionById(this.opts.resumeSessionId);
-            if (info) {
-                this.sessionPath = info.path;
-                priorMessages = (await loadSession(info.path)).filter((m) => m.role !== "system");
-            }
-        }
-        else if (this.opts.continueRecent) {
-            const recent = await getMostRecent();
-            if (recent) {
-                this.sessionPath = recent.path;
-                priorMessages = (await loadSession(recent.path)).filter((m) => m.role !== "system");
-            }
-        }
-        if (!this.sessionPath) {
-            const session = await createSession();
-            this.sessionPath = session.filePath;
-        }
-        // Rebuild the visible TUI history from the loaded messages so the chat
-        // shows the prior conversation, not just the agent's hidden context.
-        if (priorMessages && priorMessages.length > 0) {
-            bossStore.restoreHistory(priorMessages);
-        }
-        this.bossAgent = new Agent({
-            provider: this.opts.bossProvider,
-            model: this.opts.bossModel,
-            system: buildBossSystemPrompt(this.opts.projects),
-            tools,
-            apiKey: creds.accessToken,
-            accountId: creds.accountId,
-            signal: this.ac.signal,
-            cacheRetention: "short",
-            thinking: this.opts.bossThinkingLevel,
-            priorMessages,
-        });
-        // Mark every loaded message as already persisted so we only append NEW
-        // turns going forward. The system message is added by Agent's constructor
-        // and we never want to write the system prompt to disk (it's rebuilt each
-        // session from current project list) — so subtract one for it.
-        this.lastPersistedIndex = this.bossAgent.getMessages().length;
-        // Seed the context-bar estimate so it shows real progress before the first
-        // turn_end event fires. Especially critical on `ggboss continue` where
-        // we'd otherwise show 0% over a session that's already half-full.
-        const initialMessages = this.bossAgent.getMessages();
-        if (initialMessages.length > 1) {
-            bossStore.setBossInputTokens(estimateConversationTokens(initialMessages));
-        }
-    }
-    enqueueUserMessage(text) {
-        this.pendingUserMessages++;
-        bossStore.setPendingMessages(this.pendingUserMessages);
-        this.queue.push({
-            kind: "user_message",
-            text,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    /**
-     * Abort the boss's current LLM call (e.g. user pressed ESC). Workers and the
-     * orchestrator's run loop keep going. The next event in the queue gets a
-     * fresh AbortController.
-     */
-    abort() {
-        this.turnAc?.abort();
-    }
-    /** Boss tool set = orchestration tools + task management tools. */
-    buildToolSet() {
-        const bossTools = createBossTools({
-            workers: this.workers,
-            lastSummaries: this.lastSummaries,
-        });
-        const taskTools = createTaskTools({
-            workers: this.workers,
-            dispatchTaskByDescription: (project, description, fresh, taskId) => this.dispatchTaskByDescription(project, description, fresh, taskId),
-        });
-        return [...bossTools, ...taskTools];
-    }
-    /**
-     * Dispatch a single task to a specific worker, marking it in_progress and
-     * (eventually) done when the worker_turn_complete event arrives. Used by:
-     *  - the dispatch_pending tool (called by the boss agent)
-     *  - the Tasks overlay (when user presses Enter on a task)
-     *
-     * Returns immediately — fire-and-forget like prompt_worker.
-     */
-    async dispatchTaskById(taskId) {
-        const task = tasksStore.byId(taskId);
-        if (!task)
-            return { ok: false, reason: "unknown task id" };
-        const w = this.workers.get(task.project);
-        if (!w)
-            return { ok: false, reason: `unknown project: ${task.project}` };
-        if (w.getStatus() === "working")
-            return { ok: false, reason: "worker is busy" };
-        await tasksStore.update(task.id, { status: "in_progress" });
-        return this.dispatchTaskByDescription(task.project, task.description, task.fresh === true, task.id);
-    }
-    /**
-     * Dispatch a task description to a worker. Used by both the task tool and
-     * the overlay (via dispatchTaskById). Tracks the in-flight task id per
-     * project so worker_turn_complete can resolve it back to the right task.
-     */
-    async dispatchTaskByDescription(project, description, fresh, taskId) {
-        const w = this.workers.get(project);
-        if (!w) {
-            log("WARN", "dispatch", "unknown project", { project, taskId });
-            return { ok: false, reason: `unknown project: ${project}` };
-        }
-        if (w.getStatus() === "working") {
-            log("WARN", "dispatch", "worker busy", { project, taskId });
-            return { ok: false, reason: "worker is busy" };
-        }
-        if (fresh)
-            await w.newSession();
-        this.inFlightTaskByProject.set(project, taskId);
-        log("INFO", "dispatch", "task dispatched", { project, taskId, fresh });
-        await w.prompt(WORKER_PROMPT_BRIEF + description);
-        return { ok: true };
-    }
-    /**
-     * Swap the boss's LLM model. Preserves message history so the conversation
-     * continues seamlessly under the new model.
-     */
-    async switchBossModel(provider, model) {
-        const tools = this.buildToolSet();
-        const creds = await this.authStorage.resolveCredentials(provider);
-        // Capture history minus the system message — Agent re-adds system from options.
-        const oldMessages = this.bossAgent.getMessages().filter((m) => m.role !== "system");
-        this.opts.bossProvider = provider;
-        this.opts.bossModel = model;
-        this.bossAgent = new Agent({
-            provider,
-            model,
-            system: buildBossSystemPrompt(this.opts.projects),
-            tools,
-            apiKey: creds.accessToken,
-            accountId: creds.accountId,
-            signal: this.ac.signal,
-            cacheRetention: "short",
-            thinking: this.opts.bossThinkingLevel,
-            priorMessages: oldMessages,
-        });
-        bossStore.setBossModel(provider, model);
-        await saveSettings({ bossProvider: provider, bossModel: model });
-    }
-    /** Swap every worker's model. Workers keep their per-project sessions. */
-    async switchWorkerModel(provider, model) {
-        await Promise.all([...this.workers.values()].map((w) => w.switchModel(provider, model)));
-        this.opts.workerProvider = provider;
-        this.opts.workerModel = model;
-        bossStore.setWorkerModel(provider, model);
-        await saveSettings({ workerProvider: provider, workerModel: model });
-    }
-    /**
-     * Run a manual compaction now (driven by /compact). Will compact even if the
-     * threshold isn't reached yet — useful for trimming context before a long task.
-     */
-    async manualCompact() {
-        await this.runCompaction(true);
-    }
-    /** Compact only when threshold (default 80%) is exceeded. */
-    async runCompaction(force) {
-        const messages = this.bossAgent.getMessages();
-        const contextWindow = getContextWindow(this.opts.bossModel);
-        const tokens = bossStore.getInputTokens();
-        if (!force && !shouldCompact(messages, contextWindow, 0.8, tokens))
-            return;
-        bossStore.startCompaction();
-        try {
-            const creds = await this.authStorage.resolveCredentials(this.opts.bossProvider);
-            const { messages: compactedMessages, result } = await compact(messages, {
-                provider: this.opts.bossProvider,
-                model: this.opts.bossModel,
-                apiKey: creds.accessToken,
-                contextWindow,
-                signal: this.ac.signal,
-            });
-            await this.replaceBossMessages(compactedMessages);
-            // Start a new session file so `ggboss continue` resumes the COMPACTED
-            // history, not the full original. Mirrors ggcoder/AgentSession.compact.
-            const session = await createSession();
-            this.sessionPath = session.filePath;
-            this.lastPersistedIndex = 0;
-            await this.persistNewMessages();
-            bossStore.setBossInputTokens(0);
-            bossStore.endCompaction(result.originalCount, result.newCount);
-        }
-        catch (err) {
-            bossStore.cancelCompaction();
-            if (!isAbortError(err)) {
-                const message = err instanceof Error ? err.message : String(err);
-                bossStore.appendInfo(`Compaction failed: ${message}`, "error");
-            }
-        }
-    }
-    /**
-     * Append any boss messages that haven't been written yet to the session log.
-     * Skips the system message (regenerated each session from current project list).
-     */
-    async persistNewMessages() {
-        if (!this.sessionPath)
-            return;
-        const all = this.bossAgent.getMessages();
-        const newOnes = all.slice(this.lastPersistedIndex).filter((m) => m.role !== "system");
-        if (newOnes.length === 0)
-            return;
-        try {
-            await appendMessages(this.sessionPath, newOnes);
-            this.lastPersistedIndex = all.length;
-        }
-        catch {
-            // Persistence is best-effort — never crash the run loop on disk errors.
-        }
-    }
-    /**
-     * Toggle the boss's extended-thinking level. Recreates bossAgent with the
-     * new setting (Anthropic SDK reads `thinking` once on construction). Mirrors
-     * ggcoder's Shift+Tab UX. Persists to settings.json so the choice sticks
-     * across restarts.
-     */
-    async setBossThinking(level) {
-        this.opts.bossThinkingLevel = level;
-        const tools = this.buildToolSet();
-        const creds = await this.authStorage.resolveCredentials(this.opts.bossProvider);
-        const oldMessages = this.bossAgent.getMessages().filter((m) => m.role !== "system");
-        this.bossAgent = new Agent({
-            provider: this.opts.bossProvider,
-            model: this.opts.bossModel,
-            system: buildBossSystemPrompt(this.opts.projects),
-            tools,
-            apiKey: creds.accessToken,
-            accountId: creds.accountId,
-            signal: this.ac.signal,
-            cacheRetention: "short",
-            thinking: level,
-            priorMessages: oldMessages,
-        });
-        bossStore.setBossThinking(level);
-        await saveSettings({ bossThinkingLevel: level });
-    }
-    /** Recreate bossAgent with a new message history (used by compact + /clear). */
-    async replaceBossMessages(newMessages) {
-        const tools = this.buildToolSet();
-        const creds = await this.authStorage.resolveCredentials(this.opts.bossProvider);
-        // Strip system — Agent re-adds it from `system`.
-        const priorMessages = newMessages.filter((m) => m.role !== "system");
-        this.bossAgent = new Agent({
-            provider: this.opts.bossProvider,
-            model: this.opts.bossModel,
-            system: buildBossSystemPrompt(this.opts.projects),
-            tools,
-            apiKey: creds.accessToken,
-            accountId: creds.accountId,
-            signal: this.ac.signal,
-            cacheRetention: "short",
-            thinking: this.opts.bossThinkingLevel,
-            priorMessages,
-        });
-    }
-    /**
-     * Start a brand-new boss session — fresh agent with no message history,
-     * fresh session file on disk so `ggboss continue` picks up the new chat.
-     * Workers are unaffected.
-     */
-    async newSession() {
-        const session = await createSession();
-        this.sessionPath = session.filePath;
-        this.lastPersistedIndex = 0;
-        await this.replaceBossMessages([]);
-        bossStore.setBossInputTokens(0);
-        // Mark the post-construction message count (just system) as persisted so
-        // we don't try to write it.
-        this.lastPersistedIndex = this.bossAgent.getMessages().length;
-    }
-    /** Alias kept for the existing /clear path which used "reset" terminology. */
-    async resetConversation() {
-        return this.newSession();
-    }
-    async run() {
-        this.running = true;
-        while (this.running) {
-            const event = await this.queue.next();
-            if (!this.running)
-                break;
-            if (event.kind === "user_message") {
-                this.pendingUserMessages = Math.max(0, this.pendingUserMessages - 1);
-                bossStore.setPendingMessages(this.pendingUserMessages);
-            }
-            // Captured so the post-turn auto-chain can tell whether THIS event was
-            // a dispatched task (chain on) vs an ad-hoc prompt_worker like recon
-            // (chain off). Lives outside the `if` so it stays in scope down below.
-            let finishedTaskId = null;
-            if (event.kind === "worker_turn_complete") {
-                // Play the completion chime — fire-and-forget. Multiple workers
-                // finishing in quick succession will layer their sounds, which is
-                // fine: it's a chime, not a long jingle.
-                void playDoneAudio();
-                this.hadWorkerActivitySinceReady = true;
-                this.lastSummaries.set(event.summary.project, event.summary);
-                log("INFO", "worker_turn_complete", "worker finished", {
-                    project: event.summary.project,
-                    turn: event.summary.turnIndex,
-                    tools: event.summary.toolsUsed.length,
-                    failed: event.summary.toolsUsed.filter((t) => !t.ok).length,
-                });
-                // Resolve any in-flight task for this project to its final status.
-                // Boss can still override via update_task — this just gives it a sane
-                // default so the user's overlay-driven dispatches close out cleanly.
-                const taskId = this.inFlightTaskByProject.get(event.summary.project);
-                finishedTaskId = taskId ?? null;
-                if (taskId) {
-                    this.inFlightTaskByProject.delete(event.summary.project);
-                    const task = tasksStore.byId(taskId);
-                    if (task && task.status === "in_progress") {
-                        // Use the worker's SELF-REPORTED status from the trailer ("Status:
-                        // DONE | UNVERIFIED | PARTIAL | BLOCKED | INFO"). The previous
-                        // heuristic "any tool failed → blocked" was way too aggressive —
-                        // workers commonly have an incidental bash non-zero (grep with no
-                        // match, cd to wrong path) during exploration even when the task
-                        // itself was completed cleanly. Self-report is what the boss reads
-                        // anyway, so we should mark off the same signal.
-                        const reported = parseReportedStatus(event.summary.finalText);
-                        const newStatus = reportedToTaskStatus(reported, event.summary.toolsUsed.some((t) => !t.ok));
-                        await tasksStore.update(taskId, {
-                            status: newStatus,
-                            resultSummary: event.summary.finalText,
-                        });
-                    }
-                }
-            }
-            if (event.kind === "worker_error") {
-                this.hadWorkerActivitySinceReady = true;
-                log("ERROR", "worker_error", event.message, { project: event.project });
-                const taskId = this.inFlightTaskByProject.get(event.project);
-                if (taskId) {
-                    this.inFlightTaskByProject.delete(event.project);
-                    await tasksStore.update(taskId, {
-                        status: "blocked",
-                        notes: `Worker error: ${event.message}`,
-                    });
-                }
-            }
-            // Auto-compact when over 80% of context — mirrors AgentSession.runLoop.
-            // Workers handle their own compaction independently (via AgentSession).
-            await this.runCompaction(false);
-            // Snapshot every worker's status at the moment the event arrives so the
-            // boss reasons from live state, not from its memory of past dispatches.
-            // Without this the boss can hallucinate "all idle" mid-batch — by event
-            // 3 of 5 it has heard 3 completions and may assume the run is over even
-            // though workers 4 and 5 are still active.
-            const workerSnapshot = [...this.workers.entries()].map(([name, w]) => ({
-                name,
-                status: w.getStatus(),
-            }));
-            // Drain any auto-chain notices accumulated since the last event so the
-            // boss is told explicitly which projects we re-dispatched on its behalf.
-            const notices = this.pendingAutoChainNotices.splice(0);
-            const text = formatEventForBoss(event, workerSnapshot, notices);
-            bossStore.startStreaming();
-            // Fresh AbortController for this turn so ESC can cancel just this call.
-            this.turnAc = new AbortController();
-            this.bossAgent.setSignal(this.turnAc.signal);
-            try {
-                const stream = this.bossAgent.prompt(text);
-                for await (const e of stream) {
-                    switch (e.type) {
-                        case "text_delta":
-                            bossStore.appendStreamText(e.text);
-                            break;
-                        case "thinking_delta":
-                            bossStore.appendStreamThinking(e.text);
-                            break;
-                        case "tool_call_start":
-                            // Flush any preceding text so chronological order is preserved
-                            // in scrollback (text → tool → text → tool, not text-block then tool-block).
-                            bossStore.flushPendingText();
-                            bossStore.startTool(e.toolCallId, e.name, e.args);
-                            bossStore.setActivityPhase("tools");
-                            break;
-                        case "tool_call_end":
-                            bossStore.endTool(e.toolCallId, e.isError, e.durationMs, e.result, e.details);
-                            break;
-                        case "turn_end":
-                            // Mirror ggcoder/useAgentLoop: total context = uncached input +
-                            // cache reads + cache writes (Anthropic separates input/output,
-                            // others share the window so include output too). Without adding
-                            // cache, prompt-cached calls report a tiny inputTokens delta and
-                            // the footer bar appears stuck at 0%.
-                            if (e.usage) {
-                                bossStore.setBossInputTokens(computeContextUsed(e.usage, this.opts.bossProvider));
-                            }
-                            // Flush trailing text from this turn. Subsequent turns may add more.
-                            bossStore.flushPendingText();
-                            // Flush any tool-queued end-of-turn infos (e.g. add_task's
-                            // Ctrl+T hint) so they land AFTER the boss's tool calls, not
-                            // interleaved with them.
-                            bossStore.flushEndOfTurnInfos();
-                            break;
-                        case "retry":
-                            if (!e.silent) {
-                                bossStore.setRetryInfo({
-                                    reason: e.reason,
-                                    attempt: e.attempt,
-                                    maxAttempts: e.maxAttempts,
-                                    delayMs: e.delayMs,
-                                });
-                            }
-                            break;
-                        case "error":
-                            bossStore.appendInfo(formatProviderError(e.error.message), "error");
-                            break;
-                        default:
-                            break;
-                    }
-                }
-            }
-            catch (err) {
-                if (isAbortError(err)) {
-                    // Mirror ggcoder's onAborted: convert any in-flight tools to
-                    // "Stopped." entries so the user sees the same visual feedback.
-                    bossStore.interruptStreaming();
-                    if (!this.running) {
-                        bossStore.finishStreaming();
-                        return;
-                    }
-                    bossStore.appendInfo("Interrupted by user.", "warning");
-                    bossStore.finishStreaming();
-                    await this.persistNewMessages();
-                    continue;
-                }
-                const message = err instanceof Error ? err.message : String(err);
-                log("ERROR", "boss_turn", message);
-                bossStore.appendInfo(formatProviderError(message), "error");
-            }
-            bossStore.finishStreaming();
-            await this.persistNewMessages();
-            // Auto-chain: after the boss finishes processing a worker_turn_complete,
-            // if it didn't dispatch anything for that project (worker is still idle)
-            // AND there are more pending tasks for that project, fire the next one
-            // automatically. The idle check arbitrates with the boss — if the boss
-            // DID prompt_worker / dispatch_pending / re-prompt during its turn, the
-            // worker is now "working", we skip. So this only kicks in when the boss
-            // implicitly leaves the project parked.
-            // Auto-chain ONLY fires when the just-finished event was itself a
-            // dispatched task (had a taskId tracked in inFlightTaskByProject above).
-            // Otherwise we'd hijack ad-hoc prompt_worker calls — e.g. recon prompts
-            // — by dispatching pending backlog tasks the user never asked to run.
-            if (event.kind === "worker_turn_complete" && finishedTaskId) {
-                await this.maybeAutoChain(event.summary.project);
-            }
-            // All-clear chime — fires when the orchestrator winds down after a
-            // burst of activity. Conditions: at least one worker event happened
-            // since the last chime, every worker is now idle, and the queue is
-            // drained (no more events queued for the boss). Resets the flag so
-            // the next workflow gets its own chime.
-            const allWorkersIdle = [...this.workers.values()].every((w) => w.getStatus() === "idle");
-            if (this.hadWorkerActivitySinceReady && allWorkersIdle && this.queue.size() === 0) {
-                this.hadWorkerActivitySinceReady = false;
-                log("INFO", "all_clear", "all workers idle, queue empty");
-                void playReadyAudio();
-            }
-        }
-    }
-    async maybeAutoChain(project) {
-        const worker = this.workers.get(project);
-        if (!worker || worker.getStatus() !== "idle") {
-            log("DEBUG", "auto_chain", "skip — worker not idle", { project });
-            return;
-        }
-        if (this.inFlightTaskByProject.has(project)) {
-            log("DEBUG", "auto_chain", "skip — task already in flight", { project });
-            return;
-        }
-        // Pull pending OR blocked — auto-chain retries blocked tasks too so a
-        // single bad turn doesn't park the whole project. Pending is preferred.
-        const next = tasksStore.nextDispatchable(project);
-        if (!next) {
-            log("DEBUG", "auto_chain", "skip — no dispatchable tasks", { project });
-            return;
-        }
-        if (next.status === "blocked") {
-            await tasksStore.update(next.id, { status: "pending", notes: undefined });
-        }
-        log("INFO", "auto_chain", "dispatching next task", {
-            project,
-            taskId: next.id,
-            title: next.title,
-            previousStatus: next.status,
-        });
-        await this.dispatchTaskByDescription(project, next.description, next.fresh === true, next.id);
-        // Queue a note for the boss so it knows this project is on a fresh task.
-        // Without this the boss sees "X(working)" in the next event's trailer and
-        // dismisses it as stale.
-        this.pendingAutoChainNotices.push({ project, title: next.title });
-    }
-    async dispose() {
-        this.running = false;
-        this.ac.abort();
-        // Wake the queue if it's blocked on next() so the run loop can exit.
-        this.queue.push({
-            kind: "user_message",
-            text: "[shutdown]",
-            timestamp: new Date().toISOString(),
-        });
-        await Promise.all([...this.workers.values()].map((w) => w.dispose()));
-    }
-}
-/**
- * Pull the worker's self-reported "Status: X" line out of its final text. The
- * trailer is appended by every prompt via WORKER_PROMPT_BRIEF, so it should
- * always be there for task-style runs. Returns null if missing or unrecognised.
- */
-export function parseReportedStatus(finalText) {
-    // Match the LAST "Status: X" line — workers occasionally mention statuses
-    // mid-text and we want the trailer's value, not an example sentence.
-    const matches = [
-        ...finalText.matchAll(/^\s*Status:\s*(DONE|UNVERIFIED|PARTIAL|BLOCKED|INFO)\b/gim),
-    ];
-    const last = matches[matches.length - 1];
-    if (!last)
-        return null;
-    return last[1].toUpperCase();
-}
-/**
- * Map worker self-report to the task plan's status enum. Falls back to the
- * tool-failure heuristic ONLY when the trailer is missing — that's the only
- * way to recover useful state for non-compliant workers.
- */
-export function reportedToTaskStatus(reported, anyToolFailed) {
-    if (reported === "DONE")
-        return "done";
-    if (reported === "INFO")
-        return "done"; // question answered, nothing to retry
-    if (reported === "BLOCKED")
-        return "blocked";
-    // UNVERIFIED / PARTIAL: keep the task as "in_progress" so the boss's next
-    // re-prompt picks it up. Tasks-overlay shows it as the active row.
-    if (reported === "UNVERIFIED" || reported === "PARTIAL")
-        return "in_progress";
-    // No trailer — last-resort heuristic.
-    return anyToolFailed ? "blocked" : "done";
-}
-function formatEventForBoss(event, workerSnapshot, autoChainNotices) {
-    if (event.kind === "user_message") {
-        return event.text;
-    }
-    // Live worker statuses, formatted as a single trailing line so the boss
-    // always sees who's still running. Excludes the worker the event is FROM
-    // (the boss can read that worker's outcome from the event body itself).
-    const renderOthers = (excludeName) => {
-        const others = workerSnapshot
-            .filter((w) => w.name !== excludeName)
-            .map((w) => `${w.name}(${w.status})`)
-            .join(" ");
-        return others.length > 0 ? `\nother_workers: ${others}` : "";
-    };
-    // Auto-chain trailer — explicit per-project list so the boss can't dismiss
-    // the trailer's "(working)" entries as stale.
-    const renderAutoChain = () => {
-        if (autoChainNotices.length === 0)
-            return "";
-        const lines = autoChainNotices.map((n) => `  - ${n.project}: "${n.title}"`);
-        return `\nauto_dispatched_since_last_event:\n${lines.join("\n")}`;
-    };
-    if (event.kind === "worker_turn_complete") {
-        const s = event.summary;
-        const tools = s.toolsUsed.length > 0
-            ? s.toolsUsed.map((t) => `${t.ok ? "✓" : "✗"}${t.name}`).join(", ")
-            : "(none)";
-        return `[event:worker_turn_complete] project="${s.project}" turn=${s.turnIndex} timestamp=${s.timestamp}
-tools_used: ${tools}
-final_text:
-${s.finalText || "(empty)"}${renderOthers(s.project)}${renderAutoChain()}`;
-    }
-    return `[event:worker_error] project="${event.project}" timestamp=${event.timestamp}
-${event.message}${renderOthers(event.project)}${renderAutoChain()}`;
-}
-/**
- * Total context used in tokens. Mirrors ggcoder/useAgentLoop: Anthropic counts
- * uncached input + cache reads/writes (output is metered separately); other
- * providers share a single window so output counts too.
- */
-function computeContextUsed(usage, provider) {
-    const inputContext = (usage.inputTokens ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-    return provider === "anthropic" ? inputContext : inputContext + (usage.outputTokens ?? 0);
-}
-/**
- * Map raw provider error text to a human-friendly hint. Mirrors ggcoder's
- * pattern in App.tsx so users see the same diagnostic phrasing.
- */
-function formatProviderError(message) {
-    const lower = message.toLowerCase();
-    if (lower.includes("overloaded") || lower.includes("engine_overloaded")) {
-        return `${message}\nHint: provider is under heavy load — try again in a moment.`;
-    }
-    if (lower.includes("insufficient balance") ||
-        lower.includes("quota exceeded") ||
-        lower.includes("recharge")) {
-        return `${message}\nHint: billing or quota issue — check your account balance.`;
-    }
-    if (lower.includes("rate limit") ||
-        lower.includes("too many requests") ||
-        lower.includes("429")) {
-        return `${message}\nHint: provider rate limit — wait a moment before retrying.`;
-    }
-    if (lower.includes("timeout") || lower.includes("timed out")) {
-        return `${message}\nHint: provider timed out — their servers may be slow.`;
-    }
-    if (lower.includes("does not recognize the requested model") ||
-        (lower.includes("model") && (lower.includes("not exist") || lower.includes("not found")))) {
-        return `${message}\nHint: use /model to switch, or check that your account has access.`;
-    }
-    return message;
-}
-//# sourceMappingURL=orchestrator.js.map