@nowcrew/daemon 0.5.44 → 0.5.46

package/README.md

@@ -105,8 +105,10 @@ CREW_DAEMON_HOME="$HOME/.crew/daemon-dev" crew-daemon doctor --profile dev
 CREW_DAEMON_HOME="$HOME/.crew/daemon-dev" crew-daemon status --profile dev
 ```
 
-If the descriptor has drifted, the profile is stopped, or another host descriptor is not registered, the
-daemon fails closed and remains manually upgradeable.
+If the target descriptor has drifted or the profile is stopped, the daemon fails closed and remains
+manually upgradeable. On macOS, another unregistered legacy LaunchAgent may coexist only when its plist
+exactly matches a generated NowCrew service and resolves to a different npm prefix. An unverifiable or
+same-prefix descriptor still fails closed.
 
 The daemon advertises `daemon_update_v1` only when all of these conditions hold:
 
@@ -115,7 +117,7 @@ The daemon advertises `daemon_update_v1` only when all of these conditions hold:
 | Platform | macOS LaunchAgent or Linux systemd user service |
 | Entrypoint | global `@nowcrew/daemon/dist/main.js`, not npx or source/tsx |
 | Startup | `crew-daemon serve --profile <name>` through the installed service |
-| Registry | every other NowCrew descriptor on the OS user account is registered and conflict-free; the exact target legacy descriptor may be adopted once |
+| Registry | registered descriptors remain conflict-free; the exact target legacy descriptor may be adopted once; an exact macOS legacy descriptor on another npm prefix may coexist |
 | Identity | service ID, descriptor, daemon home, Agent root, entrypoint, package root, and npm prefix match |
 | Service | the selected profile is running and holds the installation lease |
 | Install root | a standard writable Unix global npm prefix can be derived from the running entrypoint |
@@ -191,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:
@@ -202,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
@@ -209,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.
@@ -217,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/computer-service.js

@@ -315,8 +315,30 @@ setTimeout(() => {
   let restarted;
   if (spec.platform === "darwin") {
     restarted = spawnSync("launchctl", ["kickstart", "-k", spec.target], { stdio: "ignore", shell: false });
-  } else {
+  } else if (spec.platform === "linux") {
     restarted = spawnSync("systemctl", ["--user", "--no-block", "restart", spec.id], { stdio: "ignore", shell: false });
+  } else {
+    const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+    const encodedExecutable = Buffer.from(spec.executable, "utf16le").toString("base64");
+    const encodedArguments = Buffer.from(spec.arguments, "utf16le").toString("base64");
+    const script = [
+      "$ErrorActionPreference='Stop';",
+      "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[1]));",
+      "$exe=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[2]));",
+      "$argv=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[3]));",
+      "$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};",
+      "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
+      "$p=Get-Process -Id ([int]$args[0]) -ErrorAction Stop;",
+      "if($p.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() -cne $args[4]){throw 'daemon process identity changed'};",
+      "$p.Kill();",
+      "if(-not $p.WaitForExit(10000)){throw 'daemon exit timeout'};",
+      "$deadline=[DateTime]::UtcNow.AddSeconds(10);",
+      "do{$task=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});if($task.Count -ne 1){throw 'scheduled task identity changed'};if([int]$task[0].State -ne 4){break};Start-Sleep -Milliseconds 100}while([DateTime]::UtcNow -lt $deadline);",
+      "if([int]$task[0].State -eq 4){throw 'scheduled task stop timeout'};",
+      "$actions=@($task[0].Actions);if($actions.Count -ne 1 -or -not [String]::Equals($actions[0].Execute,$exe,[StringComparison]::OrdinalIgnoreCase) -or $actions[0].Arguments -cne $argv){throw 'scheduled task action changed'};",
+      "& schtasks.exe /Run /TN $n | Out-Null;if($LASTEXITCODE -ne 0){throw 'scheduled task start failed'};",
+    ].join("");
+    restarted = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, String(spec.daemonPid), encodedName, encodedExecutable, encodedArguments, spec.processIdentity], { stdio: "ignore", shell: false });
   }
   if (restarted.status !== 0) process.send?.({ type: "restart-failed", status: restarted.status });
   setTimeout(() => {
@@ -326,16 +348,27 @@ setTimeout(() => {
 }, 250);
 `;
 export function scheduleServiceRestart(spec, spawnDetached = systemDetachedSpawn) {
-    if (spec.platform === "win32")
-        throw new Error("Windows detached restart is not supported");
-    if (spec.descriptorPath === null)
+    if (spec.platform !== "win32" && spec.descriptorPath === null) {
         throw new Error("service descriptor is required for restart");
+    }
     const payload = spec.platform === "darwin"
         ? {
             platform: spec.platform,
             target: `${spec.managerDomain}/${spec.id}`,
         }
-        : { platform: spec.platform, id: spec.id };
+        : spec.platform === "linux"
+            ? { platform: spec.platform, id: spec.id }
+            : {
+                platform: spec.platform,
+                id: spec.id,
+                daemonPid: process.pid,
+                executable: spec.daemonCommand[0],
+                arguments: spec.daemonCommand.slice(1).map(windowsCommandArg).join(" "),
+                processIdentity: spec.runtimeProcessIdentity,
+            };
+    if (spec.platform === "win32" && !payload.processIdentity) {
+        throw new Error("Windows daemon process identity is required for restart");
+    }
     const child = spawnDetached(process.execPath, ["-e", RESTART_HELPER_SOURCE, JSON.stringify(payload)], { detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"], shell: false });
     child.unref();
     let settleFailure;

package/dist/daemon-installation.js

@@ -1,38 +1,55 @@
 import { realpathSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-function canonicalPath(path, realpath) {
+import { posix, win32 } from "node:path";
+function canonicalPath(path, platform, realpath) {
+    const paths = platform === "win32" ? win32 : posix;
     try {
         return realpath(path);
     }
     catch (error) {
         const code = error.code;
-        return code === "ENOENT" || code === "ENOTDIR" ? resolve(path) : null;
+        return code === "ENOENT" || code === "ENOTDIR" ? paths.resolve(path) : null;
     }
 }
+function samePath(left, right, platform) {
+    return platform === "win32"
+        ? left.toLowerCase() === right.toLowerCase()
+        : left === right;
+}
 export function daemonGlobalInstallation(entryPath, platform, realpath = realpathSync.native) {
-    if (platform !== "darwin" && platform !== "linux")
+    if (platform !== "darwin" && platform !== "linux" && platform !== "win32")
+        return null;
+    const paths = platform === "win32" ? win32 : posix;
+    const packageRoot = paths.resolve(paths.dirname(entryPath), "..");
+    const globalNodeModules = paths.resolve(packageRoot, "..", "..");
+    const modulesParent = paths.dirname(globalNodeModules);
+    if (paths.basename(globalNodeModules).toLowerCase() !== "node_modules")
         return null;
-    const packageRoot = resolve(dirname(entryPath), "..");
-    const globalNodeModules = resolve(packageRoot, "..", "..");
-    const libDirectory = dirname(globalNodeModules);
-    if (basename(globalNodeModules) !== "node_modules" || basename(libDirectory) !== "lib")
+    if (platform !== "win32" && paths.basename(modulesParent) !== "lib")
         return null;
-    if (resolve(entryPath) !== resolve(packageRoot, "dist", "main.js"))
+    if (!samePath(paths.resolve(entryPath), paths.resolve(packageRoot, "dist", "main.js"), platform))
         return null;
-    if (resolve(packageRoot) !== resolve(globalNodeModules, "@nowcrew", "daemon"))
+    if (!samePath(paths.resolve(packageRoot), paths.resolve(globalNodeModules, "@nowcrew", "daemon"), platform))
         return null;
-    const canonicalPackageRoot = canonicalPath(packageRoot, realpath);
-    const canonicalGlobalNodeModules = canonicalPath(globalNodeModules, realpath);
-    const canonicalNpmPrefix = canonicalPath(dirname(libDirectory), realpath);
+    const npmPrefix = platform === "win32" ? modulesParent : paths.dirname(modulesParent);
+    const canonicalPackageRoot = canonicalPath(packageRoot, platform, realpath);
+    const canonicalGlobalNodeModules = canonicalPath(globalNodeModules, platform, realpath);
+    const canonicalNpmPrefix = canonicalPath(npmPrefix, platform, realpath);
     if (canonicalPackageRoot === null || canonicalGlobalNodeModules === null || canonicalNpmPrefix === null)
         return null;
-    if (canonicalPackageRoot !== resolve(canonicalGlobalNodeModules, "@nowcrew", "daemon"))
+    const normalizeCanonical = (path) => paths.resolve(path);
+    const normalizedPackageRoot = normalizeCanonical(canonicalPackageRoot);
+    const normalizedGlobalNodeModules = normalizeCanonical(canonicalGlobalNodeModules);
+    const normalizedNpmPrefix = normalizeCanonical(canonicalNpmPrefix);
+    if (!samePath(normalizedPackageRoot, paths.resolve(normalizedGlobalNodeModules, "@nowcrew", "daemon"), platform))
         return null;
-    if (canonicalGlobalNodeModules !== resolve(canonicalNpmPrefix, "lib", "node_modules"))
+    const expectedModules = platform === "win32"
+        ? paths.resolve(normalizedNpmPrefix, "node_modules")
+        : paths.resolve(normalizedNpmPrefix, "lib", "node_modules");
+    if (!samePath(normalizedGlobalNodeModules, expectedModules, platform))
         return null;
     return {
-        packageRoot: canonicalPackageRoot,
-        globalNodeModules: canonicalGlobalNodeModules,
-        npmPrefix: canonicalNpmPrefix,
+        packageRoot: normalizedPackageRoot,
+        globalNodeModules: normalizedGlobalNodeModules,
+        npmPrefix: normalizedNpmPrefix,
     };
 }

package/dist/daemon-update-eligibility.js

@@ -1,11 +1,14 @@
 import { access } from "node:fs/promises";
 import { constants } from "node:fs";
+import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { daemonHome, loadProfile, resolveAgentsRoot } from "./computer-profile.js";
 import { builtDaemonEntry } from "./computer-cli.js";
 import { buildServiceSpec, readServiceDescriptor, serviceStatus, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 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";
 function defaults() {
     return {
@@ -22,16 +25,35 @@ function defaults() {
         serviceStatus,
         assertWritable: (path) => access(path, constants.W_OK),
         installationLeaseHeld: daemonInstallationLeaseHeld,
+        installationRealpath: realpathSync.native,
+        inspectWindowsServiceUpdateScope,
+        inspectLegacyDescriptorInstallation: (descriptorPath) => inspectLegacyServiceInstallation(descriptorPath, process.platform, homedir(), process.getuid?.()),
     };
 }
+async function registryCoversUpdateScope(services, descriptorPaths, targetDescriptorPath, npmPrefix, inspectLegacyDescriptorInstallation) {
+    for (const descriptorPath of descriptorPaths) {
+        if (descriptorPath === targetDescriptorPath)
+            continue;
+        try {
+            assertRegistryCoversDescriptors(services, [descriptorPath]);
+            continue;
+        }
+        catch {
+            const legacy = await inspectLegacyDescriptorInstallation(descriptorPath).catch(() => null);
+            if (legacy === null || legacy.npmPrefix === npmPrefix)
+                return false;
+        }
+    }
+    return true;
+}
 export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
     const deps = { ...defaults(), ...overrides };
-    if (deps.platform !== "darwin" && deps.platform !== "linux") {
+    if (deps.platform !== "darwin" && deps.platform !== "linux" && deps.platform !== "win32") {
         return { eligible: false, reason: "unsupported_platform" };
     }
     if (!profileName)
         return { eligible: false, reason: "profile_required" };
-    const installation = daemonGlobalInstallation(deps.entryPath, deps.platform);
+    const installation = daemonGlobalInstallation(deps.entryPath, deps.platform, deps.installationRealpath);
     if (installation === null)
         return { eligible: false, reason: "global_install_required" };
     let profile;
@@ -53,6 +75,33 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         entryPath: deps.entryPath,
         profileHome: deps.profileHome,
     });
+    if (deps.platform === "win32") {
+        const scope = await deps.inspectWindowsServiceUpdateScope(spec, installation.npmPrefix)
+            .catch(() => ({ valid: false }));
+        if (!scope.valid) {
+            return { eligible: false, reason: "managed_service_identity_mismatch" };
+        }
+        if (!scope.running)
+            return { eligible: false, reason: "service_not_running" };
+        if (!scope.processIdentity) {
+            return { eligible: false, reason: "managed_service_identity_mismatch" };
+        }
+        if (!deps.installationLeaseHeld(installation.npmPrefix)) {
+            return { eligible: false, reason: "installation_lease_missing" };
+        }
+        try {
+            await deps.assertWritable(installation.globalNodeModules);
+        }
+        catch {
+            return { eligible: false, reason: "global_root_not_writable" };
+        }
+        return {
+            eligible: true,
+            profileName,
+            ...installation,
+            serviceSpec: { ...spec, runtimeProcessIdentity: scope.processIdentity },
+        };
+    }
     let selectedSpec = spec;
     let status = await deps.serviceStatus(spec);
     let services;
@@ -65,10 +114,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
     const registered = services.find((record) => record.serviceId === spec.id
         || (record.daemonHome === deps.profileHome && record.profile === profileName));
     if (registered !== undefined) {
-        try {
-            assertRegistryCoversDescriptors(services, await deps.listManagedDescriptorPaths());
-        }
-        catch {
+        if (!await registryCoversUpdateScope(services, await deps.listManagedDescriptorPaths(), spec.descriptorPath, installation.npmPrefix, deps.inspectLegacyDescriptorInstallation)) {
             return { eligible: false, reason: "managed_service_registry_incomplete" };
         }
         const descriptor = await deps.readServiceDescriptor(spec).catch(() => null);
@@ -109,12 +155,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         if (legacyDescriptor !== legacySpec.descriptor) {
             return { eligible: false, reason: "managed_service_not_registered" };
         }
-        try {
-            const descriptorPaths = await deps.listManagedDescriptorPaths();
-            const targetPath = legacySpec.descriptorPath;
-            assertRegistryCoversDescriptors(services, descriptorPaths.filter((descriptorPath) => descriptorPath !== targetPath));
-        }
-        catch {
+        if (!await registryCoversUpdateScope(services, await deps.listManagedDescriptorPaths(), legacySpec.descriptorPath, installation.npmPrefix, deps.inspectLegacyDescriptorInstallation)) {
             return { eligible: false, reason: "managed_service_registry_incomplete" };
         }
         status = await deps.serviceStatus(legacySpec);

package/dist/daemon-updater.js

@@ -48,7 +48,7 @@ export async function installExactDaemonUpdate(input) {
         await release();
         return { ok: false, errorCode: "install_failed" };
     }
-    const result = await runner(process.platform === "win32" ? "npm.cmd" : "npm", [
+    const result = await runner((input.platform ?? process.platform) === "win32" ? "npm.cmd" : "npm", [
         "install",
         "--global",
         "--prefix",

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"