@nowcrew/daemon 0.4.3 → 0.4.4

package/dist/config.js

@@ -33,6 +33,6 @@ export function loadConfig(env = process.env) {
         dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)
         resume: env.CREW_RESUME !== "off" && env.CREW_RESUME !== "0", // 默认开启;一键回退现状用 CREW_RESUME=off
         resumeWarmMs: env.CREW_RESUME_WARM_MS != null ? Number(env.CREW_RESUME_WARM_MS) : 3_600_000, // 默认 1h
-        productName: env.CREW_PRODUCT_NAME ?? "OpenSlock",
+        productName: env.CREW_PRODUCT_NAME ?? "nowcrew",
     };
 }

package/dist/main.js

@@ -11,6 +11,7 @@ import { detectDaemonLang, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
 import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
+import { initSlog, flushSlog } from "./slog.js";
 async function main() {
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
@@ -64,6 +65,7 @@ async function main() {
         process.exit(2);
     }
     process.stdout.write(`\n🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}\n\n`);
+    initSlog(config.serverUrl, config.machineToken); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
     const result = await runAgent(config, {
         handle: values.agent,
         channelId: values.channel,
@@ -71,6 +73,7 @@ async function main() {
         ...(values.display ? { displayName: values.display } : {}),
     });
     process.stdout.write(`\n— ${td("agent exited")} (code ${result.exitCode}), ${td("activities")}: ${result.activities.length} —\n`);
+    await flushSlog();
     process.exit(result.exitCode);
 }
 main().catch((e) => {

package/dist/prompt.js

@@ -1,12 +1,12 @@
 /**
- * 系统提示词与唤醒提示词构造(OpenSlock 自有设计)。
+ * 系统提示词与唤醒提示词构造(nowcrew 自有设计)。
  *
- * 描述的是 OpenSlock 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
+ * 描述的是 nowcrew 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
 export function buildSystemPrompt(ctx) {
-    const product = ctx.productName ?? "OpenSlock";
+    const product = ctx.productName ?? "nowcrew";
     return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
@@ -82,6 +82,7 @@ CRITICAL 规则:
 
 ## 沟通风格
 用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
+- 完成汇报要直接说“已在当前线程汇报”或“已在任务线程汇报”,并说明“task #N 已置为 in_review”等事实。不要写“通过 ${product} 线程汇报”这类产品名+线程的生硬说法。
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:

package/dist/runner.js

@@ -13,6 +13,7 @@ import { spawnKimi } from "./runtimes/kimi.js";
 import { normalizeEvent, parseLine, extractRunMeta } from "./normalize.js";
 import { readSession, writeSession, pickResumeId } from "./session.js";
 import { toConsoleLines } from "./console.js";
+import { dslog } from "./slog.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
 const MEMORY_INJECT_CAP = 6000;
 const ICON = {
@@ -45,9 +46,22 @@ onConsole = () => { }) {
     // 只决定「是否续用」:既有会话(sessionResume)且仍在缓存窗口内 → --resume;否则冷启动。
     const resuming = supportsNativeResume && ws.sessionResume && pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel) != null;
     // 既有会话但本轮不续用 → 轮换出新 uuid 冷启动(避免 --session-id 撞已存在会话)。
-    const launchSessionId = ws.agentSessionId && ws.sessionResume && !resuming
-        ? await rotateAgentSession(ws.runDir)
-        : ws.agentSessionId;
+    const rotated = !!(ws.agentSessionId && ws.sessionResume && !resuming);
+    const launchSessionId = rotated ? await rotateAgentSession(ws.runDir) : ws.agentSessionId;
+    // resume 决策是「会话为什么没续上/为什么重开」的直接证据,把判定依据全量留痕
+    dslog("session.resume_decision", resuming ? "续用上轮会话 (--resume)" : "冷启动新会话", {
+        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
+        task_key: input.taskKey, runtime, model: currentModel,
+        resuming, rotated, session_id: launchSessionId,
+        prior_session_id: prior?.sessionId ?? null,
+        prior_age_ms: prior ? Date.now() - prior.lastRunAt : null,
+        warm_ms: config.resumeWarmMs,
+        decision_reason: !supportsNativeResume ? "runtime_no_resume"
+            : !config.resume ? "resume_disabled"
+                : !ws.sessionResume ? "first_run"
+                    : resuming ? "warm_resume"
+                        : "warm_window_expired_or_model_changed",
+    });
     const systemPrompt = buildSystemPrompt({
         handle: input.handle,
         channelId: input.channelId,
@@ -137,6 +151,12 @@ onConsole = () => { }) {
                 : (() => {
                     throw new Error(`unsupported runtime: ${runtime}`);
                 })();
+    // 记下 OS 进程号:排查「进程被谁杀的/是否 OOM」时可与系统日志对齐
+    dslog("run.spawned", `${runtime} 进程已拉起 (pid ${child.pid})`, {
+        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
+        task_key: input.taskKey, runtime, model: currentModel,
+        os_pid: child.pid ?? null, session_id: launchSessionId, resume: resuming,
+    });
     // 4) 逐行解析 stdout → 归一化 → 回调;顺带抓 session_id(记 lastRunAt 供 warm-window)+ token usage(度量)
     const activities = [];
     // 身份是本轮下发的 launchSessionId;仍兜底采 claude 自报的 session_id(理应一致)。
@@ -222,7 +242,7 @@ onConsole = () => { }) {
         process.stdout.write(`📊 tokens: in=${u.inputTokens} out=${u.outputTokens} cache_read=${u.cacheReadTokens} cache_create=${u.cacheCreationTokens}` +
             `${u.costUsd != null ? ` cost=$${u.costUsd.toFixed(4)}` : ""} ${resuming ? "(resumed)" : "(fresh)"}\n`);
     }
-    return { exitCode, activities, model: observedModel, runtime, resumed: resuming, ...(usage ? { usage } : {}) };
+    return { exitCode, activities, model: observedModel, runtime, resumed: resuming, sessionId, ...(usage ? { usage } : {}) };
 }
 function defaultPrint(a) {
     const icon = ICON[a.kind] ?? "·";

package/dist/serve.js

@@ -4,6 +4,8 @@
  */
 import { WebSocket } from "ws";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { runAgent } from "./runner.js";
 import { collectMachineHello } from "./machine-info.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
@@ -23,6 +25,9 @@ export function serve(config, opts = {}) {
     let ws = null;
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
+    initSlog(config.serverUrl, config.machineToken);
+    dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
     // - running:正在跑的「agent:任务」去重键(同一任务重复唤醒才跳过)。
     // - agentSlots:每 agent 当前并行数;超过 MAX_PARALLEL 的进 FIFO 队列(不丢)。
@@ -56,7 +61,11 @@ export function serve(config, opts = {}) {
         ws = new WebSocket(wsUrl);
         ws.on("open", () => {
             backoff = 1000;
+            connectedAt = Date.now();
             log(`🔌 已连接控制面 ${config.serverUrl}`);
+            dslog("daemon.ws_open", "已连接控制面", { server_url: config.serverUrl });
+            // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
+            void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
             void collectMachineHello(config.agentsRoot)
                 .then((hello) => {
@@ -81,10 +90,17 @@ export function serve(config, opts = {}) {
             // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
             // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
             // 需在 NowCrew 重新 Add Computer 拿新连接命令)。
+            if (msg.type === "ready") {
+                // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
+                const r = msg;
+                setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                return;
+            }
             if (msg.type === "error") {
                 if (msg.code === "UNAUTHENTICATED") {
                     log(`🛑 控制面拒绝鉴权:机器凭证无效或已吊销 (UNAUTHENTICATED)。`);
                     log(`   请在 NowCrew 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
+                    dslog("daemon.ws_auth_rejected", "控制面拒绝鉴权:机器凭证无效或已吊销", { level: "ERROR" });
                     backoff = maxBackoff; // 退避到最大,停止每秒重连刷屏
                 }
                 return;
@@ -140,16 +156,31 @@ export function serve(config, opts = {}) {
             const threadId = msg.wake?.threadId;
             const taskKey = threadId ?? msg.channelId;
             const key = `${msg.agentHandle}:${taskKey}`;
+            // run_id 贯穿本轮全链路(wake→start→resume 决策→end),SLS 按 run_id 一查即得单轮时间线
+            const runId = randomUUID();
+            const runKeys = {
+                run_id: runId, agent_handle: msg.agentHandle, channel_id: msg.channelId,
+                thread_id: threadId ?? null, task_key: taskKey,
+            };
+            dslog("run.wake_received", `收到唤醒 ${msg.agentHandle}`, {
+                ...runKeys, reason: msg.reason ?? "", sender: msg.wake?.senderHandle,
+                content_preview: (msg.wake?.content ?? "").replace(/\s+/g, " ").slice(0, 120),
+            });
             if (running.has(key)) {
                 log(`↩︎ 跳过(该任务已在运行): ${key}`);
+                dslog("run.dedupe_skip", "跳过唤醒:该任务已在运行", { level: "WARN", ...runKeys });
                 return;
             }
             running.add(key);
             // 并行槽:同 agent 超过 MAX_PARALLEL 个任务时在此排队(不丢),有空位再跑。
+            const slotWaitStart = Date.now();
             await acquireSlot(msg.agentHandle);
+            const queueMs = Date.now() - slotWaitStart;
             const threadLabel = threadId ?? null;
             const from = msg.wake?.senderHandle ?? "?";
             const incoming = msg.wake?.content ?? "";
+            dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+            const runStartedAt = Date.now();
             log(`\n${"─".repeat(56)}`);
             log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
             log(`   channel = ${msg.channelId}`);
@@ -226,6 +257,7 @@ export function serve(config, opts = {}) {
                     handle: msg.agentHandle,
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
+                    runId, // 贯穿 SLS 日志的单轮关联键
                     // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
                     ...(threadId ? { wakeMessageId: threadId } : {}),
                     ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
@@ -252,16 +284,39 @@ export function serve(config, opts = {}) {
                     }
                     catch { /* ws 非 OPEN,忽略(用量非关键路径,丢一轮不阻塞) */ }
                 }
+                // run.end 是排查「任务没跑完就本轮结束」的核心证据:退出码 + 时长 + 最后活动 +
+                // 是否 resume + 用量。exit_code!=0 或时长异常短都值得追。
+                const lastActivity = result.activities.length
+                    ? result.activities[result.activities.length - 1].kind
+                    : null;
+                dslog("run.end", `本轮结束 ${msg.agentHandle} (exit=${result.exitCode})`, {
+                    ...runKeys,
+                    level: result.exitCode === 0 ? "INFO" : "ERROR",
+                    exit_code: result.exitCode, duration_ms: Date.now() - runStartedAt,
+                    runtime: result.runtime, model: result.model, resumed: result.resumed,
+                    session_id: result.sessionId,
+                    activity_count: result.activities.length, last_activity: lastActivity,
+                    ...(result.usage ? {
+                        tokens_input: result.usage.inputTokens, tokens_output: result.usage.outputTokens,
+                        cache_read: result.usage.cacheReadTokens, cache_creation: result.usage.cacheCreationTokens,
+                        ...(result.usage.costUsd != null ? { cost_usd: result.usage.costUsd } : {}),
+                    } : {}),
+                });
                 reportActivity({ kind: "done", label: "本轮结束" });
                 reportConsole({ stream: "result", text: "● 本轮结束" });
                 log(`✅ agent=${msg.agentHandle} 本轮完成`);
             }
             catch (e) {
                 log(`❌ runAgent 失败: ${e.message}`);
+                dslog("run.error", `runAgent 失败: ${e.message}`, {
+                    level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
+                    error_message: e.message, error_stack: e.stack,
+                });
             }
             finally {
                 running.delete(key);
                 releaseSlot(msg.agentHandle);
+                void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
             }
         });
         ws.on("close", (code) => {
@@ -275,6 +330,14 @@ export function serve(config, opts = {}) {
                 log(`   请在 NowCrew 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
             }
             log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
+            // 此刻 server 大概率不可达 → 这条会落 spool,重连 drainSpool 时补传;
+            // ts 是现在(断开时刻),排查「daemon 为什么断」以它对齐 server 侧 machine_disconnected。
+            dslog("daemon.ws_close", `控制面断开 (code ${code})`, {
+                level: "WARN", close_code: code, backoff_ms: backoff,
+                online_ms: connectedAt ? Date.now() - connectedAt : null,
+                running_tasks: [...running].join(","),
+            });
+            void flushSlog();
             setTimeout(connect, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);
         });

package/dist/slog.js

@@ -0,0 +1,214 @@
+/**
+ * daemon 侧 SLS 日志客户端 —— 透过 server 的 POST /ingest/logs 上报(daemon 不直连 SLS)。
+ *
+ * 断线补传(关键设计):
+ *   - 每条日志的 ts = 事件**实际发生时间**(epoch ms)。server 把它写成 SLS __time__,
+ *     所以补传的日志仍落在正确时间点,时间线不乱;补传条目带 spooled=true + reported_at 归因。
+ *   - 上报失败(server 不可达/断网)→ 落本地 spool(~/.crew/logs/sls-spool/*.jsonl);
+ *     下次 WS 重连成功(drainSpool)时补传。「daemon 为什么断开」的现场就靠这批日志还原。
+ *   - 进程退出(SIGINT/SIGTERM/exit)→ 残余队列同步落 spool,下次启动补传。
+ *
+ * 永不抛错、永不阻塞业务;未 init 时所有调用是 no-op(兼容单测/一次性 run 模式无凭证场景)。
+ */
+import { hostname } from "node:os";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+const FLUSH_INTERVAL_MS = 1500;
+const BATCH_SIZE = 50;
+const SPOOL_MAX_FILES = 50; // spool 目录文件数上限,超出丢最旧(日志非关键数据,防无限膨胀)
+const SPOOL_DRAIN_CAP = 1000; // 单次补传条数上限
+let cfg = null;
+let defaults = {};
+let queue = [];
+let timer = null;
+let flushing = false;
+let lastErrorAt = 0;
+function spoolDir() {
+    return process.env.CREW_SLS_SPOOL_DIR ?? join(homedir(), ".crew", "logs", "sls-spool");
+}
+/** serve/run 启动时调用一次;disabled(CREW_SLS_LOG=off)则保持 no-op。 */
+export function initSlog(serverUrl, machineToken) {
+    if (process.env.CREW_SLS_LOG === "off" || process.env.CREW_SLS_LOG === "0")
+        return;
+    cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
+    defaults = { host: hostname(), pid: process.pid };
+    // 退出兜底:残余队列同步落 spool(exit 回调只能做同步工作,append 正合适)
+    process.once("exit", () => spoolRemainingSync());
+    for (const sig of ["SIGINT", "SIGTERM"]) {
+        process.once(sig, () => {
+            spoolRemainingSync();
+            process.exit(sig === "SIGINT" ? 130 : 143);
+        });
+    }
+}
+/** 追加默认关联字段(如 ready 帧下发的 machine_id),之后每条日志自动带上。 */
+export function setSlogDefaults(fields) {
+    defaults = { ...defaults, ...fields };
+}
+/** 记一条结构化日志(异步批量上报;失败自动落 spool)。 */
+export function dslog(eventType, message, fields = {}) {
+    if (!cfg)
+        return;
+    const { level, ...rest } = fields;
+    queue.push({
+        ts: Date.now(),
+        level: level ?? (eventType.includes("error") || eventType.includes("failed") ? "ERROR" : "INFO"),
+        event_type: eventType,
+        message,
+        fields: compact({ ...defaults, ...rest }),
+    });
+    if (queue.length >= BATCH_SIZE) {
+        void flushSlog();
+        return;
+    }
+    if (!timer) {
+        timer = setTimeout(() => void flushSlog(), FLUSH_INTERVAL_MS);
+        timer.unref?.();
+    }
+}
+/** 把内存队列冲到 server;失败整批落 spool(保 ts 不丢现场)。 */
+export async function flushSlog() {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    if (!cfg || flushing || queue.length === 0)
+        return;
+    flushing = true;
+    const batch = queue;
+    queue = [];
+    try {
+        await post(batch);
+    }
+    catch (e) {
+        appendSpool(batch);
+        warnThrottled(`SLS 日志上报失败,已落本地 spool(${batch.length} 条): ${e.message}`);
+    }
+    finally {
+        flushing = false;
+    }
+}
+/**
+ * 补传本地 spool(WS 重连成功后调用):上次断连/退出前落盘的现场日志,
+ * 此刻才有机会送出。条目加 spooled=true,ts 仍是当时的发生时间。
+ */
+export async function drainSpool() {
+    if (!cfg)
+        return;
+    const dir = spoolDir();
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+    }
+    catch {
+        return; // 目录不存在 = 无积压
+    }
+    if (files.length === 0)
+        return;
+    const entries = [];
+    const consumed = [];
+    for (const f of files) {
+        if (entries.length >= SPOOL_DRAIN_CAP)
+            break;
+        const path = join(dir, f);
+        try {
+            const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const e = JSON.parse(line);
+                    if (typeof e.ts === "number" && typeof e.event_type === "string") {
+                        entries.push({ ...e, fields: { ...(e.fields ?? {}), spooled: true } });
+                    }
+                }
+                catch { /* 坏行跳过 */ }
+            }
+            consumed.push(path);
+        }
+        catch { /* 读失败跳过该文件 */ }
+    }
+    if (entries.length === 0) {
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        return;
+    }
+    try {
+        for (let i = 0; i < entries.length; i += 100) {
+            await post(entries.slice(i, i + 100));
+        }
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        process.stdout.write(`📮 已补传离线期间的 ${entries.length} 条 SLS 日志\n`);
+    }
+    catch (e) {
+        warnThrottled(`spool 补传失败,留待下次重连: ${e.message}`); // 文件保留,下次再试
+    }
+}
+// ── 内部 ─────────────────────────────────────────────────────────
+async function post(entries) {
+    const res = await fetch(`${cfg.serverUrl}/ingest/logs`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${cfg.token}`, "content-type": "application/json" },
+        body: JSON.stringify({
+            entries: entries.map((e) => ({
+                ts: e.ts, level: e.level, event_type: e.event_type, message: e.message, fields: e.fields,
+            })),
+        }),
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+}
+function appendSpool(entries) {
+    try {
+        const dir = spoolDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        rotateSpool(dir);
+        const file = join(dir, `daemon-${Date.now()}-${process.pid}.jsonl`);
+        appendFileSync(file, entries.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    }
+    catch { /* spool 也失败(磁盘只读等):放弃这批,不能影响业务 */ }
+}
+/** 目录内文件超上限时删最旧,防止长期断网把磁盘写满。 */
+function rotateSpool(dir) {
+    try {
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => ({ f, mtime: statSync(join(dir, f)).mtimeMs }))
+            .sort((a, b) => a.mtime - b.mtime);
+        for (const { f } of files.slice(0, Math.max(0, files.length - SPOOL_MAX_FILES + 1))) {
+            unlinkSync(join(dir, f));
+        }
+    }
+    catch { /* 忽略 */ }
+}
+function spoolRemainingSync() {
+    if (queue.length === 0)
+        return;
+    const batch = queue;
+    queue = [];
+    appendSpool(batch);
+}
+function warnThrottled(msg) {
+    const now = Date.now();
+    if (now - lastErrorAt > 60_000) {
+        lastErrorAt = now;
+        process.stderr.write(`[slog] ${msg}\n`);
+    }
+}
+function compact(fields) {
+    const out = {};
+    for (const [k, v] of Object.entries(fields)) {
+        if (v === undefined)
+            continue;
+        out[k] = typeof v === "string" && v.length > 4096 ? `${v.slice(0, 4096)}…(truncated)` : v;
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "ws": "^8",
-    "@nowcrew/cli": "^0.3.0"
+    "@nowcrew/cli": "^0.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",