chatccc 0.2.267 → 0.2.269

package/README.md

@@ -155,11 +155,11 @@ chatccc
 
 #### 本地任务看板（Agent Team）
 
-Agent Team 提供本地任务看板和项目主 Agent 入口。每个规范化后的本机目录对应一个独立项目和看板，固定包含“头脑风暴、Todo、Doing、Done、搁置”五列，支持新增、单击卡片编辑、拖动排序和删除任务。页面会自动保存，不需要手动提交。当前按路径识别项目，不检查 Git 仓库或 worktree 关系，任意子目录都可以作为独立项目。
+Agent Team 提供本地任务看板和项目主 Agent 入口。每个规范化后的本机目录对应一个独立项目和看板，固定包含“头脑风暴、Todo、Doing、Done、搁置”五列，支持新增、单击卡片编辑、拖动排序和删除任务。页面会自动保存，不需要手动提交。当前按路径识别项目，不检查 Git 仓库或 worktree 关系，任意子目录都可以作为独立项目。
 
-打开项目后可以选择 CCC、Claude、Cursor 或 Codex 作为主 Agent。首次设置会创建固定命名为 `主Agent-<目录短名>` 的飞书群和空 Agent Session；后续切换 Agent 或重新关联目录会复用原群，运行中的主 Agent 不允许切换。建群成员取自机器人最近一次收到的飞书私聊；如果尚无私聊记录，网页会提示先给机器人发送任意私聊消息并自动检测。项目群名不会随第一句话或 `/forget` 改变。
-
-任务卡片可通过“交给主 Agent”启动真实执行：任务会从 Todo 移到 Doing，成功后自动移到 Done，失败则保留在 Doing 并显示错误，支持停止与重试。同一项目同一时间只运行一个看板任务；运行记录持久化在本地 JSON 中，服务异常退出后会把未完成执行标记为中断，避免错误显示为仍在运行。
+打开项目后可以选择 CCC、Claude、Cursor 或 Codex 作为主 Agent。首次设置会创建固定命名为 `主Agent-<目录短名>` 的飞书群和空 Agent Session；后续切换 Agent 或重新关联目录会复用原群，运行中的主 Agent 不允许切换。建群成员取自机器人最近一次收到的飞书私聊；如果尚无私聊记录，网页会提示先给机器人发送任意私聊消息并自动检测。项目群名不会随第一句话或 `/forget` 改变。
+
+任务卡片可通过“交给主 Agent”启动真实执行：任务会从 Todo 移到 Doing，成功后自动移到 Done，失败则保留在 Doing 并显示错误，支持停止与重试。同一项目同一时间只运行一个看板任务；运行记录持久化在本地 JSON 中，服务异常退出后会把未完成执行标记为中断，避免错误显示为仍在运行。
 
 看板数据默认保存在 `~/.chatccc/agent-team/`，其中 `workspaces.json` 保存最近工作目录索引，`boards/` 保存按稳定 ID 分隔的看板 JSON，`main-agent-bindings/` 单独保存本机飞书群与 Session 绑定。目录移动或重命名后，可从最近目录列表重新关联。数据访问通过仓储接口隔离，后续接入飞书多维表格时可增加双向同步适配器，无需把本机群聊和 Session 状态混入任务同步模型。选择目录、创建群聊和启动 Agent 等操作都由本机 Node 后端执行；当前实现不依赖 Electron。
 
@@ -427,10 +427,16 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
 | `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
 | `/restart` | 重启机器人进程 |
+| `/restart safe` | 停止接受新任务，等待现有会话、缓存消息和依赖安装完成后重启 |
 | `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程；同一飞书事件跨重启去重） |
+| `/update safe` | 停止接受新任务，排空现有工作后更新并重启 |
+| `/safestatus` | 查看安全重启/更新的等待状态 |
+| `/cancelsf` | 取消尚未开始执行的安全重启/更新预约 |
 | `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
 
-`/update` 会在执行 npm 更新前把飞书消息或按钮事件 ID 原子写入 `~/.chatccc/state/update-command-guard.json`。同一 ID 跨重启重投时会静默忽略；用户主动发送的新 `/update` 因事件 ID 不同，仍可立即执行。该保护仅作用于 `/update`，普通消息与 `/restart` 的处理不变。
+`/update` 与 `/update safe` 会把飞书消息或按钮事件 ID 原子写入 `~/.chatccc/state/update-command-guard.json`。同一 ID 跨重启重投时会静默忽略；用户主动发送的新更新指令因事件 ID 不同，仍可执行。该保护不改变普通消息与重启指令的处理方式。
+
+`/restart safe` 与 `/update safe` 会先建立全局准入门禁：指令到达前已经运行或进入单会话缓存队列的工作会继续完成，之后到达的新普通任务会被提示在维护完成后重发。维护任务持久化到 `~/.chatccc/state/safe-maintenance.json`，进程意外退出后可继续排空；依赖安装、会话收尾、自动恢复和 Agent Teams 执行也计入等待条件。内存缓存随重启自然重建，磁盘会话、看板、图片等持久数据不会被清理。
 
 > **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
 

package/dist/src/agent-delegate-task-rpc.js

@@ -1,11 +1,13 @@
 import { resolve } from "node:path";
+import { homedir } from "node:os";
 import { resolveDefaultAgentTool } from "./config.js";
 import { readUtf8JsonBody } from "./agent-rpc-body.js";
 import { delegateAgentTask } from "./agent-delegate-task.js";
 import { applySharedPrefix } from "./shared-prefix.js";
+import { beginSafeMaintenanceTrackedWork, isSafeMaintenanceAdmissionClosed, } from "./safe-maintenance.js";
 export const AGENT_DELEGATE_TASK_PATH = "/api/agent/delegate-task";
 const MAX_REQUEST_BYTES = 128 * 1024;
-const VALID_TOOLS = new Set(["claude", "cursor", "codex"]);
+const VALID_TOOLS = new Set(["claude", "cursor", "codex", "ccc", "dsh"]);
 function jsonReply(res, status, data) {
     res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
     res.end(JSON.stringify(data));
@@ -37,7 +39,7 @@ function validateTool(rawTool) {
 function validateCwd(rawCwd) {
     const cwd = stringValue(rawCwd);
     if (!cwd)
-        throw new Error("cwd must be a non-empty string");
+        return homedir();
     return resolve(cwd);
 }
 export async function handleAgentDelegateTaskRequest(req, res, platform) {
@@ -69,8 +71,6 @@ export async function handleAgentDelegateTaskRequest(req, res, platform) {
         tool = validateTool(payload.tool);
         cwd = validateCwd(payload.cwd);
         const rawPrompt = promptFromPayload(payload);
-        if (!rawPrompt)
-            throw new Error("prompt must be a non-empty string");
         const sharedPrefix = applySharedPrefix(rawPrompt);
         promptText = sharedPrefix.text;
         promptNamePrefix = sharedPrefix.body || rawPrompt;
@@ -83,21 +83,31 @@ export async function handleAgentDelegateTaskRequest(req, res, platform) {
         return true;
     }
     try {
-        const result = await delegateAgentTask({
-            platform,
-            tool,
-            cwd,
-            promptText,
-            openIds,
-            chatNamePrefix: stringValue(payload.chat_name) || promptNamePrefix.slice(0, 10),
-        });
-        jsonReply(res, 200, {
-            ok: true,
-            chat_id: result.chatId,
-            session_id: result.sessionId,
-            tool: result.tool,
-            cwd: result.cwd,
-        });
+        if (isSafeMaintenanceAdmissionClosed()) {
+            jsonReply(res, 409, { ok: false, error: "ChatCCC 正在等待安全维护，暂不接受新的委派任务。" });
+            return true;
+        }
+        const release = beginSafeMaintenanceTrackedWork("agent-delegate-task");
+        try {
+            const result = await delegateAgentTask({
+                platform,
+                tool,
+                cwd,
+                promptText,
+                openIds,
+                chatNamePrefix: stringValue(payload.chat_name) || promptNamePrefix.slice(0, 10),
+            });
+            jsonReply(res, 200, {
+                ok: true,
+                chat_id: result.chatId,
+                session_id: result.sessionId,
+                tool: result.tool,
+                cwd: result.cwd,
+            });
+        }
+        finally {
+            release();
+        }
     }
     catch (err) {
         jsonReply(res, 500, { ok: false, error: err.message });
@@ -106,24 +116,27 @@ export async function handleAgentDelegateTaskRequest(req, res, platform) {
 }
 export function buildAgentDelegateTaskCapabilityPrompt(input) {
     const lines = [
-        "[ChatCCC local capability: delegate task]",
-        "You can create a separate Feishu ChatCCC agent session and assign its first task by calling this local endpoint.",
+        "[ChatCCC local capability: new session]",
+        "You can create a separate Feishu ChatCCC agent session (a new group) and optionally assign its first task by calling this local endpoint.",
         "",
         `POST ${input.url}`,
         "Content-Type: application/json; charset=utf-8",
         "",
-        'Body: {"tool":"codex|claude|cursor","cwd":"absolute working directory","open_id":"Feishu open_id to invite","prompt":"first task text"}',
+        'Body: {"tool":"claude|cursor|codex|ccc|dsh","cwd":"absolute working directory","open_id":"initiator open_id","prompt":"optional first task"}',
         "",
         "Rules:",
-        "- Use this only when the user asks you to start a separate delegated conversation/session.",
-        "- Pass cwd explicitly as an absolute local path.",
-        "- Pass tool explicitly when the user specified a target agent.",
-        "- Use open_id for one user or open_ids/openIds for multiple users.",
+        "- Use this when the user asks to start a new conversation/session, optionally in a specific directory.",
+        "- Pass open_id exactly as provided to you; the new group will only include that requester.",
+        "- Pass cwd as an absolute local path. When the user does not name a directory, use your current working directory.",
+        "- tool is optional; omit it to use the default agent, or pass one of claude/cursor/codex/ccc/dsh when the user names a tool.",
+        "- prompt is optional; omit it to just create the session without sending a first task.",
         "- The prompt is sent through the normal ChatCCC prompt path, so project prompt injection and IM skills still apply.",
         "- Request body must be UTF-8 encoded JSON bytes. Do not call Feishu Open Platform directly.",
-        "[/ChatCCC local capability: delegate task]",
+        "[/ChatCCC local capability: new session]",
     ];
     if (input.cwd)
         lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+    if (input.openId)
+        lines.splice(2, 0, `Initiator open_id: ${input.openId}`);
     return lines.join("\n");
 }

package/dist/src/agent-delegate-task.js

@@ -7,9 +7,10 @@ import { sessionChatName } from "./session-name.js";
 export async function delegateAgentTask(input) {
     const cwd = resolve(input.cwd);
     const toolLabel = toolDisplayName(input.tool);
+    const hasPrompt = input.promptText.trim().length > 0;
     const init = await initClaudeSession(input.tool, cwd);
     const sessionId = init.sessionId;
-    const chatNamePrefix = input.chatNamePrefix?.trim() || input.promptText.slice(0, 10) || "新会话";
+    const chatNamePrefix = input.chatNamePrefix?.trim() || (hasPrompt ? input.promptText.slice(0, 10) : "新会话");
     const chatName = sessionChatName(chatNamePrefix, cwd);
     let chatId;
     try {
@@ -36,13 +37,17 @@ export async function delegateAgentTask(input) {
     await input.platform.sendCard(chatId, `${toolLabel} Session Ready`, `已创建 **${toolLabel}** 会话群。\n\n` +
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
-        `下面会自动把任务作为第一句话发送给 ${toolLabel}。`, "green").catch(() => { });
+        (hasPrompt
+            ? `下面会自动把任务作为第一句话发送给 ${toolLabel}。`
+            : `直接在这里发消息即可与 ${toolLabel} 对话。`), "green").catch(() => { });
     const fastMode = getEffectiveFastModeForTool(input.tool, sessionId);
     const avatarUpdate = fastMode
         ? input.platform.setChatAvatar(chatId, input.tool, "new", { fastMode: true })
         : input.platform.setChatAvatar(chatId, input.tool, "new");
     avatarUpdate.catch(() => { });
-    await resumeAndPrompt(sessionId, input.promptText, input.platform, chatId, input.msgTimestamp ?? Date.now(), input.tool, input.traceId);
+    if (hasPrompt) {
+        await resumeAndPrompt(sessionId, input.promptText, input.platform, chatId, input.msgTimestamp ?? Date.now(), input.tool, input.traceId, input.openIds?.[0]);
+    }
     console.log(`[${ts()}] [AGENT-DELEGATE-TASK] created ${toolLabel} session=${sessionId} chat=${chatId} cwd=${cwd}`);
     return { chatId, sessionId, tool: input.tool, cwd };
 }

package/dist/src/agent-set-cwd-rpc.js

@@ -0,0 +1,73 @@
+import { resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { addRecentDir, setDefaultCwd } from "./config.js";
+import { readUtf8JsonBody } from "./agent-rpc-body.js";
+import { getChatsForSession } from "./session-chat-binding.js";
+export const AGENT_SET_CWD_PATH = "/api/agent/set-cwd";
+const MAX_REQUEST_BYTES = 64 * 1024;
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+/**
+ * Agent 本地能力：设置后续新建会话的默认工作目录（等价于 /cd，不改变当前会话）。
+ * 请求携带发起者当前 session_id，主进程据此反查 chatId，并持久化到该 chat 的
+ * working_dir 文件，同时写入最近目录记录。
+ */
+export async function handleAgentSetCwdRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_SET_CWD_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+        return true;
+    }
+    let payload;
+    try {
+        payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message || "Invalid JSON" });
+        return true;
+    }
+    const sessionId = stringValue(payload.session_id);
+    if (!sessionId) {
+        jsonReply(res, 400, { ok: false, error: "Missing session_id" });
+        return true;
+    }
+    const rawDir = stringValue(payload.dir) || stringValue(payload.path);
+    if (!rawDir) {
+        jsonReply(res, 400, { ok: false, error: "dir must be a non-empty string" });
+        return true;
+    }
+    const dir = resolve(rawDir);
+    try {
+        const st = await stat(dir);
+        if (!st.isDirectory()) {
+            jsonReply(res, 400, { ok: false, error: `path is not a directory: ${dir}` });
+            return true;
+        }
+    }
+    catch {
+        jsonReply(res, 400, { ok: false, error: `directory does not exist: ${dir}` });
+        return true;
+    }
+    const chatIds = getChatsForSession(sessionId);
+    const chatId = chatIds[0];
+    if (!chatId) {
+        jsonReply(res, 404, { ok: false, error: "No chat bound to this session; cannot set working directory." });
+        return true;
+    }
+    try {
+        await setDefaultCwd(dir, chatId);
+        await addRecentDir(dir);
+        jsonReply(res, 200, { ok: true, dir, chat_id: chatId });
+    }
+    catch (err) {
+        jsonReply(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+}

package/dist/src/agent-team/application/main-agent-service.js

@@ -2,6 +2,7 @@ import { isAgentTool } from "../../agent-tool.js";
 import { sessionChatName } from "../../session-name.js";
 import { isValidFeishuOpenId, } from "../repositories/feishu-p2p-contact-store.js";
 import { BoardStoreError } from "../repositories/board-repository.js";
+import { beginSafeMaintenanceTrackedWork, isSafeMaintenanceAdmissionClosed, } from "../../safe-maintenance.js";
 export class MainAgentService {
     options;
     now;
@@ -17,18 +18,26 @@ export class MainAgentService {
         return this.options.bindingRepository.get(projectId);
     }
     setPrimaryAgent(projectId, agentId, expectedRevision) {
+        if (isSafeMaintenanceAdmissionClosed()) {
+            throw new BoardStoreError("safe_maintenance_draining", "ChatCCC 正在等待安全维护，暂不接受新的主 Agent 设置。", 409);
+        }
         if (!isAgentTool(agentId)) {
             throw new BoardStoreError("invalid_request", `Unsupported primary Agent: ${String(agentId)}`, 400);
         }
+        const release = beginSafeMaintenanceTrackedWork("agent-team-main-agent");
         return this.exclusive(projectId, async () => {
             const board = await this.options.boardService.getBoard(projectId);
             if (board.revision !== expectedRevision) {
                 throw new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expectedRevision}, current ${board.revision})`, 409);
             }
             return this.provision(board, agentId, false);
-        });
+        }).finally(release);
     }
     relinkWorkspace(projectId, workspacePath, expectedRevision) {
+        if (isSafeMaintenanceAdmissionClosed()) {
+            throw new BoardStoreError("safe_maintenance_draining", "ChatCCC 正在等待安全维护，暂不接受目录重新关联。", 409);
+        }
+        const release = beginSafeMaintenanceTrackedWork("agent-team-relink");
         return this.exclusive(projectId, async () => {
             const existing = await this.options.bindingRepository.get(projectId);
             const currentSessionId = existing ? (await this.resolveCurrentSession(existing)).sessionId : null;
@@ -39,7 +48,7 @@ export class MainAgentService {
             if (!existing || !board.primaryAgentId)
                 return { board, binding: null };
             return this.provision(board, board.primaryAgentId, true);
-        });
+        }).finally(release);
     }
     async provision(board, agentId, forceNewSession) {
         const existing = await this.options.bindingRepository.get(board.boardId);

package/dist/src/agent-team/application/task-execution-service.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { isActiveTaskRun } from "../domain/task-run.js";
 import { BoardStoreError } from "../repositories/board-repository.js";
+import { beginSafeMaintenanceTrackedWork, isSafeMaintenanceAdmissionClosed, } from "../../safe-maintenance.js";
 export class TaskExecutionService {
     options;
     now;
@@ -12,10 +13,25 @@ export class TaskExecutionService {
         this.now = options.now ?? (() => new Date());
         this.idFactory = options.idFactory ?? randomUUID;
     }
-    listRuns(projectId) {
-        return this.options.repository.listByProject(projectId);
+    async listRuns(projectId) {
+        const runs = await this.options.repository.listByProject(projectId);
+        return runs.map(withoutTranscript);
+    }
+    async getRun(projectId, runId) {
+        const run = await this.options.repository.get(runId);
+        if (!run || run.projectId !== projectId) {
+            throw new BoardStoreError("task_run_not_found", "找不到这次任务执行记录", 404);
+        }
+        if (!isActiveTaskRun(run) || !this.options.runtime.getTranscript)
+            return run;
+        const live = await this.options.runtime.getTranscript(run.sessionId).catch(() => []);
+        return live.length ? { ...run, transcript: mergeTranscript(run.transcript, live) } : run;
     }
     async startTask(projectId, taskId, expectedRevision) {
+        if (isSafeMaintenanceAdmissionClosed()) {
+            throw new BoardStoreError("safe_maintenance_draining", "ChatCCC 正在等待安全维护，暂不接受新的 Agent Team 任务。", 409);
+        }
+        const release = beginSafeMaintenanceTrackedWork("agent-team-task-start");
         return this.exclusive(projectId, async () => {
             let board = await this.options.boardService.getBoard(projectId);
             const active = (await this.options.repository.listByProject(projectId)).find(isActiveTaskRun);
@@ -54,6 +70,10 @@ export class TaskExecutionService {
                 createdAt: timestamp,
                 updatedAt: timestamp,
             };
+            run = {
+                ...run,
+                transcript: [{ type: "prompt", at: timestamp, text: taskPrompt(run) }],
+            };
             await this.options.repository.save(run);
             try {
                 if (task.columnId !== "doing") {
@@ -80,7 +100,7 @@ export class TaskExecutionService {
                 console.error(`[Agent Team] Task run ${run.runId} failed to persist its terminal state: ${err.message}`);
             });
             return { board, run };
-        });
+        }).finally(release);
     }
     async stopRun(projectId, runId) {
         return this.exclusive(projectId, async () => {
@@ -125,14 +145,15 @@ export class TaskExecutionService {
                 prompt: taskPrompt(run),
             });
             if (result.outcome === "done") {
-                return this.finishRun(run, "succeeded", { result: result.result, moveTask: true });
+                return this.finishRun(run, "succeeded", { result: result.result, transcript: result.transcript, moveTask: true });
             }
             if (result.outcome === "stopped") {
-                return this.finishRun(run, "canceled", { error: result.error, moveTask: true });
+                return this.finishRun(run, "canceled", { error: result.error, transcript: result.transcript, moveTask: true });
             }
             return this.finishRun(run, "failed", {
                 error: result.error || (result.outcome === "auto_ended" ? "Agent response timed out" : "Agent execution failed"),
                 result: result.result,
+                transcript: result.transcript,
                 moveTask: true,
             });
         }
@@ -150,6 +171,7 @@ export class TaskExecutionService {
             state,
             updatedAt: now,
             finishedAt: now,
+            ...(details.transcript?.length ? { transcript: mergeTranscript(latest.transcript, details.transcript) } : {}),
             ...(details.result ? { result: details.result } : {}),
             ...(details.error ? { error: details.error } : {}),
         };
@@ -195,6 +217,13 @@ export class TaskExecutionService {
         }
     }
 }
+function mergeTranscript(existing, appended) {
+    return [...(existing ?? []), ...appended];
+}
+function withoutTranscript(run) {
+    const { transcript: _transcript, ...summary } = run;
+    return summary;
+}
 function taskPrompt(run) {
     return [
         "你正在执行 Agent Team 看板中的一个明确任务。请在当前工作目录完成任务，进行必要验证，并用简洁结果说明完成内容。",

package/dist/src/agent-team/domain/task-run.js

@@ -1,4 +1,5 @@
 import { isAgentTool } from "../../agent-tool.js";
+import { isExecutionTranscriptEntry } from "../../execution-transcript.js";
 export const TASK_RUN_SCHEMA_VERSION = 1;
 export function isActiveTaskRun(run) {
     return run.state === "queued" || run.state === "running";
@@ -25,5 +26,8 @@ export function parseTaskRun(value) {
         if (run[field] !== undefined && typeof run[field] !== "string")
             throw new Error(`Invalid task run ${field}`);
     }
+    if (run.transcript !== undefined && (!Array.isArray(run.transcript) || !run.transcript.every(isExecutionTranscriptEntry))) {
+        throw new Error("Invalid task run transcript");
+    }
     return run;
 }

package/dist/src/agent-team/http/board-routes.js

@@ -109,6 +109,12 @@ export function createAgentTeamRequestHandler(options) {
                 jsonReply(res, 200, { ok: true, runs });
                 return true;
             }
+            const runDetailMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/runs\/([^/]+)$/);
+            if (runDetailMatch && method === "GET") {
+                const run = await requireTaskExecutionService(taskExecutionService()).getRun(decodeURIComponent(runDetailMatch[1]), decodeURIComponent(runDetailMatch[2]));
+                jsonReply(res, 200, { ok: true, run });
+                return true;
+            }
             const runTaskMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/tasks\/([^/]+)\/run$/);
             if (runTaskMatch && method === "POST") {
                 const body = await bodyJson(req);

package/dist/src/agent-team/infrastructure/task-execution-runtime.js

@@ -11,10 +11,14 @@ export function createTaskExecutionRuntime(platform) {
             }
             return {
                 outcome,
+                ...(stream?.transcript?.length ? { transcript: stream.transcript } : {}),
                 ...(stream?.finalReply ? { result: stream.finalReply } : {}),
                 ...(stream?.terminalError?.message ? { error: stream.terminalError.message } : {}),
             };
         },
+        async getTranscript(sessionId) {
+            return (await readStreamState(sessionId))?.transcript ?? [];
+        },
         stop: stopSession,
         isSessionRunning,
     };