@nowcrew/daemon 0.5.45 → 0.5.47

package/README.md

@@ -193,8 +193,8 @@ dispatch reports unavailable instead of running on another compatible daemon. An
 the global compatible-machine pool.
 
 The daemon intersects requested permission with local policy, checks advertised resource limits, prepares
-the local workspace/environment, and launches only a built-in runtime adapter (`claude`, `codex`, or
-`kimi`). It does not decide collaboration rules, scheduled output policy, fallback delivery, or thread
+the local workspace/environment, and launches only a built-in runtime adapter (`claude`, `codex`, `kimi`,
+`hermes`, or `opencode`). It does not decide collaboration rules, scheduled output policy, fallback delivery, or thread
 behavior. Those are server responsibilities.
 
 The stable adapters keep prompts out of provider argv wherever the provider protocol allows it:
@@ -204,6 +204,8 @@ The stable adapters keep prompts out of provider argv wherever the provider prot
 | Claude | stream-json CLI | daemon-owned system prompt file | CLI session id |
 | Codex | app-server JSON-RPC over stdio | `developerInstructions` + turn input | `thread/resume` |
 | Kimi | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
+| Hermes | ACP over stdio | `session/prompt` | `session/resume` (`session/load` compatibility fallback) |
+| OpenCode | `run --format json` | stdin | `--session` |
 
 Kimi ACP currently requires a Kimi account even when the CLI has a working custom provider. Only for
 the explicit `Authentication required` response, the adapter retries once through Kimi's stream-json
@@ -211,7 +213,20 @@ CLI and carries the same native session id; unrelated ACP failures stay failures
 subject to the Windows UTF-16 argv guard, while protocol-v1 itself remains disabled on Windows until
 durable Job Object ownership is available.
 
-Codex and Kimi sessions use the same bounded per-task persistence and keyed lease as Claude when they
+Hermes uses only ACP capabilities advertised by the installed CLI. Model and effort choices come from
+a short-lived discovery session; credentials, provider profiles, plugins, and `HERMES_HOME` remain
+machine-local. A missing resumed ACP session is retried once as a fresh session.
+
+OpenCode receives the prompt through stdin and runs with both cwd and `PWD` anchored to the Agent
+workspace. Models and variants come from `opencode models --verbose` (with the plain catalog as a
+compatibility fallback). A missing resumed session is retried once without `--session`; malformed,
+empty, incomplete, or explicitly failed JSON streams remain failures. NowWork never writes
+`opencode.json` or replaces `OPENCODE_CONFIG_CONTENT`. The daemon advertises OpenCode as executable
+only when `opencode run --help` exposes `--format`, `--dangerously-skip-permissions`, `--dir`,
+`--model`, `--variant`, and `--session`; older installations remain visible as detected CLIs until
+they are upgraded, rather than falling back to a permission override that user config could weaken.
+
+Codex, Kimi, Hermes, and OpenCode sessions use the same bounded per-task persistence and keyed lease as Claude when they
 run through protocol v1. A first-progress watchdog covers a provider that accepts a turn but remains
 semantically silent; after the first semantic event, the execution's configured total timeout remains
 authoritative so a legitimate long-running tool is not killed for quiet output.
@@ -219,6 +234,10 @@ authoritative so a legitimate long-running tool is not killed for quiet output.
 Protocol support and limits are advertised in `machine:hello`. `runtimes` reports every recognized CLI
 found on `PATH`; `executionRuntimes` separately reports the installed CLIs backed by a complete built-in
 adapter. The server must use the latter for admission and treats the former as diagnostic inventory only.
+The daemon sends a conservative first hello without waiting for third-party handshakes, then refreshes it
+after the optional Kimi/Hermes/OpenCode probes finish. Work targeting those optional runtimes waits for the
+same full probe result; reconnects share one in-flight probe, and shutdown aborts any unfinished probe and
+its child process.
 Old daemons that omit `executionRuntimes` are conservatively interpreted as the intersection of installed
 CLIs and server-supported adapters. Unknown required protocol semantics are rejected before side effects.
 Protocol-0 `agent:start` remains only for the server-governed compatibility window.

package/dist/agent-memory/bridge.js

@@ -1,35 +1,126 @@
 import { createAgentMemoryClient } from "./client.js";
 import { buildCaptureMessages, extractIncomingMessage, rankMemoryItems, renderMemoryContext, } from "./policy.js";
+import { dslog } from "../slog.js";
+function safeReport(report, eventType, message, fields) {
+    try {
+        report(eventType, message, fields);
+    }
+    catch {
+        // Diagnostics must never affect optional memory recall or capture.
+    }
+}
 export function createAgentMemoryBridge(config, dependencies = {}) {
     const client = dependencies.client ?? createAgentMemoryClient(config);
+    const report = dependencies.report ?? dslog;
     const blockId = `chat_memory-${config.teamId}-${config.agentId}`;
     return {
-        recall: async (agentHandle, wakePrompt) => {
-            const incoming = agentHandle === config.agentHandle ? extractIncomingMessage(wakePrompt) : null;
-            if (incoming === null)
+        recall: async (agentHandle, wakePrompt, executionId) => {
+            const startedAt = Date.now();
+            if (agentHandle !== config.agentHandle) {
+                safeReport(report, "external_agent_memory.recall_observed", "外部 Agent Memory recall 已跳过", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "skipped",
+                    skip_reason: "handle_mismatch",
+                    duration_ms: Date.now() - startedAt,
+                });
+                return "";
+            }
+            const incoming = extractIncomingMessage(wakePrompt);
+            if (incoming === null) {
+                safeReport(report, "external_agent_memory.recall_observed", "外部 Agent Memory recall 已跳过", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "skipped",
+                    skip_reason: "wake_unparsed",
+                    duration_ms: Date.now() - startedAt,
+                });
                 return "";
+            }
             try {
                 const [core, atomic] = await Promise.all([
                     client.layer(blockId, "L3", 1),
                     client.layer(blockId, "L1", config.recallLimit),
                 ]);
-                return renderMemoryContext(core, rankMemoryItems(incoming, atomic, config.recallLimit));
+                const selected = rankMemoryItems(incoming, atomic, config.recallLimit);
+                const rendered = renderMemoryContext(core, selected);
+                safeReport(report, "external_agent_memory.recall_observed", "外部 Agent Memory recall 已完成", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "succeeded",
+                    core_count: core.length,
+                    atomic_count: atomic.length,
+                    selected_atomic_count: selected.length,
+                    rendered_bytes: Buffer.byteLength(rendered, "utf8"),
+                    duration_ms: Date.now() - startedAt,
+                });
+                return rendered;
             }
-            catch {
+            catch (error) {
+                safeReport(report, "external_agent_memory.recall_observed", "外部 Agent Memory recall 失败并已放行", {
+                    level: "WARN",
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "failed",
+                    error_name: error instanceof Error ? error.name : "unknown",
+                    duration_ms: Date.now() - startedAt,
+                });
                 return "";
             }
         },
         capture: async (agentHandle, executionId, wakePrompt, finalText) => {
-            const incoming = agentHandle === config.agentHandle ? extractIncomingMessage(wakePrompt) : null;
-            if (incoming === null)
+            const startedAt = Date.now();
+            if (agentHandle !== config.agentHandle) {
+                safeReport(report, "external_agent_memory.capture_observed", "外部 Agent Memory capture 已跳过", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "skipped",
+                    skip_reason: "handle_mismatch",
+                    duration_ms: Date.now() - startedAt,
+                });
                 return;
+            }
+            const incoming = extractIncomingMessage(wakePrompt);
+            if (incoming === null) {
+                safeReport(report, "external_agent_memory.capture_observed", "外部 Agent Memory capture 已跳过", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "skipped",
+                    skip_reason: "wake_unparsed",
+                    duration_ms: Date.now() - startedAt,
+                });
+                return;
+            }
             const messages = buildCaptureMessages(incoming, finalText);
-            if (messages === null)
+            if (messages === null) {
+                safeReport(report, "external_agent_memory.capture_observed", "外部 Agent Memory capture 已跳过", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "skipped",
+                    skip_reason: "content_filtered",
+                    duration_ms: Date.now() - startedAt,
+                });
                 return;
+            }
             try {
-                await client.importConversation(`nowwork-${executionId}`, messages);
+                const result = await client.importConversation(`nowwork-${executionId}`, messages);
+                safeReport(report, "external_agent_memory.capture_observed", "外部 Agent Memory capture 已完成", {
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "succeeded",
+                    accepted_count: result.acceptedCount,
+                    duration_ms: Date.now() - startedAt,
+                });
             }
-            catch {
+            catch (error) {
+                safeReport(report, "external_agent_memory.capture_observed", "外部 Agent Memory capture 失败并已放行", {
+                    level: "WARN",
+                    execution_id: executionId,
+                    agent_handle: agentHandle,
+                    outcome: "failed",
+                    error_name: error instanceof Error ? error.name : "unknown",
+                    duration_ms: Date.now() - startedAt,
+                });
                 // External memory is an optional side effect and cannot alter execution completion.
             }
         },

package/dist/daemon-update-controller.js

@@ -4,6 +4,12 @@ const DaemonUpdateMessageSchema = z.object({
     updateId: z.string().uuid(),
     targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
 }).strict();
+const DaemonRestartMessageSchema = z.object({
+    type: z.literal("daemon:restart"),
+    updateId: z.string().uuid(),
+    targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+}).strict();
+const DaemonControlMessageSchema = z.union([DaemonUpdateMessageSchema, DaemonRestartMessageSchema]);
 export function createDaemonUpdateController(deps) {
     const handled = new Set();
     let running = null;
@@ -17,16 +23,18 @@ export function createDaemonUpdateController(deps) {
             failed(message.updateId, "ineligible");
             return;
         }
-        const installed = await deps.install({
-            targetVersion: message.targetVersion,
-            packageRoot: eligibility.packageRoot,
-            npmPrefix: eligibility.npmPrefix,
-            onInstalling: () => {
-                deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "installing" });
-            },
-        });
-        if (!installed.ok) {
-            failed(message.updateId, installed.errorCode);
+        const preparation = message.type === "daemon:restart"
+            ? await deps.prepareRestart()
+            : await deps.install({
+                targetVersion: message.targetVersion,
+                packageRoot: eligibility.packageRoot,
+                npmPrefix: eligibility.npmPrefix,
+                onInstalling: () => {
+                    deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "installing" });
+                },
+            });
+        if (!preparation.ok) {
+            failed(message.updateId, preparation.errorCode);
             return;
         }
         let released = false;
@@ -34,7 +42,7 @@ export function createDaemonUpdateController(deps) {
             if (released)
                 return;
             released = true;
-            await installed.release();
+            await preparation.release();
         };
         deps.sendStatus({ type: "daemon:update-status", updateId: message.updateId, status: "restarting" });
         try {
@@ -66,7 +74,7 @@ export function createDaemonUpdateController(deps) {
             }
         },
         handle: async (input) => {
-            const parsed = DaemonUpdateMessageSchema.safeParse(input);
+            const parsed = DaemonControlMessageSchema.safeParse(input);
             if (!parsed.success)
                 return false;
             const message = parsed.data;

package/dist/daemon-update-eligibility.js

@@ -10,6 +10,16 @@ import { daemonInstallationLeaseHeld } from "./daemon-installation-lease.js";
 import { inspectLegacyServiceInstallation } from "./legacy-service-installation.js";
 import { inspectWindowsServiceUpdateScope } from "./windows-scheduled-task.js";
 import { assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, readManagedServiceRegistry, serviceDescriptorSha256, } from "./managed-service-registry.js";
+export async function managedDaemonCapabilities(eligibility) {
+    try {
+        return (await eligibility()).eligible
+            ? ["daemon_update_v1", "daemon_restart_v1"]
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
 function defaults() {
     return {
         platform: process.platform,

package/dist/daemon-updater.js

@@ -3,6 +3,27 @@ import { resolve } from "node:path";
 import { systemCommandRunner } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 const RELEASED_VERSION_RE = /^\d+\.\d+\.\d+$/;
+export async function prepareDaemonRestart(input) {
+    const local = input.localSlots.tryAcquireExclusive();
+    if (local === null)
+        return { ok: false, errorCode: "runtime_busy" };
+    const host = await input.hostCoordinator.tryAcquireExclusiveExecution();
+    if (host === null) {
+        local.release();
+        return { ok: false, errorCode: "runtime_busy" };
+    }
+    let released = false;
+    return {
+        ok: true,
+        release: async () => {
+            if (released)
+                return;
+            released = true;
+            await host.release();
+            local.release();
+        },
+    };
+}
 async function readPackageVersion(packageRoot) {
     const body = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
     return typeof body.version === "string" ? body.version : "";

package/dist/execution-journal.js

@@ -7,7 +7,7 @@ import { JournalLockedError, createJournalLease, } from "./execution-journal-loc
 export { JournalLockedError, JournalLockCorruptionError } from "./execution-journal-lock.js";
 const ExecutionIdSchema = z.string().uuid();
 const TimestampSchema = z.string().datetime({ offset: true });
-const RuntimeSchema = z.enum(["claude", "codex", "kimi"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode"]);
 const RUNTIME_READY_SUFFIX = ".runtime-ready";
 const RawJournalEntrySchema = z.object({
     executionId: ExecutionIdSchema,

package/dist/execution-protocol.js

@@ -8,7 +8,7 @@ const MIN_SIGNED_32_INTEGER = -2_147_483_648;
 const SequenceSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
 const TokenCountSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
 const ExitCodeSchema = z.number().int().min(MIN_SIGNED_32_INTEGER).max(MAX_PG_INTEGER);
-const RuntimeSchema = z.enum(["claude", "codex", "kimi"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode"]);
 const UnsafePathCharacterSchema = /[\p{Cc}<>:"/\\|?*]/u;
 const WindowsReservedNameSchema = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
 export const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."
@@ -22,16 +22,8 @@ const ProjectSkillRefSchema = z.object({
     projectId: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/u),
     skillName: z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._:-]*$/u),
 }).strict();
-export const ReasoningSchema = z.enum([
-    "default",
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-]);
+export const ReasoningSchema = z.string().min(1).max(64)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u, "invalid runtime reasoning token");
 export const PermissionSchema = z.enum([
     "local_default",
     "sandboxed",

package/dist/execution-runner.js

@@ -169,7 +169,10 @@ function validReasoning(spec) {
     if (spec.runtime.name === "codex") {
         return CODEX_EFFORT_LEVELS.includes(reasoning);
     }
-    return KIMI_EFFORT_LEVELS.includes(reasoning);
+    if (spec.runtime.name === "kimi") {
+        return KIMI_EFFORT_LEVELS.includes(reasoning);
+    }
+    return true;
 }
 function launchProviderConfig(config) {
     if (config === undefined)
@@ -241,8 +244,14 @@ function admission(spec, config, dependencies, at) {
         return { rejected: rejection(spec.executionId, "resource_limit", "Local execution capacity is exhausted", at) };
     }
     const permission = effectivePermission(spec, config);
-    if (spec.runtime.name === "kimi" && permission !== "full_access") {
-        return { rejected: rejection(spec.executionId, "local_policy_denied", `Kimi cannot enforce ${permission} permission`, at) };
+    if ((spec.runtime.name === "kimi" || spec.runtime.name === "hermes" || spec.runtime.name === "opencode")
+        && permission !== "full_access") {
+        const displayName = spec.runtime.name === "kimi"
+            ? "Kimi"
+            : spec.runtime.name === "hermes" ? "Hermes" : "OpenCode";
+        return {
+            rejected: rejection(spec.executionId, "local_policy_denied", `${displayName} cannot enforce ${permission} permission`, at),
+        };
     }
     return { spec, permission };
 }
@@ -404,7 +413,7 @@ export async function runExecution(config, input, dependencies) {
         let recalledMemory = "";
         if (spec.agent.memoryEnabled === true && dependencies.agentMemory !== undefined) {
             try {
-                recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt), dependencies.cancellation);
+                recalledMemory = await cancellable(dependencies.agentMemory.recall(spec.agent.handle, spec.instructions.wakePrompt, spec.executionId), dependencies.cancellation);
             }
             catch (error) {
                 if (error instanceof ExecutionCancelledError)

package/dist/external-output.js

@@ -62,6 +62,10 @@ export function decodeExternalOutputEvent(runtime, event, decoder) {
             ? decoder.push(candidate.item.text)
             : [];
     }
+    if ((runtime === "hermes" && candidate.type === "hermes.acp.text_delta")
+        || (runtime === "opencode" && candidate.type === "opencode.text_delta")) {
+        return typeof candidate.text === "string" ? decoder.push(candidate.text) : [];
+    }
     return candidate.type === undefined
         && candidate.role === "assistant"
         && typeof candidate.content === "string"

package/dist/list-models.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isWin } from "./platform.js";
+import { listHermesModels } from "./runtimes/hermes-models.js";
 const execFileRaw = promisify(execFile);
 const MODEL_PROBE_TIMEOUT_MS = 8_000;
 const MODEL_PROBE_MAX_BUFFER_BYTES = 1024 * 1024;
@@ -11,14 +12,16 @@ const execFileP = (bin, args) => execFileRaw(bin, args, {
     killSignal: "SIGKILL",
     maxBuffer: MODEL_PROBE_MAX_BUFFER_BYTES,
 });
-export async function listRuntimeModels(runtime) {
+export async function listRuntimeModels(runtime, options = {}) {
     switch (runtime) {
         case "codex":
             return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
         case "cursor":
             return parseCursorModels((await execFileP("cursor-agent", ["--list-models"])).stdout);
+        case "hermes":
+            return listHermesModels(options);
         case "opencode":
-            return parseOpencodeModels((await execFileP("opencode", ["models"])).stdout);
+            return listOpencodeModels();
         case "pi":
             return parsePiModels((await execFileP("pi", ["--list-models"])).stdout);
         default:
@@ -76,12 +79,103 @@ function parseCursorModels(stdout) {
         return { id: id.trim(), label: (label || id).trim(), ...(index === 0 ? { default: true } : {}) };
     });
 }
-function parseOpencodeModels(stdout) {
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && !line.startsWith("warning:"))
-        .map((line, index) => ({ id: line, label: line, ...(index === 0 ? { default: true } : {}) }));
+async function outputEvenOnFailure(bin, args) {
+    try {
+        return (await execFileP(bin, args)).stdout;
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (typeof stdout === "string")
+            return stdout;
+        if (Buffer.isBuffer(stdout))
+            return stdout.toString("utf8");
+        return "";
+    }
+}
+async function listOpencodeModels() {
+    const verbose = parseOpencodeModels(await outputEvenOnFailure("opencode", ["models", "--verbose"]));
+    if (verbose.length > 0)
+        return verbose;
+    return parseOpencodeModels(await outputEvenOnFailure("opencode", ["models"]));
+}
+const VARIANT_ORDER = new Map([
+    ["none", 0], ["minimal", 1], ["low", 2], ["medium", 3],
+    ["high", 4], ["xhigh", 5], ["max", 6],
+]);
+function modelIdLine(line) {
+    const id = line.trim().split(/\s+/, 1)[0] ?? "";
+    if (!id.includes("/") || /^["{[]/.test(id) || id === id.toUpperCase())
+        return null;
+    return id;
+}
+function collectJson(lines, start) {
+    let raw = "";
+    for (let index = start; index < lines.length; index += 1) {
+        if (index > start && modelIdLine(lines[index]) !== null)
+            return { raw, next: index };
+        raw += `${raw ? "\n" : ""}${lines[index]}`;
+        try {
+            JSON.parse(raw);
+            return { raw, next: index + 1 };
+        }
+        catch {
+            // A pretty-printed block is complete only when JSON.parse succeeds.
+        }
+    }
+    return { raw, next: lines.length };
+}
+function parseVariants(raw) {
+    try {
+        const meta = JSON.parse(raw);
+        const variants = meta.variants ?? {};
+        const looksReasoning = meta.reasoning === true || Object.entries(variants).some(([name, value]) => VARIANT_ORDER.has(name) || typeof value.reasoningEffort === "string" || value.thinking != null);
+        if (!looksReasoning)
+            return [];
+        return Object.entries(variants)
+            .filter(([name, value]) => name.length > 0 && value.disabled !== true)
+            .map(([name]) => name)
+            .sort((left, right) => {
+            const leftOrder = VARIANT_ORDER.get(left);
+            const rightOrder = VARIANT_ORDER.get(right);
+            if (leftOrder !== undefined && rightOrder !== undefined)
+                return leftOrder - rightOrder;
+            if (leftOrder !== undefined)
+                return -1;
+            if (rightOrder !== undefined)
+                return 1;
+            return left.localeCompare(right);
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function parseOpencodeModels(stdout) {
+    const lines = stdout.split(/\r?\n/);
+    const models = [];
+    const byId = new Map();
+    for (let index = 0; index < lines.length; index += 1) {
+        const id = modelIdLine(lines[index]);
+        if (id === null)
+            continue;
+        let modelIndex = byId.get(id);
+        if (modelIndex === undefined) {
+            modelIndex = models.length;
+            byId.set(id, modelIndex);
+            models.push({ id, label: id, ...(modelIndex === 0 ? { default: true } : {}) });
+        }
+        let next = index + 1;
+        while (next < lines.length && lines[next].trim() === "")
+            next += 1;
+        if (next >= lines.length || !lines[next].trim().startsWith("{"))
+            continue;
+        const block = collectJson(lines, next);
+        const reasoning = parseVariants(block.raw);
+        if (reasoning.length > 0)
+            models[modelIndex] = { ...models[modelIndex], reasoning };
+        index = block.next - 1;
+    }
+    return models;
 }
 function parsePiModels(stdout) {
     return stdout