c0de-agent 1.0.0 → 1.2.0

package/dist/core/slash.js

@@ -40,10 +40,9 @@ const compactCommand = {
     name: 'compact',
     description: 'Manually trigger context compaction',
     execute: async () => {
-        return {
-            _tag: 'success',
-            message: 'Compaction queued. Use the agent API to trigger with a summarizer.',
-        };
+        // 仅声明意图：真正的压缩由消费方（loop.compactContext / chat 路由）执行，
+        // 复用 createSummarizer + runCompaction，且不把 /compact 当作 user 消息发给 LLM。
+        return { _tag: 'compact' };
     },
 };
 const modelCommand = {

package/dist/core/title.js

@@ -108,8 +108,9 @@ async function generateSessionTitle(deps, sessionId, firstMessage, chatProvider,
             return;
         await updateSessionTitle(db, sessionId, title);
     }
-    catch {
-        // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流。
+    catch (e) {
+        // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流，但记录以便排查。
+        console.warn('[title] generateSessionTitle failed:', e instanceof Error ? e.message : String(e));
     }
 }
 export { DEFAULT_SESSION_TITLE, generateSessionTitle, isDefaultTitle };

package/dist/core/types.d.ts

@@ -80,6 +80,8 @@ type CommandResult = {
 } | {
     _tag: 'text';
     text: string;
+} | {
+    _tag: 'compact';
 };
 type CommandContext = {
     cwd: string;

package/dist/core/workflow.d.ts

@@ -0,0 +1,25 @@
+/**
+ * "workflowz" keyword support — Dynamic Workflow（spec: dynamic-workflow-design）。
+ *
+ * 用户在消息中包含独立单词 `workflowz` 时：
+ *  1. 后端检测到关键词（prose 感知，忽略代码块/路径/大小写变体）
+ *  2. 向当轮注入一条隐藏 system 通知（steering），引导模型用 `task` 工具批量 fan-out
+ *     做确定性的多子 agent 工作流分解
+ *
+ * 复刻自 oh-my-pi 的 modes/workflow.ts，适配 c0de-agent 的 task 工具 schema：
+ *  - 批量模式：`{ subagent_type, context, tasks: [{ prompt, description? }] }`
+ *  - 单任务模式：`{ subagent_type?, prompt, description? }`
+ */
+/**
+ * 判断 `text` 是否在 prose 中包含独立关键词 "workflowz"
+ * （小写、空白分隔）——不在代码块、行内代码或路径中。
+ *
+ * 简化版 prose 检测：移除 ``` 代码块和 `行内代码` 后再匹配。
+ */
+export declare function containsWorkflow(text: string): boolean;
+/**
+ * 工作流通知：注入为 steering system 消息，引导模型用 task 工具做批量 fan-out。
+ *
+ * 适配 c0de-agent 的 task 工具 schema（subagent_type + context + tasks[]）。
+ */
+export declare const WORKFLOW_NOTICE = "<workflow-notice>\nThe user's message contains the **workflowz** keyword: drive this task as a deterministic multi-subagent workflow. Use the `task` tool for batched fan-out \u2014 to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before you commit), or to take on scale one context can't hold (audits, migrations, broad sweeps). This overrides any default tendency to do the whole task inline when fanning out would be more thorough.\n\n<when>\nWorth it when the task benefits from decomposition + parallel coverage, or from independent/adversarial cross-checking. For a quick lookup or single edit, just do it directly \u2014 don't spin up agents. Scout inline first (list the files, scope the diff, find the call sites) to discover the work list, then fan out over it. Common shapes:\n- **Understand** \u2014 parallel readers over subsystems \u2192 structured map.\n- **Design** \u2014 independent approaches \u2192 scored synthesis.\n- **Review** \u2014 split dimensions \u2192 find per dimension \u2192 adversarially verify each finding.\n- **Research** \u2014 multi-modal sweep \u2192 deep-read the hits \u2192 synthesize.\n- **Migrate** \u2014 discover sites \u2192 transform each \u2192 verify.\n</when>\n\n<task-contract>\nCall `task` once per independent fan-out batch using the batch form:\n\n    task({\n      subagent_type: \"coder\",\n      context: \"shared background all subagents need\",\n      tasks: [\n        { prompt: \"specific assignment for agent 1\", description: \"short label\" },\n        { prompt: \"specific assignment for agent 2\", description: \"short label\" },\n      ]\n    })\n\nAvailable subagent types: `general` (full tools, recursive), `coder` (implementation), `researcher` (read-only scout), `reviewer` (code review). Pick the type that matches each task's intent.\n\n`context` carries shared background prepended to every subagent's prompt \u2014 put the shared contract, conventions, and coordination rules here.\n\nEach task in `tasks[]` must be self-contained:\n- `prompt`: exact target (files, symbols, subsystem) + what to do + acceptance criteria\n- `description`: short label for the UI\n\nEach subagent runs in an isolated session and returns its result via the `yield` tool. Subagents skip formatters, linters, and project-wide tests \u2014 the parent runs shared proof once after all results return.\n</task-contract>\n\n<structure>\nDecompose first, then batch the independent leaves:\n\n    task({\n      subagent_type: \"coder\",\n      context: \"# Goal\\nImplement feature X across the codebase\\n# Constraints\\nFollow existing patterns...\\n# Contract\\nReturn findings as structured data...\",\n      tasks: [\n        { prompt: \"# Target\\nsrc/auth/login.ts\\n# Change\\nAdd rate limiting to login endpoint\\n# Acceptance\\nRate limiter works, tests pass\", description: \"Login rate limiting\" },\n        { prompt: \"# Target\\nsrc/auth/signup.ts\\n# Change\\nAdd input validation\\n# Acceptance\\nValidation blocks invalid emails\", description: \"Signup validation\" },\n      ]\n    })\n\nPrefer one wide batch over serial calls when work items do not share files. If tasks overlap, have agents coordinate before editing.\n</structure>\n\n<patterns>\n- **Adversarial verify** \u2014 dispatch skeptical reviewers with distinct targets, then keep only findings you can verify against source.\n- **Perspective-diverse review** \u2014 use separate correctness, security, performance roles instead of identical reviewers.\n- **Completeness critic** \u2014 after the first batch, dispatch one read-only critic that asks what was missed.\n- **No silent caps** \u2014 if you bound coverage (top-N, sampling), state what was dropped and why.\n- **Parent owns closure** \u2014 subagents return evidence; the parent reads it, resolves contradictions, runs proof, and makes the final decision.\n</patterns>\n\n<execution>\n- Capture multi-phase workflow state in the visible todo system when available.\n- Batch independent subagents in one `task` call.\n- Give every subagent a narrow target, explicit non-goals, and a concrete return packet.\n- After fan-out returns, read the results, patch or decide, and run the shared gate.\n- Keep going until the task is closed \u2014 returned fan-out is a step, not a stopping point.\n</execution>\n</workflow-notice>";

package/dist/core/workflow.js

@@ -0,0 +1,98 @@
+/**
+ * "workflowz" keyword support — Dynamic Workflow（spec: dynamic-workflow-design）。
+ *
+ * 用户在消息中包含独立单词 `workflowz` 时：
+ *  1. 后端检测到关键词（prose 感知，忽略代码块/路径/大小写变体）
+ *  2. 向当轮注入一条隐藏 system 通知（steering），引导模型用 `task` 工具批量 fan-out
+ *     做确定性的多子 agent 工作流分解
+ *
+ * 复刻自 oh-my-pi 的 modes/workflow.ts，适配 c0de-agent 的 task 工具 schema：
+ *  - 批量模式：`{ subagent_type, context, tasks: [{ prompt, description? }] }`
+ *  - 单任务模式：`{ subagent_type?, prompt, description? }`
+ */
+// 检测：小写关键词，两侧为空白或字符串边界。非全局，`.test` 无状态。
+const WORKFLOW_WORD = /(?<!\S)workflowz(?!\S)/;
+/**
+ * 判断 `text` 是否在 prose 中包含独立关键词 "workflowz"
+ * （小写、空白分隔）——不在代码块、行内代码或路径中。
+ *
+ * 简化版 prose 检测：移除 ``` 代码块和 `行内代码` 后再匹配。
+ */
+export function containsWorkflow(text) {
+    // 移除 ``` ... ``` 代码块
+    const withoutBlocks = text.replace(/```[\s\S]*?```/g, '');
+    // 移除 `行内代码`
+    const withoutInline = withoutBlocks.replace(/`[^`]*`/g, '');
+    return WORKFLOW_WORD.test(withoutInline);
+}
+/**
+ * 工作流通知：注入为 steering system 消息，引导模型用 task 工具做批量 fan-out。
+ *
+ * 适配 c0de-agent 的 task 工具 schema（subagent_type + context + tasks[]）。
+ */
+export const WORKFLOW_NOTICE = `<workflow-notice>
+The user's message contains the **workflowz** keyword: drive this task as a deterministic multi-subagent workflow. Use the \`task\` tool for batched fan-out — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before you commit), or to take on scale one context can't hold (audits, migrations, broad sweeps). This overrides any default tendency to do the whole task inline when fanning out would be more thorough.
+
+<when>
+Worth it when the task benefits from decomposition + parallel coverage, or from independent/adversarial cross-checking. For a quick lookup or single edit, just do it directly — don't spin up agents. Scout inline first (list the files, scope the diff, find the call sites) to discover the work list, then fan out over it. Common shapes:
+- **Understand** — parallel readers over subsystems → structured map.
+- **Design** — independent approaches → scored synthesis.
+- **Review** — split dimensions → find per dimension → adversarially verify each finding.
+- **Research** — multi-modal sweep → deep-read the hits → synthesize.
+- **Migrate** — discover sites → transform each → verify.
+</when>
+
+<task-contract>
+Call \`task\` once per independent fan-out batch using the batch form:
+
+    task({
+      subagent_type: "coder",
+      context: "shared background all subagents need",
+      tasks: [
+        { prompt: "specific assignment for agent 1", description: "short label" },
+        { prompt: "specific assignment for agent 2", description: "short label" },
+      ]
+    })
+
+Available subagent types: \`general\` (full tools, recursive), \`coder\` (implementation), \`researcher\` (read-only scout), \`reviewer\` (code review). Pick the type that matches each task's intent.
+
+\`context\` carries shared background prepended to every subagent's prompt — put the shared contract, conventions, and coordination rules here.
+
+Each task in \`tasks[]\` must be self-contained:
+- \`prompt\`: exact target (files, symbols, subsystem) + what to do + acceptance criteria
+- \`description\`: short label for the UI
+
+Each subagent runs in an isolated session and returns its result via the \`yield\` tool. Subagents skip formatters, linters, and project-wide tests — the parent runs shared proof once after all results return.
+</task-contract>
+
+<structure>
+Decompose first, then batch the independent leaves:
+
+    task({
+      subagent_type: "coder",
+      context: "# Goal\\nImplement feature X across the codebase\\n# Constraints\\nFollow existing patterns...\\n# Contract\\nReturn findings as structured data...",
+      tasks: [
+        { prompt: "# Target\\nsrc/auth/login.ts\\n# Change\\nAdd rate limiting to login endpoint\\n# Acceptance\\nRate limiter works, tests pass", description: "Login rate limiting" },
+        { prompt: "# Target\\nsrc/auth/signup.ts\\n# Change\\nAdd input validation\\n# Acceptance\\nValidation blocks invalid emails", description: "Signup validation" },
+      ]
+    })
+
+Prefer one wide batch over serial calls when work items do not share files. If tasks overlap, have agents coordinate before editing.
+</structure>
+
+<patterns>
+- **Adversarial verify** — dispatch skeptical reviewers with distinct targets, then keep only findings you can verify against source.
+- **Perspective-diverse review** — use separate correctness, security, performance roles instead of identical reviewers.
+- **Completeness critic** — after the first batch, dispatch one read-only critic that asks what was missed.
+- **No silent caps** — if you bound coverage (top-N, sampling), state what was dropped and why.
+- **Parent owns closure** — subagents return evidence; the parent reads it, resolves contradictions, runs proof, and makes the final decision.
+</patterns>
+
+<execution>
+- Capture multi-phase workflow state in the visible todo system when available.
+- Batch independent subagents in one \`task\` call.
+- Give every subagent a narrow target, explicit non-goals, and a concrete return packet.
+- After fan-out returns, read the results, patch or decide, and run the shared gate.
+- Keep going until the task is closed — returned fan-out is a step, not a stopping point.
+</execution>
+</workflow-notice>`;

package/dist/core/worktree.js

@@ -48,8 +48,9 @@ async function applyPatchToParent(repoRoot, patch, commitMessage) {
     try {
         gitWithInput(repoRoot, ['apply'], patch);
     }
-    catch {
-        // apply 失败：尝试 3-way 合并
+    catch (e) {
+        // apply 失败：记录后尝试 3-way 合并
+        console.warn('[worktree] git apply failed, retrying with --3way:', e instanceof Error ? e.message : String(e));
         gitWithInput(repoRoot, ['apply', '--3way'], patch);
     }
     git(repoRoot, ['add', '-A']);
@@ -61,8 +62,9 @@ function removeWorktree(repoRoot, worktreeDir) {
     try {
         git(repoRoot, ['worktree', 'remove', '--force', worktreeDir]);
     }
-    catch {
-        // 清理失败忽略（可能已删）
+    catch (e) {
+        // 清理失败忽略（可能已删），但记录以便排查残留 worktree
+        console.warn('[worktree] worktree cleanup failed:', e instanceof Error ? e.message : String(e));
     }
 }
 export { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree };

package/dist/dap/session.js

@@ -112,12 +112,12 @@ function createDebugSessionManager() {
             if (!s)
                 return;
             s.session.state = 'stopped';
-            // disconnect 适配器可能已退出；吞错。
+            // disconnect 适配器可能已退出；吞错但记录，便于排查非正常退出。
             try {
                 await s.client.request('disconnect', {});
             }
-            catch {
-                /* adapter gone */
+            catch (e) {
+                console.warn('[dap] disconnect failed:', e instanceof Error ? e.message : String(e));
             }
             s.client.dispose();
             sessions.delete(sessionId);

package/dist/llm/provider.js

@@ -93,7 +93,11 @@ const toStreamChunk = (event) => {
         case 'provider-error':
             return {
                 _tag: 'error',
-                error: { message: event.message, retryable: event.retryable ?? false },
+                error: {
+                    message: event.message,
+                    retryable: event.retryable ?? false,
+                    ...(event.classification !== undefined ? { classification: event.classification } : {}),
+                },
             };
         default:
             return null;

package/dist/plugins/loader.js

@@ -59,8 +59,9 @@ async function discoverPlugins(projectDir) {
             const plugin = await loadPlugin(join(entry.path, 'index.js'));
             results.push({ name: entry.name, path: entry.path, plugin });
         }
-        catch {
-            // Skip plugins that fail to load
+        catch (e) {
+            // Plugin failed to load — skip but warn (otherwise silently inactive)
+            console.warn(`[plugin] failed to load "${entry.name}" from ${entry.path}:`, e instanceof Error ? e.message : String(e));
         }
     }
     return results;

package/dist/server/agent-manager.d.ts

@@ -26,6 +26,8 @@ type AgentManager = {
     children(parentSessionId: string): ActiveRun[];
     /** 查询所有后台任务（jobId 非空的 run）。 */
     backgroundJobs(): ActiveRun[];
+    /** 中止所有活跃 run 并清空（dev 热重载重建前调用）。 */
+    dispose(): void;
 };
 declare function createAgentManager(): AgentManager;
 export type { ActiveRun, AgentManager };

package/dist/server/agent-manager.js

@@ -49,6 +49,14 @@ function createAgentManager() {
         backgroundJobs() {
             return Array.from(runs.values()).filter((r) => r.jobId !== undefined);
         },
+        dispose() {
+            // dev 热重载重建前调用：中止所有活跃 run（loop 在 turn/流边界检测 signal
+            // → unwind → 调用方 finally 持久化 + unregister），然后清空 Map。
+            for (const run of runs.values()) {
+                abortAgent(run.state);
+            }
+            runs.clear();
+        },
     };
 }
 export { createAgentManager };

package/dist/server/app.js

@@ -18,6 +18,7 @@ import { createPermissionsRoute } from './routes/permissions.js';
 import { createProjectRoute } from './routes/project.js';
 import { createProviderRoute } from './routes/provider.js';
 import { createSessionRoute } from './routes/session.js';
+import { createTerminalRoute } from './routes/terminal.js';
 import { createToolRoute } from './routes/tool.js';
 import { createUpdateRoute } from './routes/update.js';
 /** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
@@ -44,6 +45,7 @@ function createApp(ctx) {
     app.route('/api/config', createConfigRoute(ctx));
     app.route('/api/permissions', createPermissionsRoute(ctx));
     app.route('/api/files', createFilesRoute(ctx));
+    app.route('/api/terminal', createTerminalRoute(ctx));
     // 根路径
     app.get('/', (c) => c.json({
         name: 'c0de-agent',
@@ -63,6 +65,7 @@ function createApp(ctx) {
             '/api/config',
             '/api/permissions',
             '/api/files',
+            '/api/terminal',
         ],
     }));
     // 静态文件服务（生产环境 dist-web/ 存在时启用）

package/dist/server/context.js

@@ -6,6 +6,7 @@ import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.
 import { createUpdateScheduler } from '../update/index.js';
 import { createAgentManager } from './agent-manager.js';
 import { createPermissionStore } from './permission/store.js';
+import { PTYManager } from './terminal/pty-manager.js';
 function createServerContext(opts) {
     // 测试/dev 工厂：补足 urlRegistry + hookRunner + pluginRegistry（空壳，不激活插件），
     // 生产启动走 bootstrapServerContext → initPlugins（激活 builtin + 发现外部插件）。
@@ -41,6 +42,7 @@ function createServerContext(opts) {
             }),
         }),
         cwd: opts.cwd ?? process.cwd(),
+        ptyManager: new PTYManager(),
         ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
     };
 }

package/dist/server/dev.d.ts

@@ -1,6 +1,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Hono } from 'hono';
+import type { ServerContext } from './types.js';
 declare function getDevApp(): Promise<Hono>;
+/** 获取当前 dev ctx（WebSocket 升级等需要直接访问 ptyManager 的场景）。 */
+declare function getDevCtx(): Promise<ServerContext>;
 /** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
 declare function closeDevApp(): Promise<void>;
 /**
@@ -8,4 +11,4 @@ declare function closeDevApp(): Promise<void>;
  * 用 Readable.fromWeb 管道转发 Response body，原生处理背压与分块。
  */
 declare function handleApiRequest(app: Hono, req: IncomingMessage, res: ServerResponse): Promise<void>;
-export { closeDevApp, getDevApp, handleApiRequest };
+export { closeDevApp, getDevApp, getDevCtx, handleApiRequest };

package/dist/server/dev.js

@@ -1,35 +1,92 @@
 // src/server/dev.ts
 import { Readable } from 'node:stream';
 import { createApp } from './app.js';
-import { bootstrapServerContext } from './server.js';
+import { buildServerContext, createDevDb } from './server.js';
 /**
  * 开发环境入口：初始化并返回 Hono app。
  * 供 vite dev server 中间件复用，使前后端共享同一端口。
  *
- * 用 globalThis 缓存而非模块级变量：Vite ssrLoadModule 在 server 端代码变更时会
- * 重新执行本模块，模块级 cachedApp 会重置；这会导致运行中的 AgentManager（含
- * 权限确认 pending）丢失，前端 POST /api/tools/confirm 拿不到 pending 而 404。
- * globalThis 跨模块重载保持单例，避免权限流程中途断裂。
+ * ## 全量重建（B 方案）
+ *
+ * 目标：编辑任意 server/core 代码后热重载，新代码对**新请求**全部生效——与进程重启同语义，
+ * 只是不开新进程。
+ *
+ * 缓存策略分两层：
+ *
+ * 1. **PGLite DB handle** → globalThis（唯一跨重载存活物）。
+ *    PGLite 是单写者 WASM DB，同一 dataDir 不能开第二个连接（WAL 冲突 / Aborted()），
+ *    所以 db 必须跨重载复用。其余一切重建。
+ *
+ * 2. **ctx + app** → 模块级变量。
+ *    Vite 重载本模块时归 null，下次请求触发 rebuild：
+ *      dispose 旧 ctx（abort 活跃 run + settle pending permission + stop scheduler + close handoff）
+ *      → 围绕复用的 db 调 buildServerContext（重建 agentManager/permissionStore/registries/plugins/app）
+ *      → 全部用最新代码。
+ *
+ * ## 与热升级的关系
+ *
+ * 和 `performHotUpdate` 是同一原理，差只在 spawn 新进程 vs 进程内重建。两者都：
+ *   - 保留 durable 状态（DB rows）
+ *   - 丢弃非 durable 状态（in-flight 工具执行、pending Promise resolver、活跃 run 内存态）
+ *   - 活跃 run 从最后持久化消息重启
+ *
+ * 活跃 run 被 abort 后，loop 在 turn/流边界检测 signal → unwind → 调用方 finally 持久化
+ * 状态（标记 interrupted/completed）。前端再发消息时从 DB 历史起新 run，全用新代码。
  */
-const DEV_APP_KEY = '__c0de_dev_app__';
-const DEV_CLOSE_KEY = '__c0de_dev_close__';
-async function getDevApp() {
+const DEV_DB_KEY = '__c0de_dev_db__';
+/** 模块级：随本模块重载而重置。 */
+let ctx = null;
+let app = null;
+let disposeCtx = null;
+async function rebuild() {
+    // 1. dispose 旧 ctx（不 close db）
+    if (disposeCtx) {
+        await disposeCtx();
+        disposeCtx = null;
+        ctx = null;
+        app = null;
+    }
+    // 2. 取/建 devDb（globalThis，PGLite 单写者，只建一次）
     const g = globalThis;
-    if (!g[DEV_APP_KEY]) {
-        const { ctx, close } = await bootstrapServerContext({ cwd: process.cwd() });
-        g[DEV_APP_KEY] = createApp(ctx);
-        g[DEV_CLOSE_KEY] = close;
+    if (!g[DEV_DB_KEY]) {
+        g[DEV_DB_KEY] = await createDevDb(process.cwd());
     }
-    return g[DEV_APP_KEY];
+    const db = g[DEV_DB_KEY];
+    // 3. 围绕复用的 db 重建 ctx（skipHandoff：dev 不跑热升级 handoff）
+    const built = await buildServerContext(db, { cwd: process.cwd(), skipHandoff: true });
+    ctx = built.ctx;
+    disposeCtx = built.dispose;
+    app = createApp(ctx);
+}
+async function getDevApp() {
+    if (app)
+        return app;
+    await rebuild();
+    if (!app)
+        throw new Error('dev app failed to initialize');
+    return app;
+}
+/** 获取当前 dev ctx（WebSocket 升级等需要直接访问 ptyManager 的场景）。 */
+async function getDevCtx() {
+    if (!ctx)
+        await getDevApp();
+    if (!ctx)
+        throw new Error('dev ctx not initialized');
+    return ctx;
 }
 /** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
 async function closeDevApp() {
+    if (disposeCtx) {
+        await disposeCtx();
+        disposeCtx = null;
+        ctx = null;
+        app = null;
+    }
     const g = globalThis;
-    const close = g[DEV_CLOSE_KEY];
-    if (close) {
-        await close();
-        delete g[DEV_APP_KEY];
-        delete g[DEV_CLOSE_KEY];
+    const db = g[DEV_DB_KEY];
+    if (db) {
+        await db.close();
+        delete g[DEV_DB_KEY];
     }
 }
 /**
@@ -49,16 +106,20 @@ async function handleApiRequest(app, req, res) {
     }
     const headers = new Headers();
     for (const [key, value] of Object.entries(req.headers)) {
-        if (value != null) {
-            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        if (typeof value === 'string') {
+            headers.set(key, value);
+        }
+        else if (Array.isArray(value)) {
+            for (const v of value)
+                headers.append(key, v);
         }
     }
     const init = {
         method: req.method,
         headers,
-        body: body ?? undefined,
     };
     if (body !== undefined) {
+        init.body = body;
         init.duplex = 'half';
     }
     const request = new Request(url.toString(), init);
@@ -69,15 +130,19 @@ async function handleApiRequest(app, req, res) {
     });
     const responseBody = response.body;
     if (responseBody) {
-        res.flushHeaders();
-        await new Promise((resolve, reject) => {
-            const nodeStream = Readable.fromWeb(responseBody);
-            nodeStream.on('error', reject);
-            nodeStream.pipe(res).on('finish', resolve);
+        // Readable.fromWeb 需要 web stream；Hono Response.body 已是 ReadableStream。
+        // native pipeline handles backpressure + chunked encoding for SSE.
+        Readable.fromWeb(responseBody)
+            .pipe(res)
+            .on('error', (err) => {
+            if (!res.headersSent)
+                res.statusCode = 500;
+            res.end();
+            console.error('[c0de-hono-api] response stream error:', err);
         });
     }
     else {
         res.end();
     }
 }
-export { closeDevApp, getDevApp, handleApiRequest };
+export { closeDevApp, getDevApp, getDevCtx, handleApiRequest };

package/dist/server/permission/store.d.ts

@@ -24,6 +24,8 @@ type PermissionStore = {
     resolve(toolCallId: string, approved: boolean): boolean;
     has(toolCallId: string): boolean;
     size(): number;
+    /** settle 所有 pending 为 deny 并清空（dev 热重载重建前调用）。 */
+    dispose(): void;
 };
 declare function createPermissionStore(opts?: PermissionStoreOptions): PermissionStore;
 export type { PendingPermission, PermissionRequest, PermissionStore, PermissionStoreOptions };

package/dist/server/permission/store.js

@@ -42,6 +42,15 @@ function createPermissionStore(opts = {}) {
         size() {
             return pending.size;
         },
+        dispose() {
+            // dev 热重载重建前调用：所有 pending settle 为 deny（避免悬空 Promise +
+            // timer 泄漏），clearTimeout 后清空 Map。
+            for (const [id, p] of pending) {
+                clearTimeout(p.timer);
+                p.resolve({ _tag: 'deny', reason: 'Server context disposed (hot reload)' });
+                pending.delete(id);
+            }
+        },
     };
 }
 export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/routes/chat.js

@@ -2,7 +2,10 @@ import { readFile } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent, runAgent } from '../../core/agent.js';
+import { compactContext } from '../../core/loop.js';
 import { createSlashRegistry, parseSlashInput } from '../../core/slash.js';
+import { injectSteering } from '../../core/steering.js';
+import { containsWorkflow, WORKFLOW_NOTICE } from '../../core/workflow.js';
 import { getProject } from '../../project/project.js';
 import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
 import { upsertFileSnapshot } from '../../session/snapshot.js';
@@ -63,7 +66,42 @@ function createChatRoute(ctx) {
                 return streamSSE(c, async (stream) => {
                     try {
                         const result = await cmd.execute(parsed.args, commandCtx);
-                        if (result._tag === 'error') {
+                        if (result._tag === 'compact') {
+                            // /compact：手动触发上下文压缩。复用 loop.compactContext（createSummarizer +
+                            // runCompaction），不创建主 agent、不进入 LLM turn 循环（不把 /compact 当作
+                            // user 消息发给模型）。
+                            const provider = body.provider ?? ctx.config.defaultProvider;
+                            const model = body.model ?? ctx.config.defaultModel;
+                            const agentConfig = {
+                                provider,
+                                model,
+                                tools: [],
+                                plugins: ctx.config.plugins.enabled,
+                                agentName: 'default',
+                            };
+                            const compactState = await createAgent(session, agentConfig, commandCtx.deps);
+                            try {
+                                for await (const event of compactContext(compactState, commandCtx.deps)) {
+                                    await stream.writeSSE({
+                                        event: event._tag,
+                                        data: JSON.stringify(event),
+                                    });
+                                }
+                            }
+                            catch (e) {
+                                await stream.writeSSE({
+                                    event: 'error',
+                                    data: JSON.stringify({
+                                        _tag: 'error',
+                                        error: {
+                                            _tag: 'unexpected',
+                                            message: e instanceof Error ? e.message : String(e),
+                                        },
+                                    }),
+                                });
+                            }
+                        }
+                        else if (result._tag === 'error') {
                             await stream.writeSSE({
                                 event: 'error',
                                 data: JSON.stringify({
@@ -217,6 +255,11 @@ function createChatRoute(ctx) {
                 startedAt: runStartedAt,
             });
             ctx.agentManager.register({ sessionId, state, deps });
+            // workflowz 关键词检测：用户消息包含独立关键词时注入工作流通知（steering），
+            // 引导模型用 task 工具批量 fan-out 做确定性多子 agent 分解。
+            if (containsWorkflow(message)) {
+                injectSteering(state, WORKFLOW_NOTICE);
+            }
             // 客户端断开时中止 agent
             stream.onAbort(() => {
                 ctx.agentManager.abort(sessionId);