c0de-agent 1.7.0 → 1.9.0

package/dist/core/loop/subagent.js

@@ -0,0 +1,171 @@
+import { appendMessage } from '../../session/message.js';
+import { createSession } from '../../session/session.js';
+import { generateId } from '../../shared/index.js';
+import { createAgent, runAgent } from '../agent.js';
+import { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree, } from '../worktree.js';
+/** 运行一个按类型派发的子 agent（spec: multi-agent-design §4.5）。
+ *
+ *  Host 端实现：查 agentRegistry 获取 AgentDefinition → 创建隔离子 session（agentType 记录）
+ *  → 构建子 agent（专属 prompt + 受限工具集 + yield）→ 运行到 yield 或完成 → 返回结果。
+ *  发射 subagent_start/subagent_end 事件供父 agent 转发（spec §4.5 step 7）。
+ *  abort 链接父→子。maxRecursion 控制子 agent 能否再递归派生 task（spec §4.5 step 4）。
+ *  def.isolated 时在 git worktree 中运行，结束后把 delta 自动 apply 回父仓库（spec §4.6）。
+ *  request.background 时 fork 异步运行，立即返回 running（spec §4.7）。 */
+export async function runSubAgent(deps, parent, request) {
+    // 1. 查 agent 类型
+    if (!deps.agentRegistry) {
+        return { _tag: 'error', error: 'task tool unavailable: no agent registry is wired' };
+    }
+    const def = deps.agentRegistry.get(request.agentType);
+    if (!def) {
+        return {
+            _tag: 'error',
+            error: `Unknown agent type: ${request.agentType} is not a valid agent type`,
+        };
+    }
+    const title = request.description?.trim() ||
+        `Sub-agent (${request.agentType}): ${request.prompt.slice(0, 60)}`;
+    const childId = generateId();
+    const yielded = [];
+    // 发射 subagent_start 事件（spec §4.5 step 7）
+    deps._subagentEventSink?.({
+        _tag: 'subagent_start',
+        childId,
+        agentType: request.agentType,
+        description: request.description ?? '',
+        background: request.background ?? false,
+    });
+    // 2. 创建子 session（记录 agentType）
+    let childSession;
+    try {
+        childSession = await createSession(deps.db, title, parent.session.projectId ?? undefined, request.agentType);
+    }
+    catch (e) {
+        return { _tag: 'error', error: e instanceof Error ? e.message : String(e) };
+    }
+    // 3. worktree 隔离（isolated agent）：失败回退共享 cwd
+    let worktreePath;
+    let baseline;
+    if (def.isolated) {
+        try {
+            baseline = await captureBaseline(deps.cwd);
+            worktreePath = await createWorktree(deps.cwd, `subagent-${childSession.id}`);
+        }
+        catch (e) {
+            console.warn(`[subagent] worktree creation failed, falling back to shared cwd: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    const childCwd = worktreePath ?? deps.cwd;
+    // 实际运行子 agent 的内部函数（sync 与 background 共用）
+    const runBody = async () => {
+        // 4. 构建子 agent 配置：工具集隔离 + 模型覆盖 + 递归限制 + yield
+        const parentDepth = deps._subagentDepth ?? 0;
+        const childDepth = parentDepth + 1;
+        const declaredTools = def.tools ?? parent.config.tools;
+        const maxRec = def.maxRecursion ?? 0;
+        const baseTools = childDepth > maxRec ? declaredTools.filter((t) => t !== 'task') : declaredTools;
+        const childTools = Array.from(new Set([...baseTools, 'yield']));
+        const childConfig = {
+            ...parent.config,
+            systemPrompt: def.systemPrompt,
+            // 子 agent 走整段 systemPrompt 替换，清除父的 role override 避免干扰
+            agentRolePrompt: undefined,
+            tools: childTools,
+            ...(def.model ? { model: def.model } : {}),
+            ...(request.model ? { model: request.model } : {}),
+        };
+        // 子 agent 的 deps：覆盖 cwd（worktree）+ 注入 yield 收集器 + 递归深度
+        const childDeps = {
+            ...deps,
+            cwd: childCwd,
+            _subagentYieldCollector: (data) => {
+                yielded.push(data);
+            },
+            _subagentDepth: childDepth,
+        };
+        const childState = await createAgent(childSession, childConfig, childDeps);
+        // abort 链接：父 abort 则子 abort
+        if (parent.abortController.signal.aborted) {
+            childState.abortController.abort();
+        }
+        else {
+            parent.abortController.signal.addEventListener('abort', () => childState.abortController.abort(), { once: true });
+        }
+        // 运行子 agent loop
+        const childPrompt = request.context
+            ? `CONTEXT\n${request.context}\n\nASSIGNMENT\n${request.prompt}`
+            : request.prompt;
+        const text = [];
+        let errMsg = null;
+        try {
+            for await (const ev of runAgent(childState, [{ _tag: 'text', text: childPrompt }], childDeps)) {
+                if (ev._tag === 'text_delta') {
+                    text.push(ev.text);
+                }
+                else if (ev._tag === 'error') {
+                    const e = ev.error;
+                    errMsg = e._tag === 'unexpected' || e._tag === 'provider' ? e.message : e._tag;
+                }
+            }
+        }
+        catch (e) {
+            errMsg = e instanceof Error ? e.message : String(e);
+        }
+        // 5. worktree 回传：仅成功时把 delta apply 回父仓库（spec §4.6）；无论成败都清理 worktree
+        if (baseline && worktreePath) {
+            if (errMsg === null) {
+                try {
+                    const patch = await captureDeltaPatch(worktreePath, baseline);
+                    await applyPatchToParent(deps.cwd, patch, `agent(isolated): ${title}`);
+                }
+                catch (e) {
+                    console.warn(`[subagent] worktree apply failed: ${e instanceof Error ? e.message : e}`);
+                }
+            }
+            removeWorktree(deps.cwd, worktreePath);
+        }
+        const success = errMsg === null;
+        // 发射 subagent_end 事件（spec §4.5 step 7）
+        deps._subagentEventSink?.({
+            _tag: 'subagent_end',
+            childId,
+            agentType: request.agentType,
+            success,
+            ...(success ? { output: text.join('') } : {}),
+        });
+        if (errMsg !== null) {
+            return { _tag: 'error', error: errMsg, sessionId: childSession.id };
+        }
+        const data = yielded.length > 0 ? (yielded.length === 1 ? yielded[0] : yielded) : undefined;
+        return {
+            _tag: 'success',
+            output: text.join(''),
+            sessionId: childSession.id,
+            ...(data !== undefined ? { data } : {}),
+        };
+    };
+    // 6. background 模式：fork 异步运行，立即返回 running；完成时向父 session 注入合成通知
+    if (request.background) {
+        const jobId = childSession.id;
+        void runBody()
+            .then((result) => {
+            const success = result._tag === 'success';
+            const output = success ? result.output : result.error;
+            const tag = success ? 'task_result' : 'task_error';
+            const synthetic = `<task id="${childSession.id}" state="${success ? 'completed' : 'failed'}">\n<${tag}>\n${output}\n</${tag}>\n</task>`;
+            void appendMessage(deps.db, parent.session.id, {
+                role: 'user',
+                content: [{ _tag: 'text', text: synthetic }],
+            }).catch((e) => {
+                // 通知消息持久化失败：任务已算完但父 session 收不到完成通知——记录避免静默丢失。
+                console.warn('[subagent] background 通知消息持久化失败:', e instanceof Error ? e.message : String(e));
+            });
+        })
+            .catch((e) => {
+            // background 子 agent 执行或合成失败：父 session 永远收不到结果，记录避免静默丢失。
+            console.warn('[subagent] background 子 agent 执行失败:', e instanceof Error ? e.message : String(e));
+        });
+        return { _tag: 'running', jobId, sessionId: childSession.id };
+    }
+    return runBody();
+}

package/dist/core/loop/todo.d.ts

@@ -0,0 +1,5 @@
+import type { AgentEvent, AgentState } from '../../shared/types/agent.js';
+/** Process <todo:*> tags embedded in assistant text.
+ *  Parses tags, applies them to state.todoPhases via applyTodoTags,
+ *  yields todo_update event on success, injects steering on error/view. */
+export declare function processTodoTags(state: AgentState, text: string): AsyncGenerator<AgentEvent>;

package/dist/core/loop/todo.js

@@ -0,0 +1,26 @@
+import { formatSummary } from '../../tools/builtin/todo.js';
+import { injectSteering } from '../steering.js';
+import { applyTodoTags } from '../todo-tags.js';
+/** Process <todo:*> tags embedded in assistant text.
+ *  Parses tags, applies them to state.todoPhases via applyTodoTags,
+ *  yields todo_update event on success, injects steering on error/view. */
+export async function* processTodoTags(state, text) {
+    if (text.length === 0)
+        return;
+    const result = applyTodoTags(state.todoPhases, text);
+    if (result.errors.length > 0) {
+        // Inject error feedback into steering queue for next turn
+        injectSteering(state, `<todo-tag-errors>\n${result.errors.join('\n')}\n</todo-tag-errors>`);
+    }
+    if (result.hasView) {
+        // View request: inject current state (with seq) into steering
+        const summary = formatSummary(result.phases, [], true);
+        injectSteering(state, `<todo-state>\n${summary}\n</todo-state>`);
+    }
+    // Emit event + update state if anything happened
+    const tagsFound = result.errors.length > 0 || result.hasView || result.phases !== state.todoPhases;
+    if (tagsFound) {
+        state.todoPhases = result.phases;
+        yield { _tag: 'todo_update', phases: result.phases };
+    }
+}

package/dist/core/loop.d.ts

@@ -1,7 +1,8 @@
 import { chatStream as llmChatStream } from '../llm/provider.js';
 import type { AgentEvent, AgentState } from '../shared/types/agent.js';
-import type { SubAgentRequest, SubAgentResult } from '../shared/types/tool.js';
 import type { AgentDependencies } from './types.js';
+export { compactContext } from './loop/compaction.js';
+export { runSubAgent } from './loop/subagent.js';
 type LoopDeps = AgentDependencies & {
     chatStream?: typeof llmChatStream;
     /** 子 agent 运行时注入：yield 工具的结果收集器（透传到 ToolContext.collectYield）。 */
@@ -13,23 +14,4 @@ type LoopDeps = AgentDependencies & {
     readonly _subagentDepth?: number;
 };
 export type { LoopDeps };
-/** 运行一个按类型派发的子 agent（spec: multi-agent-design §4.5）。
- *
- *  Host 端实现：查 agentRegistry 获取 AgentDefinition → 创建隔离子 session（agentType 记录）
- *  → 构建子 agent（专属 prompt + 受限工具集 + yield）→ 运行到 yield 或完成 → 返回结果。
- *  发射 subagent_start/subagent_end 事件供父 agent 转发（spec §4.5 step 7）。
- *  abort 链接父→子。maxRecursion 控制子 agent 能否再递归派生 task（spec §4.5 step 4）。
- *  def.isolated 时在 git worktree 中运行，结束后把 delta 自动 apply 回父仓库（spec §4.6）。
- *  request.background 时 fork 异步运行，立即返回 running（spec §4.7）。 */
-export declare function runSubAgent(deps: LoopDeps, parent: AgentState, request: SubAgentRequest): Promise<SubAgentResult>;
-/**
- * 执行会话压缩并刷新 token 预算。
- *
- * 自动压缩（agentLoop 阈值触发）与手动 /compact 共用此逻辑：复用
- * createSummarizer + runCompaction，压缩改写消息历史后标记下一段 trigger='compaction'。
- *
- * 成功时 yield 一条 text_delta 通知：手动 /compact 透传给用户；自动压缩由调用方
- * 静默消费。失败时抛错，由调用方决定是否记录（自动压缩非致命，仅 console.warn）。
- */
-export declare function compactContext(state: AgentState, deps: LoopDeps): AsyncGenerator<AgentEvent>;
 export declare function agentLoop(state: AgentState, deps: LoopDeps): AsyncGenerator<AgentEvent>;