@nowcrew/daemon 0.1.0 → 0.1.2

package/dist/console.js

@@ -0,0 +1,80 @@
+/**
+ * 把 coding-agent runtime 的 stream-json 事件转成**终端 console 行**(完全透传)。
+ *
+ * 与 normalize.ts 平行,但目标相反:normalize 为状态角标做**语义压缩**,这里为前端终端窗口
+ * 做**原文透传**——保留思考文本、工具调用、工具返回正文,尽量还原原生 claude CLI 的观感。
+ * 纯函数,无 IO,完整单测。
+ *
+ * 注:本转换器针对 claude 的 stream-json。codex 的 stream 格式不同,后续按 runtime 分派扩展;
+ * 前端/server 消费的 ConsoleChunk 形状是 runtime 无关的。
+ */
+/** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
+export const TOOL_RESULT_CAP = 4000;
+/** 工具输入摘要上限(标题行那一段)。 */
+const TOOL_INPUT_CAP = 160;
+/** 把工具输入压成一行摘要:Bash 取 command,其它取首个字符串字段或紧凑 JSON。 */
+function summarizeToolInput(name, input) {
+    if (!input)
+        return `⏺ ${name}`;
+    if (name === "Bash" && typeof input.command === "string") {
+        return `⏺ Bash(${clip(input.command.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`;
+    }
+    const entries = Object.entries(input);
+    const head = entries
+        .map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`)
+        .join(", ");
+    return `⏺ ${name}(${clip(head.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`;
+}
+/** 把 tool_result 的 content(string | block[])抽成纯文本。 */
+function extractToolResult(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (b && typeof b === "object" && typeof b.text === "string" ? b.text : ""))
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function clip(s, cap) {
+    return s.length > cap ? s.slice(0, cap) + `… (+${s.length - cap})` : s;
+}
+/** 把一个 stream-json 事件转成 0..N 条 console 行(完全透传)。 */
+export function toConsoleLines(event) {
+    const e = (event ?? {});
+    if (e.type === "system" && e.subtype === "init") {
+        return [{ stream: "system", text: "● claude 会话启动" }];
+    }
+    if (e.type === "result") {
+        const text = e.result?.trim() || (e.is_error ? "运行出错" : "本轮结束");
+        return [{ stream: e.is_error ? "error" : "result", text }];
+    }
+    if (e.type === "assistant" && Array.isArray(e.message?.content)) {
+        const out = [];
+        for (const block of e.message.content) {
+            if (block.type === "thinking" && block.thinking?.trim()) {
+                out.push({ stream: "thinking", text: block.thinking.trim() });
+            }
+            else if (block.type === "text" && block.text?.trim()) {
+                out.push({ stream: "text", text: block.text.trim() });
+            }
+            else if (block.type === "tool_use" && block.name) {
+                out.push({ stream: "tool", text: summarizeToolInput(block.name, block.input) });
+            }
+        }
+        return out;
+    }
+    if (e.type === "user" && Array.isArray(e.message?.content)) {
+        const out = [];
+        for (const block of e.message.content) {
+            if (block.type === "tool_result") {
+                const text = extractToolResult(block.content).trim();
+                if (text)
+                    out.push({ stream: "tool_result", text: clip(text, TOOL_RESULT_CAP) });
+            }
+        }
+        return out;
+    }
+    return [];
+}

package/dist/prompt.js

@@ -64,6 +64,9 @@ CRITICAL 规则:
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
 - **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。
+- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。被唤醒处理来信时,对这件事**只建一个 task**:\`crew task create --title "…"\`(不带 --new-thread)会把它绑到**当前线程**(触发你的那条消息所在线程),不另发顶层消息。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再 \`crew task create\` 会被服务端拒绝(报错会提示你)。
+- **进度/产出回本线程**:这件事的认领/进度/完成汇报都用 \`crew message send --thread <当前线程根>\` 回复在**这个线程里**(线程根 = 触发你的那条消息 id,即 \$CREW_WAKE_MESSAGE_ID)。**严禁把进度发到别的线程或频道顶层。**
+- **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
 - 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。
 - **交接(handoff)**:当你这一环干完、需要别的角色接手时(如开发完成 → 交给 QA 测试),用 \`crew task assign <taskId> --to <下家handle>\` 把任务交接出去,并在线程里给下家足够背景(分支名 / 改动摘要 / 测试建议)。交接后对方会被自动唤醒。**别让任务停在你手里无人跟进**。
 - **分诊(若你是总管)**:若你收到「【分诊请求】」唤醒,说明频道里有一个无人认领的任务需要你按团队职责分派。唤醒内容里已附上团队成员及其职责:判断谁最合适,用 \`crew task assign <taskId> --to <handle>\` 指派给他(若该你自己做就 \`crew task claim\`);确实没人合适时,在频道里 @发起人 说明并给建议,**不要让任务悬空**。
@@ -95,7 +98,7 @@ ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memor
  * 只有发现确实指向自己的事才转为主动处理,否则读完即停、不发声。
  */
 export function buildWakePrompt(channelId) {
-    return `先用 \`crew message read --channel ${channelId}\` 把这个频道读一遍,补齐上下文。
+    return `先补齐上下文:若本轮在某个线程里(被唤醒处理某 thread),用 \`crew thread read\` 读**当前线程 + 它的父线程**(聚焦上下文,最多向上一层);需要更全局再用 \`crew message read --channel ${channelId}\` 读整个频道。
 读完判断:其中是否有明确落到你头上的事——点名找你、@你、指派给你、请你评审,或交给你的任务。
 - 有:转入主动处理。相关任务先 \`crew task claim <taskId>\` 认领再动手,完成后用 \`crew message send --channel ${channelId}\` 回复。
 - 没有:本轮什么都不要发,读完即停。你存活期间有新消息会自动送来,无需轮询。`;

package/dist/runner.js

@@ -9,13 +9,16 @@ import { prepareWorkspace } from "./workspace.js";
 import { buildSystemPrompt, buildWakePrompt } from "./prompt.js";
 import { spawnClaude } from "./runtimes/claude.js";
 import { normalizeEvent, parseLine } from "./normalize.js";
+import { toConsoleLines } from "./console.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
 const MEMORY_INJECT_CAP = 6000;
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
     claiming: "📌", crew: "⚙️", tool: "🛠️", tool_result: "↩️", done: "✅", error: "❌",
 };
-export async function runAgent(config, input, onActivity = defaultPrint) {
+export async function runAgent(config, input, onActivity = defaultPrint, 
+// 终端透传:每条 stream-json 事件除归一化为状态活动外,再产出 console 行供前端终端窗口渲染。
+onConsole = () => { }) {
     // 1) 用机器令牌换 per-launch agent 令牌
     const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName);
     // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
@@ -25,6 +28,8 @@ export async function runAgent(config, input, onActivity = defaultPrint) {
         handle: input.handle,
         cliPath: config.cliPath,
         ...(input.taskKey ? { taskKey: input.taskKey } : {}),
+        // 仅在首次创建 MEMORY.md 时,用 agent 的 description 种子化 ## Role
+        ...(cred.config?.description ? { description: cred.config.description } : {}),
     });
     const systemPrompt = buildSystemPrompt({
         handle: input.handle,
@@ -49,6 +54,8 @@ export async function runAgent(config, input, onActivity = defaultPrint) {
         wakePrompt: input.wake ?? buildWakePrompt(input.channelId),
         dangerous: config.dangerous,
         ...(cfg.model ? { model: cfg.model } : {}),
+        // 一线程一会话:首轮 --session-id 固定 id,之后 --resume 续上(更原生地复用 claude 记忆)
+        ...(ws.agentSessionId ? { sessionId: ws.agentSessionId, resume: ws.sessionResume } : {}),
         env: {
             ...process.env,
             PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
@@ -58,6 +65,9 @@ export async function runAgent(config, input, onActivity = defaultPrint) {
             // 共享持久记忆 home(MEMORY.md/notes 在此;cwd 是本任务隔离目录)+ 本任务 work-log 路径
             CREW_HOME: ws.dir,
             CREW_TASK_LOG: ws.workLogPath,
+            // 唤醒锚点消息 id:有则 `crew task create` 把任务锚定到这条触发消息(讨论与任务锚点统一),
+            // 而非另发一条标题消息当锚点(那会让点开 task 的 thread 永远为空)。
+            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
             // per-agent 凭证隔离:XDG 指向本 agent 独立目录(gh/gcloud 等 CLI 的 token 不互相串)。
             // 不覆盖 HOME(否则会破坏 claude 自身的 ~/.claude 鉴权);常用 CLI 也单独点名隔离。
             XDG_CONFIG_HOME: join(ws.homeDir, ".config"),
@@ -87,6 +97,9 @@ export async function runAgent(config, input, onActivity = defaultPrint) {
             activities.push(a);
             onActivity(a);
         }
+        // 同一事件再透传为终端 console 行(独立于状态活动,内容不压缩)。
+        for (const c of toConsoleLines(evt))
+            onConsole(c);
     });
     child.stderr.on("data", (d) => process.stderr.write(d));
     const exitCode = await new Promise((resolve) => {

package/dist/runtimes/claude.js

@@ -13,6 +13,9 @@ export function buildClaudeArgs(input) {
     ];
     if (input.model)
         args.push("--model", input.model);
+    if (input.sessionId) {
+        args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
+    }
     if (input.dangerous)
         args.push("--dangerously-skip-permissions");
     args.push(input.wakePrompt);

package/dist/serve.js

@@ -167,6 +167,22 @@ export function serve(config, opts = {}) {
                 }
                 catch { /* ws 非 OPEN,忽略 */ }
             };
+            // 终端透传:把底层 claude 的每条 console 行按线程上送给 server(独立 seq,落库+广播给 web 终端窗口)。
+            let conSeq = 0;
+            const reportConsole = (c) => {
+                try {
+                    ws?.send(JSON.stringify({
+                        type: "agent:console",
+                        agentHandle: msg.agentHandle,
+                        channelId: msg.channelId,
+                        threadId: threadId ?? null,
+                        stream: c.stream,
+                        text: c.text,
+                        seq: conSeq++,
+                    }));
+                }
+                catch { /* ws 非 OPEN,忽略 */ }
+            };
             try {
                 // 线程聚合:触发消息即任务线程根,你的确认+后续所有回复都要发到它的线程里,
                 // 不要发顶层——这样 task 讨论全部聚合在该 thread 下。
@@ -191,9 +207,12 @@ export function serve(config, opts = {}) {
                     handle: msg.agentHandle,
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
+                    // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
+                    ...(threadId ? { wakeMessageId: threadId } : {}),
                     ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 crew message read --channel ${msg.channelId} 读频道后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
-                }, reportActivity);
+                }, reportActivity, reportConsole);
                 reportActivity({ kind: "done", label: "本轮结束" });
+                reportConsole({ stream: "result", text: "● 本轮结束" });
                 log(`✅ agent=${msg.agentHandle} 本轮完成`);
             }
             catch (e) {

package/dist/workspace.js

@@ -8,6 +8,7 @@
  * spawn runtime 时把 <ws>/.crew 置于 PATH 最前,于是 agent 的 `crew ...` 命中 wrapper。
  */
 import { mkdir, writeFile, readFile, chmod, access } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
@@ -29,7 +30,7 @@ export async function prepareWorkspace(input) {
     // MEMORY.md:首次创建"索引 + Active Context"骨架,之后由 agent 自己维护
     const memoryPath = join(dir, "MEMORY.md");
     if (!(await exists(memoryPath))) {
-        await writeFile(memoryPath, memorySeed(input.handle), "utf8");
+        await writeFile(memoryPath, memorySeed(input.handle, input.description), "utf8");
     }
     const memory = await readFile(memoryPath, "utf8");
     // 系统提示词 (每次覆盖,保证最新);省略时由调用方在拿到 memory 后自行写入。
@@ -55,17 +56,35 @@ export async function prepareWorkspace(input) {
         workLogPath = join(runDir, "work-log.md");
     }
     const workLog = (await exists(workLogPath)) ? await readFile(workLogPath, "utf8") : "";
-    return { dir, crewDir, systemPromptPath, memory, homeDir, runDir, workLogPath, workLog };
+    // 一线程一会话:tasks/<taskKey>/.session 存底层会话 id。已存在→resume 续上;否则新建。
+    let agentSessionId = null;
+    let sessionResume = false;
+    if (input.taskKey) {
+        const sessionPath = join(runDir, ".session");
+        if (await exists(sessionPath)) {
+            agentSessionId = (await readFile(sessionPath, "utf8")).trim() || null;
+            sessionResume = !!agentSessionId;
+        }
+        if (!agentSessionId) {
+            agentSessionId = randomUUID();
+            await writeFile(sessionPath, agentSessionId, "utf8");
+        }
+    }
+    return { dir, crewDir, systemPromptPath, memory, homeDir, runDir, workLogPath, workLog, agentSessionId, sessionResume };
 }
 /**
  * MEMORY.md 种子骨架:分层记忆的"索引 + Active Context"结构。
  * 第一次准备工作区时写入;之后 agent 自己维护(系统提示词里有协议)。
+ * 建 agent 时填了 description,则用它种子化 ## Role(否则留占位符,由 agent 自填)。
  */
-function memorySeed(handle) {
+function memorySeed(handle, description) {
+    const role = description?.trim()
+        ? description.trim()
+        : "(Who you are and what you're responsible for. Keep it to a few lines.)";
     return `# ${handle}
 
 ## Role
-(Who you are and what you're responsible for. Keep it to a few lines.)
+${role}
 
 ## Core Goals
 (What you optimize for.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",