@arcadeai/hypotenuse 0.19.0 → 0.20.0

package/dist/hypotenuse.js

@@ -343,7 +343,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@arcadeai/hypotenuse",
-  version: "0.19.0",
+  version: "0.20.0",
   description: "Hypotenuse \u2014 run coding agents on your machine for Linear agent sessions",
   type: "module",
   license: "Apache-2.0",
@@ -3922,9 +3922,9 @@ async function socketAnswers(socketPath, timeoutMs = 1500) {
 import { spawn as spawn3 } from "child_process";
 import {
   closeSync as closeSync3,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   openSync as openSync3,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readSync,
   rmSync as rmSync9,
   statSync as statSync5
@@ -4159,8 +4159,8 @@ class DaemonLog {
 
 // src/daemon/main.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync10, rmSync as rmSync8, writeFileSync as writeFileSync5 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync11, rmSync as rmSync8, writeFileSync as writeFileSync5 } from "fs";
 import { join as join10 } from "path";
 
 // src/acp/host.ts
@@ -7308,9 +7308,131 @@ function registrationHeartbeat() {
   };
 }
 
+// src/daemon/config-restart.ts
+class ConfigRestart {
+  deps;
+  timeoutMs;
+  pending = null;
+  generation = 0;
+  takenOver = false;
+  constructor(deps, timeoutMs) {
+    this.deps = deps;
+    this.timeoutMs = timeoutMs;
+  }
+  get isPending() {
+    return this.pending !== null;
+  }
+  get isTakenOver() {
+    return this.takenOver;
+  }
+  saved(outcome, path) {
+    if (this.takenOver)
+      return null;
+    if (this.pending !== null) {
+      if (!outcome.needsRestart) {
+        this.callOff(outcome.invalid ? `${path} is not valid now; the running config stays` : "the change that needed it was undone");
+      }
+      return null;
+    }
+    if (!outcome.needsRestart)
+      return null;
+    const problem = this.deps.startProblem();
+    if (problem) {
+      this.deps.log(`config restart not started: the daemon would not start on ${path} as it is now (${problem}); the running config stays`);
+      return null;
+    }
+    const generation = ++this.generation;
+    this.pending = generation;
+    this.deps.pauseClaims();
+    return this.wait(generation, path);
+  }
+  takeOver() {
+    this.takenOver = true;
+    if (this.pending === null)
+      return;
+    this.pending = null;
+    this.deps.log("config restart called off: a stop or restart was asked for");
+  }
+  async wait(generation, path) {
+    const idle = await this.deps.waitIdle(this.timeoutMs);
+    if (!this.current(generation))
+      return;
+    const problem = this.deps.startProblem();
+    if (problem) {
+      this.callOff(`the daemon would not start on ${path} as it is now (${problem}); the running config stays`);
+      return;
+    }
+    if (!idle)
+      await this.deps.stopTurns();
+    if (!this.current(generation))
+      return;
+    this.pending = null;
+    this.deps.restart();
+  }
+  current(generation) {
+    return this.pending === generation && !this.takenOver && !this.deps.exiting();
+  }
+  callOff(reason) {
+    if (this.pending === null)
+      return;
+    this.pending = null;
+    this.deps.resumeClaims();
+    this.deps.log(`config restart called off: ${reason}`);
+  }
+}
+
+// src/daemon/config-watch.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync9, watch } from "fs";
+import { basename as basename3, dirname as dirname8 } from "path";
+var CONFIG_WATCH_DEBOUNCE_MS = 300;
+function digest(path) {
+  if (!existsSync13(path))
+    return null;
+  try {
+    return createHash2("sha256").update(readFileSync9(path)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function watchConfigFile(path, onChange, options = {}) {
+  const name = basename3(path);
+  let last = digest(path);
+  let timer = null;
+  let watcher;
+  const settle = () => {
+    timer = null;
+    const now = digest(path);
+    if (now === null || now === last)
+      return;
+    last = now;
+    onChange();
+  };
+  try {
+    watcher = watch(dirname8(path), (_event, file) => {
+      if (file !== null && file !== name)
+        return;
+      if (timer)
+        clearTimeout(timer);
+      timer = setTimeout(settle, options.debounceMs ?? CONFIG_WATCH_DEBOUNCE_MS);
+    });
+  } catch (error) {
+    options.onError?.(error);
+    return null;
+  }
+  watcher.on("error", (error) => options.onError?.(error));
+  return {
+    close() {
+      if (timer)
+        clearTimeout(timer);
+      watcher.close();
+    }
+  };
+}
+
 // src/daemon/control-socket.ts
-import { chmodSync as chmodSync4, existsSync as existsSync13, mkdirSync as mkdirSync8, rmSync as rmSync5 } from "fs";
-import { dirname as dirname8 } from "path";
+import { chmodSync as chmodSync4, existsSync as existsSync14, mkdirSync as mkdirSync8, rmSync as rmSync5 } from "fs";
+import { dirname as dirname9 } from "path";
 var METHOD_NOT_FOUND = -32601;
 var INVALID_PARAMS = -32602;
 var INTERNAL_ERROR = -32603;
@@ -7335,8 +7457,8 @@ class ControlServer {
     this.onError = onError;
   }
   listen() {
-    mkdirSync8(dirname8(this.path), { recursive: true, mode: 448 });
-    if (existsSync13(this.path))
+    mkdirSync8(dirname9(this.path), { recursive: true, mode: 448 });
+    if (existsSync14(this.path))
       rmSync5(this.path, { force: true });
     const previous = process.umask(127);
     try {
@@ -7502,11 +7624,11 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync9,
   openSync as openSync2,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   rmSync as rmSync6,
   writeSync
 } from "fs";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 var STARTING_WINDOW_MS = 30000;
 function looksLikeDaemon(args) {
   const program = args.findIndex((arg) => {
@@ -7518,7 +7640,7 @@ function looksLikeDaemon(args) {
 function processArgs(pid) {
   try {
     if (process.platform === "linux") {
-      return readFileSync9(`/proc/${pid}/cmdline`, "utf8").split("\x00").filter(Boolean);
+      return readFileSync10(`/proc/${pid}/cmdline`, "utf8").split("\x00").filter(Boolean);
     }
     if (process.platform === "win32") {
       const out = Bun.spawnSync([
@@ -7553,7 +7675,7 @@ var realProbe = {
 function readLock(path) {
   let text;
   try {
-    text = readFileSync9(path, "utf8");
+    text = readFileSync10(path, "utf8");
   } catch {
     return;
   }
@@ -7577,7 +7699,7 @@ async function inspectLock(path, probe = realProbe, now = Date.now) {
   return now() - record.startedAt < STARTING_WINDOW_MS ? { kind: "starting", record } : { kind: "hung", record };
 }
 function writeExclusive(path, record) {
-  mkdirSync9(dirname9(path), { recursive: true, mode: 448 });
+  mkdirSync9(dirname10(path), { recursive: true, mode: 448 });
   let fd;
   try {
     fd = openSync2(path, "wx", 384);
@@ -7655,8 +7777,8 @@ function childArgs(args) {
 
 // src/daemon/state.ts
 import { Database } from "bun:sqlite";
-import { chmodSync as chmodSync5, existsSync as existsSync14, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname10 } from "path";
+import { chmodSync as chmodSync5, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname11 } from "path";
 var LIVE_LOCAL_STATES = [
   "claimed",
   "running"
@@ -7778,9 +7900,9 @@ class StateDb {
     this.path = path;
     this.now = now;
     if (path !== ":memory:") {
-      mkdirSync10(dirname10(path), { recursive: true, mode: 448 });
+      mkdirSync10(dirname11(path), { recursive: true, mode: 448 });
     }
-    const fresh = path === ":memory:" || !existsSync14(path);
+    const fresh = path === ":memory:" || !existsSync15(path);
     this.db = new Database(path, { create: true, strict: true });
     if (fresh && path !== ":memory:")
       chmodSync5(path, 384);
@@ -8598,7 +8720,7 @@ function resolvedConfigSecrets(config, env) {
 }
 
 // src/worktree/cleanup.ts
-import { existsSync as existsSync15, readdirSync, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync16, readdirSync, rmSync as rmSync7 } from "fs";
 import { join as join9, relative as relative5, resolve as resolve4 } from "path";
 
 // src/worktree/merge-state.ts
@@ -8736,14 +8858,14 @@ class WorktreeCleaner {
     if (this.inUse(wt))
       return { reason: "in use", overridable: [] };
     const reasons = [];
-    if (wt.kind === "worktree" && existsSync15(wt.path)) {
+    if (wt.kind === "worktree" && existsSync16(wt.path)) {
       const status = await this.git(["status", "--porcelain", "--", ".", `:(exclude)${KEEP_FILE}`], { cwd: wt.path });
       if (status.code !== 0 || status.stdout.trim())
         reasons.push("uncommitted changes");
       if (await this.hasUnpushed(wt))
         reasons.push("unpushed commits");
     }
-    if (existsSync15(join9(wt.path, KEEP_FILE)))
+    if (existsSync16(join9(wt.path, KEEP_FILE)))
       reasons.push("kept by request");
     return { reason: reasons[0] ?? null, overridable: reasons };
   }
@@ -8800,7 +8922,7 @@ class WorktreeCleaner {
       }
     }
     const scratch = join9(root, SCRATCH);
-    if (existsSync15(scratch)) {
+    if (existsSync16(scratch)) {
       for (const name of readdirSync(scratch)) {
         const path = join9(scratch, name);
         const id = Number(name);
@@ -8854,7 +8976,7 @@ class WorktreeCleaner {
       if (!options.dryRun)
         this.state.updateWorktree(wt.id, { keptReason: reason });
     };
-    if (!existsSync15(wt.path)) {
+    if (!existsSync16(wt.path)) {
       if (!options.dryRun) {
         if (wt.repoPath)
           await this.git(["worktree", "prune"], { cwd: wt.repoPath });
@@ -10368,6 +10490,14 @@ class Supervisor {
     this.link.beatNow();
     return { drained: this.slots.size === 0 && flushed, cancelled };
   }
+  pauseClaims() {
+    this.draining = true;
+    this.link.beatNow();
+  }
+  resumeClaims() {
+    this.draining = false;
+    this.link.beatNow();
+  }
   async waitIdle(timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (this.slots.size > 0) {
@@ -10593,18 +10723,19 @@ function revokedMarker(stateDir) {
   return join10(stateDir, "revoked.json");
 }
 function fingerprint(token) {
-  return createHash2("sha256").update(token).digest("hex");
+  return createHash3("sha256").update(token).digest("hex");
 }
 function wasRevoked(stateDir, token) {
   const file = revokedMarker(stateDir);
-  if (!existsSync16(file))
+  if (!existsSync17(file))
     return false;
   try {
-    return JSON.parse(readFileSync10(file, "utf8")).token === fingerprint(token);
+    return JSON.parse(readFileSync11(file, "utf8")).token === fingerprint(token);
   } catch {
     return false;
   }
 }
+var CONFIG_RESTART_DRAIN_MS = 10 * 60000;
 function readDaemonConfig(options, env) {
   const path = resolveConfigPath(options.config, env);
   const checked = checkConfig(path, { env, offline: true });
@@ -10677,19 +10808,55 @@ async function runDaemon(options) {
   const machine = realMachine(env);
   const api = new DaemonApi(origin, runner.token, (line) => log.debug(line));
   let exiting = false;
+  let restartScheduled = false;
+  let configHandOff = null;
   let supervisor;
   let control;
+  let watcher = null;
   const teardown = async (drain) => {
     if (drain) {
       await supervisor.drain({ timeoutMs: 1e4, cancel: false });
     } else {
       await supervisor.sink.drain(2000);
     }
+    watcher?.close();
     supervisor.close();
     control.close();
     releaseLock(paths.pidfile);
     state.close();
   };
+  const restartSelf = (fromConfig = false) => {
+    const service = env.HYPOTENUSE_SERVICE === "1";
+    const answer = {
+      restarting: true,
+      mode: service ? "service" : "re-exec"
+    };
+    if (restartScheduled)
+      return answer;
+    restartScheduled = true;
+    const handOff = setTimeout(() => {
+      configHandOff = null;
+      if (exiting)
+        return;
+      exiting = true;
+      log.info(service ? "exiting for the service manager to restart" : "re-executing");
+      teardown(false).then(() => {
+        if (service)
+          process.exit(EXIT_RESTART);
+        const [command, ...prefix] = selfCommand();
+        const child = spawn2(command, [...prefix, ...childArgs(process.argv.slice(2))], {
+          detached: true,
+          stdio: "ignore",
+          env
+        });
+        child.unref();
+        process.exit(0);
+      });
+    }, 50);
+    if (fromConfig)
+      configHandOff = handOff;
+    return answer;
+  };
   const requestExit = (exit) => {
     if (exiting)
       return;
@@ -10725,6 +10892,31 @@ async function runDaemon(options) {
       ...Object.values(credentials.servers).flatMap((s) => s.login ? [s.login.token] : [])
     ]
   });
+  const configRestart = new ConfigRestart({
+    pauseClaims: () => supervisor.pauseClaims(),
+    resumeClaims: () => supervisor.resumeClaims(),
+    waitIdle: (ms) => supervisor.waitIdle(ms),
+    stopTurns: async () => {
+      await supervisor.drain({ timeoutMs: 0, cancel: true });
+    },
+    startProblem: () => {
+      const read = readDaemonConfig(options, env);
+      if (!read.config)
+        return "the config is not valid";
+      const file = credentialsPath(env);
+      try {
+        resolveDaemonRunner(read.config, loadCredentials(file), file);
+      } catch (error) {
+        return error instanceof Error ? error.message : String(error);
+      }
+      return null;
+    },
+    exiting: () => exiting,
+    restart: () => {
+      restartSelf(true);
+    },
+    log: (message) => log.info(message)
+  }, CONFIG_RESTART_DRAIN_MS);
   control = new ControlServer(paths.socket, {
     status: () => supervisor.status({ pid: process.pid, configPath: paths.config }),
     "agents.list": (params) => supervisor.agents(Boolean(params.all)),
@@ -10742,30 +10934,23 @@ async function runDaemon(options) {
       const report = await supervisor.cleaner.run(cleanupParams(params));
       return report;
     },
-    drain: (params) => supervisor.drain({
-      timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : 600000,
-      cancel: params.cancel === true
-    }),
+    drain: (params) => {
+      configRestart.takeOver();
+      if (configHandOff) {
+        clearTimeout(configHandOff);
+        configHandOff = null;
+        restartScheduled = false;
+        log.info("config restart called off: a stop or restart was asked for");
+      }
+      return supervisor.drain({
+        timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : 600000,
+        cancel: params.cancel === true
+      });
+    },
     reload: () => supervisor.reload(),
     restart: () => {
-      const service = env.HYPOTENUSE_SERVICE === "1";
-      setTimeout(() => {
-        exiting = true;
-        log.info(service ? "exiting for the service manager to restart" : "re-executing");
-        teardown(false).then(() => {
-          if (service)
-            process.exit(EXIT_RESTART);
-          const [command, ...prefix] = selfCommand();
-          const child = spawn2(command, [...prefix, ...childArgs(process.argv.slice(2))], {
-            detached: true,
-            stdio: "ignore",
-            env
-          });
-          child.unref();
-          process.exit(0);
-        });
-      }, 50);
-      return { restarting: true, mode: service ? "service" : "re-exec" };
+      configRestart.takeOver();
+      return restartSelf();
     },
     "mcp.hello": (params) => supervisor.broker.hello(params),
     "mcp.call": (params) => supervisor.broker.call(params)
@@ -10801,6 +10986,19 @@ async function runDaemon(options) {
   });
   report({ ready: true, pid: process.pid });
   rmSync8(revokedMarker(paths.stateDir), { force: true });
+  watcher = watchConfigFile(paths.config, () => {
+    if (exiting || restartScheduled || configRestart.isTakenOver)
+      return;
+    log.info(`${paths.config} changed; reloading`);
+    const result = supervisor.reload();
+    const needsRestart = !result.error && result.requiresRestart.length > 0;
+    if (needsRestart && !configRestart.isPending) {
+      log.info("restarting to apply the config change once running turns finish", { keys: result.requiresRestart.join(",") });
+    }
+    configRestart.saved({ needsRestart, invalid: Boolean(result.error) }, paths.config);
+  }, {
+    onError: (error) => log.warn(`not watching ${paths.config} for changes (\`hypotenuse daemon reload\` still applies them): ${error instanceof Error ? error.message : String(error)}`)
+  });
 }
 
 // src/commands/daemon.ts
@@ -10962,22 +11160,22 @@ async function stopDaemon(ctx, options) {
 }
 async function tailLog(file, options) {
   const keep = (line) => !options.session || line.includes(` session=${options.session}`);
-  if (!existsSync17(file)) {
+  if (!existsSync18(file)) {
     if (!options.follow)
       throw new Error(`${file} does not exist yet`);
   } else {
-    const all = readFileSync11(file, "utf8").split(`
+    const all = readFileSync12(file, "utf8").split(`
 `).filter(Boolean).filter(keep);
     for (const line of all.slice(-options.lines))
       console.log(paintLogLine(line));
   }
   if (!options.follow)
     return;
-  let offset = existsSync17(file) ? statSync5(file).size : 0;
+  let offset = existsSync18(file) ? statSync5(file).size : 0;
   let partial = "";
   for (;; ) {
     await Bun.sleep(500);
-    if (!existsSync17(file))
+    if (!existsSync18(file))
       continue;
     const size = statSync5(file).size;
     if (size < offset)
@@ -11072,7 +11270,7 @@ function registerDaemonCommands(program) {
       const opts = this.opts();
       const located = locateDaemon(ctx);
       const sessionLog = opts.session && /^\d+$/.test(opts.session) ? sessionLogPath(located.stateDir, Number(opts.session)) : null;
-      if (sessionLog && existsSync17(sessionLog)) {
+      if (sessionLog && existsSync18(sessionLog)) {
         await tailLog(sessionLog, {
           lines: Number(opts.lines) || 200,
           follow: Boolean(opts.follow)
@@ -11538,9 +11736,9 @@ function registerCheckUpdateCommand(program) {
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "fs";
 import { hostname as hostname5 } from "os";
-import { dirname as dirname11, resolve as resolve5 } from "path";
+import { dirname as dirname12, resolve as resolve5 } from "path";
 
 // src/config/template.toml
 var template_default = `#:schema https://www.hypotenuse.cloud/schemas/config-v1.json
@@ -11687,7 +11885,7 @@ function registerConfigCommands(program) {
     await runCommand(this, async (ctx) => {
       const opts = this.opts();
       const path = ctx.configPath;
-      if (existsSync18(path) && !opts.force) {
+      if (existsSync19(path) && !opts.force) {
         throw new Error(`${path} already exists; pass --force to overwrite it`);
       }
       const machine = realMachine(ctx.env);
@@ -11704,7 +11902,7 @@ function registerConfigCommands(program) {
         repositories: repositoryBlocks(repos, ctx.env),
         cpus: navigator.hardwareConcurrency || 1
       });
-      mkdirSync11(dirname11(resolve5(path)), { recursive: true, mode: 448 });
+      mkdirSync11(dirname12(resolve5(path)), { recursive: true, mode: 448 });
       writeFileSync6(path, text);
       if (!ctx.json)
         console.log(`Wrote ${tildify(path, ctx.env)}.`);
@@ -11745,14 +11943,14 @@ function registerConfigCommands(program) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync20, statfsSync as statfsSync2, statSync as statSync6 } from "fs";
+import { existsSync as existsSync21, statfsSync as statfsSync2, statSync as statSync6 } from "fs";
 import { hostname as hostname6 } from "os";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 
 // src/commands/service.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir3, userInfo } from "os";
-import { dirname as dirname12, join as join11 } from "path";
+import { dirname as dirname13, join as join11 } from "path";
 
 // src/daemon/units/launchd.plist
 var launchd_default = `<?xml version="1.0" encoding="UTF-8"?>
@@ -11888,7 +12086,7 @@ function registerServiceCommands(program) {
         console.log(text);
         return;
       }
-      mkdirSync12(dirname12(path), { recursive: true });
+      mkdirSync12(dirname13(path), { recursive: true });
       mkdirSync12(paths.stateDir, { recursive: true, mode: 448 });
       writeFileSync7(path, text);
       if (platform === "darwin") {
@@ -11909,7 +12107,7 @@ function registerServiceCommands(program) {
   service.command("uninstall").description("Stop the service and remove its unit file").action(async function() {
     await runCommand(this, async (ctx) => {
       const path = unitPath(process.platform, ctx.env);
-      if (!path || !existsSync19(path)) {
+      if (!path || !existsSync20(path)) {
         emit(ctx, { removed: false }, () => "No service is installed.");
         return;
       }
@@ -11927,7 +12125,7 @@ function registerServiceCommands(program) {
   service.command("status").description("Show whether the service is installed and loaded, and the daemon's status").action(async function() {
     await runCommand(this, async (ctx) => {
       const path = unitPath(process.platform, ctx.env);
-      const installed = Boolean(path && existsSync19(path));
+      const installed = Boolean(path && existsSync20(path));
       let manager = "not installed";
       if (installed && process.platform === "darwin") {
         manager = run(["launchctl", "print", `gui/${userInfo().uid}/${LAUNCHD_LABEL}`], true).includes("state = running") ? "running" : "loaded, not running";
@@ -12015,7 +12213,7 @@ async function runDoctor(ctx, options) {
     return list.checks;
   }
   let runner = null;
-  if (!existsSync20(ctx.credentialsPath)) {
+  if (!existsSync21(ctx.credentialsPath)) {
     list.fail("credentials", `${tildify(ctx.credentialsPath, ctx.env)} does not exist \u2014 \`hypotenuse login\`, then \`hypotenuse runner register\``);
   } else {
     try {
@@ -12078,7 +12276,7 @@ async function runDoctor(ctx, options) {
     list.warn("daemon", "not running \u2014 `hypotenuse daemon start` or `hypotenuse service install`");
   }
   const unit = unitPath(process.platform, ctx.env);
-  if (unit && existsSync20(unit))
+  if (unit && existsSync21(unit))
     list.ok("daemon", `service unit ${tildify(unit, ctx.env)}`);
   else if (unit)
     list.warn("daemon", "no service unit \u2014 `hypotenuse service install` starts the daemon at login");
@@ -12146,8 +12344,8 @@ async function runDoctor(ctx, options) {
 `).at(-1) ?? ""}`);
   }
   let probePath = config.sessions.worktree_root;
-  while (!existsSync20(probePath) && dirname13(probePath) !== probePath)
-    probePath = dirname13(probePath);
+  while (!existsSync21(probePath) && dirname14(probePath) !== probePath)
+    probePath = dirname14(probePath);
   try {
     const fs = statfsSync2(probePath);
     const free = fs.bavail * fs.bsize;
@@ -13737,7 +13935,7 @@ function registerSessionCommands(program) {
 }
 
 // src/commands/skill.ts
-import { existsSync as existsSync21, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync13 } from "fs";
 import { join as join13 } from "path";
 var SKILL_FILE = "hypotenuse.md";
 async function readSkill() {
@@ -13746,8 +13944,8 @@ async function readSkill() {
     return embedded.text();
   for (const up of [[".."], ["..", ".."]]) {
     const path = join13(import.meta.dir, ...up, "skills", SKILL_FILE);
-    if (existsSync21(path))
-      return readFileSync12(path, "utf8");
+    if (existsSync22(path))
+      return readFileSync13(path, "utf8");
   }
   throw new Error(`This install has no skills/${SKILL_FILE}; reinstall hypotenuse.`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcadeai/hypotenuse",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Hypotenuse — run coding agents on your machine for Linear agent sessions",
   "type": "module",
   "license": "Apache-2.0",

package/skills/hypotenuse.md

@@ -41,7 +41,7 @@ server. It calls the same HTTP actions the dashboard does, as the person who sig
 | `hypotenuse telemetry exporter list\|view\|add\|edit\|remove\|test` | Where the selected project's OpenTelemetry goes: each exporter is an OTLP/HTTP collector that receives every turn as one trace, at a content level (`metadata`, `content`, or `full` — full sends prompts and source code). `list` and `view <id>` show endpoint, level, signals, sample share, header names (never values), and the last export or error (any member); `add --name <name> --endpoint <https-url> [--header KEY=VALUE...] [--content <level>] [--signals traces,metrics,logs] [--sample 0.5] [--attribute KEY=VALUE...] [--no-agent-native] [--disabled]`; `edit <id>` with the same flags plus `--clear-headers` and `--enable\|--disable` (headers are kept unless given); `remove <id>`; `test <id>` sends a probe and prints each signal's answer, exiting 1 on a failure. Changes and tests are admin-only; header values are never printed. |
 | `hypotenuse identity list\|link\|unlink` | Links between people in the project's Linear workspace and project members; routing prefers the runners of whoever started a session. `list [--user <id>]` shows each link and how it was made (e-mail match, Linear sign-in, admin); `link --user <id> --linear-user <id> [--name] [--email]` links one (admin); `unlink <id>` removes your own link, or anyone's as an admin. |
 | `hypotenuse config init\|validate\|schema\|path` | The daemon's TOML config (`-c <path>`, else `HYPOTENUSE_CONFIG`, else `~/.config/hypotenuse/config.toml`). `init [--repo <path>...] [--force]` writes a commented starter filled in from this machine; `validate [--online] [--offline]` checks shape, references, and this machine (git clones, prompt files, agent commands), and with `--online` the server, runner token, project, and team keys — exit 0 valid (warnings allowed), 1 errors, 2 unreadable; `--json` prints `{ valid, errors: [{ path, message, hint? }], warnings }`. `schema` prints the JSON Schema; `path` prints the config, state directory, and credentials file in use. |
-| `hypotenuse daemon start\|stop\|restart\|status\|logs\|reload` | The runner daemon. `start` backgrounds it and waits until it is ready (`--foreground` stays attached, as a service manager runs it; `--log-level <level>` overrides `[log] level`, and `debug` logs every agent activity); `stop [--timeout 10m] [--cancel]` lets running turns finish (or stops them) and exits, `--force` signals it without its control socket; `status` exits 3 when it is not running; `logs [-f] [-n 200] [--session <id>]` (`--session` shows that session's agent log: the agent's stderr and ACP trace); `reload` re-reads the config and says what needs a restart. One daemon per machine. |
+| `hypotenuse daemon start\|stop\|restart\|status\|logs\|reload` | The runner daemon. `start` backgrounds it and waits until it is ready (`--foreground` stays attached, as a service manager runs it; `--log-level <level>` overrides `[log] level`, and `debug` logs every agent activity); `stop [--timeout 10m] [--cancel]` lets running turns finish (or stops them) and exits, `--force` signals it without its control socket; `status` exits 3 when it is not running; `logs [-f] [-n 200] [--session <id>]` (`--session` shows that session's agent log: the agent's stderr and ACP trace); `reload` re-reads the config and says what needs a restart — the daemon also watches its config file, reloading on save and restarting itself (after running turns finish) when a change needs it. One daemon per machine. |
 | `hypotenuse agents list\|kill\|login` | The coding agents this machine runs. `list [--all]` shows the agent sessions the daemon is running (session, issue, role, agent, state, how long, pid, worktree); `kill <session-id\|ENG-123> [--reason]` stops that session's running turn, which says so in Linear (with the reason); both exit 3 when the daemon is not running. `login <agent> [--method <id>]` logs a coding agent in on this machine — a terminal login runs attached, an agent-run one over ACP — then confirms it can open a session (exit 1 if not). |
 | `hypotenuse worktrees list\|cleanup` | The git worktrees (and scratch directories) the daemon made for its sessions, one per session under `sessions.worktree_root`. `list` shows each one's repository, branch, issue, state, last use, size, and whether it is safe to remove now (not in use, no uncommitted changes, no unpushed commits, no `.hypotenuse-keep` file). `cleanup [--dry-run] [--all] [--older-than 7d] [--force]` removes what the cleanup policy allows and prints every kept one with its reason; `--all` ignores the policy, `--force` overrides every rule but "in use". Both work without a running daemon, from `state.db` and the disk. |
 | `hypotenuse service install\|uninstall\|status` | Run the daemon as a user service (launchd on macOS, systemd user unit on Linux) with the `PATH` of the installing shell; `install --print` shows the unit without installing it. Windows: prints the foreground command and the Task Scheduler recipe. |