@outerlayer/cli 0.27.1 → 0.28.1

package/dist/{chunk-5VMDGJGH.js → chunk-7UGFIWIW.js}

@@ -1,32 +1,32 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, provisionEnvironment, readProvisionOut, resolveHostBuild, workdirProblem, listenOnBroker, hostEnvironment, hostCommandEnvironment, execArgv, MICROVM_COMMAND_DIR, commandLogOffset, startMicroVmCommand, microVmCommandLine, runCommand, execCommandLine, startSender, startHostServices, finishJob, isContainerTracked, isMicroVmTracked, probeMicroVmCommand, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isTracked, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listUnreadableJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, hookLimitsFor, AttemptLogBook, microVmOomKills, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, serveLease, vmAlive, writeGuestGhConfig, ALREADY_RELEASED, inTeardown } from './chunk-6VFH52MP.js';
-import { writePendingUpdate } from './chunk-RHGF73IU.js';
-import { JOB_STATE_FORMAT, readsJobState, jobStateFormatOf } from './chunk-ZVB57WI6.js';
-import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-ABXQBEYK.js';
+import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, provisionEnvironment, readProvisionOut, resolveHostBuild, workdirProblem, listenOnBroker, hostEnvironment, hostCommandEnvironment, execArgv, MICROVM_COMMAND_DIR, commandLogOffset, startMicroVmCommand, microVmCommandLine, runCommand, execCommandLine, startSender, startHostServices, finishJob, isContainerTracked, isMicroVmTracked, probeMicroVmCommand, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isTracked, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listUnreadableJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, hookLimitsFor, AttemptLogBook, microVmOomKills, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, serveLease, vmAlive, writeGuestGhConfig, ALREADY_RELEASED, inTeardown } from './chunk-KVDVNOUK.js';
 import { decideInstalledSwitch } from './chunk-3JVYMD4G.js';
-import { fetchVersionMeta, npmVersion, npmSupportsProvenance, fetchTarballDigest, fetchProvenance, installVersion, auditSignatures } from './chunk-YETTWTAY.js';
+import { fetchVersionMeta, npmVersion, npmSupportsProvenance, fetchTarballDigest, fetchProvenance, installVersion, auditSignatures } from './chunk-E7R2GIAW.js';
 import { RUNNER_PROTOCOL } from './chunk-TPKYTORP.js';
-import { currentSkillCommand, formerSkillProblem, placeholderQueues, placeholderProblem } from './chunk-ZFBJUOYT.js';
-import { writeMarker, readMarker, currentVersion, removeMarker, entryIn, versionDir, startedThroughCurrent, switchCurrent, isInLayout, cleanVersions, stagingDir } from './chunk-MATUHHN4.js';
+import { writePendingUpdate } from './chunk-IVX3U7KV.js';
+import { JOB_STATE_FORMAT, readsJobState, jobStateFormatOf } from './chunk-ZVB57WI6.js';
+import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-66T6XJAB.js';
+import { currentSkillCommand, formerSkillProblem, placeholderQueues, placeholderProblem } from './chunk-W3FSGH2M.js';
 import { freeBytes, formatBytes } from './chunk-YYYRBYWG.js';
+import { writeMarker, readMarker, currentVersion, removeMarker, entryIn, versionDir, startedThroughCurrent, switchCurrent, isInLayout, cleanVersions, stagingDir } from './chunk-GUXWQIEY.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
-import { leaseTimeLeftMs, LEASE_SECONDS, provisionContainer, leaseExpiresAtMs, deliverContainerHooks, lifecycleSteps, lifecycleFailureReason, prepareBranch, containerCommandExec, setUpRunnerCgroup, createContainerRuntime, measureDisk, parseCpuList, ensureTunnel, keepGhConfigCurrent, filesAreCopied, gitRemoteFor, startServicesFor, createLeaseChannel } from './chunk-R7SGBXUD.js';
-import { describeCallFailure, retrySend, shortClaim, relativeToRunner, formatDuration, BuildTokens, classifyRefusal, refusalCode, createRunnerLog, formatClock } from './chunk-WSYXLLA5.js';
-import { tagToPull, pullInstruction, imageTag, writeUpdateStatus } from './chunk-M3MHHIUW.js';
+import { leaseTimeLeftMs, LEASE_SECONDS, provisionContainer, leaseExpiresAtMs, deliverContainerHooks, lifecycleSteps, lifecycleFailureReason, prepareBranch, containerCommandExec, setUpRunnerCgroup, createContainerRuntime, measureDisk, parseCpuList, ensureTunnel, keepGhConfigCurrent, filesAreCopied, gitRemoteFor, startServicesFor, createLeaseChannel } from './chunk-IKXY47R5.js';
+import { describeCallFailure, retrySend, shortClaim, relativeToRunner, formatDuration, BuildTokens, classifyRefusal, refusalCode, createRunnerLog, formatClock } from './chunk-USJZ2LDK.js';
+import { tagToPull, pullInstruction, imageTag, writeUpdateStatus } from './chunk-Z3ASAXVU.js';
 import { isVersion, compareVersions, satisfiesRange } from './chunk-TQMI335S.js';
-import { checkFit } from './chunk-7AQ5AM7U.js';
-import { fdName } from './chunk-YB3CSYXX.js';
-import { claimPidFile, writePidFile, readPidFile, releasePidFile } from './chunk-D7ECMB7B.js';
+import { checkFit } from './chunk-MQHTM4YJ.js';
+import { isBuiltinContainer, isBuiltinVm, isBuiltinProcess, loadRunnerConfig, checkHooks, builtinKind, DEFAULT_UPDATE_MAX_WAIT_HOURS } from './chunk-55XLX5PA.js';
+import { claimPidFile, writePidFile, readPidFile, releasePidFile } from './chunk-NUHZV3A4.js';
 import { startTimeOf, isSameProcess } from './chunk-JBJTC3UU.js';
-import { writeJobFile, ensureRunnerIdentity, readJobFile, builderName, runnerLabelValue, ensureFailureCount, builderSpec, ensureBuilder, spawnRun, BUILD_LABEL, RUNNER_LABEL, readJobFileChecked } from './chunk-EX5MQYEF.js';
-import { isSignatureRefusal, WorkCommandError, getJson, postJson } from './chunk-55GNQPO6.js';
-import { isBuiltinContainer, isBuiltinVm, isBuiltinProcess, loadRunnerConfig, checkHooks, builtinKind, DEFAULT_UPDATE_MAX_WAIT_HOURS } from './chunk-EPPIISRD.js';
+import { writeJobFile, ensureRunnerIdentity, readJobFile, builderName, runnerLabelValue, ensureFailureCount, builderSpec, ensureBuilder, spawnRun, BUILD_LABEL, RUNNER_LABEL, readJobFileChecked } from './chunk-VC5J7QPV.js';
 import { exceedsDisk } from './chunk-YJLHUKYS.js';
+import { isSignatureRefusal, WorkCommandError, getJson, postJson } from './chunk-X52PMPOM.js';
+import { loadHostKey, ensureHostKey, signerFor } from './chunk-YL2VDSNF.js';
+import { RUNNER_DIR_MODE, runnerDir, buildDir, attemptStamp, jobDir, RUNNER_FILE_MODE, jobsDir, pidFilePath, spoolDir, rootfsDir } from './chunk-5K3KB4YR.js';
+import { parseClaimIdentity, parseClaimedRepositories, parseUnreachable, repositoriesOf, primaryOf, sharedUserEnvironment, JOB_MOUNT, takeClaudeCredential, heldClaudeCredential, claudeCredential, currentClaudeCredential } from './chunk-HXAEQPZR.js';
 import { resolveVersion } from './chunk-RA3O54FC.js';
-import { loadHostKey, ensureHostKey, signerFor } from './chunk-Y4OKEFAX.js';
-import { RUNNER_DIR_MODE, runnerDir, buildDir, attemptStamp, jobDir, RUNNER_FILE_MODE, jobsDir, pidFilePath, spoolDir, rootfsDir } from './chunk-RHAGBUL5.js';
-import { parseClaimIdentity, parseClaimedRepositories, parseUnreachable, repositoriesOf, primaryOf, sharedUserEnvironment, JOB_MOUNT, claudeCredential } from './chunk-2I3LIRZP.js';
+import { fdName } from './chunk-XD4ZCMA4.js';
 import { COMMAND_LOST_REASON, CONTAINER_STOPPED_REASON } from './chunk-JGD5TWQ2.js';
 import { randomBytes } from 'crypto';
 import { mkdirSync, existsSync, chmodSync, writeFileSync, renameSync, statSync, readdirSync, readFileSync, closeSync, rmSync, openSync, constants, lstatSync } from 'fs';
@@ -76,7 +76,7 @@ function checkBlocked(config, probes) {
   }
   if (kind !== "own" && claudeCredential(probes.env) === void 0) {
     return {
-      reason: "there is no Claude credential in the runner's environment. Put CLAUDE_CODE_OAUTH_TOKEN (from `claude setup-token`) or ANTHROPIC_API_KEY in the runner.env beside the config, then restart the service"
+      reason: "there is no Claude credential in the runner's environment. Store CLAUDE_CODE_OAUTH_TOKEN (from `claude setup-token`) or ANTHROPIC_API_KEY with `outerlayer runner init --agent claude`, which writes the claude.env beside the config, then restart the service"
     };
   }
   return void 0;
@@ -482,7 +482,9 @@ async function prepareUpdate(args) {
     return finish(args, retryFailure(version, err));
   }
   if (!verified.ok) return finish(args, { outcome: verified.outcome, reason: verified.reason });
-  const staged = await deps.runNode([entryIn(verified.dir), "runner", "check", "--config", configPath], verified.dir);
+  const held = currentClaudeCredential(process.env);
+  const stagedEnv = held === void 0 ? void 0 : { ...process.env, [held.variable]: held.value };
+  const staged = await deps.runNode([entryIn(verified.dir), "runner", "check", "--config", configPath], verified.dir, stagedEnv);
   if (staged.status !== 0) {
     removeStaging(verified.dir);
     return finish(args, {
@@ -1777,7 +1779,7 @@ var CLAIM_REFUSAL_CODES = new Set(
   "pull_request_from_fork pull_request_on_default_branch pull_request_ambiguous pull_request_repository_not_connected repository_not_reachable branch_claimed_elsewhere".split(" ")
 );
 async function tryClaimAndStart(state, item, queue) {
-  const { postJson: postJson2 } = await import('./work-cmd-VECTYST6.js');
+  const { postJson: postJson2 } = await import('./work-cmd-COESFSHE.js');
   const log = logOf(state);
   const hostKey = await loadHostKey(state.config.configPath);
   const claim = await retrySend(
@@ -2935,14 +2937,26 @@ async function logUnusableHelper(config, runtime, log) {
   if (helper.reason === "unsupported") log.line(helper.detail);
   else if (helper.unreachable === true) log.line(`${helper.detail}, so microVM builds run without the jailer`);
 }
+function hooksOf(configPath) {
+  try {
+    return loadRunnerConfig(configPath).hooks;
+  } catch {
+    return { provision: "builtin:container" };
+  }
+}
 async function start(configPath, deps = { fetchImpl: fetch }) {
   const log = deps.log ??= createRunnerLog(deps.now ?? (() => /* @__PURE__ */ new Date()));
+  takeClaudeCredential(process.env, hooksOf(configPath));
   const update = deps.update;
   if (update !== void 0) {
     const outcome = await onStartUnderMarker({
       configPath,
       own: ownVersionOf(deps),
-      check: update.check ? () => update.check(configPath) : async () => (await import('./check-YTXFVWK7.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl }),
+      check: update.check ? () => update.check(configPath) : async () => {
+        const held = heldClaudeCredential();
+        const env = held === void 0 ? process.env : { ...process.env, [held.variable]: held.value };
+        return (await import('./check-NDDOASVO.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl, env });
+      },
       now: () => (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime(),
       log
     });

package/dist/{chunk-QKIQ2R7F.js → chunk-ATJOFXTE.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { launcherPath, writeLauncher, LauncherWriteError, pathNotes } from './chunk-QHH4OSD4.js';
-import { currentVersion, currentLink, isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-MATUHHN4.js';
+import { launcherPath, writeLauncher, LauncherWriteError, pathNotes } from './chunk-CTYSTE5C.js';
+import { currentVersion, currentLink, isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-GUXWQIEY.js';
 import { compareVersions } from './chunk-TQMI335S.js';
-import { RUNNER_DIR_MODE } from './chunk-RHAGBUL5.js';
+import { RUNNER_DIR_MODE } from './chunk-5K3KB4YR.js';
 import { realpathSync, readFileSync, mkdirSync, rmSync, cpSync, existsSync } from 'fs';
 import { dirname, sep, join } from 'path';
 

package/dist/chunk-CDDED64E.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/maintained-line.ts
+var MAINTAINED_SKILLS = ["outerlayer-evidence", "outerlayer-amend", "outerlayer-findings", "outerlayer-cli", "outerlayer-build"];
+var MAINTAINED_LINE_VERSION = /^<!-- maintained by OuterLayer (\S+?)\. /m;
+function maintainedLineVersion(text) {
+  return MAINTAINED_LINE_VERSION.exec(text)?.[1];
+}
+
+export { MAINTAINED_SKILLS, maintainedLineVersion };

package/dist/{chunk-QHH4OSD4.js → chunk-CTYSTE5C.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { currentLink } from './chunk-MATUHHN4.js';
+import { currentLink } from './chunk-GUXWQIEY.js';
 import { readFileSync, statSync, chmodSync, mkdirSync, writeFileSync, renameSync, rmSync, existsSync, lstatSync, accessSync, constants, realpathSync } from 'fs';
 import { randomBytes } from 'crypto';
 import { join, dirname, delimiter, resolve } from 'path';

package/dist/{chunk-DJHNEGNM.js → chunk-DKWQMPSL.js}

@@ -3,6 +3,8 @@ import { createRequire } from 'node:module';
 import { appendContextProvenance } from './chunk-ZJSNLVCE.js';
 import { CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
 import { readRepoConnection, findGitDirs } from './chunk-BJ3KTMDH.js';
+import { updateNoticeContext, staleMachineCopiesContext } from './chunk-5BHIBJDA.js';
+import { resolvePackageVersion } from './chunk-RA3O54FC.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { deadHooksState, huskyPrepareScript, preparePackageManagerCommand } from './chunk-TUSYOL2O.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
@@ -682,7 +684,7 @@ async function missingControlPlane(cwd, sessionId, home, env) {
     cleanupEarlierCopies(dirs);
   }
   if (!contextPossiblyGoverned(cwd, home)) return void 0;
-  const { governanceOf } = await import('./control-plane-launch-DBQA3KLJ.js');
+  const { governanceOf } = await import('./control-plane-launch-FZMD4MXX.js');
   if (await governanceOf({ cwd, env, home }) !== "governed") return void 0;
   recordMissingContext(dirs, sessionId, home);
   const launcher = `${cliInvocation()} claude`;
@@ -754,6 +756,8 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
     let hookErrorsMessage;
     let renewalHookMessage;
     let machineSkillsMessage;
+    let updateNoticeMessage;
+    let staleCopiesMessage;
     if (resolvedEvent === "SessionStart") {
       const hookErrorsBytes = fileSizeBytes(join(dir, "hook-errors.log"));
       const hookErrorsSeen = hookErrorsSeenBytes(home);
@@ -776,6 +780,18 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
       } catch (err) {
         logHookError(home, err);
       }
+      try {
+        updateNoticeMessage = updateNoticeContext(home, resolvePackageVersion(), env) ?? void 0;
+      } catch (err) {
+        logHookError(home, err);
+      }
+      if (machineSkillsMessage === void 0) {
+        try {
+          staleCopiesMessage = staleMachineCopiesContext(home, resolvePackageVersion()) ?? void 0;
+        } catch (err) {
+          logHookError(home, err);
+        }
+      }
       try {
         deadHooksMessage = deadHooksAutoHealContext(sessionCwd, home) ?? void 0;
       } catch (err) {
@@ -800,7 +816,7 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
       sessionCwd,
       (out) => process.stdout.write(out),
       missingPlane?.person,
-      [missingPlane?.agent, machineSkillsMessage, deadHooksMessage, workLaunchMessage, hookErrorsMessage, renewalHookMessage].filter(
+      [missingPlane?.agent, machineSkillsMessage, staleCopiesMessage, updateNoticeMessage, deadHooksMessage, workLaunchMessage, hookErrorsMessage, renewalHookMessage].filter(
         (s) => s !== void 0
       )
     );

package/dist/{chunk-IMOB4IOI.js → chunk-DQYMQ47E.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { MAINTAINED_SKILLS, loadMachineSkillFiles, resolvePackRoot, maintainedLineVersion } from './chunk-7OUOLGUV.js';
-import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { loadMachineSkillFiles, resolvePackRoot } from './chunk-JGML2VUN.js';
+import { MAINTAINED_SKILLS, maintainedLineVersion } from './chunk-CDDED64E.js';
 import { resolvePackageVersion } from './chunk-RA3O54FC.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { randomBytes } from 'crypto';
 import { existsSync, symlinkSync, realpathSync, lstatSync, readFileSync, mkdirSync, rmSync, renameSync, writeFileSync, cpSync } from 'fs';
 import { join, resolve, dirname, relative } from 'path';

package/dist/{chunk-YETTWTAY.js → chunk-E7R2GIAW.js}

@@ -48,10 +48,10 @@ async function fetchProvenance(version, fetchImpl) {
 }
 
 // src/runner/update/npm.ts
-function run(file, args, cwd) {
+function run(file, args, cwd, env) {
   const COMMAND_TIMEOUT_MS = 10 * 6e4;
   return new Promise((resolve) => {
-    const child = spawn(file, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: COMMAND_TIMEOUT_MS });
+    const child = spawn(file, args, { cwd, ...env === void 0 ? {} : { env }, stdio: ["ignore", "pipe", "pipe"], timeout: COMMAND_TIMEOUT_MS });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => stdout += chunk.toString());
@@ -66,10 +66,10 @@ function npmExecutable(nodePath) {
 }
 function realRunNpm(nodePath) {
   const npm = npmExecutable(nodePath);
-  return (args, cwd) => run(npm, args, cwd);
+  return (args, cwd, env) => run(npm, args, cwd, env);
 }
 function realRunNode(nodePath) {
-  return (args, cwd) => run(nodePath, args, cwd);
+  return (args, cwd, env) => run(nodePath, args, cwd, env);
 }
 function npmSupportsProvenance(version) {
   const match = /^(\d+)\.(\d+)/.exec(version.trim());

package/dist/{chunk-GFUE5TKO.js → chunk-F4FA3ZUT.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { DEFAULT_UNIT_NAME } from './chunk-7AQ5AM7U.js';
-import { parseRunnerEnv } from './chunk-STSLH5EJ.js';
-import { RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
+import { DEFAULT_UNIT_NAME } from './chunk-MQHTM4YJ.js';
+import { RUNNER_FILE_MODE } from './chunk-5K3KB4YR.js';
+import { claudeEnvPath, withoutCredentialLines } from './chunk-HXAEQPZR.js';
+import { parseRunnerEnv } from './chunk-XD4ZCMA4.js';
 import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
 
@@ -20,7 +21,6 @@ var CLAUDE_CREDENTIAL_NAMES = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"];
 var RunnerEnvError = class extends Error {
 };
 var CREDENTIAL_SHAPE = /^sk-ant-(oat|api)[0-9]*-[A-Za-z0-9_-]+$/;
-var SETS = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=/;
 function runnerEnvPath(configPath) {
   return join(dirname(configPath), "runner.env");
 }
@@ -35,18 +35,15 @@ function credentialFromStdin(text) {
   }
   return { variable: kind === "oat" ? "CLAUDE_CODE_OAUTH_TOKEN" : "ANTHROPIC_API_KEY", value };
 }
-function hasStoredCredential(configPath) {
-  const path = runnerEnvPath(configPath);
+function setsCredential(path) {
   if (!existsSync(path)) return false;
   const env = parseRunnerEnv(readFileSync(path, "utf8"));
   return CLAUDE_CREDENTIAL_NAMES.some((name) => env[name]);
 }
-function storeClaudeCredential(configPath, credential) {
-  const path = runnerEnvPath(configPath);
-  const kept = existsSync(path) ? readFileSync(path, "utf8").split("\n").filter((line) => !CLAUDE_CREDENTIAL_NAMES.includes(SETS.exec(line)?.[1] ?? "")) : [];
-  while (kept[kept.length - 1] === "") kept.pop();
-  const text = `${[...kept, `${credential.variable}=${credential.value}`].join("\n")}
-`;
+function hasStoredCredential(configPath) {
+  return setsCredential(claudeEnvPath(configPath)) || setsCredential(runnerEnvPath(configPath));
+}
+function replaceFile(path, text) {
   const temporary = `${path}.${process.pid}.tmp`;
   try {
     writeFileSync(temporary, text, { mode: RUNNER_FILE_MODE, flag: "wx" });
@@ -55,11 +52,24 @@ function storeClaudeCredential(configPath, credential) {
     rmSync(temporary, { force: true });
     throw err;
   }
+}
+function storeClaudeCredential(configPath, credential) {
+  const path = claudeEnvPath(configPath);
+  replaceFile(path, `${credential.variable}=${credential.value}
+`);
+  const runnerPath = runnerEnvPath(configPath);
+  if (existsSync(runnerPath)) {
+    const dropped = withoutCredentialLines(readFileSync(runnerPath, "utf8"));
+    if (dropped !== void 0) replaceFile(runnerPath, dropped);
+  }
   return path;
 }
 function restartForCredential(state, unitName = DEFAULT_UNIT_NAME) {
-  if (state !== "pending-restart" && state !== "differs") return void 0;
-  return `The service ${unitName} reads runner.env only when it starts. Restart it so it uses the stored credential: sudo systemctl restart ${unitName}`;
+  if (state === "differs") {
+    return `The service ${unitName} was not written by runner init, so it may not load claude.env, the one file that now holds the credential. Add EnvironmentFile=-<config directory>/claude.env to it, or run runner install --service --replace. Then restart it: sudo systemctl restart ${unitName}`;
+  }
+  if (state !== "pending-restart") return void 0;
+  return `The service ${unitName} loads claude.env only when it starts. Restart it so it uses the stored credential: sudo systemctl restart ${unitName}`;
 }
 
 export { AGENT_COMMANDS, RunnerEnvError, credentialFromStdin, hasStoredCredential, isAgentName, restartForCredential, storeClaudeCredential };

package/dist/{chunk-6TRNCUM4.js → chunk-FGF52V4V.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { rewriteControlPlanePaths, rewriteAgentsFilePaths, SUPPORTED_CONTROL_PLANE_LAYOUT, rewriteHookCommand } from './chunk-HCVLP7XA.js';
-import { MAINTAINED_SKILLS } from './chunk-7OUOLGUV.js';
+import { MAINTAINED_SKILLS } from './chunk-CDDED64E.js';
 import { existsSync, mkdirSync, copyFileSync, lstatSync, readdirSync, writeFileSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 

package/dist/{chunk-MATUHHN4.js → chunk-GUXWQIEY.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-5K3KB4YR.js';
 import { readlinkSync, realpathSync, mkdirSync, unlinkSync, symlinkSync, renameSync, readFileSync, writeFileSync, rmSync, existsSync, readdirSync } from 'fs';
 import { join, basename, sep, resolve } from 'path';
 

package/dist/{chunk-2I3LIRZP.js → chunk-HXAEQPZR.js}

@@ -1,13 +1,93 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { parseRunnerEnv } from './chunk-XD4ZCMA4.js';
 import { TARGET_TUNNEL, TARGET_LEASE, destinationTarget } from './chunk-JGD5TWQ2.js';
-import { existsSync, unlinkSync, chmodSync } from 'fs';
+import { readFileSync, existsSync, unlinkSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
 import { request as request$1, createServer } from 'http';
 import { request } from 'https';
 import { createServer as createServer$1 } from 'net';
-import { join } from 'path';
 
 createRequire(import.meta.url);
+var CLAUDE_CREDENTIAL_ID = "claude";
+var CLAUDE_ENV_FILE = "claude.env";
+function claudeEnvPath(configPath) {
+  return join(dirname(configPath), CLAUDE_ENV_FILE);
+}
+var CLAUDE_CREDENTIAL_VARIABLES = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+var FORWARDED = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"];
+function firstOf(values, source) {
+  for (const variable of FORWARDED) {
+    const value = values[variable];
+    if (value !== void 0 && value !== "") return { variable, value, source };
+  }
+  return void 0;
+}
+function readClaudeCredential(env) {
+  const fromEnvironment = firstOf(env, "environment");
+  if (fromEnvironment !== void 0) return fromEnvironment;
+  const directory = env.CREDENTIALS_DIRECTORY;
+  if (directory === void 0 || directory === "") return void 0;
+  const path = join(directory, CLAUDE_CREDENTIAL_ID);
+  try {
+    const text = readFileSync(path, "utf8");
+    const found = firstOf(parseRunnerEnv(text), "credentials-directory");
+    if (found === void 0 && text.trim() !== "") complain(path, "it sets neither CLAUDE_CODE_OAUTH_TOKEN nor ANTHROPIC_API_KEY, each as NAME=value");
+    return found;
+  } catch (err) {
+    if (err.code !== "ENOENT") complain(path, `it could not be read (${err instanceof Error ? err.message : String(err)})`);
+    return void 0;
+  }
+}
+var complained = /* @__PURE__ */ new Set();
+function complain(path, reason) {
+  if (complained.has(path)) return;
+  complained.add(path);
+  process.stderr.write(`the Claude credential file ${path} holds no usable credential: ${reason}
+`);
+}
+var held;
+var removedValues = /* @__PURE__ */ new Set();
+function holdClaudeCredential(env = process.env) {
+  held ??= readClaudeCredential(env);
+  for (const name of CLAUDE_CREDENTIAL_VARIABLES) {
+    const value = env[name];
+    if (value !== void 0 && value !== "") removedValues.add(value);
+    delete env[name];
+  }
+  return held;
+}
+function takeClaudeCredential(env, hooks) {
+  return /^builtin:(container|process|vm)$/.test(hooks.provision) ? holdClaudeCredential(env) : void 0;
+}
+function removedClaudeCredentialValues() {
+  return [...removedValues];
+}
+function heldClaudeCredential() {
+  return held;
+}
+function currentClaudeCredential(env) {
+  return held ?? readClaudeCredential(env);
+}
+var SETS = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=/;
+function credentialLineIn(text) {
+  const set = parseRunnerEnv(text);
+  const lines = text.split("\n");
+  for (const variable of FORWARDED) {
+    if ((set[variable] ?? "") === "") continue;
+    const line = lines.find((candidate) => (parseRunnerEnv(candidate)[variable] ?? "") !== "");
+    return line.replace(/^\s*(?:export\s+)?/, "").trimEnd();
+  }
+  return void 0;
+}
+function withoutCredentialLines(text) {
+  const lines = text.split("\n");
+  const kept = lines.filter((line) => !CLAUDE_CREDENTIAL_VARIABLES.includes(SETS.exec(line)?.[1] ?? ""));
+  if (kept.length === lines.length) return void 0;
+  while (kept[kept.length - 1] === "") kept.pop();
+  return kept.length === 0 ? "" : `${kept.join("\n")}
+`;
+}
 
 // src/runner/builtin-destinations.ts
 var GATEWAY_DESTINATION = "gateway";
@@ -23,16 +103,27 @@ var OAUTH_PLACEHOLDER = "sk-ant-oat01-placeholder-not-a-real-token";
 var API_KEY_PLACEHOLDER = "sk-ant-api03-placeholder-not-a-real-key";
 var ITEM_KEY_PLACEHOLDER = "olitem_placeholder-not-a-real-key";
 var ITEM_KEY_VARIABLE = "OUTERLAYER_ITEM_KEY";
-var CLAUDE_CREDENTIAL_VARIABLES = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
-function claudeCredential(hostEnv) {
-  const held = (name) => hostEnv[name] !== void 0 && hostEnv[name] !== "";
-  if (held("CLAUDE_CODE_OAUTH_TOKEN")) return { variable: "CLAUDE_CODE_OAUTH_TOKEN", placeholder: OAUTH_PLACEHOLDER };
-  if (held("ANTHROPIC_API_KEY")) return { variable: "ANTHROPIC_API_KEY", placeholder: API_KEY_PLACEHOLDER };
-  return void 0;
+function claudeCredential(hostEnv, options = {}) {
+  const credential = options.ignoreHeld === true ? readClaudeCredential(hostEnv) : currentClaudeCredential(hostEnv);
+  if (credential === void 0) return void 0;
+  return { variable: credential.variable, placeholder: credential.variable === "CLAUDE_CODE_OAUTH_TOKEN" ? OAUTH_PLACEHOLDER : API_KEY_PLACEHOLDER };
 }
 function gatewayUpstream(gatewayUrl) {
   return `${new URL(gatewayUrl).origin}/`;
 }
+function forwardedEnvironment(hostEnv) {
+  const env = {};
+  for (const name of ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"]) {
+    Object.defineProperty(env, name, {
+      enumerable: true,
+      get: () => {
+        const current = currentClaudeCredential(hostEnv);
+        return current !== void 0 && current.variable === name ? current.value : hostEnv[name];
+      }
+    });
+  }
+  return env;
+}
 function builtInDestinations(input) {
   const credential = claudeCredential(input.hostEnv);
   const apiKeyMode = credential?.variable === "ANTHROPIC_API_KEY";
@@ -55,7 +146,7 @@ function builtInDestinations(input) {
         header: apiKeyMode ? { name: "x-api-key", value: "${ANTHROPIC_API_KEY}", variables: ["ANTHROPIC_API_KEY"] } : { name: "Authorization", value: "Bearer ${CLAUDE_CODE_OAUTH_TOKEN}", variables: ["CLAUDE_CODE_OAUTH_TOKEN"] },
         env: {}
       },
-      hostEnv: input.hostEnv,
+      hostEnv: forwardedEnvironment(input.hostEnv),
       // A build's own key in either header would sit beside the runner's, and the upstream takes one of them.
       drop: ["x-api-key", "authorization"],
       socket: CLAUDE_SOCKET
@@ -661,4 +752,4 @@ function withTunnelRecord(environment, record, onlyWhenUsed = false) {
   };
 }
 
-export { AGENT_CREDENTIAL_MISSING, BUILD_HOME, BUILT_IN_NAMES, CHECKOUT_DIR, CLAUDE_CREDENTIAL_VARIABLES, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT, EVAL_INPUT_DIR, GATEWAY_PORT, GATEWAY_SOCKET, JOB_MOUNT, PROXY_WARNING_FLAG, RELAY_PORT, authorEnvironment, buildEnvironment, builtInEnvironment, checkEnvironment, checkoutPath, claudeCredential, commitIdentityRecord, containerLocalAddress, destinationEnvironment, headerVariables, isRefusedInConfig, isReservedVariable, lifecycleWorkdir, parseClaimIdentity, parseClaimedRepositories, parseIsolation, parseUnreachable, primaryOf, proxyEnvironment, repositoriesOf, repositoryPath, resolveDestinations, sharedUserEnvironment, startBuildServices, tokenHeader, withGitConfig, withHooksPath, withProxyWarningHidden, withTokenHeader, withTunnelRecord };
+export { AGENT_CREDENTIAL_MISSING, BUILD_HOME, BUILT_IN_NAMES, CHECKOUT_DIR, CLAUDE_CREDENTIAL_ID, CLAUDE_CREDENTIAL_VARIABLES, CLAUDE_ENV_FILE, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT, EVAL_INPUT_DIR, GATEWAY_PORT, GATEWAY_SOCKET, JOB_MOUNT, PROXY_WARNING_FLAG, RELAY_PORT, authorEnvironment, buildEnvironment, builtInEnvironment, checkEnvironment, checkoutPath, claudeCredential, claudeEnvPath, commitIdentityRecord, containerLocalAddress, credentialLineIn, currentClaudeCredential, destinationEnvironment, headerVariables, heldClaudeCredential, isRefusedInConfig, isReservedVariable, lifecycleWorkdir, parseClaimIdentity, parseClaimedRepositories, parseIsolation, parseUnreachable, primaryOf, proxyEnvironment, readClaudeCredential, removedClaudeCredentialValues, repositoriesOf, repositoryPath, resolveDestinations, sharedUserEnvironment, startBuildServices, takeClaudeCredential, tokenHeader, withGitConfig, withHooksPath, withProxyWarningHidden, withTokenHeader, withTunnelRecord, withoutCredentialLines };