@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/core/agent/agent-loop.js

@@ -0,0 +1,402 @@
+import { combineSignals } from '../../utils/signals.js';
+import { unifiedDiff, countChanges } from '../../utils/diff.js';
+import { readFile, stat } from 'node:fs/promises';
+import { resolve, relative } from 'node:path';
+import { isBinaryish } from '../tools/filesystem.js';
+import { homedir } from 'node:os';
+const MUTATING_TOOLS = {
+    git_add: 'git add',
+    git_commit: 'git commit',
+};
+export class AgentLoop {
+    opts;
+    runAbort = null;
+    turnCount = 0;
+    delegationsUsed = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Interrupt the in-flight run (stream or a parked tool). Safe to call anytime. */
+    abort() {
+        this.runAbort?.abort();
+    }
+    /** The active run's abort signal (undefined between runs). */
+    get runSignal() {
+        return this.runAbort?.signal;
+    }
+    get delegationsUsedCount() {
+        return this.delegationsUsed;
+    }
+    async run(userText) {
+        this.turnCount = 0;
+        this.runAbort = new AbortController();
+        const bus = this.opts.bus;
+        const userMsg = this.opts.context.addUser(userText);
+        bus.emit('onUserMessage', userMsg);
+        return this.iterate();
+    }
+    async iterate() {
+        const bus = this.opts.bus;
+        const max = this.opts.maxIterations ?? 16;
+        const runSignal = () => this.runAbort?.signal;
+        for (let turn = 0; turn < max; turn++) {
+            this.turnCount = turn + 1;
+            // Compaction: keep the outgoing context inside budget.
+            const budget = this.opts.contextBudgetTokens ?? 0;
+            if (budget > 0) {
+                const compacted = this.opts.context.compact(budget);
+                if (compacted.droppedPairs > 0) {
+                    bus.emit('onContextSummary', compacted);
+                }
+            }
+            const signal = runSignal();
+            if (signal?.aborted)
+                return { turns: this.turnCount, interrupted: true };
+            const route = this.opts.router.peek();
+            if (route)
+                bus.emit('onRoute', { ...route, strategy: route.strategy });
+            const asstMsg = {
+                id: `a_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+                role: 'assistant',
+                content: '',
+                streaming: true,
+                createdAt: Date.now(),
+                model: route?.model,
+            };
+            bus.emit('onAssistantStart', asstMsg);
+            const toolCalls = [];
+            let usage;
+            // Up-front failures (429, flaky connection, route hot-swap) are retried
+            // once after a short backoff: nothing was streamed, so replaying the
+            // identical context is safe. Failures after output started are terminal.
+            for (let attempt = 0;; attempt++) {
+                try {
+                    const streamCtl = new AbortController();
+                    const streamTimeoutMs = this.opts.streamTimeoutMs ?? 120_000;
+                    const timer = setTimeout(() => streamCtl.abort(new Error(`stream timed out after ${streamTimeoutMs}ms`)), streamTimeoutMs);
+                    const streamSignal = combineSignals([signal, streamCtl.signal]);
+                    const gen = this.opts.router.stream({
+                        messages: this.opts.context.toOutgoing(),
+                        tools: this.opts.tools.toToolDefs(),
+                        model: '',
+                        signal: streamSignal,
+                        retries: 1,
+                        retryDelayMs: 600,
+                        reasoning: this.opts.reasoning,
+                    });
+                    try {
+                        for await (const ev of gen) {
+                            if (ev.type === 'token') {
+                                asstMsg.content += ev.text;
+                                bus.emit('onToken', ev.text);
+                                await throttle(this.opts.maxTokensPerSecond);
+                            }
+                            else if (ev.type === 'reasoning') {
+                                asstMsg.reasoning = (asstMsg.reasoning ?? '') + ev.text;
+                                bus.emit('onThinking', ev.text);
+                            }
+                            else if (ev.type === 'tool_call_start') {
+                                const call = {
+                                    id: ev.id,
+                                    name: ev.name,
+                                    args: '',
+                                    status: 'pending',
+                                    startedAt: Date.now(),
+                                };
+                                toolCalls.push(call);
+                                bus.emit('onToolStart', call);
+                            }
+                            else if (ev.type === 'tool_call_args') {
+                                const call = toolCalls.find((c) => c.id === ev.id);
+                                if (call) {
+                                    call.args += ev.args;
+                                    bus.emit('onToolUpdate', { ...call });
+                                }
+                            }
+                            else if (ev.type === 'tool_call_end') {
+                                const call = toolCalls.find((c) => c.id === ev.id);
+                                if (call) {
+                                    call.name = ev.name;
+                                    call.args = ev.args;
+                                    call.status = 'running';
+                                    bus.emit('onToolUpdate', { ...call });
+                                }
+                            }
+                            else if (ev.type === 'done') {
+                                usage = ev.usage;
+                                break;
+                            }
+                        }
+                    }
+                    finally {
+                        clearTimeout(timer);
+                    }
+                    break;
+                }
+                catch (err) {
+                    if (signal?.aborted) {
+                        bus.emit('onError', new Error('Interrupted.'));
+                        bus.emit('onAssistantEnd', asstMsg);
+                        return { turns: this.turnCount, interrupted: true };
+                    }
+                    const nothingEmitted = asstMsg.content.length === 0 && toolCalls.length === 0;
+                    if (nothingEmitted && attempt === 0) {
+                        await sleep(1200);
+                        continue;
+                    }
+                    bus.emit('onError', err);
+                    bus.emit('onAssistantEnd', asstMsg);
+                    return { turns: this.turnCount, error: err?.message ?? String(err) };
+                }
+            }
+            asstMsg.streaming = false;
+            asstMsg.reasoningOpen = (asstMsg.reasoning?.length ?? 0) > 0;
+            asstMsg.toolCalls = toolCalls;
+            asstMsg.usage = usage;
+            asstMsg.model = route?.model ?? asstMsg.model;
+            if (toolCalls.length === 0) {
+                bus.emit('onAssistantEnd', asstMsg);
+                if (asstMsg.content.trim().length > 0 || this.turnCount >= max) {
+                    this.opts.context.addAssistant(asstMsg.content, { model: asstMsg.model, toolCalls });
+                    return { turns: this.turnCount };
+                }
+                // Whitespace-only generation (Gemini occasionally emits a bare "\n");
+                // don't pollute history, burn a turn slot, and try the model again.
+                continue;
+            }
+            // Execute each tool call, feed results back into context
+            for (const call of toolCalls) {
+                await this.executeTool(call);
+            }
+            this.opts.context.addAssistant(asstMsg.content, { model: asstMsg.model, toolCalls });
+            bus.emit('onAssistantEnd', asstMsg);
+            // Overflow-driven compaction (adapted from opencode's loop protection):
+            // after a tool-heavy turn, bring the outgoing context back inside budget
+            // before the next model call so a long session keeps functioning.
+            if (budget > 0 && toolCalls.length > 0) {
+                const compacted = this.opts.context.compact(budget);
+                if (compacted.droppedPairs > 0) {
+                    bus.emit('onContextSummary', compacted);
+                }
+            }
+        }
+        bus.emit('onError', new Error(`Max iterations (${max}) reached`));
+        return { turns: this.turnCount };
+    }
+    async executeTool(call) {
+        const bus = this.opts.bus;
+        const startedAt = Date.now();
+        // Delegation: the lead hands work to a sub-agent (synchronous, bounded).
+        if (call.name === 'delegate_task' && this.opts.delegate) {
+            await this.runDelegation(call);
+            return;
+        }
+        let denied = false;
+        if (call.name === 'run_shell') {
+            const decision = await this.opts.permissions.checkCommand(parseCommandArg(call.args));
+            denied = decision === 'deny';
+        }
+        else if (call.name === 'write_file') {
+            const decision = await this.opts.permissions.checkPath(parseWritePath(call.args), 'write');
+            denied = decision === 'deny';
+        }
+        else if (MUTATING_TOOLS[call.name]) {
+            const decision = await this.opts.permissions.checkCommand(MUTATING_TOOLS[call.name]);
+            denied = decision === 'deny';
+        }
+        if (this.opts.readOnly && call.name !== 'run_shell') {
+            const readOnlyDenied = ['edit_file', 'write_file', 'git_add', 'git_commit'].includes(call.name);
+            denied = denied || readOnlyDenied;
+        }
+        bus.emit('onToolUpdate', { ...call, status: 'running' });
+        if (denied) {
+            call.status = 'error';
+            call.result = 'Blocked by permission policy.';
+            call.endedAt = Date.now();
+            call.durationMs = call.endedAt - startedAt;
+            bus.emit('onToolEnd', call);
+            this.opts.context.addToolResult(call, call.result, true);
+            return;
+        }
+        const tool = this.opts.tools.get(call.name);
+        let result;
+        if (!tool) {
+            result = { content: `Unknown tool: ${call.name}`, isError: true };
+        }
+        else {
+            let args = {};
+            try {
+                args = JSON.parse(call.args);
+            }
+            catch {
+                args = { value: call.args };
+            }
+            // Diff review: snapshot the target file before a mutating edit so the
+            // change can be surfaced to the user as a reviewable unified diff.
+            const diffSnapshot = await captureSnapshot(args, this.opts.cwd ?? '', call.name);
+            // Per-tool timeout + run abort, combined.
+            const toolCtl = new AbortController();
+            const timeoutMs = this.opts.timeoutMs ?? 30_000;
+            const timer = setTimeout(() => toolCtl.abort(new Error(`tool timed out after ${timeoutMs}ms`)), timeoutMs);
+            const toolSignal = combineSignals([this.runAbort?.signal, toolCtl.signal]);
+            const ctx = this.opts.tools.createToolContext();
+            ctx.canWrite = !this.opts.readOnly;
+            ctx.signal = toolSignal;
+            if (this.opts.toolContextExtras)
+                Object.assign(ctx, this.opts.toolContextExtras);
+            try {
+                result = await raceTimeout(tool.run(args, ctx), timeoutMs + 1_000, `tool timed out after ${timeoutMs}ms`);
+            }
+            catch (err) {
+                result = { content: `Tool error: ${err.message}`, isError: true };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!result.isError && diffSnapshot) {
+                await this.emitDiff(diffSnapshot, result.content);
+            }
+        }
+        call.status = result.isError ? 'error' : 'done';
+        call.result = result.content;
+        call.endedAt = Date.now();
+        call.durationMs = call.endedAt - startedAt;
+        bus.emit('onToolEnd', call);
+        this.opts.context.addToolResult(call, result.content, result.isError ?? false);
+    }
+    async emitDiff(snapshot, toolResult) {
+        try {
+            const after = await readFile(snapshot.resolvedPath, 'utf8').catch(() => null);
+            if (after === null || after === snapshot.before)
+                return;
+            const label = snapshot.relPath;
+            const diff = unifiedDiff(snapshot.before ?? '', after, label);
+            if (!diff)
+                return;
+            const { added, removed } = countChanges(diff);
+            const fileDiff = { path: label, diff, added, removed };
+            this.opts.bus.emit('onFileDiff', fileDiff);
+        }
+        catch {
+            // Diff capture is best-effort; never break the loop over it.
+        }
+        void toolResult;
+    }
+    async runDelegation(call) {
+        const bus = this.opts.bus;
+        const startedAt = Date.now();
+        const maxDelegations = this.opts.maxDelegations ?? 6;
+        bus.emit('onToolUpdate', { ...call, status: 'running' });
+        if (this.delegationsUsed >= maxDelegations) {
+            call.status = 'error';
+            call.result = `Blocked: delegation budget (${maxDelegations}) exhausted this turn.`;
+            call.endedAt = Date.now();
+            call.durationMs = call.endedAt - startedAt;
+            bus.emit('onToolEnd', call);
+            this.opts.context.addToolResult(call, call.result, true);
+            return;
+        }
+        this.delegationsUsed++;
+        let args = {};
+        try {
+            args = JSON.parse(call.args);
+        }
+        catch {
+            args = {};
+        }
+        const parallel = Array.isArray(args.parallel) ? args.parallel.filter((j) => j && j.task) : [];
+        const jobs = parallel.length > 0
+            ? parallel.map((j) => ({ role: String(j.role ?? 'coder'), task: String(j.task ?? ''), files: j.files }))
+            : [{ role: String(args.role ?? 'coder'), task: String(args.task ?? ''), files: args.files }];
+        if (jobs.some((j) => !j.task.trim())) {
+            call.status = 'error';
+            call.result = 'Error: delegate_task requires a non-empty task for every job (single or parallel).';
+            call.endedAt = Date.now();
+            call.durationMs = call.endedAt - startedAt;
+            bus.emit('onToolEnd', call);
+            this.opts.context.addToolResult(call, call.result, true);
+            return;
+        }
+        const impl = this.opts.delegate;
+        const results = await Promise.all(jobs.map((j) => impl(j)));
+        const ok = results.every((r) => r.ok);
+        const lines = results
+            .map((r, i) => `<delegated-${jobs[i].role} ok="${r.ok}">\n${r.summary}\n</delegated-${jobs[i].role}>`)
+            .join('\n\n');
+        call.status = ok ? 'done' : 'error';
+        call.result = lines;
+        call.endedAt = Date.now();
+        call.durationMs = call.endedAt - startedAt;
+        bus.emit('onToolEnd', call);
+        this.opts.context.addToolResult(call, lines, !ok);
+    }
+}
+function parseCommandArg(args) {
+    try {
+        const parsed = JSON.parse(args);
+        return parsed.command ?? '';
+    }
+    catch {
+        return args;
+    }
+}
+function parseWritePath(args) {
+    try {
+        const parsed = JSON.parse(args);
+        return parsed.path ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function resolveCwdPath(p, cwd) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return `${homedir()}${p.slice(1)}`;
+    if (p.startsWith('/'))
+        return p;
+    return resolve(cwd, p);
+}
+async function captureSnapshot(args, cwd, toolName) {
+    if (toolName !== 'edit_file' && toolName !== 'write_file')
+        return null;
+    const rawPath = typeof args['path'] === 'string' ? args['path'] : null;
+    if (!rawPath)
+        return null;
+    const resolvedPath = resolveCwdPath(rawPath, cwd);
+    try {
+        const st = await stat(resolvedPath);
+        if (st.size > 1_500_000 || isBinaryish(resolvedPath))
+            return null;
+        const before = await readFile(resolvedPath, 'utf8');
+        return { resolvedPath, relPath: relative(cwd, resolvedPath) || rawPath, before };
+    }
+    catch {
+        // File doesn't exist yet → treat as empty "before" for a create diff.
+        return { resolvedPath, relPath: relative(cwd, resolvedPath) || rawPath, before: null };
+    }
+}
+async function throttle(maxTokensPerSecond) {
+    if (!maxTokensPerSecond || maxTokensPerSecond <= 0)
+        return;
+    await new Promise((r) => setTimeout(r, 1000 / maxTokensPerSecond));
+}
+async function raceTimeout(p, ms, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            p,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function sleep(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+}

package/dist/src/core/agents/delegate.js

@@ -0,0 +1,120 @@
+import { AgentLoop } from '../agent/agent-loop.js';
+import { ContextManager } from '../context/context-manager.js';
+import { READ_ONLY_TOOLS, CODER_TOOLS } from '../tools/registry.js';
+import { buildRoleSystemPrompt } from './prompts.js';
+const REVIEWER_TOOLS = [...READ_ONLY_TOOLS, 'run_shell'];
+const BY_ROLE = {
+    architect: READ_ONLY_TOOLS,
+    coder: CODER_TOOLS,
+    reviewer: REVIEWER_TOOLS,
+};
+/**
+ * Builds the delegate implementation bound to the live agent runtime.
+ * Each delegation runs a fresh sub-agent: isolated ContextManager, a
+ * role-restricted tool registry (shared implementations), same router,
+ * same permission policy. The parent context is NOT copied into the
+ * sub-agent — the task description is the only interface, which keeps
+ * context cheap.
+ */
+export function createDelegate(ctx) {
+    const cache = new Map();
+    return async (req) => {
+        if (!(req.role in BY_ROLE)) {
+            return { ok: false, summary: `unknown role: ${req.role}` };
+        }
+        const allowed = BY_ROLE[req.role];
+        const isReadOnly = req.role !== 'coder';
+        ctx.bus.emit('onAgentStart', { role: req.role, task: req.task });
+        let ok = false;
+        let summary = '(sub-agent produced no summary)';
+        try {
+            const systemPrompt = buildRoleSystemPrompt(req.role, {
+                cwd: ctx.cwd,
+                task: req.task,
+                files: req.files,
+            });
+            const subContext = new ContextManager(systemPrompt);
+            const subRegistry = ctx.registry.restrict(allowed);
+            const sub = new AgentLoop({
+                bus: ctx.bus,
+                router: ctx.router,
+                context: subContext,
+                tools: subRegistry,
+                permissions: ctx.permissions,
+                systemPrompt,
+                maxIterations: ctx.config.agent?.maxIterations ?? 12,
+                cwd: ctx.cwd,
+                timeoutMs: ctx.config.tools?.timeoutMs ?? 30_000,
+                streamTimeoutMs: ctx.config.runtime?.streamTimeoutMs ?? 120_000,
+                contextBudgetTokens: ctx.config.agent?.contextBudgetTokens ?? 48_000,
+                readOnly: isReadOnly,
+                reasoning: ctx.reasoning,
+            });
+            const res = await sub.run(req.task);
+            const last = lastAssistantMessage(subContext.history());
+            summary = last && last.content.trim() ? last.content.trim() : '(sub-agent finished without a summary)';
+            ok = !res.interrupted && Boolean(last?.content.trim());
+        }
+        catch (err) {
+            summary = `sub-agent crashed: ${err.message}`;
+            ok = false;
+        }
+        finally {
+            void cache;
+            ctx.bus.emit('onAgentEnd', { role: req.role, ok, summary });
+        }
+        return { ok, summary };
+    };
+}
+function lastAssistantMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role === 'assistant' && m.content.trim())
+            return m;
+    }
+    return undefined;
+}
+/** Tool exposed only to the lead loop: delegates work to a sub-agent. */
+export function createDelegateTool(opts) {
+    return {
+        name: 'delegate_task',
+        description: 'Delegate a self-contained subtask to a specialist sub-agent (architect, coder, or reviewer). The sub-agent runs its own focused loop with an isolated context seeded with your description, then returns a structured summary. Use for: architecture plans (architect, read-only), implementation (coder), independent verification (reviewer, has test shell access). Do not delegate trivial steps — only work that benefits from a dedicated focus.',
+        parameters: {
+            type: 'object',
+            properties: {
+                role: {
+                    type: 'string',
+                    enum: ['architect', 'coder', 'reviewer'],
+                    description: 'architect = read-only plan/design; coder = implements with full tools; reviewer = read-only review + test commands.',
+                },
+                task: {
+                    type: 'string',
+                    description: 'Self-contained, specific description of the subtask. Include file paths, constraints, and the definition of done.',
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional list of relevant files to bound the sub-agent scope.',
+                },
+            },
+            required: ['role', 'task'],
+        },
+        async run(args) {
+            const impl = opts.delegate();
+            const role = String(args.role ?? '');
+            const task = String(args.task ?? '');
+            const files = Array.isArray(args.files) ? args.files.map(String) : undefined;
+            if (!task.trim())
+                return { content: 'Error: delegate_task requires a non-empty task.', isError: true };
+            const result = await impl({ role, task, files });
+            return {
+                content: `<delegated-${role} ok="${result.ok ? 'true' : 'false'}">\n${result.summary}\n</delegated-${role}>`,
+                isError: !result.ok,
+            };
+        },
+    };
+}
+/** Human-readable summary of a delegation result (used by the lead). */
+export function summarizeDelegation(r) {
+    return `\n\n[delegation ${r.ok ? 'succeeded' : 'failed'}]\n${r.summary}\n`;
+}

package/dist/src/core/agents/orchestrator.js

@@ -0,0 +1,58 @@
+import { AgentLoop } from '../agent/agent-loop.js';
+import { createDelegate, createDelegateTool } from './delegate.js';
+/**
+ * Orchestrator — the Lead agent. Runs one AgentLoop that has the full tool
+ * set PLUS the `delegate_task` tool. When the lead decides to delegate, a
+ * fresh sub-agent (architect/coder/reviewer) is spawned with an isolated
+ * context and a role-restricted registry; its summary is returned as the
+ * tool result so the lead decides next steps.
+ */
+export class Orchestrator {
+    lead;
+    constructor(opts) {
+        const dctx = {
+            bus: opts.bus,
+            router: opts.router,
+            permissions: opts.permissions,
+            cwd: opts.cwd,
+            registry: opts.registry,
+            config: opts.config,
+            reasoning: opts.config.reasoning,
+        };
+        const oldDelegate = createDelegate(dctx);
+        // Bridge the legacy role union to the orchestration DelegateFn signature.
+        const delegate = ((req) => {
+            if (req.role !== 'architect' && req.role !== 'coder' && req.role !== 'reviewer') {
+                return Promise.resolve({ ok: false, summary: `unknown role: ${req.role}` });
+            }
+            return oldDelegate(req);
+        });
+        opts.registry.register(createDelegateTool({ delegate: () => delegate }));
+        this.lead = new AgentLoop({
+            bus: opts.bus,
+            router: opts.router,
+            context: opts.context,
+            tools: opts.registry,
+            permissions: opts.permissions,
+            systemPrompt: opts.systemPrompt,
+            maxIterations: opts.config.agent?.maxIterations ?? 16,
+            maxDelegations: opts.config.agent?.maxDelegations ?? 6,
+            contextBudgetTokens: opts.config.agent?.contextBudgetTokens ?? 48_000,
+            timeoutMs: opts.config.tools?.timeoutMs ?? 30_000,
+            streamTimeoutMs: opts.config.runtime?.streamTimeoutMs ?? 120_000,
+            cwd: opts.cwd,
+            delegate,
+            maxTokensPerSecond: opts.maxTokensPerSecond,
+            reasoning: opts.config.reasoning,
+        });
+    }
+    async run(userText) {
+        return this.lead.run(userText);
+    }
+    abort() {
+        this.lead.abort();
+    }
+    get delegationsUsedCount() {
+        return this.lead.delegationsUsedCount;
+    }
+}

package/dist/src/core/agents/prompts.js

@@ -0,0 +1,82 @@
+import { isTermux, platformLabel, defaultShell } from '../../utils/platform.js';
+/**
+ * Sub-agent system prompts. Each agent is a self-contained AgentLoop with its
+ * own ContextManager seeded with the delegated task. The prompts are SHORT:
+ * the environment is constant, so it is injected once instead of per-message.
+ */
+function envBlock(cwd) {
+    const env = isTermux() ? 'Termux (Android aarch64)' : platformLabel();
+    return [
+        `- Platform: ${env}`,
+        `- Shell: ${defaultShell()}`,
+        `- Working directory: ${cwd}`,
+    ].join('\n');
+}
+export function buildRoleSystemPrompt(role, opts) {
+    const scope = opts.files && opts.files.length > 0
+        ? `\nRelevant files (focus here, do not wander):\n${opts.files.map((f) => `  - ${f}`).join('\n')}`
+        : '';
+    const base = `You are orbit-agent's ${roleTitle(role)} running as a terminal agent.
+
+# Operating environment
+${envBlock(opts.cwd)}
+${scope}
+
+# Assignment
+${opts.task}`;
+    switch (role) {
+        case 'architect':
+            return `${base}
+
+# Your job
+You design the implementation plan. Explore the code, identify how things fit together, and produce a precise, minimal plan: exact files, exact changes, and the order and verification steps. 
+
+# Rules
+- You are READ-ONLY. You cannot run shell commands or modify anything; only read, search, and inspect (including git status/diff/log).
+- Base plans on evidence you actually read, never guesses.
+- Prefer the smallest changes that satisfy the assignment.
+- End with a section "## Plan" listing concrete steps with file paths.
+- Keep the final answer under ~60 lines.`;
+        case 'coder':
+            return `${base}
+
+# Your job
+You implement the assignment. You have full tool access: read, edit, write, shell, git.
+
+# Rules
+- Read before you edit. Never write content you have not verified against the current file.
+- Prefer edit_file over write_file for surgical changes.
+- Run the project's checks (tests, typecheck, build) yourself before claiming success: \`npm test\`, \`node --test dist/tests/*.test.js\`, \`npm run typecheck\`, \`npm run build\` as applicable.
+- Do not modify unrelated files. Do not commit unless the assignment says so.
+- If something is genuinely blocked, say exactly what and why.
+- End with "## Summary" listing what you changed and the verification you ran.`;
+        case 'reviewer':
+            return `${base}
+
+# Your job
+Independently review the changes against the assignment. Find real problems: bugs, regressions, architectural issues, missing tests, style drift. Do NOT rubber-stamp.
+
+# Rules
+- You are READ-ONLY for file contents (no edit_file/write_file) but MAY run shell commands to verify (tests, typecheck, diff, log).
+- Verify claims: if code was changed, run the relevant checks and zip ZERO-opinion output.
+- Report concrete, actionable findings: file:line where possible, and the exact fix.
+- End with "## Verdict": PASS or FAIL, and if FAIL, a short list of required fixes.`;
+        default:
+            return base;
+    }
+}
+function roleTitle(role) {
+    switch (role) {
+        case 'lead': return 'Lead';
+        case 'architect': return 'Architect';
+        case 'coder': return 'Coder';
+        case 'reviewer': return 'Reviewer';
+    }
+}
+export const DELEGABLE_ROLES = ['architect', 'coder', 'reviewer'];
+export const ROLE_LABELS = {
+    lead: 'lead',
+    architect: 'architect',
+    coder: 'coder',
+    reviewer: 'reviewer',
+};

package/dist/src/core/agents/types.js

@@ -0,0 +1 @@
+export {};