@outerlayer/cli 0.26.4 → 0.27.1

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

@@ -554,6 +554,24 @@ function writeSessionStartContext(event, home, cwd, write, systemMessage, extraP
   } catch {
   }
 }
+var MACHINE_CORE = "~/.agents/skills/outerlayer-build/SKILL.md";
+var BUILD_SKILL_FILES = [".agents/skills/build/SKILL.md", ".outerlayer/skills/build/SKILL.md", ".claude/skills/build/SKILL.md"];
+function machineSkillsContext(home, cwd) {
+  for (let dir = cwd; ; dir = join(dir, "..")) {
+    for (const file of BUILD_SKILL_FILES) {
+      let text;
+      try {
+        text = readFileSync(join(dir, file), "utf8");
+      } catch {
+        continue;
+      }
+      if (!text.includes(MACHINE_CORE)) return null;
+      if (existsSync(join(home, ".agents", "skills", "outerlayer-build", "SKILL.md"))) return null;
+      return `This repository's build skill reads ${MACHINE_CORE}, and that file does not exist. Tell the person that the maintained skills are not installed on this machine, and ask them to run \`${cliInvocation()} init --local\`.`;
+    }
+    if (join(dir, "..") === dir) return null;
+  }
+}
 var HEAL_RETRY_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 function healFailureMarkerPath(home, repoRoot) {
   const key = createHash("sha256").update(repoRoot).digest("hex").slice(0, 16);
@@ -664,7 +682,7 @@ async function missingControlPlane(cwd, sessionId, home, env) {
     cleanupEarlierCopies(dirs);
   }
   if (!contextPossiblyGoverned(cwd, home)) return void 0;
-  const { governanceOf } = await import('./control-plane-launch-JIQOE6BP.js');
+  const { governanceOf } = await import('./control-plane-launch-DBQA3KLJ.js');
   if (await governanceOf({ cwd, env, home }) !== "governed") return void 0;
   recordMissingContext(dirs, sessionId, home);
   const launcher = `${cliInvocation()} claude`;
@@ -735,6 +753,7 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
     let workLaunchMessage;
     let hookErrorsMessage;
     let renewalHookMessage;
+    let machineSkillsMessage;
     if (resolvedEvent === "SessionStart") {
       const hookErrorsBytes = fileSizeBytes(join(dir, "hook-errors.log"));
       const hookErrorsSeen = hookErrorsSeenBytes(home);
@@ -752,6 +771,11 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
           logHookError(home, err);
         }
       }
+      try {
+        machineSkillsMessage = machineSkillsContext(home, sessionCwd) ?? void 0;
+      } catch (err) {
+        logHookError(home, err);
+      }
       try {
         deadHooksMessage = deadHooksAutoHealContext(sessionCwd, home) ?? void 0;
       } catch (err) {
@@ -776,7 +800,7 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
       sessionCwd,
       (out) => process.stdout.write(out),
       missingPlane?.person,
-      [missingPlane?.agent, deadHooksMessage, workLaunchMessage, hookErrorsMessage, renewalHookMessage].filter(
+      [missingPlane?.agent, machineSkillsMessage, deadHooksMessage, workLaunchMessage, hookErrorsMessage, renewalHookMessage].filter(
         (s) => s !== void 0
       )
     );
@@ -810,4 +834,4 @@ function recordLinkExitFailure(argv, home = homeFromEnv(), target = process) {
   });
 }
 
-export { AUTO_SYNC_DEBOUNCE_MS, DUPLICATE_RUN_WINDOW_MS, SYNC_STALE_AFTER_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, assessSyncHealth, checkInstalledCliStaleness, contextPossiblyGoverned, formatAgo, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, installedCliDistDir, isDuplicateRun, logHookError, markWorkLeaseRenewed, maybeAutoSync, maybeRenewWorkLease, readSyncStatus, recordLinkExitFailure, refreshCommand, runHookFast, sanitizeForContext, spoolDir, workspaceRootOf, writeSyncStatus };
+export { AUTO_SYNC_DEBOUNCE_MS, DUPLICATE_RUN_WINDOW_MS, SYNC_STALE_AFTER_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, assessSyncHealth, checkInstalledCliStaleness, contextPossiblyGoverned, formatAgo, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, installedCliDistDir, isDuplicateRun, logHookError, machineSkillsContext, markWorkLeaseRenewed, maybeAutoSync, maybeRenewWorkLease, readSyncStatus, recordLinkExitFailure, refreshCommand, runHookFast, sanitizeForContext, spoolDir, workspaceRootOf, writeSyncStatus };

package/dist/{chunk-O4362FPA.js → chunk-E5IJ5533.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { autoConnect, detectActiveSession } from './chunk-H57M3HC7.js';
-import { defaultFetch, unauthorizedMessage, resolveGatewayCredentials } from './chunk-MCSINUVC.js';
+import { autoConnect, detectActiveSession } from './chunk-2F762IXY.js';
+import { defaultFetch, unauthorizedMessage, resolveGatewayCredentials } from './chunk-BWH36FOC.js';
 import { resolveRepoIdentity } from './chunk-QE3UQAHK.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';

package/dist/{chunk-JWRX5ZTT.js → chunk-EPPIISRD.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { MAX_ALLOW_HOSTS, allowHostProblem } from './chunk-UXYLWVTQ.js';
-import { parseSize } from './chunk-7RQ73DLO.js';
+import { parseSize } from './chunk-YJLHUKYS.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { isRefusedInConfig, resolveDestinations, isReservedVariable } from './chunk-2K3TCQHW.js';
+import { isRefusedInConfig, resolveDestinations, isReservedVariable } from './chunk-2I3LIRZP.js';
 import { existsSync, statSync, accessSync, constants, readFileSync } from 'fs';
 import { hostname } from 'os';
 import { join } from 'path';

package/dist/{chunk-QUP6CVBQ.js → chunk-EX5MQYEF.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RecipeError, BUILDKIT_IMAGE } from './chunk-B6K7R5UY.js';
-import { parseSize } from './chunk-7RQ73DLO.js';
+import { RecipeError, BUILDKIT_IMAGE } from './chunk-2BTFKNTR.js';
+import { parseSize } from './chunk-YJLHUKYS.js';
 import { compareVersions } from './chunk-QE3UQAHK.js';
-import { ensureHostKey } from './chunk-GWRDL75D.js';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE, runnerDir, jobsDir } from './chunk-F3BBEBPL.js';
-import { CLAUDE_PORT, JOB_MOUNT, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_SOCKET, RELAY_PORT, DESTINATION_BASE_PORT } from './chunk-2K3TCQHW.js';
+import { ensureHostKey } from './chunk-Y4OKEFAX.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE, runnerDir, jobsDir } from './chunk-RHAGBUL5.js';
+import { CLAUDE_PORT, JOB_MOUNT, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_SOCKET, RELAY_PORT, DESTINATION_BASE_PORT } from './chunk-2I3LIRZP.js';
 import { JOIN_DIR, RELAY_ID, JOIN_SOCKET, TARGET_GATEWAY, TARGET_CLAUDE, destinationTarget, RELAY_USER } from './chunk-JGD5TWQ2.js';
 import { StringDecoder } from 'string_decoder';
 import { spawn } from 'child_process';

package/dist/{chunk-KNBWOL2B.js → chunk-FP23SVDD.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runEmit } from './chunk-WX2WEERU.js';
-import { installStarterPack } from './chunk-VJBFQP3H.js';
-import { resolveGitCommonDir, defaultGitRunner } from './chunk-4UFSTKE5.js';
+import { runEmit } from './chunk-WUL2OP5A.js';
+import { installStarterPack } from './chunk-XZ6Q6ZNR.js';
+import { AGENTS_MD_LAYOUT, declareAgentsMdLayout, linkClaudeSkills, SKILLS_LINK_PATH, describeSkillsLink, isAgentsMdLayout, holdsTodaysLayoutSources, discoverOuterlayerPaths } from './chunk-LOKSLO25.js';
+import { resolveGitCommonDir, defaultGitRunner } from './chunk-BPKO76QR.js';
+import { loadTemplateFiles, loadMaintainedFiles, skillDir, AGENTS_SKILLS_BASE } from './chunk-7OUOLGUV.js';
 import { addStdioMcpEntryIfAbsent, addDocsMcpEntryIfAbsent, DOCS_MCP_SERVER_NAME } from './chunk-KT4CN6OU.js';
 import { C } from './chunk-ANPNT6PM.js';
-import { AGENTS_MD_LAYOUT, declareAgentsMdLayout, linkClaudeSkills, SKILLS_LINK_PATH, describeSkillsLink, isAgentsMdLayout, holdsTodaysLayoutSources, discoverOuterlayerPaths } from './chunk-JKNYTNYD.js';
-import { loadTemplateFiles, loadMaintainedFiles, skillDir, AGENTS_SKILLS_BASE } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { linkedAgentsPath } from './chunk-VWFOKRYS.js';
 import { cloneIsGoverned } from './chunk-YQR6E6OV.js';

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

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { DEFAULT_UNIT_NAME } from './chunk-6SPXKRQR.js';
-import { parseRunnerEnv } from './chunk-6MZSX4M7.js';
-import { RUNNER_FILE_MODE } from './chunk-F3BBEBPL.js';
+import { DEFAULT_UNIT_NAME } from './chunk-7AQ5AM7U.js';
+import { parseRunnerEnv } from './chunk-STSLH5EJ.js';
+import { RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
 import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
 

package/dist/{chunk-XLC7KEUV.js → chunk-GLUKDQS4.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-2K3TCQHW.js';
+import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-2I3LIRZP.js';
 import { symlinkSync, unlinkSync } from 'fs';
 import { join } from 'path';
 

package/dist/{chunk-GFHLEVUE.js → chunk-HWDYLXHH.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { claimPidFile, RunnerAlreadyRunningError, releasePidFile } from './chunk-IZAOO5AR.js';
+import { claimPidFile, RunnerAlreadyRunningError, releasePidFile } from './chunk-D7ECMB7B.js';
 import { startTimeOf } from './chunk-JBJTC3UU.js';
-import { CLAUDE_CODE_VERSION, NODE_IMAGE, DEFAULT_BASE_IMAGE, RecipeError, locateRecipe, readRecipe, assertBuildable, TINI_VERSION, GH_VERSION, writeSanitizedRecipe, classifyProperties, GH_SHA256, TINI_SHA256, SANITIZED_NAME } from './chunk-B6K7R5UY.js';
-import { RUNNER_DIR_MODE, repoCacheDir, imagesDir, attemptStamp, runnerDir, rootfsPathFor, RUNNER_FILE_MODE } from './chunk-F3BBEBPL.js';
-import { withGitConfig, tokenHeader, PROXY_WARNING_FLAG } from './chunk-2K3TCQHW.js';
+import { CLAUDE_CODE_VERSION, NODE_IMAGE, DEFAULT_BASE_IMAGE, RecipeError, locateRecipe, readRecipe, assertBuildable, TINI_VERSION, GH_VERSION, writeSanitizedRecipe, classifyProperties, GH_SHA256, TINI_SHA256, SANITIZED_NAME } from './chunk-2BTFKNTR.js';
+import { RUNNER_DIR_MODE, repoCacheDir, imagesDir, attemptStamp, runnerDir, rootfsPathFor, RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
+import { withGitConfig, tokenHeader, PROXY_WARNING_FLAG } from './chunk-2I3LIRZP.js';
 import { RELAY_ID, RELAY_USER } from './chunk-JGD5TWQ2.js';
 import { mkdirSync, rmSync, existsSync, mkdtempSync, cpSync, readFileSync, writeFileSync, readdirSync, lstatSync, readlinkSync } from 'fs';
 import { tmpdir } from 'os';
@@ -184,6 +184,8 @@ function toolsDockerfile(parts) {
     `RUN npm install --global --prefix /out/opt/outerlayer/claude @anthropic-ai/claude-code@${version}`,
     "COPY dist /out/opt/outerlayer/cli/dist",
     "COPY package.json /out/opt/outerlayer/cli/package.json",
+    // `outerlayer claude` installs the maintained skills from this pack into the build's home folder before the agent starts.
+    "COPY skill-pack /out/opt/outerlayer/cli/skill-pack",
     "RUN mkdir -p /out/opt/outerlayer/bin /out/usr/local/bin /out/etc/claude-code /out/build \\",
     " && cp /usr/local/bin/node /out/opt/outerlayer/bin/node \\",
     ` && printf '%s\\n' '#!/bin/sh' 'exec /opt/outerlayer/bin/node /opt/outerlayer/cli/dist/index.js "$@"' > /out/usr/local/bin/outerlayer \\`,
@@ -443,6 +445,7 @@ async function buildRepositoryImage(opts, ports) {
       try {
         cpSync(opts.cli.distDir, join(context, "dist"), { recursive: true });
         cpSync(join(opts.cli.distDir, "..", "package.json"), join(context, "package.json"));
+        cpSync(join(opts.cli.distDir, "..", "skill-pack"), join(context, "skill-pack"), { recursive: true });
         if (opts.guestHelper !== void 0) {
           mkdirSync(join(context, "guest"));
           cpSync(opts.guestHelper.path, join(context, "guest", "outerlayer-guest"));

package/dist/chunk-IMOB4IOI.js

@@ -0,0 +1,181 @@
+#!/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 { resolvePackageVersion } from './chunk-RA3O54FC.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';
+
+createRequire(import.meta.url);
+var machineSkillsBase = (home) => join(home, ".agents", "skills");
+var claudeSkillsBase = (home) => join(home, ".claude", "skills");
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+var defaultLink = (target, path) => {
+  if (process.platform === "win32") symlinkSync(resolve(realpathSync(dirname(path)), target), path, "junction");
+  else symlinkSync(target, path, "dir");
+};
+function installedVersion(folder) {
+  try {
+    return maintainedLineVersion(readFileSync(join(folder, "SKILL.md"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function entryExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function folderExists(path) {
+  try {
+    return lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function tempName(base, label) {
+  return join(base, `.${label}-${process.pid}-${randomBytes(4).toString("hex")}`);
+}
+var REPLACE_ATTEMPTS = 3;
+function replaceWith(final, build) {
+  const base = dirname(final);
+  mkdirSync(base, { recursive: true });
+  const temporary = tempName(base, "tmp");
+  try {
+    build(temporary);
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        renameSync(temporary, final);
+        return;
+      } catch (err) {
+        if (attempt >= REPLACE_ATTEMPTS - 1) throw err;
+        const old = tempName(base, "old");
+        try {
+          renameSync(final, old);
+          rmSync(old, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+}
+function writeSkill(final, files) {
+  replaceWith(final, (temporary) => {
+    for (const file of files) {
+      const abs = join(temporary, file.path);
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, file.content);
+    }
+  });
+}
+function sameFolder(a, b) {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+function linksTo(entry, target) {
+  try {
+    return lstatSync(entry).isSymbolicLink() && sameFolder(entry, target);
+  } catch {
+    return false;
+  }
+}
+function reachFromClaude(home, name, version, link, mode) {
+  const claude = claudeSkillsBase(home);
+  const folder = join(machineSkillsBase(home), name);
+  if (sameFolder(claude, machineSkillsBase(home))) return;
+  const entry = join(claude, name);
+  if (mode === "refresh" && !entryExists(entry)) return;
+  if (linksTo(entry, folder)) return;
+  if (folderExists(entry) && installedVersion(entry) === version) return;
+  mkdirSync(claude, { recursive: true });
+  try {
+    const temporary = tempName(claude, "tmp");
+    try {
+      link(relative(realpathSync(claude), realpathSync(folder)), temporary);
+      rmSync(entry, { recursive: true, force: true });
+      renameSync(temporary, entry);
+    } finally {
+      rmSync(temporary, { recursive: true, force: true });
+    }
+  } catch {
+    replaceWith(entry, (temporary) => cpSync(folder, temporary, { recursive: true }));
+  }
+}
+function installMachineSkills(opts) {
+  const result = { written: [], failures: [] };
+  const version = opts.version ?? resolvePackageVersion();
+  const base = machineSkillsBase(opts.home);
+  const link = opts.link ?? defaultLink;
+  let files;
+  const filesOf = (name) => {
+    files ??= loadMachineSkillFiles(opts.packRoot ?? resolvePackRoot(), version);
+    return files.filter((file) => file.skill === name);
+  };
+  for (const name of MAINTAINED_SKILLS) {
+    const folder = join(base, name);
+    try {
+      if (opts.mode === "refresh" && !folderExists(folder)) continue;
+      if (installedVersion(folder) !== version) {
+        writeSkill(folder, filesOf(name));
+        result.written.push(name);
+      }
+    } catch (err) {
+      result.failures.push(`${folder}: ${errorMessage(err)}`);
+      continue;
+    }
+    try {
+      reachFromClaude(opts.home, name, version, link, opts.mode);
+    } catch (err) {
+      result.failures.push(`${join(claudeSkillsBase(opts.home), name)}: ${errorMessage(err)}`);
+    }
+  }
+  return result;
+}
+function machineSkillsState(home, version = resolvePackageVersion()) {
+  return MAINTAINED_SKILLS.map((name) => {
+    const folder = join(machineSkillsBase(home), name);
+    if (!existsSync(join(folder, "SKILL.md"))) return { name, state: "missing" };
+    return { name, state: installedVersion(folder) === version ? "current" : "stale" };
+  });
+}
+function staleClaudeSkills(home, version = resolvePackageVersion()) {
+  const claude = claudeSkillsBase(home);
+  if (sameFolder(claude, machineSkillsBase(home))) return [];
+  return MAINTAINED_SKILLS.filter((name) => {
+    const entry = join(claude, name);
+    if (!entryExists(entry)) return false;
+    if (linksTo(entry, join(machineSkillsBase(home), name))) return false;
+    return installedVersion(entry) !== version;
+  });
+}
+function setupMachineSkills(home = homeFromEnv()) {
+  try {
+    return installMachineSkills({ home, mode: "setup" });
+  } catch (err) {
+    return { written: [], failures: [errorMessage(err)] };
+  }
+}
+function refreshMachineSkills(home = homeFromEnv()) {
+  try {
+    installMachineSkills({ home, mode: "refresh" });
+  } catch {
+  }
+}
+function machineRefreshSkipped(commandNames, hidden, argv) {
+  const top = commandNames.at(-1);
+  if (top === "daemon" || top === "watch" || commandNames[0] === "daemon" || commandNames[0] === "watch") return true;
+  if (hidden) return true;
+  if (argv.includes("--log-failures")) return true;
+  return top === "sync" && argv.includes("--quiet");
+}
+
+export { installMachineSkills, machineRefreshSkipped, machineSkillsState, refreshMachineSkills, setupMachineSkills, staleClaudeSkills };

package/dist/{chunk-JKNYTNYD.js → chunk-LOKSLO25.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { AGENTS_SKILLS_BASE, OUTERLAYER_SKILLS_BASE } from './chunk-HBISTTG3.js';
+import { AGENTS_SKILLS_BASE, OUTERLAYER_SKILLS_BASE } from './chunk-7OUOLGUV.js';
 import { normalizePath, CONTEXT_PIN_FILENAME } from './chunk-RKOTJQVG.js';
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, lstatSync, readlinkSync, symlinkSync, rmdirSync } from 'fs';
 import { relative, sep, join } from 'path';

package/dist/{chunk-ZMZGWLYD.js → chunk-LPFOWUHG.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { checkStarterFiles, contextIsGoverned, checkBuildSkill } from './chunk-6WTAYEKJ.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-6CGXSMKX.js';
-import { isLinkedRepository } from './chunk-PZA6ZFYW.js';
+import { checkStarterFiles, contextIsGoverned, checkBuildSkill, checkMachineSkills, checkCommittedMaintainedSkills } from './chunk-P33PZIWS.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-55GNQPO6.js';
+import { isLinkedRepository } from './chunk-N4D5TMVU.js';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
-import { checkFormerSkillNames } from './chunk-MQ743JX3.js';
-import { resolveGatewayCredentials, defaultFetch } from './chunk-MCSINUVC.js';
-import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-UZEQVPKF.js';
+import { checkFormerSkillNames } from './chunk-MHX7YX7Y.js';
+import { resolveGatewayCredentials, defaultFetch } from './chunk-BWH36FOC.js';
+import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-DJHNEGNM.js';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-I7RZHMXW.js';
 import { hookCommandEscapesControlPlane, CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
@@ -191,7 +191,7 @@ function runDoctor(env = {}) {
     ...checkInstalls(env),
     ...starter?.checks ?? [],
     ...laptop ? checkRenamedSkills(env.cwd) : [],
-    ...checkBuildSkillState(env.cwd),
+    ...checkBuildSkillState(env.cwd, home),
     ...starter !== void 0 && !starter.mcpOutdated ? checkMcpCommand(env.cwd, env.processEnv) : [],
     ...checkContextSource(env.cwd),
     ...checkGovernsList(env.cwd),
@@ -204,10 +204,10 @@ function checkRenamedSkills(cwd) {
   if (dirs === void 0 || contextIsGoverned(dirs.gitCommonDir)) return [];
   return checkFormerSkillNames(dirs.repoRoot);
 }
-function checkBuildSkillState(cwd) {
+function checkBuildSkillState(cwd, home) {
   const dirs = findGitDirs(cwd ?? process.cwd());
   if (dirs === void 0 || contextIsGoverned(dirs.gitCommonDir)) return [];
-  return checkBuildSkill(dirs.repoRoot);
+  return [...checkBuildSkill(dirs.repoRoot), ...checkMachineSkills({ repoRoot: dirs.repoRoot, home }), ...checkCommittedMaintainedSkills(dirs.repoRoot)];
 }
 function checkInstalledCli(home, cwd) {
   const name = "Installed CLI";
@@ -1174,7 +1174,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-JJ3EO7SB.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-TWS5VZEN.js');
   const configPath = defaultRunnerConfigPath();
   const checks = runDoctor({ runnerHost: hasRunnerBlock(configPath) });
   const credential = await credentialChecks();
@@ -1186,7 +1186,7 @@ async function gatherDoctorChecks() {
     const { runnerVmCheck } = await import('./doctor-53F2PYY7.js');
     checks.push(runnerVmCheck(configPath, { lima: realLima(), home: homeFromEnv(), instance: runnerVm.instance }));
   } else if (hasRunnerBlock(configPath)) {
-    const { runnerHostChecks } = await import('./doctor-U2N7AF3N.js');
+    const { runnerHostChecks } = await import('./doctor-Y4NCNSJM.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1220,8 +1220,8 @@ async function gatherDoctorChecks() {
     const service = await (async () => {
       const { existsSync: existsSync3 } = await import('fs');
       if (process.platform !== "linux" || !existsSync3("/run/systemd/system")) return void 0;
-      const { inspectService, realInspectProbes } = await import('./inspect-6UYAAXH7.js');
-      const { DEFAULT_UNIT_NAME } = await import('./install-AFMXH25X.js');
+      const { inspectService, realInspectProbes } = await import('./inspect-IPFA7AAT.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-6OIY3KHZ.js');
       const { dirname: dirname2 } = await import('path');
       return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
     })();

package/dist/{chunk-2J46BQ5Y.js → chunk-M3MHHIUW.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { isVersion, compareVersions } from './chunk-TQMI335S.js';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-F3BBEBPL.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
 import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'fs';
 import { join } from 'path';
 

package/dist/{chunk-7Z2WMXM5.js → chunk-MATUHHN4.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-F3BBEBPL.js';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-RHAGBUL5.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-MQ743JX3.js → chunk-MHX7YX7Y.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { skillDir, FORMER_MAINTAINED_NAMES, isMaintainedCopy } from './chunk-HBISTTG3.js';
+import { skillDir, FORMER_MAINTAINED_NAMES, isMaintainedCopy } from './chunk-7OUOLGUV.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { emitTree, ALL_TARGET_IDS, classifyTree } from './chunk-RKOTJQVG.js';
 import { readFileSync, existsSync, unlinkSync, rmdirSync, readdirSync } from 'fs';

package/dist/{chunk-PZA6ZFYW.js → chunk-N4D5TMVU.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
+import { isAgentsMdLayout } from './chunk-LOKSLO25.js';
 import { DEFAULT_DASHBOARD } from './chunk-6BLXUD56.js';
-import { cliFetch, resolveGatewayCredentials } from './chunk-MCSINUVC.js';
+import { cliFetch, resolveGatewayCredentials } from './chunk-BWH36FOC.js';
 import { writeRepoConnection, findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { remoteLookupFailed } from './chunk-QE3UQAHK.js';
 import { readCloudConfig } from './chunk-PJDQPF5N.js';
-import { isAgentsMdLayout } from './chunk-JKNYTNYD.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { execFileSync } from 'child_process';
 import { createInterface } from 'readline/promises';

package/dist/{chunk-WK35HB56.js → chunk-O2IJTY7L.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { launchRefusalForSession } from './chunk-ESVW4MJY.js';
-import { autoConnect, detectActiveSession } from './chunk-H57M3HC7.js';
+import { autoConnect, detectActiveSession } from './chunk-2F762IXY.js';
 import { acquireSpoolLockAt } from './chunk-BUP5N3X6.js';
-import { resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-MCSINUVC.js';
+import { resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-BWH36FOC.js';
 import { resolveRepoIdentity } from './chunk-QE3UQAHK.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { launchedItemForSession } from './chunk-T2Q7ISPE.js';

package/dist/{chunk-6WTAYEKJ.js → chunk-P33PZIWS.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { POLICY_CONTENT, VALIDATOR_FILES, VALIDATORS_DIR, POLICY_PATH } from './chunk-VJBFQP3H.js';
+import { POLICY_CONTENT, VALIDATOR_FILES, VALIDATORS_DIR, POLICY_PATH } from './chunk-XZ6Q6ZNR.js';
+import { skillsBaseFor, isAgentsMdLayout } from './chunk-LOKSLO25.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
+import { machineSkillsState, staleClaudeSkills } from './chunk-IMOB4IOI.js';
+import { resolvePackRoot, OUTERLAYER_SKILLS_BASE, skillDir, namesCore, MACHINE_SKILL_PATH, AGENTS_SKILLS_BASE, MAINTAINED_SKILLS, isMaintainedCopy, loadTemplateFiles, rewriteSkillPaths, restoreSkillPaths, TEMPLATE_SKILLS } from './chunk-7OUOLGUV.js';
 import { mcpTargetPath, INIT_STDIO_ENTRY, INIT_DOCS_ENTRY, DOCS_MCP_SERVER_NAME } from './chunk-KT4CN6OU.js';
-import { skillsBaseFor, isAgentsMdLayout } from './chunk-JKNYTNYD.js';
-import { resolvePackRoot, OUTERLAYER_SKILLS_BASE, skillDir, namesCore, loadTemplateFiles, rewriteSkillPaths, restoreSkillPaths, TEMPLATE_SKILLS } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { hasSymlinkComponent } from './chunk-VWFOKRYS.js';
 import { cloneIsGoverned } from './chunk-YQR6E6OV.js';
@@ -190,6 +191,7 @@ function checkStarterFiles(cwd, opts = {}) {
   return { checks: [{ name: NAME, status: "warn", detail: parts.join("; "), fix }], mcpOutdated };
 }
 var BUILD_PHASES = ["Intake", "Criteria", "Implement", "Review", "Pull request", "Evidence"];
+var MACHINE_CORE = `${MACHINE_SKILL_PATH}/outerlayer-build/SKILL.md`;
 var CHANGES_HEADING = "## Changes for this repository";
 var NAME2 = "Build skill";
 function changeHeadings(text) {
@@ -226,10 +228,13 @@ var read = (abs) => {
     return void 0;
   }
 };
+function buildsOf(repoRoot, folders) {
+  const source = `${folders[0]}/build/SKILL.md`;
+  return (existsSync(join(repoRoot, source)) ? [source] : folders.slice(1).map((f) => `${f}/build/SKILL.md`)).map((path) => ({ path, text: read(join(repoRoot, path)) })).filter((b) => b.text !== void 0);
+}
 function checkBuildSkill(repoRoot) {
   const folders = [".outerlayer/skills", ...skillsFolders()];
-  const source = `${folders[0]}/build/SKILL.md`;
-  const builds = (existsSync(join(repoRoot, source)) ? [source] : folders.slice(1).map((f) => `${f}/build/SKILL.md`)).map((path) => ({ path, text: read(join(repoRoot, path)) })).filter((b) => b.text !== void 0);
+  const builds = buildsOf(repoRoot, folders);
   const checks = [];
   const detached = builds.filter((b) => !namesCore(b.text));
   if (detached.length > 0) {
@@ -255,7 +260,8 @@ ${shortBuild()}`
   const agentsMd = isAgentsMdLayout(repoRoot);
   const seen = /* @__PURE__ */ new Set();
   const lacking = folders.filter((folder) => {
-    if (!namesCore(read(join(repoRoot, folder, "build", "SKILL.md")) ?? "") || existsSync(join(repoRoot, folder, "outerlayer-build", "SKILL.md"))) return false;
+    const text = read(join(repoRoot, folder, "build", "SKILL.md")) ?? "";
+    if (!namesCore(text) || text.includes(MACHINE_CORE) || existsSync(join(repoRoot, folder, "outerlayer-build", "SKILL.md"))) return false;
     let key = folder;
     try {
       key = realpathSync(join(repoRoot, folder));
@@ -275,5 +281,47 @@ ${shortBuild()}`
   }
   return checks;
 }
+function committedMaintainedFolders(repoRoot) {
+  const found = [];
+  for (const base of [AGENTS_SKILLS_BASE, ".claude/skills"]) {
+    for (const name of MAINTAINED_SKILLS) {
+      const folder = skillDir(name, base);
+      if (!hasSymlinkComponent(repoRoot, folder) && isMaintainedCopy(repoRoot, name, base)) found.push(folder);
+    }
+  }
+  return found;
+}
+function checkCommittedMaintainedSkills(repoRoot) {
+  if (!isAgentsMdLayout(repoRoot)) return [];
+  const folders = committedMaintainedFolders(repoRoot);
+  if (folders.length === 0) return [];
+  return [
+    {
+      name: "Committed maintained skills",
+      status: "warn",
+      detail: `${folders.join(", ")} ${folders.length === 1 ? "is a maintained skill" : "are maintained skills"} that every machine keeps in ${MACHINE_SKILL_PATH}/ now`,
+      fix: `Run \`${cliInvocation()} init --update\` to remove ${folders.length === 1 ? "it" : "them"}, then commit. Before you commit, every machine and runner host must run this CLI version or later, and each machine a person works on must run \`${cliInvocation()} init --local\`.`
+    }
+  ];
+}
+function checkMachineSkills(opts) {
+  const build = buildsOf(opts.repoRoot, [".outerlayer/skills", ...skillsFolders()]).find((b) => b.text.includes(MACHINE_CORE));
+  if (build === void 0) return [];
+  const problems = machineSkillsState(opts.home, opts.version).filter((s) => s.state !== "current");
+  const claudeStale = staleClaudeSkills(opts.home, opts.version);
+  if (problems.length === 0 && claudeStale.length === 0) return [];
+  const parts = [
+    ...problems.map((s) => `${MACHINE_SKILL_PATH}/${s.name} ${s.state === "missing" ? "is missing" : "is from another CLI version"}`),
+    ...claudeStale.map((name) => `~/.claude/skills/${name} is not this CLI version's copy`)
+  ];
+  return [
+    {
+      name: "Maintained skills on this machine",
+      status: "warn",
+      detail: `${build.path} reads ${MACHINE_CORE}, but ${parts.join(", ")}`,
+      fix: `Run \`${cliInvocation()} init --local\` on this machine. If it reports a failed write, fix the permissions on the folder it names first.`
+    }
+  ];
+}
 
-export { canonical, checkBuildSkill, checkStarterFiles, contentHash, contextIsGoverned, inspectStarterFiles, readShippedManifest, skillsFolders };
+export { canonical, checkBuildSkill, checkCommittedMaintainedSkills, checkMachineSkills, checkStarterFiles, committedMaintainedFolders, contentHash, contextIsGoverned, inspectStarterFiles, readShippedManifest, skillsFolders };

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { currentLink } from './chunk-7Z2WMXM5.js';
+import { currentLink } from './chunk-MATUHHN4.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-Y4BXRVDI.js → chunk-QKIQ2R7F.js}

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