@nowcrew/daemon 0.5.45 → 0.5.46

package/dist/local-memory-diagnostics.js

@@ -0,0 +1,336 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, normalize, resolve } from "node:path";
+import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
+const INJECTION_MARKERS = [
+    "## Injected MEMORY.md (bounded local context)\n",
+    "## [注入] 你的 MEMORY.md(索引,只读参考)\n",
+];
+const LOCAL_MEMORY_HASH_CAP_BYTES = 10 * 1024 * 1024;
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === "string" ? code : error instanceof Error ? error.name : "unknown";
+}
+async function inspectFile(path, signal) {
+    let metadata;
+    try {
+        metadata = await stat(path);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        return code === "ENOENT" ? { exists: false } : { exists: false, error_code: code };
+    }
+    const base = { exists: true, size_bytes: metadata.size, mtime_ms: metadata.mtimeMs };
+    if (!metadata.isFile())
+        return { ...base, hash_skipped_reason: "not_regular_file" };
+    if (metadata.size > LOCAL_MEMORY_HASH_CAP_BYTES) {
+        return { ...base, hash_skipped_reason: "too_large" };
+    }
+    try {
+        const content = await readFile(path, { encoding: "utf8", signal });
+        const facts = localMemoryContentFacts(content);
+        if (facts.scan_skipped_reason !== undefined) {
+            return { ...base, hash_skipped_reason: facts.scan_skipped_reason };
+        }
+        return { ...base, ...facts };
+    }
+    catch (error) {
+        return { ...base, error_code: errorCode(error) };
+    }
+}
+export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+    const controller = new AbortController();
+    let timer;
+    const inspection = Promise.all([
+        inspectFile(join(homeDir, "MEMORY.md"), controller.signal),
+        inspectFile(join(homeDir, "notes", "lessons.md"), controller.signal),
+    ]).then(([memory, lessons]) => ({ memory, lessons }));
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            controller.abort();
+            reject(Object.assign(new Error("local memory diagnostics timed out"), {
+                code: "diagnostics_timeout",
+            }));
+        }, Math.max(1, timeoutMs));
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([inspection, timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HASH_CAP_BYTES) {
+    const sizeBytes = Buffer.byteLength(content, "utf8");
+    if (sizeBytes > Math.max(0, maxScanBytes)) {
+        return { size_bytes: sizeBytes, scan_skipped_reason: "too_large" };
+    }
+    return {
+        size_bytes: sizeBytes,
+        sha256: createHash("sha256").update(content).digest("hex"),
+        nonblank: content.trim().length > 0,
+        markdown_heading_count: content.split(/\r?\n/).filter((line) => /^#{1,6}\s+\S/.test(line)).length,
+        lessons_reference_count: content.match(/\bnotes[\\/]lessons\.md\b/gi)?.length ?? 0,
+    };
+}
+export function analyzeLocalMemoryInjection(systemPrompt, sourceMemory) {
+    const sourceBytes = Buffer.byteLength(sourceMemory, "utf8");
+    if (sourceMemory.length === 0) {
+        return { state: "empty_source", source_bytes: 0, bounded_bytes: 0, injected_bytes: 0 };
+    }
+    const bounded = capMemoryForInject(sourceMemory);
+    const marker = INJECTION_MARKERS.find((candidate) => systemPrompt.includes(candidate));
+    if (marker === undefined) {
+        return {
+            state: "omitted",
+            source_bytes: sourceBytes,
+            bounded_bytes: Buffer.byteLength(bounded, "utf8"),
+            injected_bytes: 0,
+        };
+    }
+    const markerStart = systemPrompt.indexOf(marker) + marker.length;
+    const sectionTail = systemPrompt.slice(markerStart);
+    const nextSection = sectionTail.search(/\n\n## (?:Injected work-log|\[注入\] 本任务 work-log)/);
+    const injected = nextSection < 0 ? sectionTail : sectionTail.slice(0, nextSection);
+    const fullyInjected = injected.startsWith(bounded);
+    return {
+        state: fullyInjected
+            ? sourceMemory.length > MEMORY_INJECT_CAP ? "cap_truncated" : "full"
+            : "prompt_budget_truncated",
+        source_bytes: sourceBytes,
+        bounded_bytes: Buffer.byteLength(bounded, "utf8"),
+        injected_bytes: Buffer.byteLength(injected, "utf8"),
+    };
+}
+export function localMemoryFileChanged(before, after) {
+    if (before.exists !== after.exists)
+        return true;
+    if (!before.exists && !after.exists)
+        return false;
+    if (before.sha256 !== undefined && after.sha256 !== undefined) {
+        return before.sha256 !== after.sha256;
+    }
+    return before.size_bytes !== after.size_bytes || before.mtime_ms !== after.mtime_ms;
+}
+function normalized(path) {
+    return normalize(path).replaceAll("\\", "/");
+}
+function targetPaths(options) {
+    return {
+        homeDir: normalized(resolve(options.homeDir)),
+        runDir: normalized(resolve(options.runDir)),
+        sharedMemory: normalized(resolve(options.homeDir, "MEMORY.md")),
+        sharedLessons: normalized(resolve(options.homeDir, "notes", "lessons.md")),
+        sharedNotes: normalized(resolve(options.homeDir, "notes")),
+        cwdMemory: normalized(resolve(options.runDir, "MEMORY.md")),
+        cwdLessons: normalized(resolve(options.runDir, "notes", "lessons.md")),
+    };
+}
+function classifyExplicitPath(path, paths) {
+    const replaced = path
+        .replace(/^\$\{CREW_HOME\}/, paths.homeDir)
+        .replace(/^\$CREW_HOME/, paths.homeDir);
+    const absolute = normalized(isAbsolute(replaced) ? replaced : resolve(paths.runDir, replaced));
+    if (absolute === paths.sharedMemory)
+        return "shared_memory";
+    if (absolute === paths.sharedLessons)
+        return "shared_lessons";
+    if (absolute === paths.cwdMemory && paths.cwdMemory !== paths.sharedMemory)
+        return "cwd_shadow_memory";
+    if (absolute === paths.cwdLessons && paths.cwdLessons !== paths.sharedLessons)
+        return "cwd_shadow_lessons";
+    if (absolute.startsWith(`${paths.sharedNotes}/`))
+        return "other_shared_note";
+    return null;
+}
+function commandTargets(command, paths) {
+    const targets = new Set();
+    const expandedCommand = command
+        .replaceAll("${CREW_HOME}", paths.homeDir)
+        .replaceAll("$CREW_HOME", paths.homeDir)
+        .replace(/["']/g, "");
+    const references = [
+        { values: [paths.sharedMemory], target: "shared_memory" },
+        { values: [paths.sharedLessons], target: "shared_lessons" },
+        { values: [paths.cwdMemory], target: "cwd_shadow_memory" },
+        { values: [paths.cwdLessons], target: "cwd_shadow_lessons" },
+    ];
+    for (const reference of references) {
+        if (reference.values.some((value) => expandedCommand.includes(value)))
+            targets.add(reference.target);
+    }
+    const withoutKnownPaths = references.flatMap((reference) => reference.values)
+        .reduce((value, reference) => value.replaceAll(reference, ""), expandedCommand);
+    if (/(?:^|[\s'"`])notes[\\/]lessons\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
+        targets.add("cwd_shadow_lessons");
+    }
+    else if (/(?:^|[\s'"`])MEMORY\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
+        targets.add("cwd_shadow_memory");
+    }
+    return [...targets];
+}
+function commandOperation(command) {
+    if (/(?:^|[;&|]\s*|\s)(?:rm|unlink)\s/i.test(command))
+        return "delete";
+    if (/(?:>>?|\btee\b|\btouch\b|\btruncate\b|\bsed\s+-i\b|\bperl\b[^\n]*\s-i\b|\bapply_patch\b)/i.test(command)) {
+        return "write";
+    }
+    return "read";
+}
+function toolOperation(name) {
+    const lowered = name.toLowerCase();
+    if (["read", "readfile", "view"].includes(lowered))
+        return "read";
+    if (["write", "writefile", "edit", "multiedit", "apply_patch", "patch"].includes(lowered))
+        return "write";
+    if (["delete", "remove", "unlink"].includes(lowered))
+        return "delete";
+    return null;
+}
+function toolPath(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return null;
+    const record = input;
+    for (const key of ["file_path", "path", "filePath"]) {
+        if (typeof record[key] === "string")
+            return record[key];
+    }
+    return null;
+}
+function recordObservation(observations, counts, observation) {
+    observations.push(observation);
+    const key = `${observation.target}:${observation.operation}:${observation.outcome}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+export function createLocalMemoryAccessObserver(options) {
+    const paths = targetPaths(options);
+    const pending = new Map();
+    const counts = new Map();
+    return {
+        observe(event) {
+            const observations = [];
+            if (!event || typeof event !== "object")
+                return observations;
+            const record = event;
+            const message = record.message && typeof record.message === "object"
+                ? record.message
+                : undefined;
+            const blocks = Array.isArray(message?.content) ? message.content : [];
+            if (record.type === "assistant") {
+                for (const block of blocks) {
+                    if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string")
+                        continue;
+                    const operation = toolOperation(block.name);
+                    const path = toolPath(block.input);
+                    const target = operation === null || path === null ? null : classifyExplicitPath(path, paths);
+                    if (operation !== null && target !== null)
+                        pending.set(block.id, { operation, target });
+                }
+            }
+            if (record.type === "user") {
+                for (const block of blocks) {
+                    if (block.type !== "tool_result" || typeof block.tool_use_id !== "string")
+                        continue;
+                    const access = pending.get(block.tool_use_id);
+                    pending.delete(block.tool_use_id);
+                    if (access === undefined)
+                        continue;
+                    recordObservation(observations, counts, {
+                        ...access,
+                        outcome: block.is_error === true ? "failed" : "succeeded",
+                        evidence: "structured_tool",
+                    });
+                }
+            }
+            if (record.type === "kimi.acp.tool_call" && typeof record.id === "string") {
+                const operation = typeof record.kind === "string"
+                    ? toolOperation(record.kind)
+                    : null;
+                const fallbackOperation = operation ?? (typeof record.title === "string"
+                    ? toolOperation(record.title)
+                    : null);
+                const path = toolPath(record.input);
+                const target = fallbackOperation === null || path === null
+                    ? null
+                    : classifyExplicitPath(path, paths);
+                if (fallbackOperation !== null && target !== null) {
+                    pending.set(record.id, { operation: fallbackOperation, target });
+                }
+            }
+            if (record.type === "kimi.acp.tool_result" && typeof record.id === "string") {
+                if (record.status !== "completed" && record.status !== "failed")
+                    return observations;
+                const access = pending.get(record.id);
+                pending.delete(record.id);
+                if (access !== undefined) {
+                    recordObservation(observations, counts, {
+                        ...access,
+                        outcome: record.status === "failed" ? "failed" : "succeeded",
+                        evidence: "structured_tool",
+                    });
+                }
+            }
+            const item = record.type === "item.completed" && record.item && typeof record.item === "object"
+                ? record.item
+                : null;
+            if (item?.type === "command_execution" && typeof item.command === "string") {
+                const operation = commandOperation(item.command);
+                const outcome = typeof item.exit_code === "number"
+                    ? item.exit_code === 0 ? "succeeded" : "failed"
+                    : item.status === "completed"
+                        ? "succeeded"
+                        : item.status === "failed" || item.status === "declined"
+                            ? "failed"
+                            : "unknown";
+                for (const target of commandTargets(item.command, paths)) {
+                    recordObservation(observations, counts, { target, operation, outcome, evidence: "shell_command" });
+                }
+            }
+            const fileChange = record.type === "diagnostic.file_change" && Array.isArray(record.changes)
+                ? record
+                : item?.type === "file_change" && Array.isArray(item.changes)
+                    ? item
+                    : null;
+            if (fileChange !== null && Array.isArray(fileChange.changes)) {
+                const outcome = fileChange.status === "completed"
+                    ? "succeeded"
+                    : fileChange.status === "failed" || fileChange.status === "declined"
+                        ? "failed"
+                        : fileChange === item ? "succeeded" : "unknown";
+                for (const change of fileChange.changes) {
+                    if (!change || typeof change !== "object")
+                        continue;
+                    const detail = change;
+                    if (typeof detail.path !== "string")
+                        continue;
+                    const target = classifyExplicitPath(detail.path, paths);
+                    if (target === null)
+                        continue;
+                    recordObservation(observations, counts, {
+                        target,
+                        operation: detail.kind === "delete" ? "delete" : "write",
+                        outcome,
+                        evidence: "file_change",
+                    });
+                }
+            }
+            return observations;
+        },
+        summary() {
+            const count = (target, operation, outcome) => counts.get(`${target}:${operation}:${outcome}`) ?? 0;
+            return {
+                memory_read_succeeded: count("shared_memory", "read", "succeeded"),
+                memory_read_failed: count("shared_memory", "read", "failed"),
+                lessons_read_succeeded: count("shared_lessons", "read", "succeeded"),
+                lessons_read_failed: count("shared_lessons", "read", "failed"),
+                shared_memory_write_succeeded: count("shared_memory", "write", "succeeded"),
+                shared_lessons_write_succeeded: count("shared_lessons", "write", "succeeded"),
+                cwd_shadow_write_succeeded: count("cwd_shadow_memory", "write", "succeeded")
+                    + count("cwd_shadow_lessons", "write", "succeeded"),
+                pending_access_count: pending.size,
+            };
+        },
+    };
+}

package/dist/local-memory-telemetry.js

@@ -0,0 +1,224 @@
+import { dslog } from "./slog.js";
+import { analyzeLocalMemoryInjection, createLocalMemoryAccessObserver, inspectLocalMemoryFilesWithinDeadline, localMemoryContentFacts, localMemoryFileChanged, } from "./local-memory-diagnostics.js";
+function safeLog(eventType, message, fields) {
+    try {
+        dslog(eventType, message, fields);
+    }
+    catch {
+        // Local-memory diagnostics must never alter Agent execution.
+    }
+}
+function errorFields(error) {
+    const code = error?.code;
+    return {
+        error_name: error instanceof Error ? error.name : "unknown",
+        ...(typeof code === "string" ? { error_code: code } : {}),
+    };
+}
+export function logLocalMemoryContextPrepareFailure(identity, phase, error) {
+    safeLog("local_memory.context_prepare_failed", "本地记忆上下文准备失败", {
+        level: "WARN",
+        execution_id: identity.executionId,
+        agent_handle: identity.agentHandle,
+        task_key: identity.taskKey,
+        failure_phase: phase,
+        ...errorFields(error),
+    });
+}
+export function logLocalMemoryDiagnosticsFailure(identity, phase, error) {
+    safeLog("local_memory.diagnostics_failed", "本地记忆诊断失败并已放行", {
+        level: "WARN",
+        execution_id: identity.executionId,
+        agent_handle: identity.agentHandle,
+        task_key: identity.taskKey,
+        diagnostics_phase: phase,
+        ...errorFields(error),
+    });
+}
+function snapshotFields(snapshot) {
+    if (snapshot === null)
+        return {};
+    return {
+        memory_exists: snapshot.memory.exists,
+        memory_size_bytes: snapshot.memory.size_bytes,
+        memory_mtime_ms: snapshot.memory.mtime_ms,
+        memory_sha256: snapshot.memory.sha256,
+        memory_hash_skipped_reason: snapshot.memory.hash_skipped_reason,
+        memory_error_code: snapshot.memory.error_code,
+        memory_markdown_heading_count: snapshot.memory.markdown_heading_count,
+        memory_lessons_reference_count: snapshot.memory.lessons_reference_count,
+        lessons_exists: snapshot.lessons.exists,
+        lessons_size_bytes: snapshot.lessons.size_bytes,
+        lessons_mtime_ms: snapshot.lessons.mtime_ms,
+        lessons_sha256: snapshot.lessons.sha256,
+        lessons_hash_skipped_reason: snapshot.lessons.hash_skipped_reason,
+        lessons_error_code: snapshot.lessons.error_code,
+        lessons_markdown_heading_count: snapshot.lessons.markdown_heading_count,
+    };
+}
+function promptDelivery(runtime, stableProtocolRuntime) {
+    if (runtime === "claude")
+        return "claude_system_prompt_file";
+    if (!stableProtocolRuntime)
+        return "combined_wake_prompt";
+    return runtime === "codex" ? "codex_developer_instructions" : "kimi_protocol_prompt";
+}
+function logAccess(options, observation, sequence) {
+    safeLog("local_memory.file_access_observed", "观察到本地记忆文件访问", {
+        execution_id: options.executionId,
+        agent_handle: options.agentHandle,
+        task_key: options.taskKey,
+        runtime: options.runtime,
+        access_sequence: sequence,
+        ...observation,
+    });
+}
+export function createLocalMemoryTelemetry(options) {
+    const accessObserver = createLocalMemoryAccessObserver({
+        homeDir: options.agentDir,
+        runDir: options.runDir,
+    });
+    let beforeSnapshot = null;
+    let diagnosticsMs;
+    let accessSequence = 0;
+    let contextWasPrepared = false;
+    let runtimeStarted = false;
+    let runtimeReady = false;
+    let runtimeExitCode;
+    let executorCompleted = false;
+    return {
+        async captureBefore() {
+            const startedAt = Date.now();
+            try {
+                beforeSnapshot = await inspectLocalMemoryFilesWithinDeadline(options.agentDir, options.diagnosticsTimeoutMs);
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "before", error);
+            }
+            finally {
+                diagnosticsMs = Date.now() - startedAt;
+            }
+        },
+        contextPrepared(context) {
+            try {
+                const sourceFacts = localMemoryContentFacts(context.memory);
+                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory);
+                safeLog("local_memory.context_prepared", "本地记忆上下文已准备", {
+                    execution_id: options.executionId,
+                    agent_handle: options.agentHandle,
+                    task_key: options.taskKey,
+                    runtime: options.runtime,
+                    resumed: context.resumed,
+                    is_memory_prune: options.isMemoryPrune,
+                    memory_seed_created: context.memorySeedCreated,
+                    memory_source_read: true,
+                    memory_source_size_bytes: sourceFacts.size_bytes,
+                    memory_source_sha256: sourceFacts.sha256,
+                    memory_source_scan_skipped_reason: sourceFacts.scan_skipped_reason,
+                    memory_read_matches_snapshot: sourceFacts.sha256 === undefined
+                        || beforeSnapshot?.memory.sha256 === undefined
+                        ? undefined
+                        : sourceFacts.sha256 === beforeSnapshot.memory.sha256,
+                    memory_source_nonblank: sourceFacts.nonblank,
+                    memory_source_markdown_heading_count: sourceFacts.markdown_heading_count,
+                    memory_source_lessons_reference_count: sourceFacts.lessons_reference_count,
+                    memory_injection_state: injectionFacts.state,
+                    memory_injection_source_bytes: injectionFacts.source_bytes,
+                    memory_injection_bounded_bytes: injectionFacts.bounded_bytes,
+                    memory_injected_bytes: injectionFacts.injected_bytes,
+                    system_prompt_bytes: Buffer.byteLength(context.systemPrompt, "utf8"),
+                    prompt_delivery: promptDelivery(options.runtime, options.stableProtocolRuntime),
+                    diagnostics_ms: diagnosticsMs,
+                    ...snapshotFields(beforeSnapshot),
+                });
+                contextWasPrepared = true;
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "event_observe", error);
+            }
+        },
+        observe(event) {
+            try {
+                for (const observation of accessObserver.observe(event)) {
+                    accessSequence += 1;
+                    logAccess(options, observation, accessSequence);
+                }
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "event_observe", error);
+            }
+        },
+        markRuntimeStarted() {
+            runtimeStarted = true;
+        },
+        markRuntimeReady() {
+            runtimeReady = true;
+        },
+        markRuntimeExited(exitCode) {
+            runtimeExitCode = exitCode;
+        },
+        markExecutorCompleted() {
+            executorCompleted = true;
+        },
+        async finish() {
+            let afterSnapshot = null;
+            try {
+                afterSnapshot = await inspectLocalMemoryFilesWithinDeadline(options.agentDir, options.diagnosticsTimeoutMs);
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "after", error);
+            }
+            const memoryChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.memory, afterSnapshot.memory)
+                : undefined;
+            const lessonsChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.lessons, afterSnapshot.lessons)
+                : undefined;
+            const accessSummary = accessObserver.summary();
+            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
+                ? undefined
+                : memoryChanged || lessonsChanged;
+            const currentExecutionSharedWriteObserved = accessSummary.shared_memory_write_succeeded > 0
+                || accessSummary.shared_lessons_write_succeeded > 0;
+            safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
+                execution_id: options.executionId,
+                agent_handle: options.agentHandle,
+                task_key: options.taskKey,
+                runtime: options.runtime,
+                is_memory_prune: options.isMemoryPrune,
+                context_prepared: contextWasPrepared,
+                runtime_started: runtimeStarted,
+                runtime_ready: runtimeReady,
+                runtime_exit_code: runtimeExitCode,
+                executor_outcome: executorCompleted ? "succeeded" : "failed",
+                memory_changed: memoryChanged,
+                lessons_changed: lessonsChanged,
+                shared_files_changed_during_execution: sharedFilesChanged,
+                unexpected_shared_write: options.isMemoryPrune
+                    ? undefined
+                    : currentExecutionSharedWriteObserved
+                        ? true
+                        : sharedFilesChanged === false ? false : undefined,
+                access_observation_count: accessSequence,
+                ...accessSummary,
+                ...(afterSnapshot === null ? {} : {
+                    memory_after_exists: afterSnapshot.memory.exists,
+                    memory_after_size_bytes: afterSnapshot.memory.size_bytes,
+                    memory_after_mtime_ms: afterSnapshot.memory.mtime_ms,
+                    memory_after_sha256: afterSnapshot.memory.sha256,
+                    memory_after_hash_skipped_reason: afterSnapshot.memory.hash_skipped_reason,
+                    memory_after_error_code: afterSnapshot.memory.error_code,
+                    memory_after_markdown_heading_count: afterSnapshot.memory.markdown_heading_count,
+                    memory_after_lessons_reference_count: afterSnapshot.memory.lessons_reference_count,
+                    lessons_after_exists: afterSnapshot.lessons.exists,
+                    lessons_after_size_bytes: afterSnapshot.lessons.size_bytes,
+                    lessons_after_mtime_ms: afterSnapshot.lessons.mtime_ms,
+                    lessons_after_sha256: afterSnapshot.lessons.sha256,
+                    lessons_after_hash_skipped_reason: afterSnapshot.lessons.hash_skipped_reason,
+                    lessons_after_error_code: afterSnapshot.lessons.error_code,
+                    lessons_after_markdown_heading_count: afterSnapshot.lessons.markdown_heading_count,
+                }),
+            });
+        },
+    };
+}

package/dist/machine-info.js

@@ -15,6 +15,8 @@ import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
 import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeHermesAcp } from "./runtimes/hermes.js";
+import { probeOpenCodeRun } from "./runtimes/opencode.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const DAEMON_CAPABILITIES = [
@@ -39,6 +41,7 @@ const RUNTIME_BINS = [
     ["codex", "codex"],
     ["cursor", "cursor-agent"],
     ["gemini", "gemini"],
+    ["hermes", "hermes"],
     ["opencode", "opencode"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
@@ -59,17 +62,29 @@ 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);
 }
-async function supportsKimiAcp() {
-    return probeKimiAcp({ bin: "kimi" });
+async function supportsKimiAcp(signal) {
+    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+}
+async function supportsHermesAcp(signal) {
+    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+}
+async function supportsOpenCodeRun(signal) {
+    return probeOpenCodeRun(signal);
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, signal) {
     const present = await installed;
-    const supported = executableRuntimes(present).filter((runtime) => runtime !== "kimi");
-    if (present.includes("kimi") && await kimiAcpProbe())
-        supported.push("kimi");
-    return supported;
+    const [kimiReady, hermesReady, openCodeReady] = await Promise.all([
+        present.includes("kimi") ? kimiAcpProbe(signal) : false,
+        present.includes("hermes") ? hermesAcpProbe(signal) : false,
+        present.includes("opencode") ? openCodeProbe(signal) : false,
+    ]);
+    return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
+        : runtime === "hermes" ? hermesReady
+            : runtime === "opencode" ? openCodeReady
+                : true));
 }
+export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, signal);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));

package/dist/main.js

@@ -113,7 +113,12 @@ async function main() {
         process.exit(2);
     }
     process.stdout.write(formatDaemonLogLine(`🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}`) + "\n");
-    initSlog(config.serverUrl, config.machineToken); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
+    initSlog(config.serverUrl, config.machineToken, {
+        daemonVersion: daemonVersion(),
+        cliVersion: cliVersion(),
+        ...(values.profile === undefined ? {} : { profileName: values.profile }),
+        agentsRoot: config.agentsRoot,
+    }); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
     const result = await runAgent(config, {
         handle: values.agent,
         channelId: values.channel,

package/dist/normalize.js

@@ -34,7 +34,8 @@ export function classifyCommand(command) {
 /** 从各 runtime 的最终事件提取可交付文本。调用方按事件顺序保留最后一个非空值。 */
 export function extractFinalText(event) {
     const e = (event ?? {});
-    if (e.type === "kimi.acp.text_delta" && e.text)
+    if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "opencode.text_delta") && e.text)
         return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
         return e.result.trim();
@@ -61,13 +62,16 @@ function parseKimiBashCommand(args) {
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
-    if (e.type === "kimi.acp.text_delta" && e.text?.trim()) {
+    if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "opencode.text_delta") && e.text?.trim()) {
         return [{ kind: "text", label: "思考/说明", detail: e.text }];
     }
-    if (e.type === "kimi.acp.tool_call") {
+    if (e.type === "kimi.acp.tool_call" || e.type === "hermes.acp.tool_call"
+        || e.type === "opencode.tool_call") {
         return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
     }
-    if (e.type === "kimi.acp.tool_result") {
+    if (e.type === "kimi.acp.tool_result" || e.type === "hermes.acp.tool_result"
+        || e.type === "opencode.tool_result") {
         return [{ kind: "tool_result", label: "工具返回" }];
     }
     if (e.type === "system" && e.subtype === "init") {
@@ -86,6 +90,12 @@ export function normalizeEvent(event) {
     if (e.type === "turn.completed") {
         return [{ kind: "done", label: "本轮结束" }];
     }
+    if (e.type === "opencode.error") {
+        const detail = typeof event.message === "string"
+            ? event.message
+            : undefined;
+        return [{ kind: "error", label: "运行出错", ...(detail ? { detail } : {}) }];
+    }
     if (e.type === "result") {
         return e.is_error
             ? [{ kind: "error", label: "运行出错", ...(e.result ? { detail: e.result } : {}) }]