c0de-agent 1.7.0 → 1.9.0

package/dist/core/prompt-registry.d.ts

@@ -3,7 +3,7 @@ declare const ROLE_DESCRIPTION = "You are c0de-agent, an open-source AI coding a
 declare const ENGINEERING_PRINCIPLES = "# Engineering Principles\n- Optimize for correctness first, then for the next maintainer six months out.\n- You have agency and taste: delete code that isn't pulling its weight, refuse unnecessary abstractions, prefer boring when it's called for.\n- Consider what code compiles to. Never allocate avoidably; no needless copies or computation.\n- You are not alone in this repo. Treat unexpected changes as the user's work and adapt \u2014 never revert edits you did not make unless explicitly asked.";
 declare const TOOL_USAGE = "# Tool Usage\nYou have dedicated tools \u2014 prefer them over shell commands for file operations:\n- Reading a file or listing a directory \u2192 `read` (NOT `cat`, `head`, `tail`).\n- Finding files by name or pattern \u2192 `glob` (NOT `find`, `ls -R`).\n- Searching file contents \u2192 `grep` (NOT shell `grep`/`rg`/`ack`, NOT `awk`/`sed`).\n- Modifying files \u2192 `edit`/`write` (NOT `sed`, `echo >`, heredocs).\n\nReserve `bash` for genuine command execution: builds, tests, git, or short pipelines that compute a fact (`wc -l`, `git status`, `diff`, a checksum). Never explore a codebase with `find`/`ls`/`cat` when `read`/`glob`/`grep` can.\n\nBatch independent tool calls in a single response \u2014 parallelize file reads and independent lookups. Only sequence when one call's result informs the next.\n\nWhen referencing code, use the `file_path:line_number` pattern so the user can navigate directly.";
 declare const CODEBASE = "# Working with the Codebase\nBefore changing files, understand the existing conventions. Mimic code style, reuse existing utilities, and follow established patterns.\n- NEVER assume a library is available, even if well known. Check package.json (or equivalent) and neighboring files first.\n- When creating a new component, look at existing ones first for naming, typing, and framework conventions.\n- When editing, read the surrounding context (especially imports) to make the change idiomatic. Never introduce code that exposes or logs secrets.";
-declare const EXECUTION_WORKFLOW = "# Execution Workflow\n1. Scope \u2014 plan before touching files; research existing code and conventions.\n2. Research \u2014 read sections, not snippets. Reuse existing patterns; a second convention beside an existing one is prohibited.\n3. Decompose \u2014 break multi-step work into steps and track them with the `todo` tool; skip for trivial requests. Plan only what makes the request work.\n4. Implement \u2014 fix problems at the source. Remove obsolete code \u2014 no leftover comments, aliases, or re-exports. Prefer editing existing files over new ones.\n5. Verify \u2014 never yield non-trivial work without proof: run the relevant tests. Prefer testing behavior, not plumbing. Don't test defaults.\n6. Cleanup \u2014 changelog, tests, docs, and removing scaffolding are the LAST phase, gated on the request demonstrably working. Never pre-plan cleanup before the request works.";
+declare const EXECUTION_WORKFLOW = "# Execution Workflow\n1. Scope \u2014 plan before touching files; research existing code and conventions.\n2. Research \u2014 read sections, not snippets. Reuse existing patterns; a second convention beside an existing one is prohibited.\n3. Decompose \u2014 break multi-step work into steps and track them with the `todo` tool; skip for trivial requests. Plan only what makes the request work.\n\nYou can also manage todos inline via tags in your text output (saves a tool-call round-trip). Tags use `phase-task` sequence numbers visible in the todo summary (e.g. `1-2` = phase 1, task 2; `1` = all tasks in phase 1). Operations:\n  - `<todo:init><todo:phase name=\"Name\"><todo:item>Task</todo:item></todo:phase></todo:init>` \u2014 create/replace the list\n  - `<todo:start seq=\"1-1\" />` \u2014 mark task in progress (task-level seq only)\n  - `<todo:done seq=\"1-2\" />` \u2014 complete a task (or entire phase: `seq=\"1\"`)\n  - `<todo:drop seq=\"2-1\" />` \u2014 abandon a task\n  - `<todo:rm seq=\"1-1\" />` \u2014 remove a task\n  - `<todo:append phase=\"1\"><todo:item>New</todo:item></todo:append>` \u2014 add tasks (phase is 1-based index)\n  - `<todo:view />` \u2014 request current state\nTags remain visible in your output text; they are not stripped. Both tags and the todo tool update the same state \u2014 use whichever is more convenient.\n4. Implement \u2014 fix problems at the source. Remove obsolete code \u2014 no leftover comments, aliases, or re-exports. Prefer editing existing files over new ones.\n5. Verify \u2014 never yield non-trivial work without proof: run the relevant tests. Prefer testing behavior, not plumbing. Don't test defaults.\n6. Cleanup \u2014 changelog, tests, docs, and removing scaffolding are the LAST phase, gated on the request demonstrably working. Never pre-plan cleanup before the request works.";
 declare const VERIFICATION = "# Verification & Evidence\n- Never yield non-trivial work without proof: tests, builds, or QA.\n- Run lint and typecheck after changes if the project provides them.\n- Every claim about code, tools, or tests must be grounded. Mark anything not directly observed as [INFERENCE].\n- Verification claims must match what was actually exercised. A passing typecheck does not prove an integration.";
 declare const DELIVERY_CONTRACT = "# Delivery Contract\n- \"Done\" means the deliverable behaves as specified end-to-end \u2014 not that a scaffold compiles.\n- Never yield unless complete. A phase boundary is never a yield point.\n- Never suppress tests to make code pass. Never fabricate outputs.\n- Never substitute an easier problem: don't infer extra scope, don't treat the symptom unless asked.\n- Never ship stubs, placeholders, mocks, no-ops, or fake fallbacks as finished work.\n- Default to clean cutover: migrate every caller; leave no shims or aliases.";
 declare const GIT_SAFETY = "# Git & Safety\n- NEVER commit unless the user explicitly asks. Committing is too proactive.\n- NEVER use `git reset --hard` or `git checkout --` unless explicitly approved.\n- Do not amend a commit unless asked.\n- You may be in a dirty worktree. NEVER revert changes you did not make; if unrelated changes conflict with your task, stop and ask.";

package/dist/core/prompt-registry.js

@@ -38,6 +38,16 @@ const EXECUTION_WORKFLOW = `# Execution Workflow
 1. Scope — plan before touching files; research existing code and conventions.
 2. Research — read sections, not snippets. Reuse existing patterns; a second convention beside an existing one is prohibited.
 3. Decompose — break multi-step work into steps and track them with the \`todo\` tool; skip for trivial requests. Plan only what makes the request work.
+
+You can also manage todos inline via tags in your text output (saves a tool-call round-trip). Tags use \`phase-task\` sequence numbers visible in the todo summary (e.g. \`1-2\` = phase 1, task 2; \`1\` = all tasks in phase 1). Operations:
+  - \`<todo:init><todo:phase name="Name"><todo:item>Task</todo:item></todo:phase></todo:init>\` — create/replace the list
+  - \`<todo:start seq="1-1" />\` — mark task in progress (task-level seq only)
+  - \`<todo:done seq="1-2" />\` — complete a task (or entire phase: \`seq="1"\`)
+  - \`<todo:drop seq="2-1" />\` — abandon a task
+  - \`<todo:rm seq="1-1" />\` — remove a task
+  - \`<todo:append phase="1"><todo:item>New</todo:item></todo:append>\` — add tasks (phase is 1-based index)
+  - \`<todo:view />\` — request current state
+Tags remain visible in your output text; they are not stripped. Both tags and the todo tool update the same state — use whichever is more convenient.
 4. Implement — fix problems at the source. Remove obsolete code — no leftover comments, aliases, or re-exports. Prefer editing existing files over new ones.
 5. Verify — never yield non-trivial work without proof: run the relevant tests. Prefer testing behavior, not plumbing. Don't test defaults.
 6. Cleanup — changelog, tests, docs, and removing scaffolding are the LAST phase, gated on the request demonstrably working. Never pre-plan cleanup before the request works.`;

package/dist/core/slash.js

@@ -132,7 +132,7 @@ const workflowCommand = {
         // registry 是 server 单例（含 builtin + global + server-cwd），不含其他项目的工作流。
         const projectWorkflows = await discoverWorkflows(ctx.cwd);
         const projectByName = new Map(projectWorkflows.map((w) => [w.meta.name, w]));
-        const resolveEntry = (name) => registry.get(name) ?? projectByName.get(name);
+        const resolveEntry = (name) => registry?.get(name) ?? projectByName.get(name);
         if (subcommand === 'list') {
             // 合并 registry + 项目级（去重：同名项目级覆盖）
             const byName = new Map(registry.list().map((w) => [w.meta.name, w]));

package/dist/core/todo-tags.d.ts

@@ -0,0 +1,46 @@
+import { type TodoItem, type TodoPhase } from '../tools/builtin/todo.js';
+/** A parsed todo tag, before seq resolution. */
+type ParsedTodoTag = {
+    op: 'init';
+    phases: {
+        name: string;
+        items: string[];
+    }[];
+} | {
+    op: 'start';
+    seq: string | undefined;
+} | {
+    op: 'done';
+    seq: string | undefined;
+} | {
+    op: 'drop';
+    seq: string | undefined;
+} | {
+    op: 'rm';
+    seq: string | undefined;
+} | {
+    op: 'append';
+    phaseSeq: number;
+    items: string[];
+} | {
+    op: 'view';
+};
+/** Result of applying todo tags to phases. */
+type ApplyTodoTagsResult = {
+    phases: TodoPhase[];
+    errors: string[];
+    hasView: boolean;
+};
+/** Parse all todo tags from text, preserving document order. */
+export declare function parseTodoTags(text: string): ParsedTodoTag[];
+/** Resolve a seq string ("1-2" or "1") to a phase and/or task.
+ *  Returns undefined if out of bounds or unparseable. */
+export declare function resolveSeq(phases: TodoPhase[], seq: string | undefined): {
+    phase: TodoPhase;
+    task?: TodoItem;
+} | undefined;
+/** Parse todo tags from text, resolve all seqs against the original snapshot,
+ *  then apply sequentially. Tags are applied in document order.
+ *  Does NOT mutate the input phases (clones first). */
+export declare function applyTodoTags(phases: TodoPhase[], text: string): ApplyTodoTagsResult;
+export {};

package/dist/core/todo-tags.js

@@ -0,0 +1,192 @@
+// todo-tags: parse <todo:*> tags from assistant text and apply them to todo phases.
+// Acts as a format-conversion layer on top of todo.ts's applyParams state machine.
+// Tags are NOT stripped from the text — they remain visible to the user.
+import { applyParams, clonePhases, } from '../tools/builtin/todo.js';
+// =============================================================================
+// Tag parser
+// =============================================================================
+/** Unified regex matching self-closing and container todo tags.
+ *  Group 1 = tag name, Group 2 = attributes, Group 3 = inner content (undefined for self-closing).
+ *  Backreference \1 ensures container close tag matches open tag. */
+const TAG_RE = /<todo:(\w+)([^>]*?)(?:\/>|>([\s\S]*?)<\/todo:\1>)/g;
+/** Parse <todo:item> tags from inner content. */
+function parseItems(inner) {
+    const items = [];
+    const itemRe = /<todo:item>([\s\S]*?)<\/todo:item>/g;
+    for (const m of inner.matchAll(itemRe)) {
+        items.push((m[1] ?? '').trim());
+    }
+    return items;
+}
+/** Parse <todo:phase> blocks from init inner content. */
+function parseInitInner(inner) {
+    const phases = [];
+    const phaseRe = /<todo:phase\s+name="([^"]+)">([\s\S]*?)<\/todo:phase>/g;
+    for (const m of inner.matchAll(phaseRe)) {
+        phases.push({ name: (m[1] ?? '').trim(), items: parseItems(m[2] ?? '') });
+    }
+    // Flat items without phase wrapper → default phase
+    if (phases.length === 0) {
+        const flat = parseItems(inner);
+        if (flat.length > 0)
+            phases.push({ name: 'Tasks', items: flat });
+    }
+    return phases;
+}
+/** Parse all todo tags from text, preserving document order. */
+export function parseTodoTags(text) {
+    const tags = [];
+    for (const m of text.matchAll(TAG_RE)) {
+        const op = m[1] ?? '';
+        const attrs = m[2] ?? '';
+        const inner = m[3];
+        // Skip structural tags parsed as part of init/append
+        if (op === 'phase' || op === 'item')
+            continue;
+        switch (op) {
+            case 'init':
+                tags.push({ op: 'init', phases: parseInitInner(inner ?? '') });
+                break;
+            case 'append': {
+                const phaseMatch = /phase="([^"]+)"/.exec(attrs);
+                const phaseSeq = phaseMatch ? Number.parseInt(phaseMatch[1] ?? '', 10) : Number.NaN;
+                tags.push({ op: 'append', phaseSeq, items: parseItems(inner ?? '') });
+                break;
+            }
+            case 'start':
+            case 'done':
+            case 'drop':
+            case 'rm': {
+                const seqMatch = /seq="([^"]+)"/.exec(attrs);
+                tags.push({ op, seq: seqMatch?.[1]?.trim() });
+                break;
+            }
+            case 'view':
+                tags.push({ op: 'view' });
+                break;
+            // Unknown tag names are silently ignored
+        }
+    }
+    return tags;
+}
+// =============================================================================
+// Seq resolver
+// =============================================================================
+/** Resolve a seq string ("1-2" or "1") to a phase and/or task.
+ *  Returns undefined if out of bounds or unparseable. */
+export function resolveSeq(phases, seq) {
+    if (!seq)
+        return undefined;
+    const parts = seq.split('-').map((s) => Number.parseInt(s.trim(), 10));
+    const phaseNum = parts[0];
+    if (phaseNum === undefined || Number.isNaN(phaseNum))
+        return undefined;
+    const phaseIdx = phaseNum - 1;
+    if (phaseIdx < 0 || phaseIdx >= phases.length)
+        return undefined;
+    const phase = phases[phaseIdx];
+    if (!phase)
+        return undefined;
+    if (parts.length === 1)
+        return { phase };
+    const taskNum = parts[1];
+    if (taskNum === undefined || Number.isNaN(taskNum))
+        return undefined;
+    const taskIdx = taskNum - 1;
+    if (taskIdx < 0 || taskIdx >= phase.tasks.length)
+        return undefined;
+    const task = phase.tasks[taskIdx];
+    if (!task)
+        return undefined;
+    return { phase, task };
+}
+// =============================================================================
+// Tag → TodoInput converter
+// =============================================================================
+/** Convert a parsed tag to a TodoInput, resolving seq against the given phases snapshot. */
+function tagToTodoInput(phases, tag) {
+    switch (tag.op) {
+        case 'init':
+            return {
+                input: {
+                    op: 'init',
+                    list: tag.phases.map((p) => ({ phase: p.name, items: p.items })),
+                },
+            };
+        case 'append': {
+            if (Number.isNaN(tag.phaseSeq) || tag.phaseSeq < 1 || tag.phaseSeq > phases.length) {
+                return { error: `Phase ${tag.phaseSeq} not found (have ${phases.length} phases)` };
+            }
+            const targetPhase = phases[tag.phaseSeq - 1];
+            if (!targetPhase) {
+                return { error: `Phase ${tag.phaseSeq} not found (have ${phases.length} phases)` };
+            }
+            return {
+                input: {
+                    op: 'append',
+                    phase: targetPhase.name,
+                    items: tag.items,
+                },
+            };
+        }
+        case 'view':
+            return { input: { op: 'view' } };
+        case 'start': {
+            const resolved = resolveSeq(phases, tag.seq);
+            if (!resolved)
+                return { error: `Invalid seq "${tag.seq}"` };
+            if (!resolved.task)
+                return { error: 'start requires a task-level seq (e.g. "1-2"), not phase-level' };
+            return { input: { op: 'start', task: resolved.task.content } };
+        }
+        case 'done':
+        case 'drop':
+        case 'rm': {
+            const resolved = resolveSeq(phases, tag.seq);
+            if (!resolved)
+                return { error: `Invalid seq "${tag.seq}"` };
+            if (!resolved.task)
+                return { input: { op: tag.op, phase: resolved.phase.name } };
+            return { input: { op: tag.op, task: resolved.task.content } };
+        }
+    }
+}
+// =============================================================================
+// Main entry: applyTodoTags
+// =============================================================================
+/** Parse todo tags from text, resolve all seqs against the original snapshot,
+ *  then apply sequentially. Tags are applied in document order.
+ *  Does NOT mutate the input phases (clones first). */
+export function applyTodoTags(phases, text) {
+    const tags = parseTodoTags(text);
+    if (tags.length === 0)
+        return { phases, errors: [], hasView: false };
+    // Pre-resolve all seqs against the original snapshot (LLM writes all tags
+    // based on one view; rm shifting must not corrupt later references).
+    const inputs = [];
+    const errors = [];
+    let hasView = false;
+    for (const tag of tags) {
+        if (tag.op === 'view') {
+            hasView = true;
+            continue;
+        }
+        const { input, error } = tagToTodoInput(phases, tag);
+        if (error)
+            errors.push(error);
+        else if (input)
+            inputs.push(input);
+    }
+    // Apply sequentially on a clone
+    let current = clonePhases(phases);
+    for (const input of inputs) {
+        const result = applyParams(current, input);
+        if (result.errors.length > 0) {
+            errors.push(...result.errors);
+        }
+        else {
+            current = result.phases;
+        }
+    }
+    return { phases: current, errors, hasView };
+}

package/dist/core/workflows/builtins.js

@@ -33,7 +33,7 @@ export default async function workflow(ctx) {
 
   const allFindings = scans
     .filter((r) => r.ok)
-    .flatMap((r) => { try { return JSON.parse(r.output).findings ?? [] } catch { return [] } })
+    .flatMap((r) => { try { return JSON.parse(r.output).findings ?? [] } catch (e) { console.warn('[workflow] 子 agent 输出非 JSON，已跳过该结果:', e instanceof Error ? e.message : String(e)); return [] } })
 
   progress(\`交叉验证 \${allFindings.length} 个发现...\`, { phase: 'verify' })
   const verified = await runSubagents('reviewer', allFindings.map((f) => ({
@@ -46,7 +46,7 @@ export default async function workflow(ctx) {
 
   const confirmed = verified
     .filter((r) => r.ok)
-    .map((r) => { try { return JSON.parse(r.output) } catch { return null } })
+    .map((r) => { try { return JSON.parse(r.output) } catch (e) { console.warn('[workflow] 子 agent 输出非 JSON，已跳过该结果:', e instanceof Error ? e.message : String(e)); return null } })
     .filter((v) => v?.confirmed)
 
   progress('生成报告...', { phase: 'report' })
@@ -85,7 +85,7 @@ export default async function workflow(ctx) {
 
   const allFindings = reviews
     .filter((r) => r.ok)
-    .flatMap((r) => { try { return JSON.parse(r.output).findings ?? [] } catch { return [] } })
+    .flatMap((r) => { try { return JSON.parse(r.output).findings ?? [] } catch (e) { console.warn('[workflow] 子 agent 输出非 JSON，已跳过该结果:', e instanceof Error ? e.message : String(e)); return [] } })
 
   progress('合并去重并生成报告...', { phase: 'merge' })
   const seen = new Set()
@@ -133,7 +133,7 @@ export default async function workflow(ctx) {
 
   const allItems = analyses
     .filter((r) => r.ok)
-    .flatMap((r) => { try { return JSON.parse(r.output).items ?? [] } catch { return [] } })
+    .flatMap((r) => { try { return JSON.parse(r.output).items ?? [] } catch (e) { console.warn('[workflow] 子 agent 输出非 JSON，已跳过该结果:', e instanceof Error ? e.message : String(e)); return [] } })
 
   progress('生成迁移报告...', { phase: 'report' })
   const high = allItems.filter((i) => i.impact === 'high').length

package/dist/core/workflows/discovery.js

@@ -99,7 +99,10 @@ async function saveWorkflow(name, source, target = 'project', projectDir) {
     }
     catch (e) {
         await unlink(filePath);
-        return { ok: false, error: `Failed to load workflow: ${e instanceof Error ? e.message : String(e)}` };
+        return {
+            ok: false,
+            error: `Failed to load workflow: ${e instanceof Error ? e.message : String(e)}`,
+        };
     }
 }
 export { discoverGlobalWorkflows, discoverWorkflows, saveWorkflow };

package/dist/llm/registry.d.ts

@@ -4,13 +4,26 @@ import type { Model } from './schema/options.js';
 type RouteEntry = ReturnType<typeof openAICompatRoute> & {
     models: Record<string, ModelCapabilities>;
 };
-type Registry = {
+/**
+ * Atomic, replaceable snapshot of every route + role binding.
+ *
+ * `Registry.table` is the single mutable field on a registry; `rebuildRegistry`
+ * swaps it in one reference assignment, so a `resolveRoute` /
+ * `resolveModelByRole` call firing at any moment observes a fully
+ * self-consistent table — either the complete previous set or the complete
+ * new set — never the half-cleared / half-registered intermediate that
+ * clear()-then-register would expose to a concurrent reader.
+ */
+type RouteTable = {
     routes: Map<string, RouteEntry>;
     roles: Map<string, {
         provider: string;
         model: string;
     }>;
 };
+type Registry = {
+    table: RouteTable;
+};
 declare const createRegistry: () => Registry;
 type ProviderInput = {
     name: string;
@@ -54,7 +67,21 @@ declare const resolveModelByRole: (registry: Registry, role: ModelRole) => {
 };
 /** Bind a role to a (provider, model) pair. */
 declare const setRole: (registry: Registry, role: ModelRole, provider: string, model: string) => void;
+/**
+ * Atomically rebuild the registry's routes + roles.
+ *
+ * `builder` populates a *detached* next registry via the normal
+ * `registerProvider` / `setRole` API; only after it returns is the live
+ * `table` pointer swapped in a single reference assignment. A reader that runs
+ * at any point during the build therefore sees the previous complete table,
+ * and the moment `rebuildRegistry` returns it sees the new complete table —
+ * never the partial intermediate the builder is still filling.
+ *
+ * Prefer this over clear()-then-register whenever the registry is shared with
+ * live request handlers (e.g. config hot-reload).
+ */
+declare const rebuildRegistry: (registry: Registry, builder: (next: Registry) => void) => void;
 /** Default role + a starter catalog of well-known models. */
 declare const builtinCapabilities: Record<string, Record<string, ModelCapabilities>>;
-export type { ProviderInput, Registry, ResolveResult, RouteEntry };
-export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overrideToCapabilities, registerProvider, resolveModelByRole, resolveRoute, setRole, };
+export type { ProviderInput, Registry, ResolveResult, RouteEntry, RouteTable };
+export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overrideToCapabilities, rebuildRegistry, registerProvider, resolveModelByRole, resolveRoute, setRole, };

package/dist/llm/registry.js

@@ -1,9 +1,9 @@
 import { openAICompatRoute } from './protocols/openai-compat.js';
 import { llmError } from './schema/errors.js';
 import { model as makeModel } from './schema/options.js';
-const createRegistry = () => ({ routes: new Map(), roles: new Map() });
+const createRegistry = () => ({ table: { routes: new Map(), roles: new Map() } });
 const registerProvider = (registry, input) => {
-    registry.routes.set(input.name, {
+    registry.table.routes.set(input.name, {
         ...openAICompatRoute({
             id: input.name,
             provider: input.name,
@@ -58,7 +58,7 @@ function overrideToCapabilities(overrides) {
  * Throws NoRoute when the provider is unknown.
  */
 const resolveRoute = (registry, provider, modelId) => {
-    const route = registry.routes.get(provider);
+    const route = registry.table.routes.get(provider);
     if (route === undefined) {
         throw llmError('LLM', 'resolve', {
             _tag: 'NoRoute',
@@ -80,9 +80,9 @@ const resolveRoute = (registry, provider, modelId) => {
 /** Resolve the (provider, model) configured for a given role. */
 const resolveModelByRole = (registry, role) => {
     const key = role._tag;
-    const entry = registry.roles.get(key);
+    const entry = registry.table.roles.get(key);
     if (entry === undefined) {
-        const fallback = registry.roles.get('default');
+        const fallback = registry.table.roles.get('default');
         if (fallback === undefined) {
             throw llmError('LLM', 'resolve', {
                 _tag: 'NoRoute',
@@ -97,7 +97,25 @@ const resolveModelByRole = (registry, role) => {
 };
 /** Bind a role to a (provider, model) pair. */
 const setRole = (registry, role, provider, model) => {
-    registry.roles.set(role._tag, { provider, model });
+    registry.table.roles.set(role._tag, { provider, model });
+};
+/**
+ * Atomically rebuild the registry's routes + roles.
+ *
+ * `builder` populates a *detached* next registry via the normal
+ * `registerProvider` / `setRole` API; only after it returns is the live
+ * `table` pointer swapped in a single reference assignment. A reader that runs
+ * at any point during the build therefore sees the previous complete table,
+ * and the moment `rebuildRegistry` returns it sees the new complete table —
+ * never the partial intermediate the builder is still filling.
+ *
+ * Prefer this over clear()-then-register whenever the registry is shared with
+ * live request handlers (e.g. config hot-reload).
+ */
+const rebuildRegistry = (registry, builder) => {
+    const next = createRegistry();
+    builder(next);
+    registry.table = next.table;
 };
 /** Default role + a starter catalog of well-known models. */
 const builtinCapabilities = {
@@ -133,4 +151,4 @@ const builtinCapabilities = {
         },
     },
 };
-export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overrideToCapabilities, registerProvider, resolveModelByRole, resolveRoute, setRole, };
+export { builtinCapabilities, createRegistry, DEFAULT_MODEL_CAPABILITIES, overrideToCapabilities, rebuildRegistry, registerProvider, resolveModelByRole, resolveRoute, setRole, };

package/dist/llm/retry.d.ts

@@ -1,4 +1,4 @@
-import type { LLMErrorReason } from './schema/errors.js';
+import type { LLMErrorReason, RetryPolicy } from './schema/errors.js';
 declare const RETRY_INITIAL_DELAY = 2000;
 declare const RETRY_MAX_DELAY_NO_HEADERS = 30000;
 declare const RETRY_MAX_DELAY = 2147483647;
@@ -11,10 +11,12 @@ declare const delay: (attempt: number, error?: unknown) => number;
 type Retryable = {
     message: string;
     reason: LLMErrorReason;
+    /** Per-reason policy: caps extra retries and per-attempt delay. */
+    policy: RetryPolicy;
 };
 /**
  * Decide whether a thrown error is retryable. Returns undefined when not retryable
- * (e.g. context overflow, auth, invalid request).
+ * (e.g. context overflow, auth, invalid request, mid-stream Transport failure).
  */
 declare const retryable: (error: unknown) => Retryable | undefined;
 type RetryOptions = {

package/dist/llm/retry.js

@@ -1,4 +1,4 @@
-import { isLLMError, reasonRetryAfterMs, reasonRetryable } from './schema/errors.js';
+import { isLLMError, reasonRetryAfterMs, retryPolicy } from './schema/errors.js';
 const RETRY_INITIAL_DELAY = 2_000;
 const RETRY_BACKOFF_FACTOR = 2;
 const RETRY_MAX_DELAY_NO_HEADERS = 30_000;
@@ -43,15 +43,16 @@ const delay = (attempt, error) => {
 };
 /**
  * Decide whether a thrown error is retryable. Returns undefined when not retryable
- * (e.g. context overflow, auth, invalid request).
+ * (e.g. context overflow, auth, invalid request, mid-stream Transport failure).
  */
 const retryable = (error) => {
     if (!isLLMError(error))
         return undefined;
     const reason = error.reason;
-    if (!reasonRetryable(reason))
+    const policy = retryPolicy(reason);
+    if (!policy)
         return undefined;
-    return { message: error.message, reason };
+    return { message: error.message, reason, policy };
 };
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
@@ -67,13 +68,13 @@ const withRetry = async (fn, options) => {
         }
         catch (error) {
             const canRetry = retryable(error);
-            if (!canRetry || attempt >= options.maxRetries)
+            if (!canRetry || attempt >= Math.min(options.maxRetries, canRetry.policy.maxRetries))
                 throw error;
             attempt += 1;
             const fallbackReason = isLLMError(error)
                 ? error.reason
                 : { _tag: 'InvalidRequest', message: '' };
-            const delayMs = reasonRetryAfterMs(fallbackReason) ?? delay(attempt, error);
+            const delayMs = Math.min(reasonRetryAfterMs(fallbackReason) ?? delay(attempt, error), canRetry.policy.maxDelay);
             options.onRetry?.({ attempt, delayMs, error });
             await sleep(delayMs);
         }

package/dist/llm/schema/errors.d.ts

@@ -64,7 +64,17 @@ type LLMErrorReason = {
 };
 /** Human-readable message extracted from any reason. */
 declare const reasonMessage: (reason: LLMErrorReason) => string;
-/** Whether a reason is retryable (RateLimit / ProviderInternal). */
+/** Per-reason retry policy. `maxRetries` caps extra attempts; `maxDelay` caps each delay (ms). */
+type RetryPolicy = {
+    maxRetries: number;
+    maxDelay: number;
+};
+/**
+ * Retry policy for a reason, or undefined when the reason is not retryable.
+ * Single source of truth consulted by both `reasonRetryable` and the retry loop.
+ */
+declare const retryPolicy: (reason: LLMErrorReason) => RetryPolicy | undefined;
+/** Whether a reason is retryable (RateLimit / ProviderInternal / transient Transport). */
 declare const reasonRetryable: (reason: LLMErrorReason) => boolean;
 /** Retry-after delay in ms for reasons that carry one. */
 declare const reasonRetryAfterMs: (reason: LLMErrorReason) => number | undefined;
@@ -84,5 +94,5 @@ type ToolFailure = {
 };
 declare const toolFailure: (message: string, metadata?: Record<string, unknown>) => ToolFailure;
 declare const isToolFailure: (e: unknown) => e is ToolFailure;
-export type { HttpContext, LLMError, LLMErrorReason, ToolFailure };
-export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, toolFailure, };
+export type { HttpContext, LLMError, LLMErrorReason, RetryPolicy, ToolFailure };
+export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, retryPolicy, toolFailure, };

package/dist/llm/schema/errors.js

@@ -7,8 +7,40 @@ const reasonMessage = (reason) => {
             return reason.message;
     }
 };
-/** Whether a reason is retryable (RateLimit / ProviderInternal). */
-const reasonRetryable = (reason) => reason._tag === 'RateLimit' || reason._tag === 'ProviderInternal';
+/** Maximum extra retries for transient Transport (network) errors (3 total attempts). */
+const TRANSPORT_MAX_RETRIES = 2;
+/** Per-attempt delay ceiling (ms) for Transport retries, to avoid long stalls. */
+const TRANSPORT_MAX_DELAY = 5_000;
+/**
+ * Transport error kinds that are safe to retry — failures occurring before the
+ * provider begins streaming a response (connection / DNS / TCP reset / timeout):
+ * the request never reached the server (or the server never started processing),
+ * so retrying cannot duplicate cost or yield partial output. A mid-stream
+ * disconnect (e.g. a future `stream_interrupted` kind) is intentionally excluded,
+ * since the provider already started billing/producing.
+ */
+const RETRYABLE_TRANSPORT_KINDS = new Set(['network']);
+/**
+ * Retry policy for a reason, or undefined when the reason is not retryable.
+ * Single source of truth consulted by both `reasonRetryable` and the retry loop.
+ */
+const retryPolicy = (reason) => {
+    switch (reason._tag) {
+        case 'RateLimit':
+        case 'ProviderInternal':
+            // Defer entirely to the caller's limits; existing behavior is unchanged.
+            return { maxRetries: Number.POSITIVE_INFINITY, maxDelay: Number.POSITIVE_INFINITY };
+        case 'Transport':
+            if (reason.kind !== undefined && RETRYABLE_TRANSPORT_KINDS.has(reason.kind)) {
+                return { maxRetries: TRANSPORT_MAX_RETRIES, maxDelay: TRANSPORT_MAX_DELAY };
+            }
+            return undefined;
+        default:
+            return undefined;
+    }
+};
+/** Whether a reason is retryable (RateLimit / ProviderInternal / transient Transport). */
+const reasonRetryable = (reason) => retryPolicy(reason) !== undefined;
 /** Retry-after delay in ms for reasons that carry one. */
 const reasonRetryAfterMs = (reason) => {
     if (reason._tag === 'RateLimit' || reason._tag === 'ProviderInternal') {
@@ -30,4 +62,4 @@ const toolFailure = (message, metadata) => ({
     metadata,
 });
 const isToolFailure = (e) => typeof e === 'object' && e !== null && e._tag === 'ToolFailure';
-export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, toolFailure, };
+export { isLLMError, isToolFailure, llmError, reasonMessage, reasonRetryAfterMs, reasonRetryable, retryPolicy, toolFailure, };

package/dist/llm/transport.js

@@ -33,7 +33,11 @@ const sseFraming = async function* (stream) {
         }
     }
     finally {
-        reader.releaseLock();
+        // Cancel the underlying transport and release the exclusive lock on every
+        // exit path (normal completion, thrown error, or early consumer break).
+        // cancel() rejects on an already-closed/errored stream — swallow that so it
+        // never masks the original error propagating through the generator.
+        await reader.cancel().catch(() => { });
     }
 };
 /** Join all `data:` lines of an SSE block into one string. */

package/dist/project/resolve.js

@@ -59,14 +59,14 @@ export function getGitStatus(cwd) {
     let i = 0;
     while (i < tokens.length) {
         const token = tokens[i];
-        if (token === '')
+        if (!token)
             break; // 末尾空 token
         const xy = token.slice(0, 2);
         const code = classifyStatus(xy);
         const isRename = xy[0] === 'R' || xy[0] === 'C';
         // 重命名/复制："XY oldpath\0newpath"，状态挂在 newpath
         if (isRename && i + 1 < tokens.length) {
-            const newPath = tokens[i + 1];
+            const newPath = tokens[i + 1] ?? '';
             map[normalizePath(newPath)] = code;
             i += 2;
         }

package/dist/server/routes/chat.js

@@ -307,10 +307,17 @@ function createChatRoute(ctx) {
                 });
             }
             finally {
+                // 先从 agentManager 注销：必须最先执行，确保客户端断开使 writeSSE reject
+                // 时 agent 状态（state/deps/AbortController）不会泄漏到 Map（unregister 仅做
+                // Map.delete、不依赖 state，放最前安全）。
+                ctx.agentManager.unregister(sessionId);
                 // agentLoop 的 error/abort/max_turns 路径不 yield done，在此补发。
                 // 正常完成路径已在循环中 yield done，doneSent=true 时跳过避免重复。
+                // 客户端已断开时 writeSSE 会 reject，吞掉以保证后续 updateSessionLastRun 执行。
                 if (!doneSent) {
-                    await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    await stream
+                        .writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) })
+                        .catch(() => { });
                 }
                 // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
                 // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
@@ -321,7 +328,6 @@ function createChatRoute(ctx) {
                     model: resolvedModel,
                     startedAt: runStartedAt,
                 }).catch(() => { });
-                ctx.agentManager.unregister(sessionId);
             }
         });
     });