@arcadeai/hypotenuse 0.17.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.17.0",
+  version: "0.20.0",
   description: "Hypotenuse \u2014 run coding agents on your machine for Linear agent sessions",
   type: "module",
   license: "Apache-2.0",
@@ -752,6 +752,173 @@ function isPreset(name) {
 
 // src/config/resolve.ts
 import { basename } from "path";
+function agentById(config, id) {
+  const table = config.agents[id];
+  if (table) {
+    const base = table.preset ? [...AGENT_PRESETS[table.preset].command] : table.command ?? [];
+    return {
+      id,
+      preset: table.preset ?? null,
+      command: [...base, ...table.args],
+      env: table.env,
+      maxParallel: table.max_parallel
+    };
+  }
+  if (isPreset(id)) {
+    return {
+      id,
+      preset: id,
+      command: [...AGENT_PRESETS[id].command],
+      env: {},
+      maxParallel: undefined
+    };
+  }
+  return;
+}
+function playedRoles(config) {
+  return config.runner.roles.flatMap((role) => {
+    const table = config.roles[role];
+    return table ? [[role, table]] : [];
+  });
+}
+function resolveAgents(config) {
+  const byId = new Map;
+  for (const id of Object.keys(config.agents)) {
+    const agent = agentById(config, id);
+    if (agent)
+      byId.set(id, { ...agent, roles: [] });
+  }
+  for (const [role, table] of playedRoles(config)) {
+    const known = byId.get(table.agent);
+    if (known) {
+      if (!known.roles.includes(role))
+        known.roles.push(role);
+      continue;
+    }
+    const agent = agentById(config, table.agent);
+    if (agent)
+      byId.set(table.agent, { ...agent, roles: [role] });
+  }
+  return [...byId.values()];
+}
+function repositoryName(repo, origin) {
+  if (repo.name)
+    return repo.name;
+  const source = origin ?? repo.path;
+  return basename(source.replace(/\/+$/, "")) || "repository";
+}
+
+// src/acp/presets.ts
+var SESSION_VARIABLES = new Set([
+  "HYPOTENUSE_SESSION_ID",
+  "HYPOTENUSE_LINEAR_SESSION_ID",
+  "HYPOTENUSE_ISSUE",
+  "HYPOTENUSE_ISSUE_URL",
+  "HYPOTENUSE_BRANCH",
+  "HYPOTENUSE_BASE_BRANCH",
+  "HYPOTENUSE_ROLE",
+  "HYPOTENUSE_SESSION_URL"
+]);
+function expandVariables(value, env) {
+  return value.replace(/\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g, (_, braced, bare) => env[braced ?? bare] ?? "");
+}
+function sessionVariables(assignment, branch) {
+  return {
+    HYPOTENUSE_SESSION_ID: String(assignment.agentSessionId),
+    HYPOTENUSE_LINEAR_SESSION_ID: assignment.externalSessionId,
+    HYPOTENUSE_ISSUE: assignment.issue.identifier ?? "",
+    HYPOTENUSE_ISSUE_URL: assignment.issue.url ?? "",
+    HYPOTENUSE_BRANCH: branch ?? "",
+    HYPOTENUSE_BASE_BRANCH: assignment.repository?.baseBranch ?? "",
+    HYPOTENUSE_ROLE: assignment.role,
+    HYPOTENUSE_SESSION_URL: assignment.dashboardUrl,
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function sessionEnvironment(daemonEnv, extra) {
+  const env = {};
+  for (const [key, value] of Object.entries(daemonEnv)) {
+    if (value === undefined)
+      continue;
+    if (key.startsWith("HYPOTENUSE_") && !SESSION_VARIABLES.has(key))
+      continue;
+    env[key] = value;
+  }
+  return Object.assign(env, extra);
+}
+function resolveAgentLaunch(config, agentId, daemonEnv, extra = {}) {
+  const agent = resolveAgents(config).find((a) => a.id === agentId);
+  if (!agent || !agent.command.length)
+    return null;
+  const table = config.agents[agentId];
+  const env = sessionEnvironment(daemonEnv, {});
+  const preset = agent.preset ? AGENT_PRESETS[agent.preset] : null;
+  if (preset && "env" in preset && preset.env)
+    Object.assign(env, preset.env);
+  if (agent.command[0] === "npx")
+    env.npm_config_yes = "true";
+  for (const [key, value] of Object.entries(agent.env))
+    env[key] = expandVariables(value, daemonEnv);
+  Object.assign(env, extra);
+  return {
+    id: agent.id,
+    preset: agent.preset,
+    command: agent.command,
+    env,
+    startupTimeoutMs: table?.startup_timeout ?? 60000,
+    authMethod: table?.auth_method ?? null
+  };
+}
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { parse, TomlError } from "smol-toml";
+
+// src/config/introspect.ts
+function defOf(schema) {
+  return schema._zod.def;
+}
+function unwrap(schema) {
+  let current = schema;
+  for (;; ) {
+    const def = defOf(current);
+    if (def.innerType && ["optional", "default", "prefault", "nullable", "readonly"].includes(def.type)) {
+      current = def.innerType;
+    } else if (def.type === "pipe" && def.in) {
+      current = def.in;
+    } else {
+      return current;
+    }
+  }
+}
+function schemaAt(schema, path) {
+  let current = schema;
+  for (const segment of path) {
+    if (!current)
+      return;
+    const def = defOf(unwrap(current));
+    if (def.type === "object")
+      current = def.shape?.[String(segment)];
+    else if (def.type === "record")
+      current = def.valueType;
+    else if (def.type === "array")
+      current = def.element;
+    else
+      return;
+  }
+  return current;
+}
+function objectKeys(schema) {
+  if (!schema)
+    return [];
+  const def = defOf(unwrap(schema));
+  return def.type === "object" ? Object.keys(def.shape ?? {}) : [];
+}
+
+// src/config/schema.ts
+import { cpus, hostname } from "os";
+import { z as z9 } from "zod";
 
 // ../protocol/src/capabilities.ts
 import { z as z2 } from "zod";
@@ -1886,175 +2053,6 @@ var WorkAssignment = z8.looseObject({
 var ClaimResponse = z8.looseObject({
   assignment: WorkAssignment.nullable()
 });
-// src/config/resolve.ts
-function agentById(config, id) {
-  const table = config.agents[id];
-  if (table) {
-    const base = table.preset ? [...AGENT_PRESETS[table.preset].command] : table.command ?? [];
-    return {
-      id,
-      preset: table.preset ?? null,
-      command: [...base, ...table.args],
-      env: table.env,
-      maxParallel: table.max_parallel
-    };
-  }
-  if (isPreset(id)) {
-    return {
-      id,
-      preset: id,
-      command: [...AGENT_PRESETS[id].command],
-      env: {},
-      maxParallel: undefined
-    };
-  }
-  return;
-}
-function playedRoles(config) {
-  return config.runner.roles.flatMap((role) => {
-    const table = config.roles[role];
-    return table ? [[role, table]] : [];
-  });
-}
-function resolveAgents(config) {
-  const byId = new Map;
-  for (const id of Object.keys(config.agents)) {
-    const agent = agentById(config, id);
-    if (agent)
-      byId.set(id, { ...agent, roles: [] });
-  }
-  for (const [role, table] of playedRoles(config)) {
-    const known = byId.get(table.agent);
-    if (known) {
-      if (!known.roles.includes(role))
-        known.roles.push(role);
-      continue;
-    }
-    const agent = agentById(config, table.agent);
-    if (agent)
-      byId.set(table.agent, { ...agent, roles: [role] });
-  }
-  return [...byId.values()];
-}
-function repositoryName(repo) {
-  if (repo.name)
-    return repo.name;
-  const source = repo.remote ? normalizeRemote(repo.remote) : repo.path;
-  return basename(source.replace(/\/+$/, "")) || "repository";
-}
-
-// src/acp/presets.ts
-var SESSION_VARIABLES = new Set([
-  "HYPOTENUSE_SESSION_ID",
-  "HYPOTENUSE_LINEAR_SESSION_ID",
-  "HYPOTENUSE_ISSUE",
-  "HYPOTENUSE_ISSUE_URL",
-  "HYPOTENUSE_BRANCH",
-  "HYPOTENUSE_BASE_BRANCH",
-  "HYPOTENUSE_ROLE",
-  "HYPOTENUSE_SESSION_URL"
-]);
-function expandVariables(value, env) {
-  return value.replace(/\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g, (_, braced, bare) => env[braced ?? bare] ?? "");
-}
-function sessionVariables(assignment, branch) {
-  return {
-    HYPOTENUSE_SESSION_ID: String(assignment.agentSessionId),
-    HYPOTENUSE_LINEAR_SESSION_ID: assignment.externalSessionId,
-    HYPOTENUSE_ISSUE: assignment.issue.identifier ?? "",
-    HYPOTENUSE_ISSUE_URL: assignment.issue.url ?? "",
-    HYPOTENUSE_BRANCH: branch ?? "",
-    HYPOTENUSE_BASE_BRANCH: assignment.repository?.baseBranch ?? "",
-    HYPOTENUSE_ROLE: assignment.role,
-    HYPOTENUSE_SESSION_URL: assignment.dashboardUrl,
-    GIT_TERMINAL_PROMPT: "0"
-  };
-}
-function sessionEnvironment(daemonEnv, extra) {
-  const env = {};
-  for (const [key, value] of Object.entries(daemonEnv)) {
-    if (value === undefined)
-      continue;
-    if (key.startsWith("HYPOTENUSE_") && !SESSION_VARIABLES.has(key))
-      continue;
-    env[key] = value;
-  }
-  return Object.assign(env, extra);
-}
-function resolveAgentLaunch(config, agentId, daemonEnv, extra = {}) {
-  const agent = resolveAgents(config).find((a) => a.id === agentId);
-  if (!agent || !agent.command.length)
-    return null;
-  const table = config.agents[agentId];
-  const env = sessionEnvironment(daemonEnv, {});
-  const preset = agent.preset ? AGENT_PRESETS[agent.preset] : null;
-  if (preset && "env" in preset && preset.env)
-    Object.assign(env, preset.env);
-  if (agent.command[0] === "npx")
-    env.npm_config_yes = "true";
-  for (const [key, value] of Object.entries(agent.env))
-    env[key] = expandVariables(value, daemonEnv);
-  Object.assign(env, extra);
-  return {
-    id: agent.id,
-    preset: agent.preset,
-    command: agent.command,
-    env,
-    startupTimeoutMs: table?.startup_timeout ?? 60000,
-    authMethod: table?.auth_method ?? null
-  };
-}
-
-// src/config/loader.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname as dirname2 } from "path";
-import { parse, TomlError } from "smol-toml";
-
-// src/config/introspect.ts
-function defOf(schema) {
-  return schema._zod.def;
-}
-function unwrap(schema) {
-  let current = schema;
-  for (;; ) {
-    const def = defOf(current);
-    if (def.innerType && ["optional", "default", "prefault", "nullable", "readonly"].includes(def.type)) {
-      current = def.innerType;
-    } else if (def.type === "pipe" && def.in) {
-      current = def.in;
-    } else {
-      return current;
-    }
-  }
-}
-function schemaAt(schema, path) {
-  let current = schema;
-  for (const segment of path) {
-    if (!current)
-      return;
-    const def = defOf(unwrap(current));
-    if (def.type === "object")
-      current = def.shape?.[String(segment)];
-    else if (def.type === "record")
-      current = def.valueType;
-    else if (def.type === "array")
-      current = def.element;
-    else
-      return;
-  }
-  return current;
-}
-function objectKeys(schema) {
-  if (!schema)
-    return [];
-  const def = defOf(unwrap(schema));
-  return def.type === "object" ? Object.keys(def.shape ?? {}) : [];
-}
-
-// src/config/schema.ts
-import { cpus, hostname } from "os";
-import { z as z9 } from "zod";
-
 // src/config/durations.ts
 var DURATION_UNITS = {
   ms: 1,
@@ -2252,7 +2250,6 @@ function buildConfigSchema(ctx) {
   const repository = z9.strictObject({
     name: z9.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "letters, digits, `.`, `_`, `-`").max(64).optional().describe("Unique; used in worktree paths"),
     path: path().describe("An existing git clone"),
-    remote: z9.string().trim().min(1).optional().describe("The repository's remote; must match origin"),
     base_branch: z9.string().trim().min(1).optional().describe("The branch worktrees start from"),
     setup: strings().default([]).describe("Shell commands run in each new worktree"),
     setup_timeout: duration().prefault("10m").describe("Per setup command"),
@@ -2592,11 +2589,11 @@ function originHead(machine, path) {
   return result.code === 0 && ref.startsWith("origin/") ? ref.slice("origin/".length) : null;
 }
 function resolveRepository(machine, repo) {
-  const remote = repo.remote ? normalizeRemote(repo.remote) : originOf(machine, repo.path);
+  const remote = originOf(machine, repo.path);
   if (!remote)
     return null;
   return {
-    name: repositoryName({ ...repo, remote }),
+    name: repositoryName(repo, remote),
     remote,
     baseBranch: repo.base_branch ?? originHead(machine, repo.path) ?? "main",
     path: repo.path
@@ -3140,35 +3137,7 @@ function validateReferences(config) {
       hint: 'the default denies edit, delete, move, and execute: { default = "allow", edit = "deny", delete = "deny", move = "deny", execute = "deny" }'
     });
   }
-  const names = new Map;
-  const remotes = new Map;
   config.repositories.forEach((repo, index) => {
-    const name = repositoryName(repo);
-    if (!repo.name && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
-      errors.push({
-        path: `repositories[${index}]`,
-        message: `"${name}" is not a usable repository name (letters, digits, \`.\`, \`_\`, \`-\`); set name`
-      });
-    }
-    const firstName = names.get(name);
-    if (firstName !== undefined) {
-      errors.push({
-        path: `repositories[${index}].name`,
-        message: `"${name}" is already repositories[${firstName}]`
-      });
-    } else
-      names.set(name, index);
-    if (repo.remote) {
-      const remote = normalizeRemote(repo.remote);
-      const first = remotes.get(remote);
-      if (first !== undefined) {
-        errors.push({
-          path: `repositories[${index}].remote`,
-          message: `${remote} is already repositories[${first}]`
-        });
-      } else
-        remotes.set(remote, index);
-    }
     if (repo.cleanup === "ttl" && config.sessions.cleanup_ttl === undefined) {
       errors.push({
         path: `repositories[${index}].cleanup`,
@@ -3259,6 +3228,8 @@ function validateMachine(config, machine, options = {}) {
       message: `git ${version.join(".")} is older than ${MIN_GIT_VERSION.join(".")}`
     });
   }
+  const origins = new Map;
+  const names = new Map;
   config.repositories.forEach((repo, index) => {
     const at = `repositories[${index}]`;
     if (!machine.isDirectory(repo.path)) {
@@ -3285,21 +3256,37 @@ function validateMachine(config, machine, options = {}) {
       return;
     }
     const origin = originOf(machine, repo.path);
-    const configured = repo.remote ? normalizeRemote(repo.remote) : null;
     if (!origin) {
       errors.push({
-        path: `${at}.remote`,
+        path: `${at}.path`,
         message: `${home(repo.path)} has no origin remote`
       });
       return;
     }
-    if (configured && origin !== configured) {
+    const first = origins.get(origin);
+    if (first !== undefined) {
       errors.push({
-        path: `${at}.remote`,
-        message: `origin is ${origin}, config says ${configured}`
+        path: `${at}.path`,
+        message: `${home(repo.path)} is another clone of ${origin}, already repositories[${first}]`
       });
       return;
     }
+    origins.set(origin, index);
+    const name = repositoryName(repo, origin);
+    if (!repo.name && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+      errors.push({
+        path: `${at}`,
+        message: `"${name}" (from origin ${origin}) is not a usable repository name (letters, digits, \`.\`, \`_\`, \`-\`); set name`
+      });
+    }
+    const firstName = names.get(name);
+    if (firstName !== undefined) {
+      errors.push({
+        path: `${at}.name`,
+        message: `"${name}" is already repositories[${firstName}]${repo.name ? "" : ` (from origin ${origin}); set name`}`
+      });
+    } else
+      names.set(name, index);
     const base = repo.base_branch ?? originHead(machine, repo.path) ?? "main";
     if (!options.offline) {
       const heads = machine.git(["ls-remote", "--heads", "origin", base], repo.path);
@@ -3935,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
@@ -4172,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
@@ -4634,7 +4621,7 @@ function coAuthorEnvironment(env, hooksDir, coAuthor) {
 
 // src/worktree/manager.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
-import { join as join6 } from "path";
+import { isAbsolute as isAbsolute5, join as join6, relative as relative4, resolve as resolve2 } from "path";
 
 // src/worktree/branch.ts
 var SLUG_MAX = 40;
@@ -5187,6 +5174,10 @@ ${stderrTail(fetched)}
           return { row: previous, reused: true };
         }
         request.output(`not reusing ${previous.path}: HEAD is ${head.stdout.trim() || "unreadable"}, not ${previous.branch}`);
+      } else {
+        const orphan = await this.ownOrphan(request, repository);
+        if (orphan)
+          return { row: orphan, reused: true };
       }
       if (!this.diskStatus(request.config).enough) {
         if (!cleaned)
@@ -5237,6 +5228,45 @@ ${stderrTail(fetched)}
       return { row: created, reused: false };
     });
   }
+  async ownOrphan(request, repository) {
+    const id = request.assignment.agentSessionId;
+    const root = resolve2(request.config.sessions.worktree_root);
+    const list = await this.git(["worktree", "list", "--porcelain"], {
+      cwd: repository.path
+    });
+    if (list.code !== 0)
+      return null;
+    for (const block of list.stdout.split(`
+
+`)) {
+      const path = /^worktree (.+)$/m.exec(block)?.[1];
+      const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
+      if (!path || !branch || !existsSync10(path))
+        continue;
+      const rel = relative4(root, path);
+      if (rel === "" || rel.startsWith("..") || isAbsolute5(rel))
+        continue;
+      if (await this.branchOwner(repository.path, branch) !== id)
+        continue;
+      const known = this.state.worktreeAt(path);
+      if (known && (known.state === "removed" || known.agentSessionId !== id))
+        continue;
+      const row = known ?? this.state.insertWorktree({
+        kind: "worktree",
+        repository: repository.name,
+        repoPath: repository.path,
+        path,
+        branch,
+        baseBranch: repository.baseBranch,
+        agentSessionId: id
+      });
+      this.state.updateWorktree(row.id, { state: "active", touch: true });
+      this.state.linkWorktree(id, row.id);
+      request.output(`reusing ${path} on ${branch}: a previous daemon made it but did not record it`);
+      return this.state.worktree(row.id) ?? row;
+    }
+    return null;
+  }
   reusable(agentSessionId) {
     const session = this.state.session(agentSessionId);
     const row = session?.worktreeId ? this.state.worktree(session.worktreeId) : null;
@@ -5582,7 +5612,7 @@ import {
   rmSync as rmSync4,
   writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute5, join as join7, resolve as resolve2, sep } from "path";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute6, join as join7, resolve as resolve3, sep } from "path";
 
 class OutsideWorktree extends Error {
   path;
@@ -5641,7 +5671,7 @@ class ConfinedFs {
     const root = this.roots[0];
     if (!root)
       throw new OutsideWorktree(path);
-    return isAbsolute5(path) ? resolve2(path) : resolve2(root, path);
+    return isAbsolute6(path) ? resolve3(path) : resolve3(root, path);
   }
   read(path, line, limit) {
     const real = this.resolveExisting(path);
@@ -5935,7 +5965,7 @@ function callText(call) {
 }
 
 // src/acp/mcp-servers.ts
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
 var HYPOTENUSE_SERVER_NAME = "hypotenuse";
 var VARIABLE = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g;
 
@@ -5985,7 +6015,7 @@ function turnMcpServers(role, caps, env, hypotenuse) {
       const [command, ...args] = s.command;
       servers.push({
         name: s.name,
-        command: isAbsolute6(command) ? command : Bun.which(command, { PATH: env.PATH ?? "" }) ?? command,
+        command: isAbsolute7(command) ? command : Bun.which(command, { PATH: env.PATH ?? "" }) ?? command,
         args,
         env: pairs(s.name, s.env, env)
       });
@@ -7032,11 +7062,10 @@ class Turn {
     return stop === "end_turn" ? this.result("completed") : this.result("failed", `stopReason: ${stop}`);
   }
   repositoryName() {
+    if (this.workspace?.repository)
+      return this.workspace.repository.name;
     const remote = this.ctx.assignment.repository?.remote;
-    if (!remote)
-      return null;
-    const repo = this.ctx.config.repositories.find((r) => r.remote && r.remote.includes(remote));
-    return repo ? repositoryName(repo) : remote.split("/").pop() ?? null;
+    return remote ? remote.split("/").pop() ?? null : null;
   }
   async stopped() {
     const reason = this.endReason ?? "stop";
@@ -7279,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;
@@ -7306,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 {
@@ -7473,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) => {
@@ -7489,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([
@@ -7524,7 +7675,7 @@ var realProbe = {
 function readLock(path) {
   let text;
   try {
-    text = readFileSync9(path, "utf8");
+    text = readFileSync10(path, "utf8");
   } catch {
     return;
   }
@@ -7548,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);
@@ -7626,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"
@@ -7749,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);
@@ -8002,7 +8153,7 @@ class StateDb {
 
 // src/daemon/supervisor.ts
 import { hostname as hostname3 } from "os";
-import { isAbsolute as isAbsolute7 } from "path";
+import { isAbsolute as isAbsolute8 } from "path";
 
 // src/telemetry/collector.ts
 var SCOPE = { name: "hypotenuse.daemon", version: package_default.version };
@@ -8569,8 +8720,8 @@ function resolvedConfigSecrets(config, env) {
 }
 
 // src/worktree/cleanup.ts
-import { existsSync as existsSync15, readdirSync, rmSync as rmSync7 } from "fs";
-import { join as join9, relative as relative4, resolve as resolve3 } from "path";
+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
 var MERGE_STATE_TTL_MS = 10 * 60000;
@@ -8707,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 };
   }
@@ -8733,7 +8884,7 @@ class WorktreeCleaner {
     return result.stdout.trim() !== "";
   }
   async adopt() {
-    const root = resolve3(this.config().sessions.worktree_root);
+    const root = resolve4(this.config().sessions.worktree_root);
     const known = new Set(this.state.worktrees({ live: true }).map((w) => w.path));
     let adopted = 0;
     for (const repo of this.options.repositories?.() ?? []) {
@@ -8749,7 +8900,7 @@ class WorktreeCleaner {
         const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
         if (!path || !branch || known.has(path))
           continue;
-        const rel = relative4(root, path);
+        const rel = relative5(root, path);
         if (rel.startsWith("..") || rel === "")
           continue;
         const session = await this.git(["config", "--worktree", "--get", "hypotenuse.session"], { cwd: path });
@@ -8771,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);
@@ -8825,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 });
@@ -10339,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) {
@@ -10508,7 +10667,7 @@ function changedKeys(a, b, prefix = "") {
   return JSON.stringify(a) === JSON.stringify(b) ? [] : [prefix];
 }
 function resolveCommand(command, env) {
-  if (isAbsolute7(command))
+  if (isAbsolute8(command))
     return command;
   return Bun.which(command, { PATH: env.PATH ?? "" }) ?? command;
 }
@@ -10564,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 });
@@ -10648,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;
@@ -10696,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)),
@@ -10713,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)
@@ -10772,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
@@ -10933,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)
@@ -11043,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)
@@ -11509,13 +11736,14 @@ 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 resolve4 } 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
-# The hypotenuse daemon's config. Every key: https://www.hypotenuse.cloud/docs/config
+# The hypotenuse daemon's config. Only what has no default is set; the rest is read from git and
+# your sign-in. Every key: https://www.hypotenuse.cloud/docs/config
 # Check it with \`hypotenuse config validate\`; apply edits with \`hypotenuse daemon reload\`.
 config_version = 1
 
@@ -11532,8 +11760,9 @@ roles = ["manager", "worker"]    # drop "manager" to only implement issues
 # teams = ["ENG"]                # only these Linear teams (empty: every team)
 # labels = ["frontend"]          # an issue needs one of these labels
 
-[agents.{{agent}}]
-preset = "{{agent}}"
+# Only to change how an agent is launched; a role can name a preset directly.
+# [agents.{{agent}}]
+# preset = "{{agent}}"
 # max_parallel = 2               # jobs using this agent at once
 
 [roles.worker]
@@ -11556,7 +11785,7 @@ agent = "{{agent}}"
 # keepalive_interval = "10m"     # must stay under Linear's 30m stale window
 
 [log]
-level = "info"
+# level = "info"
 `;
 
 // src/commands/config.ts
@@ -11571,41 +11800,31 @@ function detectPreset(machine) {
   }
   return "claude";
 }
-function repositoryBlocks(machine, paths, env) {
+function repositoryBlocks(paths, env) {
+  const overrides = [
+    '# base_branch = "develop"           # default: the branch origin/HEAD names',
+    '# setup = ["bun install --frozen-lockfile"]'
+  ];
   if (paths.length === 0) {
     return [
-      "# One table per repository this runner works in (`config init --repo <path>` fills these in):",
+      "# One table per git clone this runner works in (`config init --repo <path>` fills these in):",
       "# [[repositories]]",
-      '# name = "web"',
       '# path = "~/code/web"',
-      '# remote = "github.com/acme/web"',
-      '# base_branch = "main"',
-      '# setup = ["bun install --frozen-lockfile"]'
+      ...overrides
     ].join(`
 `);
   }
-  return paths.map((path) => {
-    const remote = originOf(machine, path);
-    const name = repositoryName({
-      path,
-      remote: remote ?? undefined
-    });
-    const base = originHead(machine, path) ?? "main";
-    return [
-      "[[repositories]]",
-      `name = ${JSON.stringify(name)}`,
-      `path = ${JSON.stringify(tildify(path, env))}`,
-      remote ? `remote = ${JSON.stringify(remote)}` : "# remote = (no origin remote found)",
-      `base_branch = ${JSON.stringify(base)}`,
-      "# setup = []"
-    ].join(`
-`);
-  }).join(`
+  return paths.map((path) => [
+    "[[repositories]]",
+    `path = ${JSON.stringify(tildify(path, env))}`,
+    ...overrides
+  ].join(`
+`)).join(`
 
 `);
 }
 function renderTemplate2(input) {
-  return template_default.replaceAll("{{server}}", input.server ? `url = ${JSON.stringify(input.server)}` : '# url = "https://api.hypotenuse.cloud"').replaceAll("{{hostname}}", hostname5().replace(/\.local$/i, "")).replaceAll("{{jobs}}", String(defaultMaxParallelJobs(input.cpus))).replaceAll("{{agent}}", input.agent).replaceAll("{{repositories}}", input.repositories);
+  return template_default.replaceAll("{{server}}", `# url = ${JSON.stringify(input.server ?? "https://api.hypotenuse.cloud")}   # default: where this machine's runner is registered`).replaceAll("{{hostname}}", hostname5().replace(/\.local$/i, "")).replaceAll("{{jobs}}", String(defaultMaxParallelJobs(input.cpus))).replaceAll("{{agent}}", input.agent).replaceAll("{{repositories}}", input.repositories);
 }
 async function validateFile(ctx, options) {
   const path = ctx.configPath;
@@ -11666,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);
@@ -11680,10 +11899,10 @@ function registerConfigCommands(program) {
       const text = renderTemplate2({
         server,
         agent: detectPreset(machine),
-        repositories: repositoryBlocks(machine, repos, ctx.env),
+        repositories: repositoryBlocks(repos, ctx.env),
         cpus: navigator.hardwareConcurrency || 1
       });
-      mkdirSync11(dirname11(resolve4(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)}.`);
@@ -11724,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"?>
@@ -11867,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") {
@@ -11888,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;
       }
@@ -11906,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";
@@ -11994,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 {
@@ -12057,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");
@@ -12125,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;
@@ -13716,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() {
@@ -13725,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.17.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. |