@cabane/companion 0.6.192 → 0.6.194

package/dist/cli.js

@@ -7560,6 +7560,7 @@ function parseRunnerInput(env, stdin) {
     baseUrl: required(env, RUNNER_ENV.url),
     credential: credentials.credential,
     ...credentials.secrets ? { secrets: credentials.secrets } : {},
+    ...credentials.grants ? { grants: credentials.grants } : {},
     dispatch,
     turnId: required(env, RUNNER_ENV.turnId),
     resumed: env[RUNNER_ENV.resumed] === "1",
@@ -7579,7 +7580,8 @@ function runnerEnv(input) {
 function runnerStdin(input) {
   return `${JSON.stringify({
     credential: input.credential,
-    ...input.secrets ? { secrets: input.secrets } : {}
+    ...input.secrets ? { secrets: input.secrets } : {},
+    ...input.grants ? { grants: input.grants } : {}
   })}
 `;
 }
@@ -7684,7 +7686,8 @@ var init_protocol = __esm({
     });
     credentialsSchema = z14.object({
       credential: z14.string().startsWith("cabrn_"),
-      secrets: z14.record(z14.string(), z14.string()).optional()
+      secrets: z14.record(z14.string(), z14.string()).optional(),
+      grants: z14.record(z14.string(), z14.record(z14.string(), z14.string())).optional()
     });
   }
 });
@@ -7811,7 +7814,12 @@ async function mintForRunner(opts, payload, handleOpts, signal, log2) {
       // The one turn the credential will operate: this run's.
       turnId: handleOpts.turnId
     });
-    return { ok: true, credential: minted.credential, runnerId: minted.runnerId };
+    return {
+      ok: true,
+      credential: minted.credential,
+      runnerId: minted.runnerId,
+      deviceGrants: minted.deviceGrants ?? []
+    };
   } catch (err) {
     if (signal.aborted) return { ok: false, reason: "cancelled" };
     const status2 = err instanceof ApiError ? err.status : 0;
@@ -7906,10 +7914,12 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   try {
     const boxed = launch.boxed === true;
     const env = runnerExecEnv(launch.env ?? process.env, boxed);
+    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
     const input = {
       baseUrl: opts.baseUrl,
       credential: minted.credential,
       ...boxed ? { secrets: launch.secrets?.() ?? {} } : {},
+      ...Object.keys(grants).length > 0 ? { grants } : {},
       dispatch: payload,
       turnId,
       resumed: handleOpts.resumed,
@@ -8072,11 +8082,101 @@ var init_launch = __esm({
   }
 });
 
+// src/grants.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join14 } from "path";
+import { z as z15 } from "zod";
+function allowedGrantVariable(name) {
+  return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
+}
+function environmentSafe(value) {
+  return !value.includes("\0");
+}
+function grantsPath() {
+  return join14(cabaneDir(), "grants.json");
+}
+function readGrants(keys, report) {
+  if (keys.length === 0) return {};
+  const file = loadGrantsFile(report);
+  const out = {};
+  for (const key of keys) {
+    if (!allowedGrantVariable(key) || !Object.hasOwn(file, key)) continue;
+    const entry = {};
+    for (const [variable, value] of Object.entries(file[key])) {
+      if (allowedGrantVariable(variable) && environmentSafe(value)) entry[variable] = value;
+      else report.refusedVariable(key, variable);
+    }
+    out[key] = entry;
+  }
+  return out;
+}
+function loadGrantsFile(report) {
+  const path = grantsPath();
+  if (!existsSync9(path)) return {};
+  let raw;
+  try {
+    raw = readFileSync7(path, "utf8");
+  } catch (err) {
+    const code = err.code ?? "unknown error";
+    report.unreadable(`couldn't read ${path}: ${code}`);
+    return {};
+  }
+  if (raw.trim().length === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    report.unreadable(`${path} is not valid JSON.`);
+    return {};
+  }
+  const result = grantsFileSchema.safeParse(parsed);
+  if (!result.success) {
+    report.unreadable(
+      `${path} must map a secret's variable name to an object of "VARIABLE": "value" pairs (e.g. { "HAS_PROD_ACCESS": { "RENDER_API_KEY": "rnd_\u2026" } }).`
+    );
+    return {};
+  }
+  return result.data;
+}
+function harnessSecretEnv(parts) {
+  const env = {};
+  const dropped = [];
+  for (const [name, value] of Object.entries({
+    ...parts.deviceDefaults,
+    ...parts.granted,
+    ...parts.issued
+  })) {
+    if (environmentSafe(value)) env[name] = value;
+    else dropped.push(name);
+  }
+  return { env, dropped };
+}
+function grantEnv(sent, issuedBySecret, issued) {
+  const env = {};
+  for (const [key, entry] of Object.entries(sent ?? {})) {
+    if (!Object.hasOwn(issuedBySecret, key)) continue;
+    for (const [variable, value] of Object.entries(entry)) {
+      if (Object.hasOwn(issued, variable) || Object.hasOwn(env, variable)) continue;
+      env[variable] = value;
+    }
+  }
+  return env;
+}
+var VARIABLE_NAME_RE, grantsFileSchema;
+var init_grants = __esm({
+  "src/grants.ts"() {
+    "use strict";
+    init_config();
+    VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
+  }
+});
+
 // src/work-dir.ts
 import { statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function pairDirectory(root, pair) {
-  return join14(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
+  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
 }
 function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
   const skipped = [];
@@ -8101,7 +8201,7 @@ var init_work_dir = __esm({
 
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function createSkipState() {
   return { skipped: false, reason: null };
 }
@@ -8152,7 +8252,7 @@ function createTurnControlMcpServer(acts, skipState) {
           SKIP_TURN_TOOL,
           TURN_CONTROL_TOOL_DESCRIPTIONS.skip_turn,
           {
-            reason: z15.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
+            reason: z16.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
           },
           async (args) => {
             skipState.skipped = true;
@@ -8168,22 +8268,22 @@ function createTurnControlMcpServer(acts, skipState) {
         ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.ask,
         {
-          targetUserId: z15.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
-          question: z15.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
-          headline: z15.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
-          options: z15.array(z15.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
-          questions: z15.array(
-            z15.object({
-              headline: z15.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
-              body: z15.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
-              options: z15.array(
-                z15.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
+          targetUserId: z16.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
+          question: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
+          headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
+          options: z16.array(z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
+          questions: z16.array(
+            z16.object({
+              headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
+              body: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
+              options: z16.array(
+                z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
               ).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.options"])
             })
           ).min(1).max(MAX_ASK_ITEMS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.questions),
-          replaces: z15.object({
-            askId: z15.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
-            reason: z15.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
+          replaces: z16.object({
+            askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
+            reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
           }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.replaces)
         },
         async (args) => {
@@ -8224,9 +8324,9 @@ function createTurnControlMcpServer(acts, skipState) {
         WAKE_ME_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.wake_me,
         {
-          afterSeconds: z15.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
-          at: z15.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
-          note: z15.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
+          afterSeconds: z16.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
+          at: z16.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
+          note: z16.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
         },
         async (args) => {
           const hasAfter = args.afterSeconds !== void 0;
@@ -8260,8 +8360,8 @@ function createTurnControlMcpServer(acts, skipState) {
         WITHDRAW_ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.withdraw_ask,
         {
-          askId: z15.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
-          reason: z15.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
+          askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
+          reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
         },
         async (args) => performAct(acts, {
           kind: "withdraw_ask",
@@ -8359,10 +8459,10 @@ var init_build_options = __esm({
 // src/codex-config.ts
 import { readFile as readFile2 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { parse } from "smol-toml";
 function codexConfigPath(env = process.env, home = homedir7()) {
-  return join15(env.CODEX_HOME || join15(home, ".codex"), "config.toml");
+  return join16(env.CODEX_HOME || join16(home, ".codex"), "config.toml");
 }
 async function readCodexConfigSetsSandboxMode(path = codexConfigPath()) {
   let text;
@@ -8389,13 +8489,13 @@ var init_codex_config = __esm({
 // src/codex-images.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function createCodexImagePreparer(opts) {
   const doFetch = opts.fetch ?? fetch;
   const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
   return async (urls, signal) => {
     signal.throwIfAborted();
-    const dir2 = await mkdtemp(join16(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
+    const dir2 = await mkdtemp(join17(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
     const cleanup = async () => {
       try {
         await rm(dir2, { recursive: true, force: true });
@@ -8416,7 +8516,7 @@ function createCodexImagePreparer(opts) {
         const ext = EXTENSIONS[type];
         if (!ext) throw new Error(`not a vision image type: ${type || "none"}`);
         const bytes = new Uint8Array(await res.arrayBuffer());
-        const path = join16(dir2, `image-${index + 1}.${ext}`);
+        const path = join17(dir2, `image-${index + 1}.${ext}`);
         await writeFile(path, bytes, { mode: 384 });
         return path;
       } catch (err) {
@@ -8458,9 +8558,9 @@ var init_codex_images = __esm({
 import { createReadStream } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { createInterface as createInterface2 } from "readline";
-function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join17(homedir8(), ".codex")) {
+function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join18(homedir8(), ".codex")) {
   return async (threadId) => {
     try {
       const rollout = await findRollout(codexHome, threadId);
@@ -8477,7 +8577,7 @@ async function findRollout(codexHome, threadId) {
   const suffix = `-${threadId}.jsonl`;
   for (const offset of [0, -DAY_MS, DAY_MS]) {
     const day = new Date(createdAt + offset);
-    const dir2 = join17(
+    const dir2 = join18(
       codexHome,
       "sessions",
       String(day.getUTCFullYear()),
@@ -8491,7 +8591,7 @@ async function findRollout(codexHome, threadId) {
       continue;
     }
     const name = names.find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
-    if (name) return join17(dir2, name);
+    if (name) return join18(dir2, name);
   }
   return null;
 }
@@ -8623,22 +8723,22 @@ var init_prepare_failure = __esm({
 });
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "fs";
-import { join as join18 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
+import { join as join19 } from "path";
 function dirFor(workspaceId) {
-  return join18(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join19(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join18(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join19(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor2(workspaceId, conversationId, agentId) {
-  return join18(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join19(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor2(workspaceId, conversationId, agentId);
-  if (!existsSync9(path)) return null;
+  if (!existsSync10(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
@@ -8669,18 +8769,18 @@ var init_prepared = __esm({
 });
 
 // src/secrets.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join19 } from "path";
-import { z as z16 } from "zod";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join20 } from "path";
+import { z as z17 } from "zod";
 function secretsPath() {
-  return join19(cabaneDir(), "secrets.json");
+  return join20(cabaneDir(), "secrets.json");
 }
 function loadSecretValues() {
   const path = secretsPath();
-  if (!existsSync10(path)) return {};
+  if (!existsSync11(path)) return {};
   let raw;
   try {
-    raw = readFileSync8(path, "utf8");
+    raw = readFileSync9(path, "utf8");
   } catch (err) {
     throw new ConfigError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -8798,7 +8898,7 @@ var init_secrets = __esm({
     init_config();
     init_errors();
     PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-    secretStoreSchema = z16.record(z16.string(), z16.string());
+    secretStoreSchema = z17.record(z17.string(), z17.string());
     SECRET_ENV_NAME = /^CABANE_MCP_(\d+)$/;
   }
 });
@@ -8830,9 +8930,9 @@ var init_turn_env = __esm({
 
 // src/transcript-writer.ts
 import { appendFileSync, chmodSync as chmodSync4, copyFileSync, mkdirSync as mkdirSync8, readdirSync, rmSync as rmSync6 } from "fs";
-import { basename as basename3, dirname as dirname7, join as join20 } from "path";
+import { basename as basename3, dirname as dirname7, join as join21 } from "path";
 function transcriptsDir() {
-  return join20(cabaneDir(), "transcripts");
+  return join21(cabaneDir(), "transcripts");
 }
 function fileName(meta) {
   const d = new Date(meta.ts);
@@ -8858,7 +8958,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync6(join20(dir2, f), { force: true });
+      rmSync6(join21(dir2, f), { force: true });
     } catch {
     }
   }
@@ -8876,7 +8976,7 @@ var init_transcript_writer = __esm({
       onWarn;
       constructor(dir2, meta, onWarn) {
         this.onWarn = onWarn;
-        this.path = join20(dir2, fileName(meta));
+        this.path = join21(dir2, fileName(meta));
         try {
           mkdirSync8(dir2, { recursive: true });
           try {
@@ -8905,10 +9005,10 @@ var init_transcript_writer = __esm({
       preserveAnomaly() {
         if (this.broken) return;
         try {
-          const dir2 = join20(dirname7(this.path), "anomalies");
+          const dir2 = join21(dirname7(this.path), "anomalies");
           mkdirSync8(dir2, { recursive: true, mode: 448 });
           chmodSync4(dir2, 448);
-          const target = join20(dir2, basename3(this.path));
+          const target = join21(dir2, basename3(this.path));
           copyFileSync(this.path, target);
           chmodSync4(target, 384);
           pruneOld(dir2, ANOMALY_RETAIN);
@@ -9204,6 +9304,7 @@ var init_turn_execution = __esm({
     init_cabane_command();
     init_boot_id();
     init_src();
+    init_grants();
     init_work_dir();
     init_build_options();
     init_bundled_binaries();
@@ -9575,7 +9676,19 @@ var init_turn_execution = __esm({
           throw this.concluded(reason, reason);
         }
         this.resolvedMcpServers = resolvedMcpServers;
-        this.secretEnv = { ...secretEnv, ...harnessLoginEnv(secretStore, this.turnContext.runtime) };
+        const granted = grantEnv(this.opts.deviceGrants, this.turnContext.secretEnv ?? {}, secretEnv);
+        const harness = harnessSecretEnv({
+          deviceDefaults: harnessLoginEnv(secretStore, this.turnContext.runtime),
+          granted,
+          issued: secretEnv
+        });
+        if (harness.dropped.length > 0) {
+          turnLog.warn(
+            { variables: harness.dropped },
+            "Left out a secret value this turn: it contains a NUL character, which no environment can hold."
+          );
+        }
+        this.secretEnv = harness.env;
         this.secretStore = secretStore;
       }
       async prepareEnvironment() {
@@ -10346,11 +10459,11 @@ var init_turn_execution = __esm({
 
 // src/dispatcher.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { join as join22 } from "path";
 function checkoutState(cwd) {
   if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync11(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
+  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
   let entries;
   try {
     entries = readdirSync2(cwd);
@@ -10360,15 +10473,15 @@ function checkoutState(cwd) {
   if (entries.length === 0) {
     return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
   }
-  const gitPath = join21(cwd, ".git");
-  if (!existsSync11(gitPath)) return { ok: true, reason: "usable" };
+  const gitPath = join22(cwd, ".git");
+  if (!existsSync12(gitPath)) return { ok: true, reason: "usable" };
   let stat;
   try {
     stat = statSync4(gitPath);
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
-  if (stat.isDirectory() && !existsSync11(join21(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync12(join22(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -10476,15 +10589,15 @@ var init_dispatcher = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync as renameSync5,
   rmSync as rmSync7,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var MAX_ENTRIES, MAX_AGE_MS, Outbox;
 var init_outbox = __esm({
   "src/outbox.ts"() {
@@ -10502,10 +10615,10 @@ var init_outbox = __esm({
       // Resolved lazily (per call) so tests that swap HOME between
       // cases route writes at the right tmpdir.
       dir() {
-        return join22(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+        return join23(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
       }
       fileFor(turnId, seq) {
-        return join22(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+        return join23(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
       }
       // Persist a commit for later draining. Atomic (temp file + rename) so a
       // concurrent `list()` never reads a half-written entry, then enforces the
@@ -10537,7 +10650,7 @@ var init_outbox = __esm({
       // wedging the drain.
       list() {
         const dir2 = this.dir();
-        if (!existsSync13(dir2)) return [];
+        if (!existsSync14(dir2)) return [];
         let names;
         try {
           names = readdirSync3(dir2);
@@ -10547,9 +10660,9 @@ var init_outbox = __esm({
         const entries = [];
         for (const name of names) {
           if (!name.endsWith(".json")) continue;
-          const full = join22(dir2, name);
+          const full = join23(dir2, name);
           try {
-            const parsed = JSON.parse(readFileSync10(full, "utf8"));
+            const parsed = JSON.parse(readFileSync11(full, "utf8"));
             if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
               entries.push(parsed);
             } else {
@@ -10583,7 +10696,7 @@ var init_outbox = __esm({
       // different: it is positive evidence that nothing was ever queued here.
       maxSeqForTurn(turnId) {
         const dir2 = this.dir();
-        if (!existsSync13(dir2)) return 0;
+        if (!existsSync14(dir2)) return 0;
         const names = readdirSync3(dir2);
         const prefix = `${encodeURIComponent(turnId)}__`;
         let max = 0;
@@ -10603,7 +10716,7 @@ var init_outbox = __esm({
       }
       size() {
         const dir2 = this.dir();
-        if (!existsSync13(dir2)) return 0;
+        if (!existsSync14(dir2)) return 0;
         try {
           return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
         } catch {
@@ -10654,7 +10767,7 @@ var init_outbox = __esm({
 
 // src/runner/exec-shim.ts
 import { chmodSync as chmodSync6, mkdirSync as mkdirSync18, mkdtempSync, rmSync as rmSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -10664,10 +10777,10 @@ function createShimDir() {
   return {
     write(argv) {
       if (!dir2) {
-        mkdirSync18(join32(cabaneDir(), "runner"), { recursive: true });
-        dir2 = mkdtempSync(join32(cabaneDir(), "runner", "turn-"));
+        mkdirSync18(join33(cabaneDir(), "runner"), { recursive: true });
+        dir2 = mkdtempSync(join33(cabaneDir(), "runner", "turn-"));
       }
-      const path = join32(dir2, `exec-${++count}`);
+      const path = join33(dir2, `exec-${++count}`);
       writeFileSync11(path, `#!/bin/sh
 exec ${argv.map(shellQuote).join(" ")} "$@"
 `);
@@ -10815,6 +10928,8 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
     // The launcher's copy of the device's secrets, when it sent one: a runner
     // in a box has no `secrets.json` to read.
     ...input.secrets ? { secretStore: makeStore(input.secrets) } : {},
+    // The grants-file entries the launcher read for this dispatch's turn.
+    ...input.grants ? { deviceGrants: input.grants } : {},
     log: log2,
     ...queryFn ? { queryFn } : {},
     ...spec.opencodeServerUrl ? { opencodeServerUrl: spec.opencodeServerUrl } : {},
@@ -12905,7 +13020,7 @@ var ConnectorHealthStore = class {
 init_dispatcher();
 
 // src/host-report.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { userInfo as userInfo2 } from "os";
 function inContainer(signals) {
   if (signals.dockerenv) return true;
@@ -12916,11 +13031,11 @@ function inContainer(signals) {
 function readContainerSignals() {
   let cgroup = null;
   try {
-    cgroup = readFileSync9("/proc/1/cgroup", "utf8");
+    cgroup = readFileSync10("/proc/1/cgroup", "utf8");
   } catch {
     cgroup = null;
   }
-  return { dockerenv: existsSync12("/.dockerenv"), cgroup, env: process.env };
+  return { dockerenv: existsSync13("/.dockerenv"), cgroup, env: process.env };
 }
 function osUser() {
   try {
@@ -13207,6 +13322,7 @@ var DispatchClaims = class {
 init_outbox();
 init_run_config();
 init_secrets();
+init_grants();
 
 // src/sse.ts
 init_errors();
@@ -13332,20 +13448,20 @@ init_transcript_writer();
 
 // src/updater.ts
 import { spawn as spawn6 } from "child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync15, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
-import { dirname as dirname11, join as join26 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
+import { dirname as dirname11, join as join27 } from "path";
 
 // src/boot-rule.ts
 import {
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   realpathSync as realpathSync4,
   renameSync as renameSync6,
   rmSync as rmSync8,
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname8, join as join23 } from "path";
+import { dirname as dirname8, join as join24 } from "path";
 var UNCONFIRMED_WINDOW_MS = 10 * 6e4;
 var MAX_STAGE_ATTEMPTS = 3;
 function superseded(pending, ...running) {
@@ -13369,42 +13485,42 @@ function rolledBackState(state, pending, reason, now) {
 // src/install-layout.ts
 init_config();
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   lstatSync,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync4,
   realpathSync as realpathSync5,
   renameSync as renameSync7,
   rmSync as rmSync9,
   symlinkSync as symlinkSync2
 } from "fs";
-import { dirname as dirname9, join as join24 } from "path";
+import { dirname as dirname9, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function versionsDir() {
-  return join24(cabaneDir(), "versions");
+  return join25(cabaneDir(), "versions");
 }
 function currentLink() {
-  return join24(cabaneDir(), "current");
+  return join25(cabaneDir(), "current");
 }
 function bootGuardPath() {
-  return join24(cabaneDir(), "boot-guard.mjs");
+  return join25(cabaneDir(), "boot-guard.mjs");
 }
 function pinnedNodeDir() {
-  return join24(cabaneDir(), "node");
+  return join25(cabaneDir(), "node");
 }
 function pinnedNodePath() {
-  return join24(pinnedNodeDir(), "bin", "node");
+  return join25(pinnedNodeDir(), "bin", "node");
 }
 function versionPackageRoot(version) {
-  return join24(versionsDir(), version, "node_modules", "@cabane", "companion");
+  return join25(versionsDir(), version, "node_modules", "@cabane", "companion");
 }
 function ownPackageRoot(moduleUrl = import.meta.url) {
   return dirname9(dirname9(fileURLToPath5(moduleUrl)));
 }
 function packageVersion(root) {
   try {
-    const pkg2 = JSON.parse(readFileSync12(join24(root, "package.json"), "utf8"));
+    const pkg2 = JSON.parse(readFileSync13(join25(root, "package.json"), "utf8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -13413,7 +13529,7 @@ function packageVersion(root) {
 function currentRoot() {
   try {
     const root = realpathSync5(currentLink());
-    return existsSync14(join24(root, "dist", "cli.js")) ? root : null;
+    return existsSync15(join25(root, "dist", "cli.js")) ? root : null;
   } catch {
     return null;
   }
@@ -13432,11 +13548,11 @@ function pointCurrentAt(root) {
 }
 function pruneVersions(keep) {
   const dir2 = versionsDir();
-  if (!existsSync14(dir2)) return [];
+  if (!existsSync15(dir2)) return [];
   const removed = [];
   for (const name of readdirSync4(dir2)) {
     if (keep.includes(name)) continue;
-    rmSync9(join24(dir2, name), { recursive: true, force: true });
+    rmSync9(join25(dir2, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -13455,36 +13571,36 @@ function compareVersions(a, b) {
 
 // src/update-state.ts
 init_config();
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync13, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join25 } from "path";
-import { z as z17 } from "zod";
-var resultSchema = z17.object({
-  kind: z17.enum(["updated", "rolled_back", "failed"]),
-  from: z17.string(),
-  to: z17.string(),
-  at: z17.string(),
-  reason: z17.string().optional()
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, join as join26 } from "path";
+import { z as z18 } from "zod";
+var resultSchema = z18.object({
+  kind: z18.enum(["updated", "rolled_back", "failed"]),
+  from: z18.string(),
+  to: z18.string(),
+  at: z18.string(),
+  reason: z18.string().optional()
 });
-var pendingSchema = z17.object({
-  from: z17.string(),
+var pendingSchema = z18.object({
+  from: z18.string(),
   // The package root `current` pointed at before the swap, so a rollback can point it back.
-  fromRoot: z17.string(),
-  to: z17.string(),
-  at: z17.string(),
-  boots: z17.number().int().nonnegative()
+  fromRoot: z18.string(),
+  to: z18.string(),
+  at: z18.string(),
+  boots: z18.number().int().nonnegative()
 });
-var stateSchema = z17.object({
-  server: z17.object({ latest: z17.string(), minimum: z17.string(), at: z17.string() }).optional(),
+var stateSchema = z18.object({
+  server: z18.object({ latest: z18.string(), minimum: z18.string(), at: z18.string() }).optional(),
   pending: pendingSchema.optional(),
   lastResult: resultSchema.optional(),
-  failed: z17.object({ version: z17.string(), attempts: z17.number().int(), at: z17.string() }).optional()
+  failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
-  return join25(dir2, "update.json");
+  return join26(dir2, "update.json");
 }
 function readUpdateState(path = updateStatePath()) {
   try {
-    const parsed = stateSchema.safeParse(JSON.parse(readFileSync13(path, "utf8")));
+    const parsed = stateSchema.safeParse(JSON.parse(readFileSync14(path, "utf8")));
     return parsed.success ? parsed.data : {};
   } catch {
     return {};
@@ -13525,12 +13641,12 @@ function versionToStage(input) {
   return latest;
 }
 function rollBack(pending, reason, now = /* @__PURE__ */ new Date()) {
-  if (existsSync15(pending.fromRoot)) pointCurrentAt(pending.fromRoot);
+  if (existsSync16(pending.fromRoot)) pointCurrentAt(pending.fromRoot);
   return updateUpdateState((state) => rolledBackState(state, pending, reason, now));
 }
 function writeBootGuard(root = ownPackageRoot()) {
-  const built = join26(root, "dist", "boot-guard.js");
-  if (!existsSync15(built)) return false;
+  const built = join27(root, "dist", "boot-guard.js");
+  if (!existsSync16(built)) return false;
   const target = bootGuardPath();
   mkdirSync14(dirname11(target), { recursive: true });
   const tmp = `${target}.${process.pid}.tmp`;
@@ -13569,17 +13685,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
 async function stageVersion(version, harnesses, deps = {}) {
   const run = deps.run ?? runProcess;
   const node = deps.execPath ?? process.execPath;
-  const target = join26(versionsDir(), version);
+  const target = join27(versionsDir(), version);
   const placed = versionPackageRoot(version);
-  if (existsSync15(placed)) {
+  if (existsSync16(placed)) {
     if (!await verifyInstall(placed, version, harnesses, { run, execPath: node }))
       return { ok: true, root: placed };
   }
-  const npm = join26(dirname11(node), "npm");
-  if (!existsSync15(npm))
+  const npm = join27(dirname11(node), "npm");
+  if (!existsSync16(npm))
     return { ok: false, reason: `there is no npm beside Node at ${dirname11(node)}` };
   mkdirSync14(versionsDir(), { recursive: true });
-  const staging = join26(versionsDir(), `.${version}.staging-${process.pid}`);
+  const staging = join27(versionsDir(), `.${version}.staging-${process.pid}`);
   rmSync10(staging, { recursive: true, force: true });
   const installed = await run(
     npm,
@@ -13608,7 +13724,7 @@ async function stageVersion(version, harnesses, deps = {}) {
       return { ok: false, reason: `version ${version} isn't published yet`, unpublished: true };
     return { ok: false, reason: `npm couldn't install it: ${lastLine(installed.stderr)}` };
   }
-  const root = join26(staging, "node_modules", "@cabane", "companion");
+  const root = join27(staging, "node_modules", "@cabane", "companion");
   const verdict = await verifyInstall(root, version, harnesses, { run, execPath: node });
   if (verdict) {
     rmSync10(staging, { recursive: true, force: true });
@@ -13620,7 +13736,7 @@ async function stageVersion(version, harnesses, deps = {}) {
 }
 async function verifyInstall(root, version, harnesses, deps) {
   if (packageVersion(root) !== version) return `the installed package isn't version ${version}`;
-  const answered = await deps.run(deps.execPath, [join26(root, "dist", "bin.js"), "--version"], {
+  const answered = await deps.run(deps.execPath, [join27(root, "dist", "bin.js"), "--version"], {
     timeoutMs: 6e4,
     env: { ...process.env, CABANE_LAUNCH_SELF: "1" }
   });
@@ -13628,7 +13744,7 @@ async function verifyInstall(root, version, harnesses, deps) {
     return `it doesn't start: ${lastLine(answered.stderr) || "no version printed"}`;
   }
   if (harnesses.length === 0) return null;
-  const probed = await deps.run(deps.execPath, [join26(root, "dist", "postinstall.js"), "--json"], {
+  const probed = await deps.run(deps.execPath, [join27(root, "dist", "postinstall.js"), "--json"], {
     timeoutMs: 6e4
   });
   let resolutions = {};
@@ -14625,6 +14741,14 @@ var CompanionSupervisor = class {
             (m) => this.log.warn({ err: m }, "Could not read the secrets file for a boxed turn.")
           )
         } : {},
+        // Read per dispatch, for the secret variables its mint named and no others.
+        grants: (keys) => readGrants(keys, {
+          refusedVariable: (key, variable) => this.log.warn(
+            { key, variable },
+            "Skipped a variable in ~/.cabane/grants.json: its name must use capital letters, digits and underscores, not starting with CABANE_, and its value cannot contain a NUL character."
+          ),
+          unreadable: (message2) => this.log.warn({ err: message2 }, "Could not read the grants file.")
+        }),
         ...this.runnerEnv ? { env: this.runnerEnv } : {},
         reportRunnerGone: (report) => this.reportRunnerGone(report),
         connectorHealth: this.connectorHealth,
@@ -15317,10 +15441,10 @@ function handleUncaught(log2, err, origin) {
 
 // src/crash-marker.ts
 init_config();
-import { existsSync as existsSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync14, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join28 } from "path";
 function crashMarkerPath() {
-  return join27(cabaneDir(), "last-error.json");
+  return join28(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -15332,7 +15456,7 @@ function recordCrash(rec2) {
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync16(path)) rmSync11(path, { force: true });
+    if (existsSync17(path)) rmSync11(path, { force: true });
   } catch {
   }
 }
@@ -15340,8 +15464,8 @@ function clearCrash() {
 // src/stray-companion.ts
 init_config();
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { join as join29 } from "path";
 var COMPANION_ENTRY = /@cabane\/companion\/|cabane-companion|(^|[\s/])cabane\s|\.cabane\/(versions|current|boot-guard)/;
 var START = /\sstart(\s|$)/;
 function companionStarts(psOutput) {
@@ -15358,7 +15482,7 @@ function companionStarts(psOutput) {
 }
 function stateDirOf(env) {
   const home = env.CABANE_COMPANION_HOME || env.HOME;
-  return home ? join28(home, ".cabane") : null;
+  return home ? join29(home, ".cabane") : null;
 }
 function envFromPsE(output, command) {
   const line = output.replace(/\n$/, "");
@@ -15373,7 +15497,7 @@ function envFromPsE(output, command) {
 function envFromProc(pid) {
   try {
     const env = {};
-    for (const entry of readFileSync15(`/proc/${pid}/environ`, "utf8").split("\0")) {
+    for (const entry of readFileSync16(`/proc/${pid}/environ`, "utf8").split("\0")) {
       const eq = entry.indexOf("=");
       if (eq > 0) env[entry.slice(0, eq)] = entry.slice(eq + 1);
     }
@@ -15625,15 +15749,15 @@ import { createHash as createHash3 } from "crypto";
 import {
   chmodSync as chmodSync5,
   cpSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   renameSync as renameSync10,
   rmSync as rmSync12,
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir9, userInfo as userInfo3 } from "os";
-import { dirname as dirname12, join as join29, sep as sep3 } from "path";
+import { dirname as dirname12, join as join30, sep as sep3 } from "path";
 function servicePlatform(platform = process.platform) {
   if (platform === "linux") return "systemd";
   if (platform === "darwin") return "launchd";
@@ -15648,18 +15772,18 @@ function launchdLabel(env = process.env) {
   return serviceName(env).replace(/^cabane-companion/, "ai.cabane.companion").replace("-", ".");
 }
 function serviceNode(execPath = process.execPath) {
-  return existsSync17(pinnedNodePath()) ? pinnedNodePath() : execPath;
+  return existsSync18(pinnedNodePath()) ? pinnedNodePath() : execPath;
 }
 function servicePaths(platform, env = process.env, home = homedir9(), node = serviceNode()) {
-  const unitFile = platform === "systemd" ? join29(
-    env.XDG_CONFIG_HOME || join29(home, ".config"),
+  const unitFile = platform === "systemd" ? join30(
+    env.XDG_CONFIG_HOME || join30(home, ".config"),
     "systemd",
     "user",
     `${serviceName(env)}.service`
-  ) : join29(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
+  ) : join30(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
   return {
     unitFile,
-    envFile: join29(cabaneDir(), "service.env"),
+    envFile: join30(cabaneDir(), "service.env"),
     node,
     entry: bootGuardPath()
   };
@@ -15726,7 +15850,7 @@ function renderLaunchdPlist(paths, env = process.env, servicePath) {
     "  <key>ThrottleInterval</key><integer>5</integer>",
     // The companion writes its own log; the console copy would only grow a second one.
     "  <key>StandardOutPath</key><string>/dev/null</string>",
-    `  <key>StandardErrorPath</key><string>${xml(join29(cabaneDir(), "service-error.log"))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join30(cabaneDir(), "service-error.log"))}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -15782,7 +15906,7 @@ async function installService(deps = {}) {
   const paths = servicePaths(platform, env, deps.home, node);
   const servicePath = await loginShellPath(run, env);
   mkdirSync16(dirname12(paths.envFile), { recursive: true });
-  const existing = existsSync17(paths.envFile) ? readFileSync16(paths.envFile, "utf8") : "";
+  const existing = existsSync18(paths.envFile) ? readFileSync17(paths.envFile, "utf8") : "";
   writeFileSync10(paths.envFile, withServicePath(existing, servicePath), { mode: 384 });
   chmodSync5(paths.envFile, 384);
   mkdirSync16(dirname12(paths.unitFile), { recursive: true });
@@ -15838,7 +15962,7 @@ async function uninstallService(deps = {}) {
   const platform = servicePlatform(deps.platform);
   if (!platform) return { ok: true, lines: [] };
   const paths = servicePaths(platform, env, deps.home);
-  if (!existsSync17(paths.unitFile)) return { ok: true, lines: ["No Cabane service is installed."] };
+  if (!existsSync18(paths.unitFile)) return { ok: true, lines: ["No Cabane service is installed."] };
   await removeUnit(platform, paths, env, run);
   return { ok: true, lines: [] };
 }
@@ -15865,16 +15989,16 @@ async function seedManagedInstall(deps) {
     return { ok: true, root: own };
   }
   const target = versionPackageRoot(version);
-  if (!existsSync17(target)) {
-    const staging = join29(versionsDir(), `.${version}.seed-${process.pid}`);
+  if (!existsSync18(target)) {
+    const staging = join30(versionsDir(), `.${version}.seed-${process.pid}`);
     rmSync12(staging, { recursive: true, force: true });
     try {
-      cpSync(own, join29(staging, "node_modules", "@cabane", "companion"), {
+      cpSync(own, join30(staging, "node_modules", "@cabane", "companion"), {
         recursive: true,
         verbatimSymlinks: true
       });
-      rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
-      renameSync10(staging, join29(versionsDir(), version));
+      rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
+      renameSync10(staging, join30(versionsDir(), version));
     } catch (err) {
       rmSync12(staging, { recursive: true, force: true });
       return {
@@ -15885,7 +16009,7 @@ async function seedManagedInstall(deps) {
   }
   const unrunnable = await verifyInstall(target, version, [], deps);
   if (unrunnable) {
-    rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
+    rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
     return { ok: false, reason: `The copy of Cabane for the service can't run: ${unrunnable}.` };
   }
   pointCurrentAt(target);
@@ -15897,7 +16021,7 @@ function tildeDir() {
 function unitNode(platform, unitFile) {
   let text;
   try {
-    text = readFileSync16(unitFile, "utf8");
+    text = readFileSync17(unitFile, "utf8");
   } catch {
     return null;
   }
@@ -15919,9 +16043,9 @@ async function serviceState(deps = {}) {
   };
   if (!platform) return none;
   const paths = servicePaths(platform, env, deps.home);
-  if (!existsSync17(paths.unitFile)) return none;
+  if (!existsSync18(paths.unitFile)) return none;
   const node = unitNode(platform, paths.unitFile);
-  const nodeOk = node === null || existsSync17(node);
+  const nodeOk = node === null || existsSync18(node);
   if (platform === "systemd") {
     const r2 = await run(
       "systemctl",
@@ -15953,7 +16077,7 @@ async function serviceState(deps = {}) {
 function serviceInstalled(deps = {}) {
   const platform = servicePlatform(deps.platform);
   if (!platform) return false;
-  return existsSync17(servicePaths(platform, deps.env ?? process.env, deps.home).unitFile);
+  return existsSync18(servicePaths(platform, deps.env ?? process.env, deps.home).unitFile);
 }
 function writeAtomic(path, content) {
   const tmp = `${path}.${process.pid}.tmp`;
@@ -15967,12 +16091,12 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
-function rewriteScriptWrappers(dir2 = join29(cabaneDir(), "bin")) {
+function rewriteScriptWrappers(dir2 = join30(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
-    const path = join29(dir2, name);
+    const path = join30(dir2, name);
     let text;
     try {
-      text = readFileSync16(path, "utf8");
+      text = readFileSync17(path, "utf8");
     } catch {
       continue;
     }
@@ -16641,7 +16765,7 @@ function writeCompletedPairing(raw) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 
 // src/commands/logs.ts
 init_cabane_command();
@@ -16726,9 +16850,9 @@ async function logs(opts = {}) {
 init_cabane_command();
 init_install_kind();
 init_cabane_command();
-import { readdirSync as readdirSync5, realpathSync as realpathSync6, existsSync as existsSync18 } from "fs";
+import { readdirSync as readdirSync5, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname13, join as join30 } from "path";
+import { dirname as dirname13, join as join31 } from "path";
 init_config();
 init_secrets();
 init_term();
@@ -17014,7 +17138,7 @@ function versionLine() {
   const install = companionInstall();
   const own = installedCommandPath({ install });
   if (install === "script") {
-    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join30(homedir10(), ".cabane"))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join31(homedir10(), ".cabane"))})`;
   }
   if (own)
     return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname13(dirname13(own)))})`;
@@ -17040,7 +17164,7 @@ function otherInstall(install, own) {
     }
   };
   if (install === "npm") {
-    const script = join30(
+    const script = join31(
       homedir10(),
       ".cabane",
       "node",
@@ -17049,11 +17173,11 @@ function otherInstall(install, own) {
       "@cabane",
       "companion"
     );
-    return existsSync18(script) ? join30(homedir10(), ".cabane") : null;
+    return existsSync19(script) ? join31(homedir10(), ".cabane") : null;
   }
   const found = firstOnPath("cabane-companion", process.env.PATH);
   if (!found) return null;
-  const ownAlias = own ? real(join30(dirname13(own), "cabane-companion")) : null;
+  const ownAlias = own ? real(join31(dirname13(own), "cabane-companion")) : null;
   return real(found) === ownAlias ? null : dirname13(found);
 }
 function runningMode(running, service2) {
@@ -17259,8 +17383,8 @@ init_cabane_command();
 init_errors();
 init_src();
 init_transcript_writer();
-import { existsSync as existsSync19, readFileSync as readFileSync17, readdirSync as readdirSync6 } from "fs";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join31 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync6 } from "fs";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join32 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -17277,7 +17401,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join31(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join32(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -17360,7 +17484,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync17(join31(dir2, f), "utf8"),
+    read: (f) => readFileSync18(join32(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -17396,7 +17520,7 @@ function listTranscriptFiles(dir2) {
     if (!entry.isDirectory() || entry.name === "anomalies") continue;
     let inner;
     try {
-      inner = readdirSync6(join31(dir2, entry.name));
+      inner = readdirSync6(join32(dir2, entry.name));
     } catch {
       continue;
     }
@@ -17415,7 +17539,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join31(dir2, f));
+    const { meta, outcome } = peek(join32(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -17437,7 +17561,7 @@ function peek(path) {
   let meta;
   let outcome;
   try {
-    for (const line of readFileSync17(path, "utf8").split("\n")) {
+    for (const line of readFileSync18(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
       const t = str2(rec(o)?.type);
@@ -17450,14 +17574,14 @@ function peek(path) {
 }
 function resolveTarget(dir2, target) {
   if (isAbsolute2(target) || target.includes("/")) {
-    if (existsSync19(target)) return target;
-    if (!isAbsolute2(target) && existsSync19(join31(dir2, target))) return join31(dir2, target);
+    if (existsSync20(target)) return target;
+    if (!isAbsolute2(target) && existsSync20(join32(dir2, target))) return join32(dir2, target);
     throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join31(dir2, target);
-  if (existsSync19(exact)) return exact;
+  const exact = join32(dir2, target);
+  if (existsSync20(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join31(dir2, matches[0]);
+  if (matches.length === 1) return join32(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`${cabane("transcript")}\` to list them.`
@@ -17471,7 +17595,7 @@ function resolveTarget(dir2, target) {
 function renderFile(path) {
   let content;
   try {
-    content = readFileSync17(path, "utf8");
+    content = readFileSync18(path, "utf8");
   } catch (err) {
     throw new CompanionError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -17644,7 +17768,7 @@ program.command("setup [code]").description("set up this device: find your agent
   });
 });
 program.command("write-paired-config", { hidden: true }).description("persist an already-completed device enrollment payload from stdin.").action(() => {
-  writeCompletedPairing(readFileSync18(0, "utf8"));
+  writeCompletedPairing(readFileSync19(0, "utf8"));
 });
 program.command("start").description("run Cabane on this device in the background.").option("--foreground", "run attached in this terminal (for terminals and supervisors)").option("--daemon", "run in the background (the default; kept for compatibility)").addOption(new Option("--server <url>").hideHelp()).addOption(
   new Option("--log-level <level>", "info (default), warn, or debug").choices([