@sagentlab/navarch-runtime 0.1.6 → 0.1.8

package/README.md

@@ -24,7 +24,7 @@ git clone <this repo> && cd sagentlab/runtime
 ./install.sh          # checks node, npm install, npm run build
 export NAVARCH_API_BASE=https://navarch.example.com
 node bin/navarch.cjs register --token <enrollment-token> --name my-machine-1
-node bin/navarch.cjs start
+node bin/navarch.cjs supervise
 ```
 
 Or, once dependencies are installed:
@@ -32,7 +32,7 @@ Or, once dependencies are installed:
 ```sh
 npm run build
 NAVARCH_API_BASE=https://navarch.example.com npm run register -- --token <enrollment-token> --name my-machine-1
-npm start
+npm run supervise
 ```
 
 `register` is the one command that prints the machine's auth token — exactly
@@ -61,7 +61,7 @@ project only (it will never be dispatched work from any other project).
 ```sh
 npx @sagentlab/navarch-runtime connect --token flmt_<...> --project <project-id> \
     --name my-agent-1 --agent codex --api-base https://navarch.example.com
-node bin/navarch.cjs start
+npx @sagentlab/navarch-runtime supervise
 ```
 
 (`@sagentlab/navarch-runtime` is published to npm, so `npx
@@ -76,6 +76,7 @@ The from-source flow — `git clone` + `./install.sh` + `node bin/navarch.cjs
 | `register --token <t> --name <n> [--agent claude-code\|codex] […]` | Registers this machine, saves its local agent choice, and prints the token once. |
 | `connect --token <t> --name <n> [--agent claude-code\|codex] [--project <id>] […]` | Connects this machine to one project, saves its local agent choice, and prints the token once. |
 | `start [--agent claude-code\|codex]` | Runs the daemon. A start-time agent choice overrides the saved choice. |
+| `supervise [--agent claude-code\|codex]` | Runs the daemon under the update supervisor, enabling drain-safe automatic updates and rollback. |
 | `doctor` | Prints resolved config + Docker/registration status; no side effects. |
 
 ## Active-task guidance
@@ -102,13 +103,49 @@ The daemon logs `restarting the agent turn in the same worktree` when it
 delivers guidance. Lowering the lease-heartbeat interval makes guidance arrive
 sooner, but keep it comfortably below the 15-minute lease TTL.
 
-## Safely upgrading and restarting the daemon
-
-The daemon does not currently drain sessions during shutdown: `SIGINT` or
-`SIGTERM` stops new claims and heartbeats, then exits immediately. Stopping it
-with an active session can interrupt the agent before it reports completion;
-the control plane must then wait for the lease to expire and requeue the task.
-Do not use an ordinary daemon restart as a way to deliver guidance.
+## Automatic and manual runtime upgrades
+
+Run long-lived agents with `navarch-runtime supervise`. The worker advertises
+its package version and updater protocol on each machine heartbeat. When the
+control plane assigns an eligible release, it:
+
+1. Downloads the exact `@sagentlab/navarch-runtime@<version>` tarball with npm
+   lifecycle scripts disabled and verifies the control-plane-recorded SHA-512
+   integrity.
+2. Stages it under `$NAVARCH_CONFIG_DIR/versions/<version>` while existing
+   sessions continue.
+3. Stops claiming, reports zero available capacity, and waits for both an
+   in-flight claim and every active session to finish.
+4. Atomically writes `pending-update.json` and exits with the supervisor-only
+   handoff code. The supervisor starts the staged binary with the same config
+   directory and machine identity.
+5. Commits the activation after the replacement completes its first successful
+   heartbeat, persisting `active-runtime.json` so machine restarts keep using
+   the verified release. A crash or two-minute health timeout before then
+   restores the previous binary.
+
+The control plane never supplies a package name, URL, path, or shell command:
+only an exact semver and npm SHA-512 integrity for the fixed package name are
+accepted. Rollouts are assigned by the machine's server-managed `stable` or
+`canary` channel and deterministic rollout percentage. Set
+`NAVARCH_AUTO_UPDATE=off` to keep telemetry but disable automatic activation.
+
+Plain `navarch-runtime start` continues to work and reports available releases,
+but deliberately does not activate them because no parent process would exist
+to perform a safe handoff or rollback.
+
+After publishing a runtime, an operator records the immutable npm metadata in
+`runtime_releases`. Obtain the integrity with
+`npm view @sagentlab/navarch-runtime@<version> dist.integrity`, then insert the
+exact version, returned integrity, release channel, and desired rollout
+percentage. Start with `channel='canary'` or a small `rollout_percent`; raising
+the percentage keeps existing machines in the same deterministic cohort.
+
+### Manual fallback
+
+`SIGINT` or `SIGTERM` now stops new claims and drains active sessions before
+exiting. A second signal forces an immediate exit and can interrupt work, so use
+it only when abandoning the active leases is intentional.
 
 Use this sequence for an upgrade:
 
@@ -158,8 +195,10 @@ unchanged across the deployment.
 | `NAVARCH_SANDBOX_MODE` | `host` | `host` uses the resources already available to the agent process. Set `docker` explicitly for container isolation. |
 | `NAVARCH_DOCKER_IMAGE` | `node:20-slim` | Image used for the per-session container. |
 | `NAVARCH_AGENT` | saved choice, then `claude-code` | Local choice of agent CLI: `claude-code` or `codex`. Overrides the choice saved by `connect`/`register`; `start --agent` has highest priority. |
+| `NAVARCH_UPDATE_CHANNEL` | `stable` | Release channel advertised by the worker (`stable` or `canary`); the server-managed machine channel remains authoritative. |
+| `NAVARCH_AUTO_UPDATE` | on under `supervise` | Set `off`, `false`, or `0` to report releases without staging or activating them. Automatic activation is always off under plain `start`. |
 | `NAVARCH_CLAUDE_BIN` | `claude` | Path/name of the Claude Code CLI binary. |
-| `NAVARCH_CLAUDE_EXTRA_ARGS` | — | Comma list of extra CLI args appended after `--mcp-config` (Claude Code). Supplying an explicit permission flag such as `--allowedTools` or `--permission-mode` replaces the unattended session's default `--dangerously-skip-permissions`. |
+| `NAVARCH_CLAUDE_EXTRA_ARGS` | — | Comma list of extra CLI args appended after `--mcp-config` (Claude Code). `--allowedTools`/`--disallowedTools` layer rules onto auto mode; an explicit `--permission-mode`, `--permission-prompt-tool`, or bypass flag replaces the unattended default `--permission-mode auto`. |
 | `NAVARCH_CODEX_BIN` | `codex` | Path/name of the Codex CLI binary. |
 | `NAVARCH_CODEX_EXTRA_ARGS` | — | Comma list of extra CLI args appended after the generated MCP `-c` overrides and `--json` (Codex). |
 | `NAVARCH_MCP_CONFIG_PATH` | — | Path to the platform MCP config passed as `--mcp-config`. |
@@ -172,13 +211,16 @@ A machine typically runs several sessions concurrently (`NAVARCH_MAX_SESSIONS`),
 each in its own git worktree. The runtime enforces the same boundary for both
 supported coding agents, using each CLI's native enforcement point:
 
-- **Claude Code:** permission bypass skips prompts but not hooks, so the
-  runtime generates a Claude settings file (`src/worktree-guard.cts`, passed
-  as `--settings`) that installs `bin/worktree-guard-hook.cjs` as a fail-closed
-  `PreToolUse` hook.
+- **Claude Code:** the runtime uses `--permission-mode auto`, which sends
+  approval decisions through Claude Code's background safety classifier. It
+  does not blanket-preapprove the lease-scoped Navarch MCP tools. A generated
+  settings file (`src/worktree-guard.cts`, passed as `--settings`) also installs
+  `bin/worktree-guard-hook.cjs` as a fail-closed `PreToolUse` boundary hook.
 - **Codex:** the runtime passes a one-off native permission profile with
-  `--ask-for-approval never`. Codex's OS sandbox grants read/write access only
-  to the allowed roots and denies the surrounding multi-session workspace.
+  `approval_policy="on-request"` and `approvals_reviewer="auto_review"`.
+  Codex's OS sandbox grants read/write access only to the allowed roots and
+  denies the surrounding multi-session workspace, while eligible escalations
+  are decided by the automatic reviewer rather than waiting for human input.
   `--ignore-user-config` and an untrusted project-config override prevent a
   user or checked-in legacy `sandbox_mode` from silently disabling the
   generated profile; Codex authentication still comes from `CODEX_HOME`, and
@@ -207,12 +249,14 @@ An operator-supplied `--settings` in `NAVARCH_CLAUDE_EXTRA_ARGS`, or an
 explicit Codex permission/sandbox option in `NAVARCH_CODEX_EXTRA_ARGS`, takes
 precedence over the generated policy.
 
-The full mechanism was verified live on 2026-07-19 against a real
-`claude -p --dangerously-skip-permissions --settings <generated file>` run:
-the `PreToolUse` hook fires under permission bypass, an in-worktree Read and
-`git --version` succeed, and a cross-session Read and a Bash redirect into a
-sibling session are both blocked with the guard's message (and nothing lands
-on disk).
+Claude auto mode requires Claude Code 2.1.83 or later and an eligible account,
+model, and first-party Anthropic API provider. If those requirements are not
+met, Claude Code rejects auto mode instead of silently bypassing checks.
+
+The auto-review launch paths were verified live on 2026-07-20 with Claude Code
+2.1.214 (`--permission-mode auto`) and Codex CLI 0.144.1 (the generated
+permission profile plus `approvals_reviewer="auto_review"`). Both completed an
+unattended smoke task successfully.
 
 ## Choosing an agent (Claude Code vs. Codex)
 
@@ -263,7 +307,7 @@ envelope as a compatibility fallback.
 cli.cts
  ├─ register            → api.registerMachine()      → machine-store.cts (writes machine.json once)
  ├─ connect             → api.connectMachine()       → machine-store.cts (writes machine.json once)
- └─ start
+ ├─ start
      ├─ MachineHeartbeatLoop   (heartbeat-loop.cts)   → api.machineHeartbeat()   [every NAVARCH_HEARTBEAT_INTERVAL_MS]
      └─ ClaimLoop              (claim-loop.cts)        → api.claim()             [every NAVARCH_POLL_INTERVAL_MS, gated by CapacityTracker]
           └─ runSession (session.cts), one per claimed lease, run concurrently up to NAVARCH_MAX_SESSIONS:
@@ -282,6 +326,10 @@ cli.cts
                6. api.completeLease(), reporting agent_type: config.agentType
                7. sandbox.wipe() when present; remove the session workspace
                   unconditionally (finally block)
+ └─ supervise                  → supervisor.cts starts the worker with IPC
+      └─ update directive      → update-installer.cts stages exact npm release
+           └─ drain + exit 75  → supervisor activates candidate, waits for
+                                 healthy heartbeat, or rolls back
 ```
 
 `adapter.cts` (top-level) is now a backward-compat re-export of

package/bin/worktree-guard-hook.cjs

@@ -8,12 +8,11 @@
  * Multiple sessions run concurrently on one machine (claim-loop.cts), each
  * confined by convention to its own git worktree
  * (`<workspaceRoot>/sessions/<sessionId>/repo` — git-worktree.cts). The
- * adapter launches Claude with --dangerously-skip-permissions (adapters/
- * claude.cts), which bypasses permission prompts but NOT hooks: Claude Code
- * runs PreToolUse hooks in every permission mode, so this script is the
- * enforcement point that keeps an agent from reading or writing another
- * session's worktree, the operator's home directory, or anything else
- * unrelated to its task.
+ * adapter launches Claude in auto permission mode (adapters/claude.cts).
+ * Claude Code runs PreToolUse hooks in every permission mode, so this script
+ * is the enforcement point that keeps an agent from reading or writing
+ * another session's worktree, the operator's home directory, or anything
+ * else unrelated to its task.
  *
  * Protocol (Claude Code hooks): the hook receives {tool_name, tool_input,
  * cwd, ...} as JSON on stdin. Exit 0 allows the tool call; exit 2 blocks it

package/dist/adapters/claude.cjs

@@ -4,17 +4,6 @@ exports.claudeCodeAdapter = void 0;
 exports.runClaudeCodeAdapter = runClaudeCodeAdapter;
 const node_child_process_1 = require("node:child_process");
 const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
-const NAVARCH_MCP_ALLOWED_TOOLS = [
-    "mcp__navarch__task_comment",
-    "mcp__navarch__record_decision",
-    "mcp__navarch__request_approval",
-    "mcp__navarch__register_resource",
-    "mcp__navarch__create_task",
-    "mcp__navarch__list_triage_tasks",
-    "mcp__navarch__groom_triage_task",
-    "mcp__navarch__defer_triage_task",
-    "mcp__navarch__file_pr_review",
-];
 /**
  * Headless Claude Code adapter (project-plan.md §3.9 / implementation-plan.md
  * WP-07): `claude -p "<context bundle>" --mcp-config platform-mcp.json
@@ -37,28 +26,18 @@ const NAVARCH_MCP_ALLOWED_TOOLS = [
  */
 async function runClaudeCodeAdapter(options) {
     const args = ["-p", options.prompt];
-    const hasExplicitPermissionPolicy = options.extraArgs.some((arg) => [
-        "--allowedTools",
-        "--allowed-tools",
-        "--disallowedTools",
-        "--disallowed-tools",
-        "--permission-mode",
-        "--permission-prompt-tool",
-        "--dangerously-skip-permissions",
-    ].includes(arg));
-    // Navarch sessions are unattended: a permission prompt can never be
-    // answered and leaves Claude unable to edit the task's isolated worktree.
-    // The runtime owns that worktree (and, in Docker mode, the surrounding
-    // container), so make the non-interactive session capable of completing
-    // coding tasks by default. Operators can replace this with a narrower
-    // Claude permission policy through NAVARCH_CLAUDE_EXTRA_ARGS.
-    if (!hasExplicitPermissionPolicy) {
-        args.push("--dangerously-skip-permissions");
+    const hasExplicitPermissionMode = options.extraArgs.some((arg) => ["--permission-mode", "--permission-prompt-tool", "--dangerously-skip-permissions"].some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
+    // Navarch sessions are unattended, so route permission decisions through
+    // Claude Code's native auto-mode classifier instead of prompting a human or
+    // bypassing checks. Operators can replace this with a different permission
+    // policy through NAVARCH_CLAUDE_EXTRA_ARGS.
+    if (!hasExplicitPermissionMode) {
+        args.push("--permission-mode", "auto");
     }
     // The worktree-guard settings file (worktree-guard.cts) installs the
-    // PreToolUse boundary hook. Hooks run even under permission bypass, so this
-    // is what keeps an unattended session inside its own worktree on a machine
-    // running several agents. An operator-supplied --settings (via
+    // PreToolUse boundary hook. Hooks run in auto mode, so this remains a
+    // fail-closed boundary around each worktree on a machine running several
+    // agents. An operator-supplied --settings (via
     // NAVARCH_CLAUDE_EXTRA_ARGS) wins — two --settings flags on one invocation
     // would be ambiguous, and session.cts logs the guard as skipped.
     if (options.settingsPath && !options.extraArgs.includes("--settings")) {
@@ -66,14 +45,9 @@ async function runClaudeCodeAdapter(options) {
     }
     if (options.mcpConfigPath) {
         args.push("--mcp-config", options.mcpConfigPath);
-        // The Navarch server scopes every call to the authenticated lease and
-        // enforces task/project authorization. Keep its tools explicit for
-        // operator-supplied policies and for compatibility with Claude versions
-        // that still inspect allowedTools while permission bypass is active.
-        if (!options.extraArgs.includes("--allowedTools") &&
-            !options.extraArgs.includes("--allowed-tools")) {
-            args.push("--allowedTools", NAVARCH_MCP_ALLOWED_TOOLS.join(","));
-        }
+        // Do not blanket-preapprove Navarch MCP tools: auto mode should review
+        // their side effects too. Operators can still add an explicit
+        // --allowedTools policy through NAVARCH_CLAUDE_EXTRA_ARGS.
     }
     // Only append the default when the caller hasn't already asked for a
     // specific --output-format (extraArgs wins so an operator can opt back

package/dist/adapters/codex.cjs

@@ -32,10 +32,11 @@ const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
  *   variables so machine/lease credentials never appear in argv.
  * - Host-mode sessions use a generated native Codex permission profile that
  *   denies reads and writes outside the session worktree, shared Git dir,
- *   temp dirs, and operator-approved extra roots. It also uses `--ask-for-
- *   approval never`, so a boundary violation fails back to the unattended
- *   agent instead of waiting for input. Explicit permission-policy arguments
- *   in NAVARCH_CODEX_EXTRA_ARGS replace that generated profile.
+ *   temp dirs, and operator-approved extra roots. Interactive approval
+ *   requests use `approval_policy="on-request"` with the native automatic
+ *   reviewer, so unattended sessions retain safety review without waiting for
+ *   human input. Explicit permission-policy arguments in
+ *   NAVARCH_CODEX_EXTRA_ARGS replace that generated profile.
  * - `NAVARCH_CODEX_EXTRA_ARGS` (`extraArgs`) wins over the default `--json`
  *   exactly like the Claude adapter's `--output-format` opt-out, so an
  *   operator can fall back to plain-text output (or add the real

package/dist/capacity.cjs

@@ -14,6 +14,7 @@ function computeAvailableCapacity(maxSessions, activeSessions) {
 class CapacityTracker {
     maxSessions;
     active = new Set();
+    idleWaiters = new Set();
     constructor(maxSessions) {
         this.maxSessions = maxSessions;
     }
@@ -36,6 +37,17 @@ class CapacityTracker {
     }
     release(sessionId) {
         this.active.delete(sessionId);
+        if (this.active.size === 0) {
+            for (const resolve of this.idleWaiters)
+                resolve();
+            this.idleWaiters.clear();
+        }
+    }
+    /** Resolves once every acquired lease has finished and released its slot. */
+    waitForIdle() {
+        if (this.active.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
     }
 }
 exports.CapacityTracker = CapacityTracker;

package/dist/claim-loop.cjs

@@ -20,6 +20,7 @@ class ClaimLoop {
     timer = null;
     stopped = false;
     claimInFlight = false;
+    quiescenceWaiters = new Set();
     constructor(api, config, capacity, runSession) {
         this.api = api;
         this.config = config;
@@ -29,6 +30,7 @@ class ClaimLoop {
     start() {
         if (this.timer)
             return;
+        this.stopped = false;
         this.timer = setInterval(() => void this.tick(), this.config.pollIntervalMs);
     }
     stop() {
@@ -36,6 +38,18 @@ class ClaimLoop {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = null;
+        this.resolveQuiescenceWaiters();
+    }
+    /**
+     * Stops new polls and waits for a claim request already on the wire to
+     * settle. If that request returns a lease, the session is still run; callers
+     * must then wait for CapacityTracker.waitForIdle() before restarting.
+     */
+    async drain() {
+        this.stop();
+        if (!this.claimInFlight)
+            return;
+        await new Promise((resolve) => this.quiescenceWaiters.add(resolve));
     }
     async tick() {
         if (this.stopped || this.claimInFlight || !this.capacity.hasCapacity())
@@ -75,7 +89,15 @@ class ClaimLoop {
         }
         finally {
             this.claimInFlight = false;
+            this.resolveQuiescenceWaiters();
         }
     }
+    resolveQuiescenceWaiters() {
+        if (this.claimInFlight)
+            return;
+        for (const resolve of this.quiescenceWaiters)
+            resolve();
+        this.quiescenceWaiters.clear();
+    }
 }
 exports.ClaimLoop = ClaimLoop;

package/dist/cli.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const config_cjs_1 = require("./config.cjs");
+const node_crypto_1 = require("node:crypto");
 const machine_store_cjs_1 = require("./machine-store.cjs");
 const api_cjs_1 = require("./api.cjs");
 const capacity_cjs_1 = require("./capacity.cjs");
@@ -10,6 +11,8 @@ const claim_loop_cjs_1 = require("./claim-loop.cjs");
 const session_cjs_1 = require("./session.cjs");
 const sandbox_cjs_1 = require("./sandbox.cjs");
 const logger_cjs_1 = require("./logger.cjs");
+const update_coordinator_cjs_1 = require("./update-coordinator.cjs");
+const supervisor_cjs_1 = require("./supervisor.cjs");
 const log = (0, logger_cjs_1.createLogger)("cli");
 const PACKAGE_NAME = "@sagentlab/navarch-runtime";
 /**
@@ -99,7 +102,7 @@ async function registerCommand(flags) {
     console.log("Machine registered.");
     console.log(`  machine_id: ${result.machine_id}`);
     console.log(`  token:      ${result.token}`);
-    console.log(`\nStored in ${config.configDir}/machine.json (mode 0600). Run \`${invocation("start")}\` to begin serving tasks.`);
+    console.log(`\nStored in ${config.configDir}/machine.json (mode 0600). Run \`${invocation("supervise")}\` to begin serving tasks.`);
 }
 /**
  * `navarch-runtime connect` — "Connect an agent to a project"
@@ -147,7 +150,7 @@ async function connectCommand(flags) {
     console.log("Machine connected.");
     console.log(`  machine_id: ${result.machine_id}`);
     console.log(`  token:      ${result.token}`);
-    console.log(`\nStored in ${config.configDir}/machine.json (mode 0600). Run \`${invocation("start")}\` to begin serving tasks.`);
+    console.log(`\nStored in ${config.configDir}/machine.json (mode 0600). Run \`${invocation("supervise")}\` to begin serving tasks.`);
 }
 async function startCommand(flags) {
     const baseConfig = (0, config_cjs_1.loadRuntimeConfig)();
@@ -160,20 +163,52 @@ async function startCommand(flags) {
     const config = { ...baseConfig, agentType };
     const api = new api_cjs_1.NavarchApiClient({ baseUrl: identity.api_base, token: identity.token });
     const capacity = new capacity_cjs_1.CapacityTracker(config.maxSessions);
-    const heartbeat = new heartbeat_loop_cjs_1.MachineHeartbeatLoop(api, identity.machine_id, config, capacity);
     const claimLoop = new claim_loop_cjs_1.ClaimLoop(api, config, capacity, (claimed, sessionId) => (0, session_cjs_1.runSession)({ api, config }, claimed, sessionId));
+    const bootId = (0, node_crypto_1.randomUUID)();
+    const updateCoordinatorRef = {};
+    let readySent = false;
+    const heartbeat = new heartbeat_loop_cjs_1.MachineHeartbeatLoop(api, identity.machine_id, config, capacity, bootId, (result) => updateCoordinatorRef.current?.consider(result.update), () => {
+        if (!readySent && process.send) {
+            readySent = true;
+            process.send({ type: "navarch-ready", boot_id: bootId });
+        }
+    });
+    updateCoordinatorRef.current = new update_coordinator_cjs_1.RuntimeUpdateCoordinator({
+        config,
+        claimLoop,
+        capacity,
+        heartbeat,
+    });
     heartbeat.start();
     claimLoop.start();
     log.info(`navarch-runtime started: machine=${identity.name} agent=${config.agentType} max_sessions=${config.maxSessions} api_base=${identity.api_base}`);
+    let shuttingDown = false;
     const shutdown = () => {
-        log.info("shutting down...");
-        heartbeat.stop();
-        claimLoop.stop();
-        process.exit(0);
+        if (shuttingDown) {
+            log.warn("second shutdown signal received; forcing exit with active work");
+            process.exit(1);
+        }
+        shuttingDown = true;
+        void (async () => {
+            log.info("shutting down: draining active sessions...");
+            heartbeat.setUpdateState("draining");
+            await claimLoop.drain();
+            await capacity.waitForIdle();
+            heartbeat.stop();
+            log.info("shutdown drain complete");
+            process.exit(0);
+        })();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
 }
+async function superviseCommand(flags) {
+    const config = (0, config_cjs_1.loadRuntimeConfig)();
+    const agentType = agentFromFlag(flags);
+    const workerArgs = agentType ? ["--agent", agentType] : [];
+    const exitCode = await (0, supervisor_cjs_1.superviseRuntime)(config.configDir, process.argv[1] ?? "", workerArgs);
+    process.exitCode = exitCode;
+}
 async function doctorCommand(flags) {
     const config = (0, config_cjs_1.loadRuntimeConfig)();
     const dockerOk = await (0, sandbox_cjs_1.isDockerAvailable)();
@@ -206,6 +241,7 @@ Usage:
   navarch-runtime connect --token <enrollment-token> --name <machine-name> \\
       [--agent claude-code|codex] [--project <project-id>] [--capabilities a,b] [--max-sessions N] [--api-base url]
   navarch-runtime start [--agent claude-code|codex]
+  navarch-runtime supervise [--agent claude-code|codex]
   navarch-runtime doctor
 
 Configuration is via NAVARCH_* environment variables; see runtime/README.md.
@@ -224,6 +260,9 @@ async function main(argv = process.argv.slice(2)) {
             case "start":
                 await startCommand(flags);
                 break;
+            case "supervise":
+                await superviseCommand(flags);
+                break;
             case "doctor":
                 await doctorCommand(flags);
                 break;

package/dist/config.cjs

@@ -67,5 +67,8 @@ function loadRuntimeConfig(env = process.env) {
             .split(node_path_1.default.delimiter)
             .map((s) => s.trim())
             .filter(Boolean),
+        updateChannel: env.NAVARCH_UPDATE_CHANNEL === "canary" ? "canary" : "stable",
+        autoUpdate: env.NAVARCH_SUPERVISED === "1" &&
+            !["off", "false", "0"].includes(env.NAVARCH_AUTO_UPDATE ?? ""),
     };
 }

package/dist/git-worktree.cjs

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitWorktree = void 0;
+exports.branchSlug = branchSlug;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = require("node:fs");
 const sandbox_cjs_1 = require("./sandbox.cjs");
@@ -28,7 +29,7 @@ class GitWorktree {
         this.sessionRoot = node_path_1.default.join(options.workspaceRoot, "sessions", sessionKey);
         this.worktreePath = node_path_1.default.join(this.sessionRoot, "repo");
         this.repositoryPath = node_path_1.default.join(options.workspaceRoot, "repositories", `${projectKey}.git`);
-        this.branch = `navarch/${safePathSegment(options.taskId).slice(0, 32)}-${sessionKey.slice(0, 12)}`;
+        this.branch = `navarch/${branchSlug(options)}-${sessionKey.toLowerCase().slice(0, 8)}`;
         this.runner = options.runner ?? sandbox_cjs_1.nodeCommandRunner;
         this.cloneUrl = options.cloneUrl;
         this.githubToken = options.githubToken;
@@ -87,6 +88,8 @@ class GitWorktree {
     async runGit(args, authenticated) {
         const credentialArgs = authenticated && this.githubToken
             ? [
+                "-c",
+                "credential.helper=",
                 "-c",
                 'credential.helper=!f() { echo username=x-access-token; echo "password=$GITHUB_TOKEN"; }; f',
             ]
@@ -130,6 +133,32 @@ async function pathExists(value) {
         return false;
     }
 }
+/**
+ * Kebab-case slug for the session branch, derived from the task summary so
+ * branch names read like `navarch/fix-login-redirect-a1b2c3d4` instead of a
+ * UUID mash. Falls back to the task type, then a task-id prefix, when the
+ * summary yields nothing. Output contains only [a-z0-9-] with no leading or
+ * trailing dash, so it is always a valid git ref component (no `..`, no
+ * trailing `.lock`).
+ */
+function branchSlug(options) {
+    for (const candidate of [options.taskSummary, options.taskType]) {
+        const slug = (candidate ?? "")
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+/, "")
+            .slice(0, 40)
+            .replace(/-+$/, "");
+        if (slug)
+            return slug;
+    }
+    const idSlug = safePathSegment(options.taskId)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .slice(0, 8)
+        .replace(/^-+|-+$/g, "");
+    return idSlug || "task";
+}
 function safePathSegment(value) {
     const safe = value.replace(/[^A-Za-z0-9_.-]/g, "-").replace(/^-+|-+$/g, "");
     if (!safe)

package/dist/heartbeat-loop.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MachineHeartbeatLoop = void 0;
+const version_cjs_1 = require("./version.cjs");
 const logger_cjs_1 = require("./logger.cjs");
 const log = (0, logger_cjs_1.createLogger)("heartbeat");
 /**
@@ -14,12 +15,21 @@ class MachineHeartbeatLoop {
     machineId;
     config;
     capacity;
+    bootId;
+    onResult;
+    onHealthy;
     timer = null;
-    constructor(api, machineId, config, capacity) {
+    updateState = "idle";
+    lastUpdateError;
+    draining = false;
+    constructor(api, machineId, config, capacity, bootId, onResult, onHealthy) {
         this.api = api;
         this.machineId = machineId;
         this.config = config;
         this.capacity = capacity;
+        this.bootId = bootId;
+        this.onResult = onResult;
+        this.onHealthy = onHealthy;
     }
     start() {
         if (this.timer)
@@ -32,12 +42,28 @@ class MachineHeartbeatLoop {
             clearInterval(this.timer);
         this.timer = null;
     }
+    setUpdateState(state, error) {
+        this.updateState = state;
+        this.lastUpdateError = error;
+        this.draining = state === "draining";
+        void this.tick();
+    }
     async tick() {
         try {
-            await this.api.machineHeartbeat(this.machineId, {
-                available_capacity: this.capacity.available(),
+            const result = await this.api.machineHeartbeat(this.machineId, {
+                available_capacity: this.draining ? 0 : this.capacity.available(),
                 capabilities: this.config.capabilities,
+                runtime: {
+                    version: version_cjs_1.RUNTIME_VERSION,
+                    updater_protocol: version_cjs_1.UPDATER_PROTOCOL_VERSION,
+                    channel: this.config.updateChannel,
+                    state: this.updateState,
+                    boot_id: this.bootId,
+                    ...(this.lastUpdateError ? { last_update_error: this.lastUpdateError } : {}),
+                },
             });
+            this.onHealthy?.();
+            this.onResult?.(result);
         }
         catch (err) {
             log.warn(`machine heartbeat failed: ${String(err)}`);

package/dist/session.cjs

@@ -92,6 +92,8 @@ async function runSession(deps, claimed, sessionId) {
         workspaceRoot: config.workspaceRoot,
         projectId: task.project_id,
         taskId: task.id,
+        taskSummary: task.summary,
+        taskType: task.task_type,
         sessionId,
         cloneUrl,
         githubToken,

package/dist/supervisor.cjs

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superviseRuntime = superviseRuntime;
+const node_child_process_1 = require("node:child_process");
+const logger_cjs_1 = require("./logger.cjs");
+const update_installer_cjs_1 = require("./update-installer.cjs");
+const log = (0, logger_cjs_1.createLogger)("supervisor");
+const UPDATE_RESTART_EXIT_CODE = 75;
+function runWorker(binPath, args, healthTimeoutMs, setCurrentChild, onHealthy) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(process.execPath, [binPath, "start", ...args], {
+            env: { ...process.env, NAVARCH_SUPERVISED: "1" },
+            stdio: ["inherit", "inherit", "inherit", "ipc"],
+        });
+        setCurrentChild(child);
+        let healthy = false;
+        let healthSignalReceived = false;
+        let healthTimedOut = false;
+        let healthCommit = Promise.resolve();
+        let healthTimer = null;
+        let forceKillTimer = null;
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (healthTimer)
+                clearTimeout(healthTimer);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            setCurrentChild(null);
+            void healthCommit.finally(() => resolve({ code, healthy }));
+        };
+        if (healthTimeoutMs !== null) {
+            healthTimer = setTimeout(() => {
+                if (!healthy) {
+                    healthTimedOut = true;
+                    log.error("updated runtime missed its startup health deadline; rolling back");
+                    child.kill("SIGTERM");
+                    forceKillTimer = setTimeout(() => child.kill("SIGKILL"), 10_000);
+                }
+            }, healthTimeoutMs);
+        }
+        child.on("message", (message) => {
+            if (!healthSignalReceived &&
+                !healthTimedOut &&
+                typeof message === "object" &&
+                message !== null &&
+                message.type === "navarch-ready") {
+                healthSignalReceived = true;
+                healthCommit = onHealthy()
+                    .then(() => {
+                    healthy = true;
+                    if (healthTimer)
+                        clearTimeout(healthTimer);
+                    if (forceKillTimer)
+                        clearTimeout(forceKillTimer);
+                })
+                    .catch((error) => {
+                    log.error(`could not commit runtime activation: ${String(error)}`);
+                    child.kill("SIGTERM");
+                });
+            }
+        });
+        child.once("error", (error) => {
+            log.error(`could not start runtime worker: ${String(error)}`);
+            finish(1);
+        });
+        child.once("exit", (code) => finish(code ?? 1));
+    });
+}
+/** Runs the worker and owns update activation, health checking, and rollback. */
+async function superviseRuntime(configDir, initialBinPath, workerArgs = [], healthTimeoutMs = 120_000) {
+    let currentBin = initialBinPath;
+    let rollbackBin = null;
+    let candidatePending = null;
+    let awaitingCandidateHealth = false;
+    let currentChild = null;
+    let stopping = false;
+    const forwardSignal = (signal) => {
+        stopping = true;
+        currentChild?.kill(signal);
+    };
+    const onSigint = () => forwardSignal("SIGINT");
+    const onSigterm = () => forwardSignal("SIGTERM");
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    try {
+        const active = await (0, update_installer_cjs_1.readActiveRuntime)(configDir);
+        if (active) {
+            try {
+                const verified = await (0, update_installer_cjs_1.verifyManagedRuntime)(configDir, active);
+                currentBin = verified.bin_path;
+                log.info(`starting active managed runtime ${active.version}`);
+            }
+            catch (error) {
+                log.warn(`ignoring invalid active runtime pointer: ${String(error)}`);
+            }
+        }
+        while (!stopping) {
+            const candidateThisRun = awaitingCandidateHealth;
+            const result = await runWorker(currentBin, workerArgs, candidateThisRun ? healthTimeoutMs : null, (child) => {
+                currentChild = child;
+            }, async () => {
+                if (candidateThisRun) {
+                    if (!candidatePending)
+                        throw new Error("candidate has no pending release metadata");
+                    await (0, update_installer_cjs_1.writeActiveRuntime)(configDir, candidatePending);
+                    await (0, update_installer_cjs_1.clearPendingUpdate)(configDir);
+                    awaitingCandidateHealth = false;
+                    rollbackBin = null;
+                    candidatePending = null;
+                    log.info("updated runtime reported healthy; activation committed");
+                }
+            });
+            if (stopping)
+                return result.code;
+            if (candidateThisRun && !result.healthy) {
+                if (!rollbackBin)
+                    return 1;
+                log.warn("updated runtime failed before becoming healthy; restoring previous version");
+                currentBin = rollbackBin;
+                rollbackBin = null;
+                awaitingCandidateHealth = false;
+                candidatePending = null;
+                await (0, update_installer_cjs_1.clearPendingUpdate)(configDir);
+                continue;
+            }
+            if (result.code !== UPDATE_RESTART_EXIT_CODE)
+                return result.code;
+            const pending = await (0, update_installer_cjs_1.readPendingUpdate)(configDir);
+            if (!pending) {
+                log.error("worker requested an update restart without a pending update");
+                return 1;
+            }
+            const verified = await (0, update_installer_cjs_1.verifyManagedRuntime)(configDir, pending);
+            rollbackBin = currentBin;
+            currentBin = verified.bin_path;
+            candidatePending = pending;
+            awaitingCandidateHealth = true;
+            log.info(`activating staged runtime ${pending.version}`);
+        }
+        return 0;
+    }
+    finally {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+    }
+}

package/dist/update-coordinator.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeUpdateCoordinator = void 0;
+const logger_cjs_1 = require("./logger.cjs");
+const update_installer_cjs_1 = require("./update-installer.cjs");
+const version_cjs_1 = require("./version.cjs");
+const log = (0, logger_cjs_1.createLogger)("update");
+class RuntimeUpdateCoordinator {
+    options;
+    targetInProgress = null;
+    warnedUnsupervised = false;
+    constructor(options) {
+        this.options = options;
+    }
+    consider(directive) {
+        if (!directive || directive.target_version === version_cjs_1.RUNTIME_VERSION)
+            return;
+        if (!this.options.config.autoUpdate) {
+            if (!this.warnedUnsupervised) {
+                log.warn(`runtime ${directive.target_version} is available; run under \`navarch-runtime supervise\` to activate updates automatically`);
+                this.warnedUnsupervised = true;
+            }
+            return;
+        }
+        if (this.targetInProgress)
+            return;
+        this.targetInProgress = directive.target_version;
+        void this.apply(directive);
+    }
+    async apply(directive) {
+        const { config, heartbeat, claimLoop, capacity } = this.options;
+        try {
+            heartbeat.setUpdateState("staging");
+            log.info(`staging runtime ${directive.target_version}`);
+            const staged = await (this.options.stage ?? update_installer_cjs_1.stageRuntimeUpdate)(config.configDir, directive);
+            heartbeat.setUpdateState("draining");
+            log.info("runtime update staged; draining active sessions before restart");
+            await claimLoop.drain();
+            await capacity.waitForIdle();
+            await (0, update_installer_cjs_1.writePendingUpdate)(config.configDir, staged, directive.rollout_id);
+            log.info(`runtime ${directive.target_version} ready; handing off to supervisor`);
+            (this.options.requestRestart ?? ((code) => process.exit(code)))(75);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.error(`runtime update failed: ${message}`);
+            heartbeat.setUpdateState("failed", message.slice(0, 500));
+            claimLoop.start();
+            this.targetInProgress = null;
+        }
+    }
+}
+exports.RuntimeUpdateCoordinator = RuntimeUpdateCoordinator;

package/dist/update-installer.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUpdateDirective = validateUpdateDirective;
+exports.stageRuntimeUpdate = stageRuntimeUpdate;
+exports.writePendingUpdate = writePendingUpdate;
+exports.readPendingUpdate = readPendingUpdate;
+exports.clearPendingUpdate = clearPendingUpdate;
+exports.writeActiveRuntime = writeActiveRuntime;
+exports.readActiveRuntime = readActiveRuntime;
+exports.assertSafePendingUpdate = assertSafePendingUpdate;
+exports.verifyManagedRuntime = verifyManagedRuntime;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const PACKAGE_NAME = "@sagentlab/navarch-runtime";
+const EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/;
+const SHA512_INTEGRITY = /^sha512-[A-Za-z0-9+/]+={0,2}$/;
+const defaultRunner = async (file, args) => {
+    const result = await execFileAsync(file, args, { maxBuffer: 10 * 1024 * 1024 });
+    return { stdout: result.stdout, stderr: result.stderr };
+};
+function validateUpdateDirective(directive) {
+    if (!EXACT_SEMVER.test(directive.target_version)) {
+        throw new Error(`Invalid runtime target version: ${directive.target_version}`);
+    }
+    if (!SHA512_INTEGRITY.test(directive.integrity)) {
+        throw new Error("Runtime update is missing a valid SHA-512 integrity value.");
+    }
+    if (!directive.rollout_id || directive.rollout_id.length > 128) {
+        throw new Error("Runtime update has an invalid rollout id.");
+    }
+}
+async function verifyInstalledPackage(packageDir, version, integrity) {
+    const manifest = JSON.parse(await node_fs_1.promises.readFile(node_path_1.default.join(packageDir, "package.json"), "utf8"));
+    if (manifest.name !== PACKAGE_NAME || manifest.version !== version) {
+        throw new Error("Staged runtime package identity did not match the requested release.");
+    }
+    const recordedIntegrity = (await node_fs_1.promises.readFile(node_path_1.default.join(packageDir, ".navarch-integrity"), "utf8")).trim();
+    if (recordedIntegrity !== integrity) {
+        throw new Error("Staged runtime integrity did not match the release directive.");
+    }
+    const binPath = node_path_1.default.join(packageDir, "bin", "navarch.cjs");
+    await node_fs_1.promises.access(binPath);
+    return { version, integrity, bin_path: binPath };
+}
+/** Downloads and verifies an exact immutable npm release without running package scripts. */
+async function stageRuntimeUpdate(configDir, directive, runner = defaultRunner) {
+    validateUpdateDirective(directive);
+    const versionsDir = node_path_1.default.join(configDir, "versions");
+    const targetDir = node_path_1.default.join(versionsDir, directive.target_version);
+    await node_fs_1.promises.mkdir(versionsDir, { recursive: true, mode: 0o700 });
+    try {
+        const staged = await verifyInstalledPackage(targetDir, directive.target_version, directive.integrity);
+        await runner(process.execPath, [staged.bin_path, "--help"]);
+        return staged;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await node_fs_1.promises.rm(targetDir, { recursive: true, force: true });
+    }
+    const stagingDir = node_path_1.default.join(versionsDir, `.staging-${(0, node_crypto_1.randomUUID)()}`);
+    const installDir = node_path_1.default.join(stagingDir, "install");
+    await node_fs_1.promises.mkdir(installDir, { recursive: true, mode: 0o700 });
+    try {
+        const packed = await runner("npm", [
+            "pack",
+            `${PACKAGE_NAME}@${directive.target_version}`,
+            "--json",
+            "--ignore-scripts",
+            "--pack-destination",
+            stagingDir,
+        ]);
+        const packResult = JSON.parse(packed.stdout);
+        const artifact = packResult[0];
+        if (!artifact ||
+            typeof artifact.filename !== "string" ||
+            artifact.integrity !== directive.integrity) {
+            throw new Error("Downloaded runtime tarball failed its release integrity check.");
+        }
+        const tarballPath = node_path_1.default.join(stagingDir, node_path_1.default.basename(artifact.filename));
+        await runner("npm", [
+            "install",
+            "--prefix",
+            installDir,
+            "--ignore-scripts",
+            "--omit=dev",
+            "--no-audit",
+            "--no-fund",
+            "--package-lock=false",
+            tarballPath,
+        ]);
+        const installedPackage = node_path_1.default.join(installDir, "node_modules", "@sagentlab", "navarch-runtime");
+        await node_fs_1.promises.writeFile(node_path_1.default.join(installedPackage, ".navarch-integrity"), `${directive.integrity}\n`, { mode: 0o600 });
+        await node_fs_1.promises.rename(installedPackage, targetDir);
+        const staged = await verifyInstalledPackage(targetDir, directive.target_version, directive.integrity);
+        await runner(process.execPath, [staged.bin_path, "--help"]);
+        return staged;
+    }
+    finally {
+        await node_fs_1.promises.rm(stagingDir, { recursive: true, force: true });
+    }
+}
+function pendingPath(configDir) {
+    return node_path_1.default.join(configDir, "pending-update.json");
+}
+function activePath(configDir) {
+    return node_path_1.default.join(configDir, "active-runtime.json");
+}
+async function writePendingUpdate(configDir, staged, rolloutId) {
+    const pending = { ...staged, rollout_id: rolloutId };
+    const tempPath = `${pendingPath(configDir)}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    await node_fs_1.promises.writeFile(tempPath, `${JSON.stringify(pending, null, 2)}\n`, { mode: 0o600 });
+    await node_fs_1.promises.rename(tempPath, pendingPath(configDir));
+}
+async function readPendingUpdate(configDir) {
+    try {
+        return JSON.parse(await node_fs_1.promises.readFile(pendingPath(configDir), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function clearPendingUpdate(configDir) {
+    await node_fs_1.promises.rm(pendingPath(configDir), { force: true });
+}
+async function writeActiveRuntime(configDir, pending) {
+    const active = { ...pending, activated_at: new Date().toISOString() };
+    const tempPath = `${activePath(configDir)}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    await node_fs_1.promises.writeFile(tempPath, `${JSON.stringify(active, null, 2)}\n`, { mode: 0o600 });
+    await node_fs_1.promises.rename(tempPath, activePath(configDir));
+}
+async function readActiveRuntime(configDir) {
+    try {
+        return JSON.parse(await node_fs_1.promises.readFile(activePath(configDir), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function assertSafePendingUpdate(configDir, pending) {
+    if (!EXACT_SEMVER.test(pending.version))
+        throw new Error("Pending update has an invalid version.");
+    const expectedBin = node_path_1.default.resolve(configDir, "versions", pending.version, "bin", "navarch.cjs");
+    if (node_path_1.default.resolve(pending.bin_path) !== expectedBin) {
+        throw new Error("Pending update executable is outside the managed versions directory.");
+    }
+}
+/** Re-verifies a persisted managed pointer before the supervisor executes it. */
+async function verifyManagedRuntime(configDir, runtime) {
+    assertSafePendingUpdate(configDir, runtime);
+    const packageDir = node_path_1.default.resolve(configDir, "versions", runtime.version);
+    return verifyInstalledPackage(packageDir, runtime.version, runtime.integrity);
+}

package/dist/version.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATER_PROTOCOL_VERSION = exports.RUNTIME_VERSION = void 0;
+// package.json is always included in an npm package, even though the runtime's
+// explicit `files` allowlist only names dist/bin/README.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const packageJson = require("../package.json");
+exports.RUNTIME_VERSION = typeof packageJson.version === "string" ? packageJson.version : "0.0.0-unknown";
+exports.UPDATER_PROTOCOL_VERSION = 1;

package/dist/worktree-guard.cjs

@@ -88,8 +88,12 @@ function codexWorktreeGuardArgs(options) {
     }
     return [
         "--ignore-user-config",
-        "--ask-for-approval",
-        "never",
+        // Keep approvals interactive at the policy layer, but route them to
+        // Codex's automatic reviewer because `codex exec` has no human available.
+        "-c",
+        'approval_policy="on-request"',
+        "-c",
+        'approvals_reviewer="auto_review"',
         "-c",
         `projects.${tomlString(node_path_1.default.resolve(options.worktreePath))}.trust_level="untrusted"`,
         "-c",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Navarch machine-side session manager: registers a machine, claims tasks from the control-plane dispatcher, runs them via the Claude Code or Codex adapter, and reports results back.",
   "type": "commonjs",
   "license": "MIT",
@@ -38,6 +38,7 @@
     "test:watch": "vitest",
     "prepublishOnly": "npm run build && npm test",
     "start": "node bin/navarch.cjs start",
+    "supervise": "node bin/navarch.cjs supervise",
     "register": "node bin/navarch.cjs register",
     "connect": "node bin/navarch.cjs connect",
     "doctor": "node bin/navarch.cjs doctor"