@nowcrew/daemon 0.1.1 → 0.2.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 OpenSlock contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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

@@ -37,7 +37,7 @@ export function buildSystemPrompt(ctx) {
    \`\`\`
    也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <msg码>\`(msg 码来自 read/search 输出里的 \`msg=\` 前 8 位)。
 5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
-6. **\`crew task create --channel <id> --title "<标题>"\`** —— 新建任务(把一件事登记成可追踪的工作项)。
+6. **\`crew task create --channel <id> --title "<标题>" --thread <当前线程根msgId>\`** —— 新建任务并**绑定到当前线程**。\`--thread\` 传你读到的那条**触发消息 id**(线程根),任务就和讨论同处一个线程。省略 \`--thread\` 会另起新线程,**几乎总是错的——务必带上**。
 7. **\`crew task claim <taskId>\`** —— 认领任务(动手前必做)。
 8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
 9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
@@ -64,6 +64,9 @@ CRITICAL 规则:
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
 - **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。
+- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。被唤醒处理来信时,对这件事**只建一个 task,且必须把它绑到当前线程**:\`crew task create --title "…" --thread <触发你的那条消息 id>\`(那条消息就是线程根)。**一定要带 \`--thread\`**——不带会另起一条飘在顶层的新线程,task 就和你的讨论分家了(这正是要避免的)。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再建会被服务端拒绝(报错会提示你)。
+- **进度/产出回本线程**:这件事的认领/进度/完成汇报都用 \`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,15 +9,18 @@ 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);
+    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, input.wakeMessageId);
     // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
     //    先 prepare 拿到 memory/workLog,再 build 系统提示词(注入记忆索引)写入。
     const ws = await prepareWorkspace({
@@ -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/token.js

@@ -1,12 +1,17 @@
 /** 用机器令牌为某 agent 换取 per-launch 的 sk_agent_*。 */
-export async function mintAgentToken(serverUrl, machineToken, handle, displayName, fetchImpl = fetch) {
+export async function mintAgentToken(serverUrl, machineToken, handle, displayName, wakeThreadRoot, fetchImpl = fetch) {
     const res = await fetchImpl(`${serverUrl}/daemon/agents/token`, {
         method: "POST",
         headers: {
             authorization: `Bearer ${machineToken}`,
             "content-type": "application/json",
         },
-        body: JSON.stringify(displayName ? { handle, displayName } : { handle }),
+        // 把本轮唤醒的线程根钉到 per-launch 令牌:服务端据此让 task/消息默认绑/回当前线程。
+        body: JSON.stringify({
+            handle,
+            ...(displayName ? { displayName } : {}),
+            ...(wakeThreadRoot ? { wakeThreadRoot } : {}),
+        }),
     });
     const body = (await res.json().catch(() => null));
     if (!res.ok || !body?.success || !body.data) {

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.1",
+  "version": "0.2.0",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,16 +16,9 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "daemon": "tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
-    "@nowcrew/cli": "^0.1.0",
-    "ws": "^8"
+    "ws": "^8",
+    "@nowcrew/cli": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -33,5 +26,11 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "daemon": "tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}