dahrk-node 0.1.4 → 0.1.5

package/dist/main.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync5, realpathSync as realpathSync3, writeFileSync as writeFileSync7 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import { homedir as homedir3 } from "os";
-import { basename, join as join8 } from "path";
+import { homedir as homedir4 } from "os";
+import { basename, join as join9 } from "path";
 import { pathToFileURL } from "url";
 
 // ../../packages/edge/src/ws-client.ts
@@ -22,11 +22,11 @@ function createMockRunner(runtime) {
   return {
     runtime,
     async runBatch(ctx, onTrace) {
-      const tool2 = ctx.config.tools?.[0] ?? "shell";
+      const tool3 = ctx.config.tools?.[0] ?? "shell";
       const toolUseId = "mock-tool-1";
       const events = [
         { seq: 0, runtime, type: "thought", ts: nowIso(), text: "mock: planning the stage" },
-        { seq: 1, runtime, type: "action", ts: nowIso(), tool: tool2, toolUseId, input: { note: "mock action" } },
+        { seq: 1, runtime, type: "action", ts: nowIso(), tool: tool3, toolUseId, input: { note: "mock action" } },
         { seq: 2, runtime, type: "observation", ts: nowIso(), toolUseId, output: { ok: true } },
         { seq: 3, runtime, type: "response", ts: nowIso(), text: "mock: stage complete" }
       ];
@@ -371,6 +371,47 @@ function raceNextTurn(pending, idleMs, signal) {
     );
   });
 }
+function createElicitTurnRouter(turns, opts) {
+  const conversation = new ManagedMailbox();
+  const ref = { settle: null };
+  void (async () => {
+    try {
+      for await (const t of turns) {
+        const settle = ref.settle;
+        if (settle) settle({ kind: "reply", text: t.text });
+        else conversation.push(t);
+      }
+    } finally {
+      conversation.end();
+      const settle = ref.settle;
+      if (settle) settle({ kind: "cancel" });
+    }
+  })();
+  const ask = (firstReply, onRaise) => {
+    if (ref.settle) return Promise.resolve({ kind: "busy" });
+    onRaise();
+    return new Promise((resolve2) => {
+      let settled = false;
+      const finish = (o) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        opts.signal.removeEventListener("abort", onAbort);
+        ref.settle = null;
+        resolve2(o);
+      };
+      const onAbort = () => finish({ kind: "cancel" });
+      const timer = setTimeout(() => finish({ kind: "noreply" }), firstReply ? opts.firstReplyMs : opts.idleMs);
+      if (opts.signal.aborted) {
+        finish({ kind: "cancel" });
+        return;
+      }
+      opts.signal.addEventListener("abort", onAbort, { once: true });
+      ref.settle = finish;
+    });
+  };
+  return { conversation, ask };
+}
 
 // ../../packages/executor-worktree/src/stage-complete-tool.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
@@ -401,6 +442,52 @@ function createStageCompleteTool() {
   };
 }
 
+// ../../packages/executor-worktree/src/ask-user-question-tool.ts
+import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+var ASK_USER_QUESTION_TOOL_NAME = "mcp__ask__ask_user_question";
+var ASK_USER_QUESTION_ALIAS = "AskUserQuestion";
+var optionSchema = z2.object({
+  label: z2.string(),
+  description: z2.string().optional().default(""),
+  preview: z2.string().optional()
+});
+var questionSchema = z2.object({
+  question: z2.string(),
+  header: z2.string().optional().default(""),
+  options: z2.array(optionSchema).min(1),
+  multiSelect: z2.boolean().optional()
+});
+function toElicitQuestion(q) {
+  const options = q.options.map((o) => ({ label: o.label, value: o.label }));
+  const described = q.options.filter((o) => (o.description ?? "").trim());
+  const lines = described.map((o) => `- ${o.label}: ${(o.description ?? "").trim()}`);
+  const prompt = lines.length ? `${q.question}
+
+${lines.join("\n")}` : q.question;
+  return { prompt, options, ...q.multiSelect ? { multiSelect: true } : {} };
+}
+function createAskUserQuestionTool(deps) {
+  const askTool = tool2(
+    "ask_user_question",
+    "Ask the human a structured multiple-choice question and wait for their selection. Use this when you need the human to choose between options before you can continue.",
+    { questions: z2.array(questionSchema).min(1) },
+    async (args) => {
+      const first = args.questions[0];
+      const question = toElicitQuestion(first);
+      const prompt = args.questions.length > 1 ? `${question.prompt}
+
+(Note: ${args.questions.length} questions were asked at once; answer this one first, then ask the rest.)` : question.prompt;
+      const text = await deps.ask({ ...question, prompt });
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  return {
+    server: createSdkMcpServer2({ name: "ask", version: "0.0.0", tools: [askTool] }),
+    allowedToolName: ASK_USER_QUESTION_TOOL_NAME
+  };
+}
+
 // ../../packages/executor-worktree/src/claude-adapter.ts
 var COALESCE_MS = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
 var MAX_TURNS = Number(process.env.DAHRK_MAX_TURNS ?? process.env.SKAKEL_MAX_TURNS ?? 64);
@@ -419,6 +506,10 @@ var policyCanUseTool = async (ctx, toolName, input) => {
   }
   return { behavior: "allow", updatedInput: input };
 };
+var interactiveCanUseTool = (summarising, stageAllowedToolName, ctx, toolName, input) => summarising && toolName !== stageAllowedToolName ? Promise.resolve({
+  behavior: "deny",
+  message: "Summarise from the work you just did; reply with the sentence only, no tools."
+}) : policyCanUseTool(ctx, toolName, input);
 function buildBrokeredMcpServers(ctx) {
   const servers = ctx.config.mcpServers;
   if (!servers || servers.length === 0 || !ctx.mcpProxyBaseUrl) return void 0;
@@ -507,6 +598,27 @@ function createClaudeRunner() {
     async runInteractive(ctx, turns, onTrace) {
       const emit = makeEmit("claude-code", onTrace);
       const stageTool = createStageCompleteTool();
+      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
+      let awaitingFirstReply = true;
+      const router = createElicitTurnRouter(turns, { signal: abortController.signal, firstReplyMs, idleMs });
+      const askTool = createAskUserQuestionTool({
+        ask: async (question) => {
+          const outcome = await router.ask(awaitingFirstReply, () => {
+            emit({ type: "elicitation", prompt: question.prompt, signal: "select", options: question.options });
+            ctx.emitElicit?.(question);
+          });
+          switch (outcome.kind) {
+            case "reply":
+              return `The user selected: ${outcome.text}`;
+            case "busy":
+              return "Only one question can be asked at a time; wait for the current one to be answered, then ask again.";
+            case "noreply":
+              return "No response from the user; proceed with your best judgement.";
+            case "cancel":
+              return "The question was cancelled.";
+          }
+        }
+      });
       const brokered = buildBrokeredMcpServers(ctx);
       let summarising = false;
       const options = {
@@ -514,12 +626,17 @@ function createClaudeRunner() {
         // Keep the cwd-anchoring preset; fold the stage instruction in via `append` so the
         // interactive persona still gets it without losing the working-directory context.
         systemPrompt: hasSystemPrompt(ctx) ? { type: "preset", preset: "claude_code", append: resolveStagePrompt(ctx) } : CLAUDE_CODE_SYSTEM_PROMPT,
-        // Inject the stage-complete exit tool alongside any brokered MCP servers (parity with batch).
-        mcpServers: { dahrk: stageTool.server, ...brokered ?? {} },
-        // Auto-approve the exit tool; `allowedTools` is an auto-approve list, not a whitelist, so it
-        // does not restrict the other tools canUseTool allows.
-        allowedTools: [stageTool.allowedToolName],
-        canUseTool: async (toolName, input) => summarising && toolName !== stageTool.allowedToolName ? { behavior: "deny", message: "Summarise from the work you just did; reply with the sentence only, no tools." } : policyCanUseTool(ctx, toolName, input),
+        // Inject the stage-complete exit tool and the AskUserQuestion shadow alongside any brokered
+        // MCP servers (parity with batch).
+        mcpServers: { dahrk: stageTool.server, ask: askTool.server, ...brokered ?? {} },
+        // Redirect the built-in AskUserQuestion to the shadow tool so a structured question surfaces
+        // as a Linear elicitation. The redirect is name-only and single-hop; the tool still runs, so
+        // this is mapping, not gating (DHK-344 / DHK-223).
+        toolAliases: { [ASK_USER_QUESTION_ALIAS]: askTool.allowedToolName },
+        // Auto-approve the injected tools; `allowedTools` is an auto-approve list, not a whitelist, so
+        // it does not restrict the other tools canUseTool allows.
+        allowedTools: [stageTool.allowedToolName, askTool.allowedToolName],
+        canUseTool: async (toolName, input) => interactiveCanUseTool(summarising, stageTool.allowedToolName, ctx, toolName, input),
         maxTurns: MAX_TURNS,
         includePartialMessages: false
       };
@@ -529,7 +646,7 @@ function createClaudeRunner() {
       const q = query({ prompt: mailbox, options });
       active = q;
       const it = q[Symbol.asyncIterator]();
-      const humanIter = turns[Symbol.asyncIterator]();
+      const humanIter = router.conversation[Symbol.asyncIterator]();
       const state = newBufferState();
       const consumeTurn = async () => {
         for (; ; ) {
@@ -539,8 +656,6 @@ function createClaudeRunner() {
           if (res.isResult) return res.responseText;
         }
       };
-      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
-      let awaitingFirstReply = true;
       let exited = null;
       let pending = humanIter.next();
       try {
@@ -1230,8 +1345,11 @@ function sanitizeBranchName(name) {
   if (!name) return name;
   return name.replace(/[`~^:?*[\]\\@{}\s]/g, "-").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/\.lock(\/|$)/g, "$1").replace(/^[.\-/]+/, "").replace(/[.\-/]+$/, "").replace(/-{2,}/g, "-");
 }
+function resolveWorktreesDir(override) {
+  return override ?? process.env.DAHRK_WORKTREES_DIR ?? process.env.SKAKEL_WORKTREES_DIR ?? join2(homedir(), ".dahrk", "worktrees");
+}
 function createGitService(opts = {}) {
-  const worktreesDir = opts.worktreesDir ?? process.env.DAHRK_WORKTREES_DIR ?? process.env.SKAKEL_WORKTREES_DIR ?? join2(homedir(), ".dahrk", "worktrees");
+  const worktreesDir = resolveWorktreesDir(opts.worktreesDir);
   const mirrorsDir = opts.mirrorsDir ?? process.env.DAHRK_MIRRORS_DIR ?? process.env.SKAKEL_MIRRORS_DIR ?? join2(homedir(), ".dahrk", "mirrors");
   const authorName = opts.authorName ?? process.env.DAHRK_GIT_AUTHOR_NAME ?? "Dahrk";
   const authorEmail = opts.authorEmail ?? process.env.DAHRK_GIT_AUTHOR_EMAIL ?? "noreply@dahrk.ai";
@@ -1334,6 +1452,7 @@ function createGitService(opts = {}) {
     scratchPath: join2(worktreePath, ".skakel", "scratch")
   });
   return {
+    worktreesDir,
     async createWorktree(spec) {
       const { repoId, gitUrl, baseBranch, runId } = spec;
       const branchName = sanitizeBranchName(spec.branch ?? `dahrk/${runId}`);
@@ -1662,12 +1781,12 @@ function evaluatePolicies(event, rules) {
   }
   return ALLOW;
 }
-function denyToolRule(tool2) {
+function denyToolRule(tool3) {
   return {
     name: "deny_tool",
     evaluate(event) {
-      if (event.kind === "action" && event.tool === tool2) {
-        return { verdict: "deny", policy: "deny_tool", reason: `tool "${tool2}" is denied` };
+      if (event.kind === "action" && event.tool === tool3) {
+        return { verdict: "deny", policy: "deny_tool", reason: `tool "${tool3}" is denied` };
       }
       return null;
     }
@@ -1748,7 +1867,15 @@ function buildRules(policies, ctx) {
   const rules = [];
   let stageToolCalls = 0;
   for (const p of policies) {
-    if ("write_scope" in p) {
+    if ("read_only" in p && p.read_only) {
+      rules.push({
+        name: "read_only",
+        evaluate(event) {
+          if (event.kind !== "action" || !WRITE_TOOLS.has(event.tool)) return null;
+          return { verdict: "deny", policy: "read_only", reason: `read-only stage: "${event.tool}" is not permitted` };
+        }
+      });
+    } else if ("write_scope" in p) {
       const { branches, repos } = p.write_scope;
       rules.push({
         name: "write_scope",
@@ -2249,11 +2376,11 @@ function createStageRunner(deps) {
       let denied = false;
       const authorisedActions = [];
       const runtime = agentConfig.runtime;
-      const actionKey = (tool2, input) => {
+      const actionKey = (tool3, input) => {
         try {
-          return `${tool2}\0${JSON.stringify(input)}`;
+          return `${tool3}\0${JSON.stringify(input)}`;
         } catch {
-          return `${tool2}\0`;
+          return `${tool3}\0`;
         }
       };
       const policyReason = (verdict) => verdict.reason ?? `tool action denied by ${verdict.policy}`;
@@ -2266,12 +2393,12 @@ function createStageRunner(deps) {
         streamEvent(writer.append({ seq: 0, ts: nowIso2(), type: "state", runtime, event: "policy-deny", detail: reason }));
         deps.sendProgress({ jobId, kind: "error", ts: nowIso2(), text: reason });
       };
-      const authorizeToolUse = (tool2, input) => {
-        const verdict = evaluatePolicies({ kind: "action", stageId, tool: tool2, input }, rules);
+      const authorizeToolUse = (tool3, input) => {
+        const verdict = evaluatePolicies({ kind: "action", stageId, tool: tool3, input }, rules);
         if (verdict.verdict === "deny") {
           recordDeny(verdict);
         } else {
-          authorisedActions.push(actionKey(tool2, input));
+          authorisedActions.push(actionKey(tool3, input));
         }
         return verdict;
       };
@@ -2319,7 +2446,17 @@ function createStageRunner(deps) {
         // The adapter persists each runtime-native record under the attempt's raw/ sidecar
         // and stamps the rawRef onto the emitted event.
         writeRaw: writer.writeRaw,
-        authorizeToolUse
+        authorizeToolUse,
+        // Wire the interactive AskUserQuestion elicitation seam (DHK-344): the adapter calls this when
+        // the agent asks a structured question, and the edge relays it to the hub as an `elicit` frame.
+        ...deps.sendElicit ? {
+          emitElicit: (question) => deps.sendElicit({
+            jobId,
+            prompt: question.prompt,
+            options: question.options,
+            ...question.multiSelect ? { multiSelect: true } : {}
+          })
+        } : {}
       };
       const interactive = agentConfig.interaction === "interactive";
       let result;
@@ -2565,6 +2702,9 @@ async function startEdgeNode(opts) {
     ...opts.tenantId ? { tenantId: opts.tenantId } : {},
     rules,
     sendProgress: (progress) => send({ type: "progress", progress }),
+    // DHK-344: relay a mid-interactive-stage AskUserQuestion to the hub as an `elicit` frame; the hub
+    // raises the Linear elicitation and the human's pick returns on the existing `turn` frame.
+    sendElicit: (frame) => send({ type: "elicit", ...frame }),
     trace,
     ...opts.retention ? { retention: opts.retention } : {}
   };
@@ -2684,7 +2824,11 @@ async function startEdgeNode(opts) {
         ...opts.name ? { name: opts.name } : {},
         os: osPlatform(),
         arch: osArch(),
-        clientVersion: opts.clientVersion ?? "0.0.0"
+        clientVersion: opts.clientVersion ?? "0.0.0",
+        // Advertise the resolved worktree base so the hub records each run's real worktree location in
+        // the projection instead of an advisory placeholder. Single-sourced from the git service so it
+        // always matches where worktrees actually land.
+        worktreesDir: gitService.worktreesDir
       });
       for (const frame of lastResults.values()) send(frame);
       startHeartbeat(sock, opts.heartbeatMs ?? 5e3);
@@ -2865,7 +3009,7 @@ function probeHub(opts) {
 
 // src/cli.ts
 import { parseArgs } from "util";
-var COMMANDS = /* @__PURE__ */ new Set(["start", "run", "doctor", "update"]);
+var COMMANDS = /* @__PURE__ */ new Set(["start", "run", "service", "doctor", "update"]);
 var isCommand = (s) => COMMANDS.has(s);
 function parseCli(argv) {
   const [first, ...rest] = argv;
@@ -2884,6 +3028,7 @@ function parseCli(argv) {
     flagArgs = rest;
   }
   if (command === "run") return parseRun(flagArgs);
+  if (command === "service") return parseService(flagArgs);
   if (command === "update") return parseUpdate(flagArgs);
   let values;
   try {
@@ -2942,6 +3087,44 @@ function parseRun(flagArgs) {
   };
   return { kind: "run", flags };
 }
+var SERVICE_ACTIONS = /* @__PURE__ */ new Set(["install", "uninstall"]);
+var isServiceAction = (s) => SERVICE_ACTIONS.has(s);
+function parseService(flagArgs) {
+  let values;
+  let positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      args: flagArgs,
+      options: {
+        token: { type: "string" },
+        name: { type: "string" },
+        "hub-url": { type: "string" },
+        help: { type: "boolean", default: false }
+      },
+      allowPositionals: true
+    }));
+  } catch (e) {
+    return { kind: "error", message: e.message };
+  }
+  if (values.help) return { kind: "help", command: "service" };
+  if (positionals.length === 0) {
+    return { kind: "error", message: "service: missing action (`dahrk service install` or `uninstall`)" };
+  }
+  if (positionals.length > 1) {
+    return { kind: "error", message: `service: unexpected argument "${positionals[1]}" (one action at a time)` };
+  }
+  const action = positionals[0];
+  if (!isServiceAction(action)) {
+    return { kind: "error", message: `service: unknown action "${action}" (expected install or uninstall)` };
+  }
+  const flags = {
+    action,
+    ...values.token ? { token: values.token } : {},
+    ...values.name ? { name: values.name } : {},
+    ...values["hub-url"] ? { hubUrl: values["hub-url"] } : {}
+  };
+  return { kind: "service", flags };
+}
 function parseUpdate(flagArgs) {
   let values;
   try {
@@ -2989,6 +3172,24 @@ function usage(bin, command) {
       "  --token <token>    Enrolment token to verify against the hub (or set DAHRK_ENROL_TOKEN)."
     ].join("\n");
   }
+  if (command === "service") {
+    return [
+      `Usage: ${bin} service install|uninstall [options]`,
+      "",
+      "Install (or remove) the node as an always-on service that starts on boot and restarts on",
+      "failure - a launchd LaunchAgent on macOS, a systemd user service on Linux. No pm2, no root.",
+      "The node id persisted at ~/.dahrk/node.json means it re-attaches as the same node across reboots.",
+      "",
+      "Actions:",
+      "  install      Generate and register the service, then start it.",
+      "  uninstall    Stop, deregister, and remove the service.",
+      "",
+      "Options (install; baked into the service, uninstall ignores them):",
+      "  --token <token>    Enrolment token (required; or set DAHRK_ENROL_TOKEN).",
+      "  --hub-url <url>    Hub WebSocket URL (or set DAHRK_HUB_URL).",
+      "  --name <name>      Display-name override (else the hub assigns one)."
+    ].join("\n");
+  }
   if (command === "doctor") {
     return [
       `Usage: ${bin} doctor [options]`,
@@ -3018,6 +3219,7 @@ function usage(bin, command) {
     "Commands:",
     "  start     Run the edge node (default). Needs a --token and a hub URL.",
     "  run       Run a workflow locally (engine-backed), e.g. `run preflight`.",
+    "  service   Install/uninstall the node as an always-on service (launchd/systemd).",
     "  doctor    Preflight checks: Node, runtimes, hub reachability, token validity.",
     "  update    Update the client to the latest release (or print how for your channel).",
     "  version   Print the client version.",
@@ -3374,9 +3576,257 @@ function gatherHostFacts(repoPath) {
   };
 }
 
-// src/update.ts
+// src/service.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { realpathSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, realpathSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir3, platform as osPlatform3, userInfo } from "os";
+import { join as join8 } from "path";
+var LAUNCHD_LABEL = "ai.dahrk.node";
+var SYSTEMD_UNIT = "dahrk-node.service";
+function detectManager(plat) {
+  if (plat === "darwin") return "launchd";
+  if (plat === "linux") return "systemd";
+  return "unsupported";
+}
+function serviceEnv(inputs) {
+  return {
+    DAHRK_ENROL_TOKEN: inputs.token,
+    ...inputs.hubUrl ? { DAHRK_HUB_URL: inputs.hubUrl } : {},
+    ...inputs.name ? { DAHRK_NODE_NAME: inputs.name } : {},
+    ...inputs.pathEnv ? { PATH: inputs.pathEnv } : {}
+  };
+}
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function renderLaunchdPlist(inputs) {
+  const argv = [inputs.nodeBin, inputs.scriptPath, "start"];
+  const env = serviceEnv(inputs);
+  const progArgs = argv.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n");
+  const envEntries = Object.entries(env).map(([k, v]) => `    <key>${xmlEscape(k)}</key>
+    <string>${xmlEscape(v)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${progArgs}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(inputs.homeDir)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(join8(inputs.logDir, "node.out.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(join8(inputs.logDir, "node.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function systemdEnvValue(v) {
+  return /\s/.test(v) ? `"${v.replace(/"/g, '\\"')}"` : v;
+}
+function renderSystemdUnit(inputs) {
+  const exec = [inputs.nodeBin, inputs.scriptPath, "start"].map((a) => /\s/.test(a) ? `"${a}"` : a).join(" ");
+  const env = serviceEnv(inputs);
+  const envLines = Object.entries(env).map(([k, v]) => `Environment=${k}=${systemdEnvValue(v)}`).join("\n");
+  return `[Unit]
+Description=Dahrk node (self-managed edge node)
+Documentation=https://dahrk.ai/docs
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${exec}
+${envLines}
+WorkingDirectory=${inputs.homeDir}
+Restart=on-failure
+RestartSec=3
+RestartPreventExitStatus=78
+
+[Install]
+WantedBy=default.target
+`;
+}
+function buildPlan(inputs) {
+  if (inputs.manager === "launchd") {
+    const filePath2 = join8(inputs.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    return {
+      manager: "launchd",
+      label: LAUNCHD_LABEL,
+      filePath: filePath2,
+      content: renderLaunchdPlist(inputs),
+      // Unload first so a re-install picks up the rewritten plist; a not-loaded unload is a no-op.
+      installCommands: [
+        { argv: ["launchctl", "unload", filePath2], ignoreFailure: true },
+        { argv: ["launchctl", "load", "-w", filePath2] }
+      ],
+      uninstallCommands: [{ argv: ["launchctl", "unload", "-w", filePath2], ignoreFailure: true }],
+      logHint: `tail -f ${join8(inputs.logDir, "node.err.log")}`
+    };
+  }
+  const filePath = join8(inputs.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+  const user = userInfo().username;
+  return {
+    manager: "systemd",
+    label: SYSTEMD_UNIT,
+    filePath,
+    content: renderSystemdUnit(inputs),
+    // Reload to see the new unit, enable+start it, then enable linger so it survives logout / boots
+    // headless. Linger can be denied without privilege on some hosts, so it is best-effort.
+    installCommands: [
+      { argv: ["systemctl", "--user", "daemon-reload"] },
+      { argv: ["systemctl", "--user", "enable", "--now", SYSTEMD_UNIT] },
+      { argv: ["loginctl", "enable-linger", user], ignoreFailure: true }
+    ],
+    uninstallCommands: [
+      { argv: ["systemctl", "--user", "disable", "--now", SYSTEMD_UNIT], ignoreFailure: true },
+      { argv: ["systemctl", "--user", "daemon-reload"], ignoreFailure: true }
+    ],
+    logHint: `journalctl --user -u ${SYSTEMD_UNIT} -f`
+  };
+}
+function printUnsupported(out) {
+  out("dahrk service is supported on macOS (launchd) and Linux (systemd) only.");
+  out("On other platforms, run the node under a process manager such as pm2 (see the README).");
+  return 1;
+}
+function runCommands(commands, d) {
+  for (const cmd of commands) {
+    const code = d.run(cmd.argv);
+    if (code !== 0 && !cmd.ignoreFailure) {
+      d.out(`  command failed (${code}): ${cmd.argv.join(" ")}`);
+      return code;
+    }
+  }
+  return 0;
+}
+async function runServiceInstall(inputs, deps = {}) {
+  const d = { ...defaultDeps3(), ...deps };
+  d.out("dahrk service install");
+  d.out("");
+  const manager = detectManager(d.platform);
+  if (manager === "unsupported") return printUnsupported(d.out);
+  if (!inputs.token) {
+    d.out("No enrolment token: pass --token <token> or set DAHRK_ENROL_TOKEN.");
+    d.out("Get one at https://app.dahrk.ai.");
+    return 2;
+  }
+  const plan = buildPlan({
+    manager,
+    nodeBin: d.nodeBin,
+    scriptPath: d.scriptPath,
+    token: inputs.token,
+    ...inputs.name ? { name: inputs.name } : {},
+    ...inputs.hubUrl ? { hubUrl: inputs.hubUrl } : {},
+    ...d.pathEnv ? { pathEnv: d.pathEnv } : {},
+    homeDir: d.homeDir,
+    logDir: d.logDir
+  });
+  try {
+    if (manager === "launchd") d.mkdirp(d.logDir);
+    d.mkdirp(dirOf(plan.filePath));
+    d.writeFile(plan.filePath, plan.content);
+  } catch (e) {
+    d.out(`Could not write the service file at ${plan.filePath}: ${e.message}`);
+    return 1;
+  }
+  d.out(`Wrote ${plan.manager} service: ${plan.filePath}`);
+  const code = runCommands(plan.installCommands, d);
+  d.out("");
+  if (code !== 0) {
+    d.out(`The service file is in place but registering it failed (exit ${code}).`);
+    d.out("Fix the reported error and re-run `dahrk service install`, or load it yourself.");
+    return code;
+  }
+  d.out("Installed. The node will start on boot and restart on failure.");
+  d.out(`  logs:      ${plan.logHint}`);
+  d.out("  uninstall: dahrk service uninstall");
+  return 0;
+}
+async function runServiceUninstall(deps = {}) {
+  const d = { ...defaultDeps3(), ...deps };
+  d.out("dahrk service uninstall");
+  d.out("");
+  const manager = detectManager(d.platform);
+  if (manager === "unsupported") return printUnsupported(d.out);
+  const plan = buildPlan({
+    manager,
+    nodeBin: d.nodeBin,
+    scriptPath: d.scriptPath,
+    token: "-",
+    homeDir: d.homeDir,
+    logDir: d.logDir
+  });
+  if (!d.fileExists(plan.filePath)) {
+    d.out(`No service installed (${plan.filePath} not found). Nothing to do.`);
+    return 0;
+  }
+  runCommands(plan.uninstallCommands, d);
+  try {
+    d.removeFile(plan.filePath);
+  } catch (e) {
+    d.out(`Deregistered, but could not delete ${plan.filePath}: ${e.message}`);
+    return 1;
+  }
+  d.out(`Removed ${plan.filePath}. The node will no longer start on boot.`);
+  return 0;
+}
+function dirOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? path : path.slice(0, i);
+}
+function resolveScriptPath() {
+  const argv1 = process.argv[1] ?? "";
+  try {
+    return realpathSync(argv1);
+  } catch {
+    return argv1;
+  }
+}
+var defaultDeps3 = () => ({
+  platform: osPlatform3(),
+  homeDir: homedir3(),
+  nodeBin: process.execPath,
+  scriptPath: resolveScriptPath(),
+  logDir: join8(process.env.DAHRK_STATE_DIR ?? join8(homedir3(), ".dahrk"), "logs"),
+  // Snapshot the operator's PATH at install time so the daemon finds git + the runtime CLIs (Homebrew /
+  // npm-global bins) that a supervisor's minimal PATH would otherwise hide.
+  pathEnv: process.env.PATH,
+  mkdirp: (dir) => void mkdirSync6(dir, { recursive: true }),
+  writeFile: (path, content) => writeFileSync6(path, content),
+  removeFile: (path) => rmSync4(path, { force: true }),
+  fileExists: (path) => existsSync5(path),
+  run: (argv) => {
+    const [cmd, ...args] = argv;
+    try {
+      execFileSync5(cmd, args, { stdio: "inherit" });
+      return 0;
+    } catch (e) {
+      const status = e.status;
+      return typeof status === "number" ? status : 1;
+    }
+  },
+  out: (line) => void process.stdout.write(`${line}
+`)
+});
+
+// src/update.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import { realpathSync as realpathSync2 } from "fs";
 var LATEST_URL = "https://registry.npmjs.org/dahrk-node/latest";
 var CHANNEL_COMMANDS = {
   npm: "npm install -g dahrk-node@latest",
@@ -3397,7 +3847,7 @@ function detectChannel(binPath) {
   if (!binPath) return "unknown";
   let resolved = binPath;
   try {
-    resolved = realpathSync(binPath);
+    resolved = realpathSync2(binPath);
   } catch {
   }
   if (/[\\/]node_modules[\\/]dahrk-node[\\/]/.test(resolved)) return "npm";
@@ -3425,7 +3875,7 @@ function printChannelCommands(out) {
   out(`  curl:     ${CHANNEL_COMMANDS.curl}`);
 }
 async function runUpdate(inputs, deps = {}) {
-  const d = { ...defaultDeps3(), ...deps };
+  const d = { ...defaultDeps4(), ...deps };
   const current = inputs.currentVersion;
   d.out("dahrk update");
   d.out("");
@@ -3482,14 +3932,14 @@ async function fetchLatestVersion() {
 function spawnUpgrade(argv) {
   const [cmd, ...args] = argv;
   try {
-    execFileSync5(cmd, args, { stdio: "inherit" });
+    execFileSync6(cmd, args, { stdio: "inherit" });
     return 0;
   } catch (e) {
     const status = e.status;
     return typeof status === "number" ? status : 1;
   }
 }
-var defaultDeps3 = () => ({
+var defaultDeps4 = () => ({
   binPath: process.argv[1],
   fetchLatest: fetchLatestVersion,
   runUpgrade: spawnUpgrade,
@@ -3498,19 +3948,19 @@ var defaultDeps3 = () => ({
 });
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.4";
+var CLIENT_VERSION = "0.1.5";
 var DEFAULT_HUB_URL = "wss://api.dahrk.ai";
 var list = (v) => (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 var RUNTIMES = ["claude-code", "codex", "pi"];
 var isRuntime = (r) => RUNTIMES.includes(r);
 function stateDir(env) {
-  return env.DAHRK_STATE_DIR ?? join8(homedir3(), ".dahrk");
+  return env.DAHRK_STATE_DIR ?? join9(homedir4(), ".dahrk");
 }
 function legacyStateDir(env) {
-  return env.DAHRK_STATE_DIR ? void 0 : join8(homedir3(), ".skakel");
+  return env.DAHRK_STATE_DIR ? void 0 : join9(homedir4(), ".skakel");
 }
 function readNodeId(file) {
-  if (!existsSync5(file)) return void 0;
+  if (!existsSync6(file)) return void 0;
   try {
     const parsed = JSON.parse(readFileSync5(file, "utf8"));
     if (typeof parsed.nodeId === "string" && parsed.nodeId) return parsed.nodeId;
@@ -3522,18 +3972,18 @@ function resolveNodeId(env, opts = {}) {
   if (env.DAHRK_NODE_ID) return env.DAHRK_NODE_ID;
   if (opts.ephemeral) return randomUUID3();
   const dir = stateDir(env);
-  const file = join8(dir, "node.json");
+  const file = join9(dir, "node.json");
   const existing = readNodeId(file);
   if (existing) return existing;
   const legacy = legacyStateDir(env);
   if (legacy) {
-    const legacyId = readNodeId(join8(legacy, "node.json"));
+    const legacyId = readNodeId(join9(legacy, "node.json"));
     if (legacyId) return legacyId;
   }
   const nodeId = randomUUID3();
   try {
-    mkdirSync6(dir, { recursive: true });
-    writeFileSync6(file, `${JSON.stringify({ nodeId }, null, 2)}
+    mkdirSync7(dir, { recursive: true });
+    writeFileSync7(file, `${JSON.stringify({ nodeId }, null, 2)}
 `);
   } catch (e) {
     console.warn(`could not persist node id to ${file}: ${e.message}`);
@@ -3659,6 +4109,22 @@ async function main() {
     case "run":
       process.exitCode = await runWorkflow(parsed.flags);
       break;
+    case "service": {
+      if (parsed.flags.action === "uninstall") {
+        process.exitCode = await runServiceUninstall();
+        break;
+      }
+      const env = applyEnvAliases(process.env);
+      const token = parsed.flags.token ?? env.DAHRK_ENROL_TOKEN;
+      const name = parsed.flags.name ?? env.DAHRK_NODE_NAME;
+      const hubUrl = parsed.flags.hubUrl ?? env.DAHRK_HUB_URL;
+      process.exitCode = await runServiceInstall({
+        ...token ? { token } : {},
+        ...name ? { name } : {},
+        ...hubUrl ? { hubUrl } : {}
+      });
+      break;
+    }
     case "update":
       process.exitCode = await runUpdate({ currentVersion: CLIENT_VERSION, check: parsed.flags.check });
       break;
@@ -3671,7 +4137,7 @@ var invokedAsEntrypoint = (() => {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    return pathToFileURL(realpathSync2(argv1)).href === import.meta.url;
+    return pathToFileURL(realpathSync3(argv1)).href === import.meta.url;
   } catch {
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dahrk-node",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -34,7 +34,7 @@
   "exports": "./dist/main.js",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.183",
-    "@dahrk/contracts": "^0.1.0",
+    "@dahrk/contracts": "^0.1.1",
     "@openai/codex-sdk": "0.141.0",
     "ws": "^8.18.0",
     "zod": "^3.23.8"