@legioncodeinc/honeycomb 0.1.8 → 0.1.9

package/bundle/cli.js

@@ -6,38 +6,52 @@ var __export = (target, all) => {
 };
 
 // dist/src/commands/contracts.js
+var VERB_GROUPS = Object.freeze([
+  { key: "memory", label: "Memory & recall" },
+  { key: "knowledge", label: "Knowledge & skills" },
+  { key: "agents", label: "Agents, routing & config" },
+  { key: "account", label: "Account & workspaces" },
+  { key: "system", label: "Setup & system" }
+]);
 var VERB_TABLE = Object.freeze([
-  { verb: "setup", cls: "local", summary: "detect assistants, wire hooks, bring up the daemon" },
-  { verb: "install", cls: "local", summary: "bring up the daemon (health-gated) + open the dashboard (PRD-050a)" },
-  { verb: "status", cls: "local", summary: "daemon connectivity + login + D1\u2013D5 environment health" },
-  { verb: "daemon", cls: "local", summary: "start | stop | status the loopback daemon (3850)" },
-  { verb: "dashboard", cls: "local", summary: "launch the daemon-served dashboard (020b)" },
-  { verb: "telemetry", cls: "local", summary: "show exactly what adoption telemetry has been / would be sent (--show, PRD-050e)" },
-  { verb: "pollinate", cls: "storage", summary: "trigger a pollinating consolidation pass on the daemon (009/026)" },
-  { verb: "maintenance", cls: "storage", summary: "run version-history compaction over version-bumped tables (030)" },
-  { verb: "remember", cls: "storage", summary: "write a memory through the daemon (--type fact|convention|preference|decision|gotcha|reference)" },
-  { verb: "recall", cls: "storage", summary: "recall memories through the daemon" },
-  { verb: "memory", cls: "storage", summary: "lifecycle: conflicts (list/resolve), stale-refs (list), inspect <id> --lifecycle (058d)" },
-  { verb: "agent", cls: "storage", summary: "run an agent turn through the daemon" },
-  { verb: "ontology", cls: "storage", summary: "inspect/propose ontology changes through the daemon" },
-  { verb: "secret", cls: "storage", summary: "manage named secrets through the daemon" },
-  { verb: "settings", cls: "storage", summary: "get/set/list vault settings + provider\u2192model selector through the daemon" },
-  { verb: "asset", cls: "storage", summary: "register/promote/demote/style skills+agents through the tier\xD7style lattice (033)" },
-  { verb: "skill", cls: "storage", summary: "skillify scope/pull/unpull/force/promote through the daemon (promote = cross-project, 049c)" },
-  { verb: "skillify", cls: "storage", summary: "pull team skills from the daemon (016c)" },
-  { verb: "hook", cls: "local", summary: "inspect/wire harness hooks" },
-  { verb: "route", cls: "storage", summary: "manage inference routes through the daemon" },
-  { verb: "sources", cls: "storage", summary: "connect/index/purge sources through the daemon" },
-  { verb: "graph", cls: "storage", summary: "build/query the codebase graph through the daemon" },
-  { verb: "goal", cls: "storage", summary: "manage goals/KPIs through the daemon" },
-  { verb: "whoami", cls: "auth", summary: "show the authenticated user, org, and workspace (GET /me)" },
-  { verb: "org", cls: "auth", summary: "list/switch org (passthrough to the auth dispatcher)" },
-  { verb: "workspace", cls: "auth", summary: "list/switch/use workspace (passthrough to the auth dispatcher)" },
-  { verb: "workspaces", cls: "auth", summary: "list workspaces in the active org (alias of `workspace list`)" },
-  { verb: "project", cls: "auth", summary: "list/bind/use projects + show the resolved per-folder scope (049d)" },
-  { verb: "sessions", cls: "storage", summary: "list/prune captured sessions through the daemon" },
-  { verb: "uninstall", cls: "local", summary: "reverse only Honeycomb's changes" },
-  { verb: "update", cls: "local", summary: "self-update the CLI, daemon, and bundles" }
+  // Memory & recall — the product's core write/read/lifecycle surface.
+  { verb: "remember", cls: "storage", group: "memory", summary: "write a memory through the daemon (--type fact|convention|preference|decision|gotcha|reference)" },
+  { verb: "recall", cls: "storage", group: "memory", summary: "recall memories through the daemon" },
+  { verb: "memory", cls: "storage", group: "memory", summary: "lifecycle: conflicts (list/resolve), stale-refs (list), inspect <id> --lifecycle (058d)" },
+  { verb: "sessions", cls: "storage", group: "memory", summary: "list/prune captured sessions through the daemon" },
+  { verb: "pollinate", cls: "storage", group: "memory", summary: "trigger a pollinating consolidation pass on the daemon (009/026)" },
+  { verb: "maintenance", cls: "storage", group: "memory", summary: "run version-history compaction over version-bumped tables (030)" },
+  // Knowledge & skills — skills, assets, ontology, the codebase graph, and goals.
+  { verb: "skill", cls: "storage", group: "knowledge", summary: "skillify scope/pull/unpull/force/promote through the daemon (promote = cross-project, 049c)" },
+  { verb: "skillify", cls: "storage", group: "knowledge", summary: "pull team skills from the daemon (016c)" },
+  { verb: "asset", cls: "storage", group: "knowledge", summary: "register/promote/demote/style skills+agents through the tier\xD7style lattice (033)" },
+  { verb: "ontology", cls: "storage", group: "knowledge", summary: "inspect/propose ontology changes through the daemon" },
+  { verb: "graph", cls: "storage", group: "knowledge", summary: "build/query the codebase graph through the daemon" },
+  { verb: "sources", cls: "storage", group: "knowledge", summary: "connect/index/purge sources through the daemon" },
+  { verb: "goal", cls: "storage", group: "knowledge", summary: "manage goals/KPIs through the daemon" },
+  // Agents, routing & config — agent turns, inference routes, secrets, and vault settings.
+  { verb: "agent", cls: "storage", group: "agents", summary: "run an agent turn through the daemon" },
+  { verb: "route", cls: "storage", group: "agents", summary: "manage inference routes through the daemon" },
+  { verb: "secret", cls: "storage", group: "agents", summary: "manage named secrets through the daemon" },
+  { verb: "settings", cls: "storage", group: "agents", summary: "get/set/list vault settings + provider\u2192model selector through the daemon" },
+  // Account & workspaces — auth, identity, and the org/workspace/project scope surface.
+  { verb: "login", cls: "auth", group: "account", summary: "authenticate via device flow, or --token <key> for headless (023)" },
+  { verb: "logout", cls: "auth", group: "account", summary: "remove the shared credentials and sign out (023)" },
+  { verb: "whoami", cls: "auth", group: "account", summary: "show the authenticated user, org, and workspace (GET /me)" },
+  { verb: "org", cls: "auth", group: "account", summary: "list/switch org (passthrough to the auth dispatcher)" },
+  { verb: "workspace", cls: "auth", group: "account", summary: "list/switch/use workspace (passthrough to the auth dispatcher)" },
+  { verb: "workspaces", cls: "auth", group: "account", summary: "list workspaces in the active org (alias of `workspace list`)" },
+  { verb: "project", cls: "auth", group: "account", summary: "list/bind/use projects + show the resolved per-folder scope (049d)" },
+  // Setup & system — install/onboard, daemon lifecycle, dashboard, hooks, telemetry, update.
+  { verb: "setup", cls: "local", group: "system", summary: "detect assistants, wire hooks, bring up the daemon" },
+  { verb: "install", cls: "local", group: "system", summary: "bring up the daemon (health-gated) + open the dashboard (PRD-050a)" },
+  { verb: "status", cls: "local", group: "system", summary: "daemon connectivity + login + D1\u2013D5 environment health" },
+  { verb: "daemon", cls: "local", group: "system", summary: "start | stop | status the loopback daemon (3850)" },
+  { verb: "dashboard", cls: "local", group: "system", summary: "launch the daemon-served dashboard (020b)" },
+  { verb: "hook", cls: "local", group: "system", summary: "inspect/wire harness hooks" },
+  { verb: "telemetry", cls: "local", group: "system", summary: "show exactly what adoption telemetry has been / would be sent (--show, PRD-050e)" },
+  { verb: "update", cls: "local", group: "system", summary: "self-update the CLI, daemon, and bundles" },
+  { verb: "uninstall", cls: "local", group: "system", summary: "reverse only Honeycomb's changes" }
 ]);
 function lookupVerb(verb) {
   return VERB_TABLE.find((v) => v.verb === verb);
@@ -514,6 +528,15 @@ var PROVIDER_CATALOG = Object.freeze([
     // Suggestions only — OpenRouter accepts a free-form `vendor/model` id (passthrough).
     models: Object.freeze(["anthropic/claude-sonnet-4.6", "openai/gpt-4o"]),
     openEnded: true
+  }),
+  Object.freeze({
+    // PRD-063a: Portkey is a GATEWAY, not a model vendor — its `portkey.config` id is
+    // free-form (a config or virtual-key id copied from the Portkey dashboard), so it is
+    // `openEnded: true` like OpenRouter and carries NO curated model list of its own.
+    id: "portkey",
+    label: "Portkey",
+    models: Object.freeze([]),
+    openEnded: true
   })
 ]);
 function providerEntry(provider) {
@@ -16488,10 +16511,10 @@ function flagValue3(argv, flag) {
   return v !== void 0 && !v.startsWith("--") ? v : void 0;
 }
 function parseSkillId(raw) {
-  const sep3 = raw.lastIndexOf("--");
-  if (sep3 <= 0)
+  const sep4 = raw.lastIndexOf("--");
+  if (sep4 <= 0)
     return { name: raw, author: "" };
-  return { name: raw.slice(0, sep3), author: raw.slice(sep3 + 2) };
+  return { name: raw.slice(0, sep4), author: raw.slice(sep4 + 2) };
 }
 function buildSkillRequest(argv) {
   const sub = subcommandOf(argv);
@@ -17235,7 +17258,7 @@ function buildAllowedProperties(input) {
 }
 var systemTelemetryClock = () => (/* @__PURE__ */ new Date()).toISOString();
 var DEFAULT_EMIT_TIMEOUT_MS = 2e3;
-var HONEYCOMB_VERSION = true ? "0.1.8" : "0.0.0-dev";
+var HONEYCOMB_VERSION = true ? "0.1.9" : "0.0.0-dev";
 async function emitTelemetry(event, opts, deps = {}) {
   const env = deps.env ?? process.env;
   const key = deps.posthogKey ?? POSTHOG_KEY;
@@ -17378,7 +17401,7 @@ function renderGlassBoxText(view) {
 // dist/src/shared/constants.js
 var DAEMON_PORT = 3850;
 var DAEMON_HOST = "127.0.0.1";
-var HONEYCOMB_VERSION2 = true ? "0.1.8" : "0.0.0-dev";
+var HONEYCOMB_VERSION2 = true ? "0.1.9" : "0.0.0-dev";
 var PRODUCT_SLUG = "honeycomb";
 
 // dist/src/commands/install.js
@@ -17461,6 +17484,19 @@ function openDashboardWithFallback(opener, out) {
   const opened = opener(loopback);
   out(opened ? `\u2192 opening dashboard at ${loopback}\u2026` : `\u2192 dashboard is ready at ${loopback} (open it in your browser).`);
 }
+async function reportDaemonSupervision(deps, out) {
+  if (deps.lifecycle === void 0)
+    return;
+  try {
+    const status3 = await deps.lifecycle.status();
+    if (status3.serviceManager !== void 0) {
+      out(`\u2713 daemon registered as an OS service (${status3.serviceManager}): it restarts on crash and starts on boot.`);
+    } else {
+      out("note: daemon running as a detached process (OS service registration unavailable on this host).");
+    }
+  } catch {
+  }
+}
 async function runInstallCommand(argv, deps) {
   const out = deps.out ?? ((line) => console.log(line));
   const opener = deps.openDashboard ?? openLocalDashboardUrl;
@@ -17477,6 +17513,7 @@ async function runInstallCommand(argv, deps) {
     return { exitCode: 1 };
   }
   out(`\u2713 daemon up on ${DAEMON_HOST}:${DAEMON_PORT}.`);
+  await reportDaemonSupervision(deps, out);
   const wrote = writeInstalledMarker(ref, deps.dir, out);
   if (wrote)
     out(`\u2713 onboarding marked installed (ref: ${ref}).`);
@@ -17535,12 +17572,26 @@ function parseInvocation(argv) {
   const tail = verb === "" ? argv.slice(i) : argv.slice(i + 1);
   return { verb, argv: tail, flags };
 }
+var HONEYCOMB_BANNER = [
+  "   __    __    __",
+  "  /  \\__/  \\__/  \\     H O N E Y C O M B",
+  "  \\__/  \\__/  \\__/",
+  "  /  \\__/  \\__/  \\     shared agent memory for your coding tools",
+  "  \\__/  \\__/  \\__/"
+].join("\n");
 function usageText() {
-  const lines = [`${PRODUCT_SLUG} v${HONEYCOMB_VERSION2}`, "", "usage: honeycomb <command> [options]", "", "commands:"];
-  for (const spec of VERB_TABLE) {
-    lines.push(`  ${spec.verb.padEnd(11)} ${spec.summary}`);
+  const lines = [HONEYCOMB_BANNER, "", `${PRODUCT_SLUG} v${HONEYCOMB_VERSION2}`, "", "usage: honeycomb <command> [options]", ""];
+  const pad = VERB_TABLE.reduce((w, s2) => Math.max(w, s2.verb.length), 0) + 2;
+  for (const { key, label } of VERB_GROUPS) {
+    const rows = VERB_TABLE.filter((s2) => s2.group === key);
+    if (rows.length === 0)
+      continue;
+    lines.push(`${label}:`);
+    for (const spec of rows)
+      lines.push(`  ${spec.verb.padEnd(pad)}${spec.summary}`);
+    lines.push("");
   }
-  lines.push("", "global flags: --help  --version  --json  --dry-run");
+  lines.push("global flags: --help  --version  --json  --dry-run");
   return lines.join("\n");
 }
 function lifecycleOf(deps) {
@@ -17663,13 +17714,14 @@ function createDispatcher() {
 
 // dist/src/cli/runtime.js
 import { spawn } from "node:child_process";
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname8, join as join12, resolve as resolve7 } from "node:path";
+import { mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync2 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname8, join as join13, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // dist/src/daemon/runtime/auth/deeplake-issuer.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-var realSleeper = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+var realSleeper = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 var DEEPLAKE_CLIENT_HEADER = "X-Deeplake-Client";
 var DEEPLAKE_ORG_HEADER = "X-Activeloop-Org-Id";
 var DEEPLAKE_CLIENT_VALUE = "honeycomb";
@@ -20119,6 +20171,273 @@ async function launchDashboard(options = {}) {
   return renderDashboard(source);
 }
 
+// dist/src/cli/daemon-service.js
+import { createRequire } from "node:module";
+import { homedir as homedir12 } from "node:os";
+import { join as join12, normalize, resolve as resolve7, sep as sep3 } from "node:path";
+var SERVICE_LABEL = "ai.honeycomb.daemon";
+var SERVICE_TASK_NAME = "HoneycombDaemon";
+var SERVICE_MODE_ENV = "HONEYCOMB_DAEMON_SERVICE";
+function detectServiceManager(env = process.env, platform2 = process.platform) {
+  if ((env[SERVICE_MODE_ENV] ?? "").trim().toLowerCase() === "spawn")
+    return null;
+  if (platform2 === "darwin")
+    return "launchd";
+  if (platform2 === "win32")
+    return "schtasks";
+  if (platform2 === "linux") {
+    const xdg = (env.XDG_RUNTIME_DIR ?? "").trim();
+    if (xdg.length > 0)
+      return "systemd-user";
+    return null;
+  }
+  return null;
+}
+function defaultServiceRunner() {
+  const require2 = createRequire(import.meta.url);
+  const cp = require2("node:child_process");
+  const fs = require2("node:fs");
+  return {
+    run(cmd, args) {
+      const out = cp.execFileSync(cmd, [...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 15e3,
+        windowsHide: true
+      });
+      return typeof out === "string" ? out.trim() : "";
+    },
+    writeFile(path, contents) {
+      fs.mkdirSync(join12(path, ".."), { recursive: true });
+      fs.writeFileSync(path, contents, { encoding: "utf8" });
+    },
+    removeFile(path) {
+      try {
+        fs.rmSync(path, { force: true });
+      } catch {
+      }
+    },
+    fileExists(path) {
+      try {
+        return fs.existsSync(path);
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function containedUnitPath(home, segments) {
+  const resolvedHome = normalize(resolve7(home));
+  const candidate = normalize(resolve7(resolvedHome, ...segments));
+  const homeWithSep = resolvedHome.endsWith(sep3) ? resolvedHome : resolvedHome + sep3;
+  if (candidate !== resolvedHome && !candidate.startsWith(homeWithSep)) {
+    throw new Error("resolved service unit path escapes the home dir");
+  }
+  return candidate;
+}
+function launchdPlistPath(home) {
+  return containedUnitPath(home, ["Library", "LaunchAgents", `${SERVICE_LABEL}.plist`]);
+}
+function systemdUnitPath(home) {
+  return containedUnitPath(home, [".config", "systemd", "user", `${SERVICE_LABEL}.service`]);
+}
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderLaunchdPlist(spec) {
+  const argv = [spec.nodePath, ...spec.nodeFlags, spec.entry];
+  const argvXml = argv.map((a) => `		<string>${xmlEscape(a)}</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>${SERVICE_LABEL}</string>
+	<key>ProgramArguments</key>
+	<array>
+${argvXml}
+	</array>
+	<key>WorkingDirectory</key>
+	<string>${xmlEscape(spec.workspace)}</string>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>HONEYCOMB_WORKSPACE</key>
+		<string>${xmlEscape(spec.workspace)}</string>
+	</dict>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>KeepAlive</key>
+	<true/>
+	<key>ProcessType</key>
+	<string>Background</string>
+</dict>
+</plist>
+`;
+}
+function renderSystemdUnit(spec) {
+  const execStart = [spec.nodePath, ...spec.nodeFlags, spec.entry].map((a) => `"${a}"`).join(" ");
+  return `[Unit]
+Description=Honeycomb primary daemon (127.0.0.1:3850)
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+WorkingDirectory=${spec.workspace}
+Environment=HONEYCOMB_WORKSPACE=${spec.workspace}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+function assertCmdSafe(value) {
+  if (/[&|<>^"%\r\n]/.test(value)) {
+    throw new Error("unsafe character in service path; refusing to build schtasks /TR command");
+  }
+}
+function buildSchtasksCreateArgs(spec) {
+  assertCmdSafe(spec.workspace);
+  assertCmdSafe(spec.nodePath);
+  assertCmdSafe(spec.entry);
+  const nodeFlags = spec.nodeFlags.length > 0 ? `${spec.nodeFlags.join(" ")} ` : "";
+  const tr = `cmd /c "cd /d "${spec.workspace}" && set HONEYCOMB_WORKSPACE=${spec.workspace} && "${spec.nodePath}" ${nodeFlags}"${spec.entry}""`;
+  return [
+    "/Create",
+    "/TN",
+    SERVICE_TASK_NAME,
+    "/TR",
+    tr,
+    "/SC",
+    "ONLOGON",
+    "/RL",
+    "LIMITED",
+    "/F"
+  ];
+}
+function specHome(spec) {
+  return spec.home ?? homedir12();
+}
+function createDaemonServiceController(manager, runner = defaultServiceRunner()) {
+  if (manager === "launchd")
+    return launchdController(runner);
+  if (manager === "systemd-user")
+    return systemdController(runner);
+  return schtasksController(runner);
+}
+function launchdController(runner) {
+  function domain2() {
+    return `gui/${process.getuid?.() ?? 501}`;
+  }
+  return {
+    manager: "launchd",
+    register(spec) {
+      const path = launchdPlistPath(specHome(spec));
+      runner.writeFile(path, renderLaunchdPlist(spec));
+      runner.run("launchctl", ["bootstrap", domain2(), path]);
+      return { ok: true, manager: "launchd" };
+    },
+    unregister(spec) {
+      const path = launchdPlistPath(specHome(spec));
+      try {
+        runner.run("launchctl", ["bootout", `${domain2()}/${SERVICE_LABEL}`]);
+      } catch {
+      }
+      runner.removeFile(path);
+      return { ok: true, manager: "launchd" };
+    },
+    restart(_spec) {
+      runner.run("launchctl", ["kickstart", "-k", `${domain2()}/${SERVICE_LABEL}`]);
+      return { ok: true, manager: "launchd" };
+    },
+    stop(_spec) {
+      runner.run("launchctl", ["kill", "SIGTERM", `${domain2()}/${SERVICE_LABEL}`]);
+      return { ok: true, manager: "launchd" };
+    },
+    isRegistered(spec) {
+      return runner.fileExists(launchdPlistPath(specHome(spec)));
+    }
+  };
+}
+function systemdController(runner) {
+  const unit = `${SERVICE_LABEL}.service`;
+  return {
+    manager: "systemd-user",
+    register(spec) {
+      const path = systemdUnitPath(specHome(spec));
+      runner.writeFile(path, renderSystemdUnit(spec));
+      runner.run("systemctl", ["--user", "daemon-reload"]);
+      runner.run("systemctl", ["--user", "enable", "--now", unit]);
+      return { ok: true, manager: "systemd-user" };
+    },
+    unregister(spec) {
+      try {
+        runner.run("systemctl", ["--user", "disable", "--now", unit]);
+      } catch {
+      }
+      runner.removeFile(systemdUnitPath(specHome(spec)));
+      try {
+        runner.run("systemctl", ["--user", "daemon-reload"]);
+      } catch {
+      }
+      return { ok: true, manager: "systemd-user" };
+    },
+    restart(_spec) {
+      runner.run("systemctl", ["--user", "restart", unit]);
+      return { ok: true, manager: "systemd-user" };
+    },
+    stop(_spec) {
+      runner.run("systemctl", ["--user", "stop", unit]);
+      return { ok: true, manager: "systemd-user" };
+    },
+    isRegistered(spec) {
+      return runner.fileExists(systemdUnitPath(specHome(spec)));
+    }
+  };
+}
+function schtasksController(runner) {
+  return {
+    manager: "schtasks",
+    register(spec) {
+      runner.run("schtasks", buildSchtasksCreateArgs(spec));
+      runner.run("schtasks", ["/Run", "/TN", SERVICE_TASK_NAME]);
+      return { ok: true, manager: "schtasks" };
+    },
+    unregister(_spec) {
+      try {
+        runner.run("schtasks", ["/End", "/TN", SERVICE_TASK_NAME]);
+      } catch {
+      }
+      try {
+        runner.run("schtasks", ["/Delete", "/TN", SERVICE_TASK_NAME, "/F"]);
+      } catch {
+      }
+      return { ok: true, manager: "schtasks" };
+    },
+    restart(spec) {
+      try {
+        runner.run("schtasks", ["/End", "/TN", SERVICE_TASK_NAME]);
+      } catch {
+      }
+      runner.run("schtasks", ["/Run", "/TN", SERVICE_TASK_NAME]);
+      return { ok: true, manager: "schtasks" };
+    },
+    stop(_spec) {
+      runner.run("schtasks", ["/End", "/TN", SERVICE_TASK_NAME]);
+      return { ok: true, manager: "schtasks" };
+    },
+    isRegistered(_spec) {
+      try {
+        runner.run("schtasks", ["/Query", "/TN", SERVICE_TASK_NAME]);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
 // dist/src/cli/runtime.js
 function daemonBaseUrl2() {
   return `http://${DAEMON_HOST}:${DAEMON_PORT}`;
@@ -20136,19 +20455,38 @@ function tenancyHeaders(creds) {
 var DAEMON_NODE_FLAGS = ["--experimental-sqlite"];
 function resolveDaemonEntry() {
   const here = dirname8(fileURLToPath3(import.meta.url));
-  const bundledSibling = resolve7(here, "..", "daemon", "index.js");
-  const devSibling = resolve7(here, "..", "..", "..", "daemon", "index.js");
+  const bundledSibling = resolve8(here, "..", "daemon", "index.js");
+  const devSibling = resolve8(here, "..", "..", "..", "daemon", "index.js");
   return process.env.HONEYCOMB_DAEMON_ENTRY ?? bundledSibling ?? devSibling;
 }
 var DEFAULT_START_TIMEOUT_MS = 45e3;
 var START_POLL_INTERVAL_MS = 150;
 function runtimeDir() {
-  return join12(homedir12(), ".honeycomb");
+  return join13(homedir13(), ".honeycomb");
+}
+function resolveDaemonWorkspace() {
+  const fromEnv = process.env.HONEYCOMB_WORKSPACE;
+  const candidates = [fromEnv !== void 0 && fromEnv.length > 0 ? fromEnv : process.cwd(), runtimeDir()];
+  for (const dir of candidates) {
+    if (canWriteDir(dir))
+      return dir;
+  }
+  return runtimeDir();
+}
+function canWriteDir(dir) {
+  try {
+    mkdirSync8(dir, { recursive: true });
+    const probe = mkdtempSync(join13(dir, ".hc-spawn-probe-"));
+    rmSync2(probe, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function readDaemonPid() {
   const { readFile: readFile2 } = await import("node:fs/promises");
   try {
-    const raw = (await readFile2(join12(runtimeDir(), "daemon.pid"), "utf8")).trim();
+    const raw = (await readFile2(join13(runtimeDir(), "daemon.pid"), "utf8")).trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -20163,44 +20501,128 @@ function isPidAlive(pid) {
     return err?.code === "EPERM";
   }
 }
-function buildDaemonLifecycle(client) {
+function buildServiceSpec() {
+  return {
+    nodePath: process.execPath,
+    entry: resolveDaemonEntry(),
+    nodeFlags: DAEMON_NODE_FLAGS,
+    workspace: resolveDaemonWorkspace()
+  };
+}
+async function spawnDaemonAndWait(client) {
+  const entry = resolveDaemonEntry();
+  const workspace = resolveDaemonWorkspace();
+  const child = spawn(process.execPath, [...DAEMON_NODE_FLAGS, entry], {
+    detached: true,
+    stdio: "ignore",
+    cwd: workspace,
+    env: { ...process.env, HONEYCOMB_WORKSPACE: workspace },
+    // Hide the transient console window on Windows: a detached daemon spawn is never an
+    // interactive terminal the user needs to see.
+    windowsHide: true
+  });
+  child.unref();
+  const deadline = Date.now() + DEFAULT_START_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, START_POLL_INTERVAL_MS));
+    if (await client.ping())
+      return { started: true, alreadyRunning: false };
+  }
+  return { started: false, alreadyRunning: false };
+}
+async function waitForHealth(client) {
+  const deadline = Date.now() + DEFAULT_START_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await client.ping())
+      return true;
+    await new Promise((r) => setTimeout(r, START_POLL_INTERVAL_MS));
+  }
+  return false;
+}
+async function signalDaemonStop() {
+  const pid = await readDaemonPid();
+  if (pid === null || !isPidAlive(pid))
+    return false;
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildDaemonLifecycle(client, options = {}) {
+  const manager = options.serviceManager !== void 0 ? options.serviceManager : detectServiceManager();
+  const controllerFor = options.controllerFor ?? ((m) => createDaemonServiceController(m));
+  let controller = null;
+  function serviceController() {
+    if (manager === null)
+      return null;
+    if (controller === null) {
+      try {
+        controller = controllerFor(manager);
+      } catch {
+        return null;
+      }
+    }
+    return controller;
+  }
   return {
     async start() {
       if (await client.ping())
         return { started: false, alreadyRunning: true };
-      const entry = resolveDaemonEntry();
-      const child = spawn(process.execPath, [...DAEMON_NODE_FLAGS, entry], {
-        detached: true,
-        stdio: "ignore",
-        env: process.env,
-        // Hide the transient console window on Windows — a detached daemon spawn is never
-        // an interactive terminal the user needs to see.
-        windowsHide: true
-      });
-      child.unref();
-      const deadline = Date.now() + DEFAULT_START_TIMEOUT_MS;
-      while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, START_POLL_INTERVAL_MS));
-        if (await client.ping())
-          return { started: true, alreadyRunning: false };
-      }
-      return { started: false, alreadyRunning: false };
+      const svc = serviceController();
+      if (svc !== null) {
+        try {
+          svc.register(buildServiceSpec());
+          if (await waitForHealth(client))
+            return { started: true, alreadyRunning: false };
+          return { started: false, alreadyRunning: false };
+        } catch {
+        }
+      }
+      return spawnDaemonAndWait(client);
     },
     async stop() {
-      const pid = await readDaemonPid();
-      if (pid === null || !isPidAlive(pid))
-        return { stopped: false };
-      try {
-        process.kill(pid, "SIGTERM");
-        return { stopped: true };
-      } catch {
-        return { stopped: false };
+      const svc = serviceController();
+      if (svc !== null) {
+        try {
+          svc.stop(buildServiceSpec());
+          return { stopped: true };
+        } catch {
+        }
       }
+      return { stopped: await signalDaemonStop() };
     },
     async status() {
       const pid = await readDaemonPid();
       const running = pid !== null && isPidAlive(pid);
-      return running ? { running, pid, port: DAEMON_PORT } : { running: false, port: DAEMON_PORT };
+      const svc = serviceController();
+      let serviceManager;
+      if (svc !== null) {
+        try {
+          if (svc.isRegistered(buildServiceSpec()))
+            serviceManager = svc.manager;
+        } catch {
+        }
+      }
+      if (running) {
+        return serviceManager !== void 0 ? { running, pid, port: DAEMON_PORT, serviceManager } : { running, pid, port: DAEMON_PORT };
+      }
+      return serviceManager !== void 0 ? { running: false, port: DAEMON_PORT, serviceManager } : { running: false, port: DAEMON_PORT };
+    },
+    async restart() {
+      const svc = serviceController();
+      if (svc !== null && svc.isRegistered(buildServiceSpec())) {
+        try {
+          svc.restart(buildServiceSpec());
+          const ok2 = await waitForHealth(client);
+          return { restarted: ok2, viaService: true };
+        } catch {
+        }
+      }
+      await signalDaemonStop();
+      const { started, alreadyRunning } = await spawnDaemonAndWait(client);
+      return { restarted: started || alreadyRunning, viaService: false };
     }
   };
 }