@nowcrew/daemon 0.1.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/config.js

@@ -0,0 +1,33 @@
+/** daemon 配置:从 env 读取,解析 crew CLI 路径 (注入给 agent 的 wrapper 用)。 */
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createRequire } from "node:module";
+export class ConfigError extends Error {
+}
+function defaultCliPath() {
+    // 已发布场景(npx):crew CLI 是 daemon 的依赖,从 node_modules 解析 @nowcrew/cli。
+    try {
+        return createRequire(import.meta.url).resolve("@nowcrew/cli/dist/main.js");
+    }
+    catch {
+        // 开发场景(monorepo):daemon/src → 上两级到 crew/,再进 cli/dist/main.js
+        const here = dirname(fileURLToPath(import.meta.url));
+        return resolve(here, "../../cli/dist/main.js");
+    }
+}
+export function loadConfig(env = process.env) {
+    const serverUrl = (env.CREW_SERVER_URL ?? "http://127.0.0.1:3000").replace(/\/+$/, "");
+    const machineToken = env.CREW_MACHINE_TOKEN ?? "";
+    if (!machineToken) {
+        throw new ConfigError("缺少 CREW_MACHINE_TOKEN (sk_machine_*,由 seed 打印)");
+    }
+    return {
+        serverUrl,
+        machineToken,
+        agentsRoot: env.CREW_AGENTS_ROOT ?? resolve(homedir(), ".crew/agents"),
+        cliPath: env.CREW_CLI_PATH ?? defaultCliPath(),
+        runtimeBin: env.CREW_RUNTIME ?? "claude",
+        dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)
+    };
+}

package/dist/machine-info.js

@@ -0,0 +1,55 @@
+/**
+ * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
+ * runtimes 探测靠 `which <bin>`,只报真实可执行的 CLI(用于展示 Detected Runtimes)。
+ */
+import { hostname, arch, platform } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+const execFileP = promisify(execFile);
+/** 候选 runtime CLI:展示名 → 可执行文件名。 */
+const RUNTIME_BINS = [
+    ["claude", "claude"],
+    ["codex", "codex"],
+    ["cursor", "cursor-agent"],
+    ["gemini", "gemini"],
+    ["opencode", "opencode"],
+    ["copilot", "copilot"],
+    ["kimi", "kimi"],
+    ["pi", "pi"],
+];
+async function isInstalled(bin) {
+    try {
+        await execFileP("which", [bin]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 并发探测所有候选 runtime,返回已安装的展示名列表。 */
+export async function detectRuntimes() {
+    const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
+    return checks.filter((x) => x !== null);
+}
+function daemonVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(resolve(here, "../package.json"), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export async function collectMachineHello() {
+    return {
+        type: "machine:hello",
+        hostname: hostname(),
+        os: `${platform()} ${arch()}`,
+        daemonVersion: daemonVersion(),
+        runtimes: await detectRuntimes(),
+    };
+}

package/dist/main.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * crew-daemon 入口 (M3b 当前形态:本地手动唤醒一个 agent 跑一轮)。
+ *   crew-daemon run --agent <handle> --channel <id> [--wake "<text>"] [--display "<name>"]
+ *
+ * 后续 (M3c):常驻 + 连 server 控制面 WS,由 agent:start 自动唤醒。
+ */
+import { parseArgs } from "node:util";
+import { loadConfig, ConfigError } from "./config.js";
+import { runAgent } from "./runner.js";
+import { serve } from "./serve.js";
+async function main() {
+    const { values, positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {
+            agent: { type: "string" },
+            channel: { type: "string" },
+            wake: { type: "string" },
+            display: { type: "string" },
+            // 连接参数(也可用 CREW_SERVER_URL / CREW_MACHINE_TOKEN 环境变量)
+            "server-url": { type: "string" },
+            "api-key": { type: "string" },
+            token: { type: "string" }, // --api-key 的别名
+        },
+    });
+    // 无子命令时默认 serve(对齐 `npx @nowcrew/daemon@latest --server-url ... --api-key ...`)
+    const cmd = positionals[0] ?? "serve";
+    if (cmd !== "run" && cmd !== "serve") {
+        process.stderr.write("用法:\n  npx @nowcrew/daemon@latest --server-url <url> --api-key <sk_machine_*>   # 连接并常驻\n  crew-daemon run --agent <h> --channel <id> [--wake ...]                  # 手动跑一次\n");
+        process.exit(2);
+    }
+    // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
+    if (values["server-url"])
+        process.env.CREW_SERVER_URL = values["server-url"];
+    const apiKey = values["api-key"] ?? values.token;
+    if (apiKey)
+        process.env.CREW_MACHINE_TOKEN = apiKey;
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (e) {
+        if (e instanceof ConfigError) {
+            process.stderr.write(e.message + "\n");
+            process.exit(3);
+        }
+        throw e;
+    }
+    if (cmd === "serve") {
+        process.stdout.write(`\n🛰️  crew-daemon 常驻,连接 ${config.serverUrl} 控制面...\n`);
+        serve(config);
+        await new Promise(() => { }); // 常驻,直到被 kill
+        return;
+    }
+    if (!values.agent || !values.channel) {
+        process.stderr.write("用法: crew-daemon run --agent <handle> --channel <id> [--wake ...]\n");
+        process.exit(2);
+    }
+    process.stdout.write(`\n🚀 唤醒 agent "${values.agent}" 处理频道 ${values.channel}\n\n`);
+    const result = await runAgent(config, {
+        handle: values.agent,
+        channelId: values.channel,
+        ...(values.wake ? { wake: values.wake } : {}),
+        ...(values.display ? { displayName: values.display } : {}),
+    });
+    process.stdout.write(`\n— agent 退出 (code ${result.exitCode}),共 ${result.activities.length} 个活动 —\n`);
+    process.exit(result.exitCode);
+}
+main().catch((e) => {
+    process.stderr.write(`crew-daemon: ${e.message}\n`);
+    process.exit(1);
+});

package/dist/normalize.js

@@ -0,0 +1,66 @@
+/**
+ * 把 coding-agent runtime 的 stream-json 事件归一化为**语义活动**。
+ *
+ * 这是 daemon 的关键职责:前端/server 看到的是"在读历史/领任务/发消息",而非裸 Bash。
+ * 纯函数,无 IO,完整单测。
+ */
+/** 把一条 Bash 命令归类为语义活动 (仅看 crew 子命令)。 */
+export function classifyCommand(command) {
+    const c = command.trim();
+    if (/^crew\s+message\s+read\b/.test(c))
+        return { kind: "reading", label: "读历史", detail: c };
+    if (/^crew\s+message\s+send\b/.test(c))
+        return { kind: "sending", label: "发消息", detail: c };
+    if (/^crew\s+message\s+check\b/.test(c))
+        return { kind: "checking", label: "查未读", detail: c };
+    if (/^crew\s+task\s+claim\b/.test(c))
+        return { kind: "claiming", label: "领任务", detail: c };
+    if (/^crew\b/.test(c))
+        return { kind: "crew", label: "crew 命令", detail: c };
+    return { kind: "tool", label: "执行命令", detail: c };
+}
+/** 把一个 stream-json 事件归一化为 0..N 个活动。 */
+export function normalizeEvent(event) {
+    const e = (event ?? {});
+    if (e.type === "system" && e.subtype === "init") {
+        return [{ kind: "init", label: "agent 启动" }];
+    }
+    if (e.type === "result") {
+        return e.is_error
+            ? [{ kind: "error", label: "运行出错", ...(e.result ? { detail: e.result } : {}) }]
+            : [{ kind: "done", label: "本轮结束", ...(e.result ? { detail: e.result } : {}) }];
+    }
+    if (e.type === "assistant" && Array.isArray(e.message?.content)) {
+        const out = [];
+        for (const block of e.message.content) {
+            if (block.type === "text" && block.text?.trim()) {
+                out.push({ kind: "text", label: "思考/说明", detail: block.text.trim() });
+            }
+            else if (block.type === "tool_use" && block.name === "Bash" && block.input?.command) {
+                out.push(classifyCommand(block.input.command));
+            }
+            else if (block.type === "tool_use" && block.name) {
+                out.push({ kind: "tool", label: `工具:${block.name}` });
+            }
+        }
+        return out;
+    }
+    if (e.type === "user" && Array.isArray(e.message?.content)) {
+        const hasResult = e.message.content.some((b) => b.type === "tool_result");
+        if (hasResult)
+            return [{ kind: "tool_result", label: "工具返回" }];
+    }
+    return [];
+}
+/** 解析一行 ndjson;非法行返回 null。 */
+export function parseLine(line) {
+    const t = line.trim();
+    if (!t)
+        return null;
+    try {
+        return JSON.parse(t);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/prompt.js

@@ -0,0 +1,102 @@
+/**
+ * 系统提示词与唤醒提示词构造(OpenSlock 自有设计)。
+ *
+ * 描述的是 OpenSlock 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
+ * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
+ * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
+ */
+export function buildSystemPrompt(ctx) {
+    return `你是 "${ctx.handle}",OpenSlock(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。OpenSlock 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
+
+## 你是谁
+你的 workspace 和 MEMORY.md 跨会话保留,被唤醒时可恢复上下文。你会被启动、空闲时休眠、有人给你发消息时再次唤醒。把自己当成一位始终在线、随时间积累知识、通过交互形成专长的同事——而不是一次性聊天机器人。
+
+## 当前运行时上下文(由 OpenSlock 注入,权威)
+- Handle: ${ctx.handle}${ctx.agentId ? `\n- Agent ID: ${ctx.agentId}` : ""}
+- 你被唤醒处理的频道: ${ctx.channelId}
+- **你的 cwd 是本任务的隔离工作目录**(代码检出/构建/草稿都放这里;你可能同时有多个并行运行,各自 cwd 独立,互不干扰)。
+- **共享持久记忆 home: \`$CREW_HOME\`**${ctx.homeDir ? `(${ctx.homeDir})` : ""}——MEMORY.md 与 notes/ 在这里,跨你的所有任务共享。
+
+## 并行与记忆(CRITICAL — 防冲突 + 防上下文膨胀)
+你**可能同时在处理多个任务**(你自己的多个并行进程)。为避免互相覆盖、并保持上下文精简,严格遵守:
+- **只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
+- **任务进行中不要改 \`$CREW_HOME/MEMORY.md\` 或 notes/**(那是共享文件,多个并行运行同时写会冲突)。这些只读参考;沉淀经验留到任务关闭时由系统触发的收尾来做。
+- **跨任务协调看实时清单**:用 \`crew task list --mine\` 查你当前所有任务及其状态(谁在排队、谁在评审)。例:你一次只能测一个页面时,据此判断"正在测 #1、#2 排队",在 #2 的工作日志里标注"等 #1 完成"。
+- 需要更多背景时再 \`Read $CREW_HOME/notes/<topic>.md\`;不要一次把所有笔记读进上下文。
+
+## 通信 —— 只能用 crew CLI
+所有 chat / task 操作必须经 \`crew\` CLI(daemon 已把它注入你的 PATH)。仅可使用以下命令:
+1. **\`crew whoami\`** —— 查看你自己的身份。
+2. **\`crew message read --channel <id>\`** —— 读频道历史(读取即自动推进你的已读/新鲜度游标)。支持 \`--after <seq>\` / \`--limit <n>\`。
+3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。工作中可在自然断点随时用。
+4. **\`crew message send --channel <id>\`** —— 发消息。正文从 stdin 读,用 heredoc 避免 shell 解释引号/反引号/代码块:
+   \`\`\`bash
+   crew message send --channel <id> <<'CREWMSG'
+   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
+   CREWMSG
+   \`\`\`
+   也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <msg码>\`(msg 码来自 read/search 输出里的 \`msg=\` 前 8 位)。
+5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
+6. **\`crew task create --channel <id> --title "<标题>"\`** —— 新建任务(把一件事登记成可追踪的工作项)。
+7. **\`crew task claim <taskId>\`** —— 认领任务(动手前必做)。
+8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
+9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
+10. **\`crew task assign <taskId> --to <handle>\`** —— 把任务指派/交接给另一个 agent(用于交接,见下)。
+
+CLI 成功时打印人类可读文本到 stdout;失败时 stderr 给出错误,并用**退出码**告诉你下一步:
+- \`4\` = 任务已被他人认领 / 不可认领 → 停手,别抢,转做别的。
+- \`6\` = freshness hold(目标有你没看过的新消息)→ 先 \`crew message read\` 再重试。
+- \`3\` = 鉴权失败;\`5\` = 目标不存在;\`2\` = 参数错误。
+
+CRITICAL 规则:
+- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**
+- **一个 shell 命令只跑一个 crew 命令**,读完它的输出,再决定下一条。不要把多个 crew 命令串到一行。
+- **动手干活前必须先 \`crew task claim\`**;claim 失败就转做别的任务。
+
+## 启动序列
+1. 若本轮已带具体来信,先判断是否需要立即确认/提问/声明接手;需要就先用 \`crew message send\` 发出,再去深挖上下文。
+2. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
+3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
+4. 收到消息就处理,并用 \`crew message send\` 回复。
+5. **做完你负责的所有事再停。** 多步任务(调研/改码/测试)要全部完成、汇报结果后再停。新消息会在你存活期间自动送达,无需轮询等待。
+
+## 消息与任务
+- 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
+- **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
+- **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。
+- 任务状态流:\`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\`);确实没人合适时,在频道里 @发起人 说明并给建议,**不要让任务悬空**。
+- **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。
+
+## 协作礼仪
+- **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
+- **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
+- **claim 后再动手**:claim 失败立即停手,换一个任务。
+- **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
+- **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。
+
+## 沟通风格
+用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
+
+## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
+你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:
+1. **MEMORY.md = 索引 + 角色**:指向你全部知识的目录。系统每次已把它(截断索引版)注入到本提示词末尾,**通常不必再去读整文件**;要某领域明细时再 \`Read $CREW_HOME/notes/<file>.md\`。别一次把所有 notes 读进上下文。
+2. **notes/<domain>.md = 明细**:领域知识、用户偏好、频道说明、经验教训(\`notes/lessons.md\`)。**任务进行中只读不写**(多个并行运行同时写会冲突)。
+3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。
+
+**沉淀与瘦身由系统触发,不要平时做**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时才把可复用经验从 work-log 提炼进 \`notes/lessons.md\`、更新 MEMORY.md 索引、并清掉该任务的 work-log。平时别动 MEMORY.md/notes,既防并行冲突,也防 MEMORY.md 膨胀。
+
+**为什么(CRITICAL)**:上下文会被周期压缩;你的恢复力来自——注入的 MEMORY.md 索引(始终精简)+ 本任务 work-log + 按需读 notes,而**不是**把一切堆进 MEMORY.md。
+${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memory}` : ""}${ctx.workLog ? `\n## [注入] 本任务 work-log(续上进度;更新写到 $CREW_TASK_LOG)\n${ctx.workLog}` : ""}`;
+}
+/**
+ * 唤醒提示词(OpenSlock 自有设计)。默认"只读补课"模式:先把频道读一遍补齐上下文,
+ * 只有发现确实指向自己的事才转为主动处理,否则读完即停、不发声。
+ */
+export function buildWakePrompt(channelId) {
+    return `先用 \`crew message read --channel ${channelId}\` 把这个频道读一遍,补齐上下文。
+读完判断:其中是否有明确落到你头上的事——点名找你、@你、指派给你、请你评审,或交给你的任务。
+- 有:转入主动处理。相关任务先 \`crew task claim <taskId>\` 认领再动手,完成后用 \`crew message send --channel ${channelId}\` 回复。
+- 没有:本轮什么都不要发,读完即停。你存活期间有新消息会自动送来,无需轮询。`;
+}

package/dist/runner.js

@@ -0,0 +1,101 @@
+/**
+ * Agent 运行编排:换令牌 → 备 workspace → spawn runtime → 归一化事件流。
+ */
+import { createInterface } from "node:readline";
+import { writeFile } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { mintAgentToken } from "./token.js";
+import { prepareWorkspace } from "./workspace.js";
+import { buildSystemPrompt, buildWakePrompt } from "./prompt.js";
+import { spawnClaude } from "./runtimes/claude.js";
+import { normalizeEvent, parseLine } from "./normalize.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) {
+    // 1) 用机器令牌换 per-launch agent 令牌
+    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName);
+    // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
+    //    先 prepare 拿到 memory/workLog,再 build 系统提示词(注入记忆索引)写入。
+    const ws = await prepareWorkspace({
+        agentsRoot: config.agentsRoot,
+        handle: input.handle,
+        cliPath: config.cliPath,
+        ...(input.taskKey ? { taskKey: input.taskKey } : {}),
+    });
+    const systemPrompt = buildSystemPrompt({
+        handle: input.handle,
+        channelId: input.channelId,
+        agentId: cred.agentId,
+        homeDir: ws.dir,
+        // 只注入 MEMORY.md 的索引/角色部分(截断),避免上下文膨胀;明细让 agent 按需读 notes/。
+        memory: ws.memory.length > MEMORY_INJECT_CAP
+            ? ws.memory.slice(0, MEMORY_INJECT_CAP) + "\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md 或 notes/)"
+            : ws.memory,
+        workLog: ws.workLog,
+    });
+    await writeFile(ws.systemPromptPath, systemPrompt, "utf8");
+    // 3) spawn runtime,注入 PATH(crew wrapper)、凭证 env、以及 agent 运行时配置
+    //    provider=custom → BYOC(ANTHROPIC_BASE_URL/API_KEY);reasoning → 思考预算;model → --model
+    const cfg = cred.config ?? {};
+    const REASONING_TOKENS = { low: "4000", medium: "10000", high: "31999" };
+    const child = spawnClaude({
+        bin: config.runtimeBin,
+        cwd: ws.runDir, // 本任务隔离工作目录(并行运行互不干扰)
+        systemPromptPath: ws.systemPromptPath,
+        wakePrompt: input.wake ?? buildWakePrompt(input.channelId),
+        dangerous: config.dangerous,
+        ...(cfg.model ? { model: cfg.model } : {}),
+        env: {
+            ...process.env,
+            PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
+            CREW_SERVER_URL: config.serverUrl,
+            CREW_TOKEN: cred.token,
+            CREW_CHANNEL: input.channelId,
+            // 共享持久记忆 home(MEMORY.md/notes 在此;cwd 是本任务隔离目录)+ 本任务 work-log 路径
+            CREW_HOME: ws.dir,
+            CREW_TASK_LOG: ws.workLogPath,
+            // per-agent 凭证隔离:XDG 指向本 agent 独立目录(gh/gcloud 等 CLI 的 token 不互相串)。
+            // 不覆盖 HOME(否则会破坏 claude 自身的 ~/.claude 鉴权);常用 CLI 也单独点名隔离。
+            XDG_CONFIG_HOME: join(ws.homeDir, ".config"),
+            XDG_DATA_HOME: join(ws.homeDir, ".local", "share"),
+            XDG_CACHE_HOME: join(ws.homeDir, ".cache"),
+            GH_CONFIG_DIR: join(ws.homeDir, ".config", "gh"),
+            CLOUDSDK_CONFIG: join(ws.homeDir, ".config", "gcloud"),
+            // provider custom = BYOC:为该 agent 单独设置 Anthropic 端点/密钥
+            ...(cfg.provider === "custom" && cfg.providerBaseUrl ? { ANTHROPIC_BASE_URL: cfg.providerBaseUrl } : {}),
+            ...(cfg.provider === "custom" && cfg.providerApiKey ? { ANTHROPIC_API_KEY: cfg.providerApiKey } : {}),
+            // reasoning → 思考预算 (claude 读 MAX_THINKING_TOKENS)
+            ...(cfg.reasoning && cfg.reasoning !== "default" && REASONING_TOKENS[cfg.reasoning]
+                ? { MAX_THINKING_TOKENS: REASONING_TOKENS[cfg.reasoning] }
+                : {}),
+            // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
+            ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
+        },
+    });
+    // 4) 逐行解析 stdout → 归一化 → 回调
+    const activities = [];
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+        const evt = parseLine(line);
+        if (!evt)
+            return;
+        for (const a of normalizeEvent(evt)) {
+            activities.push(a);
+            onActivity(a);
+        }
+    });
+    child.stderr.on("data", (d) => process.stderr.write(d));
+    const exitCode = await new Promise((resolve) => {
+        child.on("close", (code) => resolve(code ?? 0));
+    });
+    return { exitCode, activities };
+}
+function defaultPrint(a) {
+    const icon = ICON[a.kind] ?? "·";
+    const detail = a.detail ? `  ${a.detail.replace(/\s+/g, " ").slice(0, 120)}` : "";
+    process.stdout.write(`${icon} ${a.label}${detail}\n`);
+}

package/dist/runtimes/claude.js

@@ -0,0 +1,27 @@
+/**
+ * Claude Code runtime 适配:print + stream-json 模式,headless 驱动。
+ */
+import { spawn } from "node:child_process";
+export function buildClaudeArgs(input) {
+    const args = [
+        "--print",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--append-system-prompt-file",
+        input.systemPromptPath,
+    ];
+    if (input.model)
+        args.push("--model", input.model);
+    if (input.dangerous)
+        args.push("--dangerously-skip-permissions");
+    args.push(input.wakePrompt);
+    return args;
+}
+export function spawnClaude(input) {
+    return spawn(input.bin, buildClaudeArgs(input), {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}

package/dist/serve.js

@@ -0,0 +1,223 @@
+/**
+ * 常驻模式 (M3c):连接 server 控制面 WS,注册机器,监听 agent:start 自动唤醒 agent。
+ * 断线指数退避重连。一个 agent:start 进来就跑一次现有的 runAgent。
+ */
+import { WebSocket } from "ws";
+import { join } from "node:path";
+import { runAgent } from "./runner.js";
+import { collectMachineHello } from "./machine-info.js";
+import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
+import { listSkills } from "./skills.js";
+import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
+// normalize.ts 的活动种类 → activity 枚举
+const ACTIVITY_MAP = {
+    init: "working", text: "thinking", reading: "reading", sending: "sending",
+    checking: "checking", claiming: "claiming", crew: "working", tool: "working",
+    tool_result: "working", done: "done", error: "error",
+};
+export function serve(config, opts = {}) {
+    const wsUrl = config.serverUrl.replace(/^http/, "ws") +
+        `/daemon/connect?key=${encodeURIComponent(config.machineToken)}`;
+    let stopped = false;
+    let ws = null;
+    let backoff = 1000;
+    const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
+    // - running:正在跑的「agent:任务」去重键(同一任务重复唤醒才跳过)。
+    // - agentSlots:每 agent 当前并行数;超过 MAX_PARALLEL 的进 FIFO 队列(不丢)。
+    const MAX_PARALLEL = Number(process.env.CREW_MAX_PARALLEL) || 4;
+    const running = new Set();
+    const agentSlots = new Map();
+    const waitQueue = new Map();
+    const acquireSlot = async (handle) => {
+        const n = agentSlots.get(handle) ?? 0;
+        if (n < MAX_PARALLEL) {
+            agentSlots.set(handle, n + 1);
+            return;
+        }
+        await new Promise((resolve) => {
+            const q = waitQueue.get(handle) ?? [];
+            q.push(resolve);
+            waitQueue.set(handle, q);
+        });
+        agentSlots.set(handle, (agentSlots.get(handle) ?? 0) + 1);
+    };
+    const releaseSlot = (handle) => {
+        agentSlots.set(handle, Math.max(0, (agentSlots.get(handle) ?? 1) - 1));
+        const q = waitQueue.get(handle);
+        if (q && q.length)
+            (q.shift())();
+    };
+    const log = (s) => process.stdout.write(s + "\n");
+    function connect() {
+        if (stopped)
+            return;
+        ws = new WebSocket(wsUrl);
+        ws.on("open", () => {
+            backoff = 1000;
+            log(`🔌 已连接控制面 ${config.serverUrl}`);
+            // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
+            void collectMachineHello()
+                .then((hello) => {
+                try {
+                    ws?.send(JSON.stringify(hello));
+                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · runtimes=[${hello.runtimes.join(",")}]`);
+                }
+                catch { /* 非 OPEN,忽略 */ }
+            })
+                .catch(() => { });
+            opts.onOpen?.(ws);
+        });
+        ws.on("message", async (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
+            if (msg.type === "raft:inspect" || msg.type === "raft:import") {
+                const req = msg;
+                const reply = (r) => {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", reqId: req.reqId, ...r }));
+                    }
+                    catch { /* 忽略 */ }
+                };
+                try {
+                    const data2 = req.type === "raft:inspect"
+                        ? await inspectRaftWorkspace(req.path)
+                        : await importRaftWorkspace(req.path, join(config.agentsRoot, req.handle));
+                    if (req.type === "raft:import") {
+                        log(`📦 已导入 raft 工作区 → ${req.handle}: 复制 ${data2.copied.length} 项`);
+                    }
+                    reply({ ok: true, data: data2 });
+                }
+                catch (e) {
+                    reply({ ok: false, error: e.message });
+                }
+                return;
+            }
+            // workspace 文件浏览 / skills 枚举请求 (只读、沙箱;见 workspace-fs.ts / skills.ts)
+            if (msg.type === "fs:list" || msg.type === "fs:read" || msg.type === "skills:list") {
+                const req = msg;
+                const root = join(config.agentsRoot, req.handle);
+                const reply = (r) => {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", reqId: req.reqId, ...r }));
+                    }
+                    catch { /* 忽略 */ }
+                };
+                try {
+                    const data2 = req.type === "fs:list" ? await listWorkspace(root, req.path)
+                        : req.type === "fs:read" ? await readWorkspaceFile(root, req.path)
+                            : await listSkills(config.agentsRoot, req.handle);
+                    reply({ ok: true, data: data2 });
+                }
+                catch (e) {
+                    reply({ ok: false, error: e.message });
+                }
+                return;
+            }
+            if (msg.type !== "agent:start")
+                return; // ready/error 等忽略
+            // 任务键 = 线程锚点(≈任务)优先,否则频道。同一 agent 的不同任务可并行;同一任务重复唤醒才跳过。
+            const threadId = msg.wake?.threadId;
+            const taskKey = threadId ?? msg.channelId;
+            const key = `${msg.agentHandle}:${taskKey}`;
+            if (running.has(key)) {
+                log(`↩︎ 跳过(该任务已在运行): ${key}`);
+                return;
+            }
+            running.add(key);
+            // 并行槽:同 agent 超过 MAX_PARALLEL 个任务时在此排队(不丢),有空位再跑。
+            await acquireSlot(msg.agentHandle);
+            const threadCode = threadId ? threadId.slice(0, 8) : null;
+            const from = msg.wake?.senderHandle ?? "?";
+            const incoming = msg.wake?.content ?? "";
+            log(`\n${"─".repeat(56)}`);
+            log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
+            log(`   channel = ${msg.channelId}`);
+            log(`   thread  = ${threadCode ? `${threadCode} (要求线程内回复)` : "(无,顶层回复)"}`);
+            if (incoming)
+                log(`📥 来信 @${from}: ${incoming.replace(/\s+/g, " ").slice(0, 200)}`);
+            let actSeq = 0;
+            const reportActivity = (a) => {
+                const det = a.detail ? a.detail.replace(/\s+/g, " ").trim() : "";
+                // 发消息时尽量打印回复正文/目标(--content "..." 或 heredoc 首行)
+                let line = `  · ${a.label}`;
+                if (a.kind === "sending") {
+                    const m = det.match(/--content\s+"([^"]*)"/) || det.match(/<<'?\w+'?\s*(.*)/);
+                    line = `  💬 回复${threadCode ? `(thread ${threadCode})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
+                }
+                else if (det) {
+                    line += ` ${det.slice(0, 80)}`;
+                }
+                log(line);
+                try {
+                    ws?.send(JSON.stringify({
+                        type: "agent:activity",
+                        agentHandle: msg.agentHandle,
+                        channelId: msg.channelId,
+                        activity: ACTIVITY_MAP[a.kind] ?? "working",
+                        detail: a.detail || a.label,
+                        seq: actSeq++,
+                    }));
+                }
+                catch { /* ws 非 OPEN,忽略 */ }
+            };
+            try {
+                // 线程聚合:触发消息即任务线程根,你的确认+后续所有回复都要发到它的线程里,
+                // 不要发顶层——这样 task 讨论全部聚合在该 thread 下。
+                const threadHint = threadCode
+                    ? `\n**所有回复都必须发到这条消息的线程里**(任务线程):用 crew message send --channel ${msg.channelId} --thread ${threadCode} 发送,不要发频道顶层。`
+                    : "";
+                // channel(广播投递):你是频道成员之一,自己判断是否与你职责相关——相关才行动(回复 /
+                // crew task create / claim / 交接给下一棒),不相关就不回(频道沉默不算失败,避免人人都答)。
+                const reasonHint = msg.reason === "channel"
+                    ? `\n这是频道里的新消息(广播给频道成员)。**先判断是否属于你的职责**:与你无关就直接结束、不要回复(频道沉默不算失败);相关才接手。`
+                    : "";
+                // 关键协作礼仪:一旦决定接手,**第一步就先在频道发一句简短确认**
+                // (例:"收到,我接 task #N。先做 X / 排查 Y,有结论再同步"),别让频道空着干等;
+                // 然后再开始读日志/跑命令。干完用 @下一棒 或 crew task assign 交接。
+                const sendCmd = threadCode
+                    ? `crew message send --channel ${msg.channelId} --thread ${threadCode}`
+                    : `crew message send --channel ${msg.channelId}`;
+                const ackHint = `\n**协作礼仪:决定接手后,务必先用 \`${sendCmd}\` 在该任务线程发一句简短确认**(收到 + 我接 task #N + 接下来要做什么),再开始干活——不要闷头工作把线程空着。`;
+                // 图片/文件附件:crew message read 会在消息下列出附件及其 id;图片需下载后用 Read 工具查看,才能真正"看到"内容。
+                const attHint = `\n若消息带图片/文件附件(read 会列出 id),用 \`crew attachment get <id>\` 下载到本地,图片再用 Read 工具打开查看后再处理。`;
+                await runAgent(config, {
+                    handle: msg.agentHandle,
+                    channelId: msg.channelId,
+                    taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
+                    ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 crew message read --channel ${msg.channelId} 读频道后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
+                }, reportActivity);
+                reportActivity({ kind: "done", label: "本轮结束" });
+                log(`✅ agent=${msg.agentHandle} 本轮完成`);
+            }
+            catch (e) {
+                log(`❌ runAgent 失败: ${e.message}`);
+            }
+            finally {
+                running.delete(key);
+                releaseSlot(msg.agentHandle);
+            }
+        });
+        ws.on("close", () => {
+            if (stopped)
+                return;
+            log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
+            setTimeout(connect, backoff);
+            backoff = Math.min(backoff * 2, maxBackoff);
+        });
+        ws.on("error", () => ws?.close());
+    }
+    connect();
+    return {
+        stop: () => {
+            stopped = true;
+            ws?.close();
+        },
+    };
+}

package/dist/skills.js

@@ -0,0 +1,56 @@
+/**
+ * 枚举某 agent 可用的 skill,供 Profile 的 SKILLS 区展示。两个来源:
+ *  - workspace 私有:<agentsRoot>/<handle>/skills/<name>/SKILL.md
+ *  - 全局共享:    ~/.claude/skills/<name>/SKILL.md (可经 CREW_GLOBAL_SKILLS_DIR 覆盖)
+ *
+ * 每个 skill = 一个目录,内含 SKILL.md;从其 YAML frontmatter 取 name/description,
+ * 缺失则回退到目录名。只读、容错(目录不存在/无 frontmatter 都不报错)。
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const globalSkillsDir = () => process.env.CREW_GLOBAL_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+/** 从 SKILL.md 顶部 YAML frontmatter 取 name / description (简易解析,够用)。 */
+function parseFrontmatter(md) {
+    const m = md.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!m)
+        return {};
+    const out = {};
+    for (const line of m[1].split("\n")) {
+        const kv = line.match(/^(name|description)\s*:\s*(.+?)\s*$/);
+        if (kv) {
+            const val = kv[2].replace(/^["']|["']$/g, "");
+            if (kv[1] === "name")
+                out.name = val;
+            else
+                out.description = val;
+        }
+    }
+    return out;
+}
+async function readSkillsFrom(dir, scope) {
+    const names = await readdir(dir).catch(() => []);
+    const skills = [];
+    for (const name of names) {
+        if (name.startsWith("."))
+            continue;
+        const skillMd = join(dir, name, "SKILL.md");
+        const s = await stat(skillMd).catch(() => null);
+        if (!s || !s.isFile())
+            continue;
+        const md = await readFile(skillMd, "utf8").catch(() => "");
+        const fm = parseFrontmatter(md);
+        skills.push({ scope, name: fm.name || name, description: fm.description ?? "" });
+    }
+    return skills;
+}
+/** 列出 agent 的 workspace 私有 + 全局 skill,按 name 排序。 */
+export async function listSkills(agentsRoot, handle) {
+    const [ws, global] = await Promise.all([
+        readSkillsFrom(join(agentsRoot, handle, "skills"), "workspace"),
+        readSkillsFrom(globalSkillsDir(), "global"),
+    ]);
+    const all = [...ws, ...global];
+    all.sort((a, b) => (a.scope !== b.scope ? (a.scope === "workspace" ? -1 : 1) : a.name.localeCompare(b.name)));
+    return all;
+}

package/dist/token.js

@@ -0,0 +1,16 @@
+/** 用机器令牌为某 agent 换取 per-launch 的 sk_agent_*。 */
+export async function mintAgentToken(serverUrl, machineToken, handle, displayName, 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 }),
+    });
+    const body = (await res.json().catch(() => null));
+    if (!res.ok || !body?.success || !body.data) {
+        throw new Error(`换取 agent 令牌失败 (HTTP ${res.status}): ${body?.error?.message ?? ""}`);
+    }
+    return body.data;
+}

package/dist/workspace-fs.js

@@ -0,0 +1,80 @@
+/**
+ * 只读、沙箱化地暴露某 agent 工作区 (<agentsRoot>/<handle>/) 给控制面查看。
+ *
+ * 安全铁律:
+ *  - 所有路径都 resolve 后必须仍落在 agent 根内 (防 `..` / 符号链接逃逸)。
+ *  - 隐藏内部目录与点文件 (.crew / .git / 任何 . 开头)。
+ *  - 只回文本文件,二进制拒绝;单文件大小上限,超出截断。
+ *  - 仅 list / read,无写删。
+ */
+import { realpath, readdir, readFile, stat } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+export class FsError extends Error {
+}
+const MAX_FILE_BYTES = 256 * 1024; // 单文件查看上限 256KB
+const HIDDEN = new Set([".crew", ".git", ".slock"]);
+const isHidden = (name) => name.startsWith(".") || HIDDEN.has(name);
+/** 把相对路径安全解析到 root 内的绝对路径;越界抛错。realpath 兜底符号链接逃逸。 */
+async function safeResolve(root, rel) {
+    const rootResolved = await realpath(root);
+    const target = resolve(rootResolved, rel.replace(/^\/+/, ""));
+    const withSep = rootResolved.endsWith(sep) ? rootResolved : rootResolved + sep;
+    if (target !== rootResolved && !target.startsWith(withSep)) {
+        throw new FsError("path escapes workspace");
+    }
+    // 解析真实路径再校验一次 (符号链接)
+    let real;
+    try {
+        real = await realpath(target);
+    }
+    catch {
+        return target; // 不存在的路径交给后续 stat 报错
+    }
+    if (real !== rootResolved && !real.startsWith(withSep)) {
+        throw new FsError("path escapes workspace (symlink)");
+    }
+    return real;
+}
+/** 列出某目录 (相对 root)。隐藏点文件/内部目录;目录在前、按名排序。 */
+export async function listWorkspace(root, rel) {
+    // 工作区尚未创建 (agent 还没跑过):返回空,而不是报错
+    const rootExists = await stat(root).then((s) => s.isDirectory()).catch(() => false);
+    if (!rootExists)
+        return { root: resolve(root), path: rel.replace(/^\/+/, ""), entries: [] };
+    const rootResolved = await realpath(root);
+    const dir = await safeResolve(root, rel);
+    const st = await stat(dir).catch(() => null);
+    if (!st || !st.isDirectory())
+        throw new FsError("not a directory");
+    const names = await readdir(dir);
+    const entries = [];
+    for (const name of names) {
+        if (isHidden(name))
+            continue;
+        const full = join(dir, name);
+        const s = await stat(full).catch(() => null);
+        if (!s)
+            continue;
+        if (s.isDirectory())
+            entries.push({ name, type: "dir" });
+        else if (s.isFile())
+            entries.push({ name, type: "file", size: s.size });
+    }
+    entries.sort((a, b) => a.type !== b.type ? (a.type === "dir" ? -1 : 1) : a.name.localeCompare(b.name));
+    return { root: rootResolved, path: rel.replace(/^\/+/, ""), entries };
+}
+/** 读取某文本文件 (相对 root)。二进制/超大拒绝或截断。 */
+export async function readWorkspaceFile(root, rel) {
+    const file = await safeResolve(root, rel);
+    const s = await stat(file).catch(() => null);
+    if (!s || !s.isFile())
+        throw new FsError("not a file");
+    const buf = await readFile(file);
+    // 二进制探测:含 NUL 即视为二进制
+    const sample = buf.subarray(0, Math.min(buf.length, 8192));
+    if (sample.includes(0))
+        throw new FsError("binary file not viewable");
+    const truncated = buf.length > MAX_FILE_BYTES;
+    const content = buf.subarray(0, MAX_FILE_BYTES).toString("utf8");
+    return { path: rel.replace(/^\/+/, ""), content, truncated, size: buf.length };
+}

package/dist/workspace-import.js

@@ -0,0 +1,127 @@
+/**
+ * 导入一个已有的 raft agent 工作区到本机的 crew 工作区。
+ *
+ * raft 工作区目录(~/.slock/agents/<uuid>/)里:
+ *   - 用户内容(复制):MEMORY.md、notes/、artifacts/、incoming/、*.html 等非隐藏文件
+ *   - raft 内部(不复制,crew 自己重建):.git/、.slock/(系统提示词/mcp/CLI wrapper)
+ *
+ * crew 侧的唯一 id、隐藏的 .crew/(system-prompt + crew wrapper)由 prepareWorkspace 在
+ * 首次运行时生成,DB 行另起新 uuid —— 所以这里只搬运用户内容,内部一律重建。
+ */
+import { readFile, writeFile, readdir, stat, cp, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/** 一律跳过的隐藏/内部条目(其余 dotfile 也跳过)。 */
+const SKIP = new Set([".git", ".slock", ".crew", ".DS_Store"]);
+/** 展开开头的 `~` 为用户主目录(daemon 在被测机器上跑,路径里常带 ~)。 */
+export function expandHome(p) {
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/** 从 MEMORY.md 反填:H1 → name;`## Role` 段正文 → description(无 Role 则取 H1 后首段)。 */
+export function parseMemory(md) {
+    const lines = md.split(/\r?\n/);
+    let name = "";
+    let h1Idx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^#\s+(.+?)\s*$/);
+        if (m) {
+            name = m[1].trim();
+            h1Idx = i;
+            break;
+        }
+    }
+    const sectionBody = (startIdx) => {
+        const body = [];
+        for (let i = startIdx; i < lines.length; i++) {
+            if (/^#{1,6}\s+/.test(lines[i]))
+                break; // 下一个标题为止
+            body.push(lines[i]);
+        }
+        return body.join("\n").trim();
+    };
+    let description = "";
+    const roleIdx = lines.findIndex((l) => /^##\s+Role\b/i.test(l));
+    if (roleIdx >= 0)
+        description = sectionBody(roleIdx + 1);
+    if (!description && h1Idx >= 0)
+        description = sectionBody(h1Idx + 1); // 兜底:H1 后首段
+    return { name, description: description.slice(0, 3000) };
+}
+/**
+ * 导入时清空 MEMORY.md 的 `## Active Context` 段:其内容是 raft 里的在办任务进度(含任务 id),
+ * 这些 id 在新的 OpenSlock 里不一定存在,照搬会误导。保留标题,正文换成占位提示让 agent 重新记录。
+ * 其它段(Role/索引/领域知识)照常保留。
+ */
+export function stripActiveContext(md) {
+    const lines = md.split(/\r?\n/);
+    const start = lines.findIndex((l) => /^##\s+Active Context\b/i.test(l));
+    if (start < 0)
+        return md;
+    // 段落结束 = 下一个 # / ## 标题,或 `---` 分隔线,或文件末尾
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^#{1,2}\s+/.test(lines[i]) || /^---\s*$/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const replacement = [
+        lines[start], // 原 `## Active Context` 标题
+        "<!-- (导入时已清空:raft 的在办任务/任务 id 不属于本 OpenSlock。开工时在此重新记录当前进度。) -->",
+        "",
+    ];
+    return [...lines.slice(0, start), ...replacement, ...lines.slice(end)].join("\n");
+}
+async function assertDir(srcPath) {
+    let st;
+    try {
+        st = await stat(srcPath);
+    }
+    catch {
+        throw new Error(`workspace path not found: ${srcPath}`);
+    }
+    if (!st.isDirectory())
+        throw new Error(`not a directory: ${srcPath}`);
+}
+/** 读取 raft 工作区元信息(name/description/可复制条目),不写入任何文件。 */
+export async function inspectRaftWorkspace(rawPath) {
+    const srcPath = expandHome(rawPath);
+    await assertDir(srcPath);
+    let memory;
+    try {
+        memory = await readFile(join(srcPath, "MEMORY.md"), "utf8");
+    }
+    catch {
+        throw new Error("no MEMORY.md in this folder — is it a raft agent workspace?");
+    }
+    const { name, description } = parseMemory(memory);
+    const all = await readdir(srcPath);
+    const entries = all.filter((e) => !SKIP.has(e) && !e.startsWith("."));
+    return { name, description, fileCount: entries.length, entries };
+}
+/** 复制 raft 工作区的用户内容到目标目录(隐藏/内部条目不复制)。 */
+export async function importRaftWorkspace(rawPath, destDir) {
+    const srcPath = expandHome(rawPath);
+    await assertDir(srcPath);
+    await mkdir(destDir, { recursive: true });
+    const all = await readdir(srcPath);
+    const copied = [];
+    for (const e of all) {
+        if (SKIP.has(e) || e.startsWith("."))
+            continue;
+        if (e === "MEMORY.md") {
+            // MEMORY.md 特殊处理:剥离 Active Context(陈旧任务 id)后再落地,其余原样保留。
+            const cleaned = stripActiveContext(await readFile(join(srcPath, e), "utf8"));
+            await writeFile(join(destDir, e), cleaned, "utf8");
+        }
+        else {
+            await cp(join(srcPath, e), join(destDir, e), { recursive: true });
+        }
+        copied.push(e);
+    }
+    return { copied, dir: destDir };
+}

package/dist/workspace.js

@@ -0,0 +1,89 @@
+/**
+ * 准备 agent 在本机的工作区:
+ *   <agentsRoot>/<handle>/
+ *     ├── MEMORY.md                     长期记忆/角色 (首次创建种子)
+ *     ├── .crew/system-prompt.md        注入 runtime 的系统提示词
+ *     └── .crew/crew                    注入 PATH 的 CLI wrapper (0755)
+ *
+ * spawn runtime 时把 <ws>/.crew 置于 PATH 最前,于是 agent 的 `crew ...` 命中 wrapper。
+ */
+import { mkdir, writeFile, readFile, chmod, access } from "node:fs/promises";
+import { join } from "node:path";
+/** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
+export function safeKey(key) {
+    return key.replace(/[^\w.-]+/g, "_").replace(/^[-.]+/, "").slice(0, 80) || "default";
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function prepareWorkspace(input) {
+    const dir = join(input.agentsRoot, input.handle);
+    const crewDir = join(dir, ".crew");
+    await mkdir(crewDir, { recursive: true });
+    // MEMORY.md:首次创建"索引 + Active Context"骨架,之后由 agent 自己维护
+    const memoryPath = join(dir, "MEMORY.md");
+    if (!(await exists(memoryPath))) {
+        await writeFile(memoryPath, memorySeed(input.handle), "utf8");
+    }
+    const memory = await readFile(memoryPath, "utf8");
+    // 系统提示词 (每次覆盖,保证最新);省略时由调用方在拿到 memory 后自行写入。
+    const systemPromptPath = join(crewDir, "system-prompt.md");
+    if (input.systemPrompt != null)
+        await writeFile(systemPromptPath, input.systemPrompt, "utf8");
+    // crew wrapper:exec 构建后的 CLI;凭证/地址经 env 注入,故 wrapper 极简
+    const wrapper = join(crewDir, "crew");
+    await writeFile(wrapper, `#!/bin/sh\nexec node ${JSON.stringify(input.cliPath)} "$@"\n`, "utf8");
+    await chmod(wrapper, 0o755);
+    // 每个 agent 独立的 XDG 配置根:隔离第三方 CLI 凭证,避免 agent 之间互相串号
+    const homeDir = join(dir, ".home");
+    await mkdir(join(homeDir, ".config"), { recursive: true });
+    await mkdir(join(homeDir, ".local", "share"), { recursive: true });
+    await mkdir(join(homeDir, ".cache"), { recursive: true });
+    // 每任务隔离的运行目录(并行运行互不干扰的 cwd)+ per-task work-log。
+    // 无 taskKey(罕见)时回退到共享 dir(单运行旧行为)。
+    let runDir = dir;
+    let workLogPath = join(dir, "tasks", "default", "work-log.md");
+    if (input.taskKey) {
+        runDir = join(dir, "tasks", safeKey(input.taskKey));
+        await mkdir(runDir, { recursive: true });
+        workLogPath = join(runDir, "work-log.md");
+    }
+    const workLog = (await exists(workLogPath)) ? await readFile(workLogPath, "utf8") : "";
+    return { dir, crewDir, systemPromptPath, memory, homeDir, runDir, workLogPath, workLog };
+}
+/**
+ * MEMORY.md 种子骨架:分层记忆的"索引 + Active Context"结构。
+ * 第一次准备工作区时写入;之后 agent 自己维护(系统提示词里有协议)。
+ */
+function memorySeed(handle) {
+    return `# ${handle}
+
+## Role
+(Who you are and what you're responsible for. Keep it to a few lines.)
+
+## Core Goals
+(What you optimize for.)
+
+## Knowledge Index
+<!-- The map to your detailed notes. Add a line here whenever you create a note. -->
+<!-- e.g. - [Channels](notes/channels.md) — what each channel is for -->
+<!-- e.g. - [User Preferences](notes/user-preferences.md) — conventions to follow -->
+
+## Active Context
+<!-- Running log of what you're doing now: in-progress tasks, next steps, what you owe whom.
+     Write an entry here BEFORE a long task so you can resume after sleep/compaction. -->
+
+---
+How to maintain this file:
+- This is the FIRST file read on every startup (including after context compaction).
+- Keep it self-sufficient: reading only this file should tell you who you are, what you
+  know (and which note to read for detail), what you're working on, and what you owe.
+- Put details in notes/<topic>.md; keep this file an index + active context.
+`;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@nowcrew/daemon",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
+  "license": "Apache-2.0",
+  "bin": {
+    "crew-daemon": "./dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ws": "^8",
+    "@nowcrew/cli": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8",
+    "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"
+  }
+}