@outerlayer/cli 0.22.1 → 0.23.0

package/dist/{chunk-V7SAQ645.js → chunk-VJBFQP3H.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { resolvePackRoot, loadTemplateFiles, loadMaintainedFiles, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-5OCIHFGE.js';
 import { C } from './chunk-ANPNT6PM.js';
+import { resolvePackRoot, OUTERLAYER_SKILLS_BASE, loadTemplateFiles, loadMaintainedFiles, rewriteSkillPaths, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
+import { linkedAgentsPath } from './chunk-VWFOKRYS.js';
 import { resolvePackageVersion } from './chunk-RA3O54FC.js';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
@@ -26,16 +27,19 @@ function assertKnownTemplate(name) {
 function installStarterPack(opts) {
   const packRoot = opts.packRoot ?? resolvePackRoot();
   const version = opts.version ?? resolvePackageVersion();
-  const templateFiles = loadTemplateFiles(packRoot, version);
-  const maintainedFiles = loadMaintainedFiles(packRoot, version);
+  const base = opts.base ?? OUTERLAYER_SKILLS_BASE;
+  const linked = base.startsWith(".agents/") ? linkedAgentsPath(opts.repoRoot) : void 0;
+  if (linked !== void 0) throw new StarterPackError(`${linked} is a link, and a write there would land outside the repository; replace it with a folder and run this again`);
+  const templateFiles = loadTemplateFiles(packRoot, version, base);
+  const maintainedFiles = loadMaintainedFiles(packRoot, version, base);
   const validatorFiles = VALIDATOR_FILES.map(({ name }) => ({
     path: `${VALIDATORS_DIR}/${name}`,
-    content: readFileSync(join(packRoot, "validators", name), "utf8")
+    content: rewriteSkillPaths(readFileSync(join(packRoot, "validators", name), "utf8"), base)
   }));
   const copied = [];
   const kept = [];
   for (const skill of TEMPLATE_SKILLS) {
-    if (existsSync(join(opts.repoRoot, skillDir(skill)))) {
+    if (existsSync(join(opts.repoRoot, skillDir(skill, base)))) {
       kept.push(skill);
       continue;
     }
@@ -67,6 +71,7 @@ function installStarterPack(opts) {
     validatorsWritten.push(file.path);
   }
   return {
+    base,
     copied,
     kept,
     maintained: [...written.created, ...written.rewritten],
@@ -75,21 +80,23 @@ function installStarterPack(opts) {
     validatorsKept
   };
 }
-var skillFile = (skill) => `${skillDir(skill)}/SKILL.md`;
+var skillFile = (skill, base) => `${skillDir(skill, base)}/SKILL.md`;
 function validatorLabel(path) {
   return VALIDATOR_FILES.find(({ name }) => path === `${VALIDATORS_DIR}/${name}`)?.label ?? "a check";
 }
 function formatStarterPackOutput(result) {
   const lines = [];
-  lines.push(`${C.green}\u2713${C.reset} Installed the starter skills in .outerlayer/skills/`, "");
+  const { base } = result;
+  lines.push(`${C.green}\u2713${C.reset} Installed the starter skills in ${base}/`, "");
   lines.push("Yours to edit \u2014 copied once, never overwritten:");
   for (const skill of TEMPLATE_SKILLS) {
     lines.push(
-      result.kept.includes(skill) ? `  ${C.dim}kept${C.reset} ${skillDir(skill)}/ ${C.dim}(already exists, left exactly as it is)${C.reset}` : `  ${skillFile(skill)}`
+      result.kept.includes(skill) ? `  ${C.dim}kept${C.reset} ${skillDir(skill, base)}/ ${C.dim}(already exists, left exactly as it is)${C.reset}` : `  ${skillFile(skill, base)}`
     );
   }
-  lines.push("", "Rewritten on every emit \u2014 edits are overwritten by the installed CLI:");
-  for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill)}`);
+  const rewriter = base === OUTERLAYER_SKILLS_BASE ? "emit" : "`init --update`";
+  lines.push("", `Rewritten on every ${rewriter} \u2014 edits are overwritten by the installed CLI:`);
+  for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill, base)}`);
   lines.push(
     "",
     result.policy === "written" ? `${C.green}\u2713${C.reset} Wrote ${POLICY_PATH} (review required)` : `${C.dim}${POLICY_PATH} already exists \u2014 left as it is${C.reset}`,
@@ -98,8 +105,10 @@ function formatStarterPackOutput(result) {
     ),
     ...result.validatorsKept.map((path) => `${C.dim}${path} already exists \u2014 left as it is${C.reset}`),
     "",
-    `Next: create .outerlayer/config.json naming your agent tools, for example {"targets": ["claude-code"]},`,
-    `then run ${C.yellow}${cliInvocation()} context emit${C.reset} to compile the skills into their native files.`
+    ...base === OUTERLAYER_SKILLS_BASE ? [
+      `Next: create .outerlayer/config.json naming your agent tools, for example {"targets": ["claude-code"]},`,
+      `then run ${C.yellow}${cliInvocation()} context emit${C.reset} to compile the skills into their native files.`
+    ] : [`Agents read these skills from ${base}/ as they are. Nothing needs compiling.`]
   );
   return lines.join("\n") + "\n";
 }

package/dist/{chunk-ZNPE7FW5.js → chunk-VPEGE3QZ.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-5OCIHFGE.js';
+import { MAINTAINED_SKILLS } from './chunk-HBISTTG3.js';
 import { existsSync, mkdirSync, copyFileSync, lstatSync, readdirSync, writeFileSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 

package/dist/{chunk-W3SWJ2TD.js → chunk-VWFOKRYS.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { readContextManifest, removeContextManifest } from './chunk-YQR6E6OV.js';
 import { removePreCommitGuardHook } from './chunk-TUSYOL2O.js';
-import { CONTEXT_PIN_FILENAME } from './chunk-WFSUUUAN.js';
+import { CONTEXT_PIN_FILENAME } from './chunk-RKOTJQVG.js';
 import { execFileSync } from 'child_process';
 import { lstatSync, existsSync, unlinkSync, readdirSync, rmdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname, isAbsolute } from 'path';
@@ -80,6 +80,9 @@ function hasSymlinkComponent(root, rel) {
   }
   return false;
 }
+function linkedAgentsPath(root) {
+  return [".agents", ".agents/skills"].find((rel) => hasSymlinkComponent(root, rel));
+}
 function trackedPaths(repoRoot) {
   try {
     const out = execFileSync("git", ["ls-files", "-z", "--", "AGENTS.md", ".claude", ".outerlayer"], {
@@ -171,4 +174,4 @@ function cleanupEarlierCopies(input) {
   return result;
 }
 
-export { cleanupEarlierCopies, hasSymlinkComponent };
+export { cleanupEarlierCopies, hasSymlinkComponent, linkedAgentsPath };

package/dist/{chunk-XCRZTXRL.js → chunk-WX2WEERU.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { retiredSkillPaths, removeRetiredSkills } from './chunk-USWVXQIH.js';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-5OCIHFGE.js';
+import { retiredSkillPaths, removeRetiredSkills } from './chunk-MQ743JX3.js';
 import { C } from './chunk-ANPNT6PM.js';
+import { isAgentsMdLayout, discoverOuterlayerPaths, isForeignTree, toRepoRelative } from './chunk-JKNYTNYD.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-WFSUUUAN.js';
+import { emitTree, generatedHeaderSource, parseOuterlayerConfig, classifyTree } from './chunk-RKOTJQVG.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, unlinkSync, rmdirSync, readdirSync } from 'fs';
-import { join, dirname, relative, sep } from 'path';
+import { join, dirname } from 'path';
 
 createRequire(import.meta.url);
 var CONTENT_KINDS = /* @__PURE__ */ new Set(["instructions", "skill", "skill-reference", "command", "mcp"]);
@@ -14,6 +15,13 @@ var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 var NO_CONFIG_MESSAGE = 'no .outerlayer/config.json with a non-empty targets array \u2014 create one, e.g. {"targets": ["claude-code"]}';
 var EmitError = class extends Error {
 };
+var EMIT_NOT_NEEDED_NOTICE = `Claude Code and Codex read AGENTS.md and .agents/skills/ without a generated copy. Run \`${cliInvocation()} init --update\` to move this repository there and stop committing generated files.`;
+var NATIVE_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+function noticeFor(repoRoot, targets) {
+  if (targets.length === 0 || !targets.every((t) => NATIVE_TARGETS.has(t))) return void 0;
+  return isAgentsMdLayout(repoRoot) ? void 0 : EMIT_NOT_NEEDED_NOTICE;
+}
+var HAND_OWNED_OUTPUT = /(^|\/)(CLAUDE\.md|AGENTS\.md|\.claude\/skills\/|\.agents\/skills\/)/;
 function resolveTargetsFromConfig(repoRoot) {
   const configPath = join(repoRoot, ".outerlayer", "config.json");
   if (!existsSync(configPath)) throw new EmitError(NO_CONFIG_MESSAGE);
@@ -24,36 +32,6 @@ function resolveTargetsFromConfig(repoRoot) {
   const detail = result.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
   throw new EmitError(`invalid .outerlayer/config.json \u2014 ${detail}`);
 }
-function toRepoRelative(repoRoot, absPath) {
-  return normalizePath(relative(repoRoot, absPath).split(sep).join("/"));
-}
-function discoverOuterlayerPaths(repoRoot) {
-  const out = [];
-  walk(repoRoot, repoRoot, false, out);
-  return out.sort();
-}
-function isForeignTree(dir) {
-  return existsSync(join(dir, ".git")) || existsSync(join(dir, CONTEXT_PIN_FILENAME));
-}
-function walk(dir, repoRoot, insideOuterlayer, out) {
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isSymbolicLink()) continue;
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (!insideOuterlayer && SKIP_DIRS.has(entry.name)) continue;
-      if (!insideOuterlayer && isForeignTree(full)) continue;
-      walk(full, repoRoot, insideOuterlayer || entry.name === ".outerlayer", out);
-    } else if (entry.isFile() && insideOuterlayer) {
-      out.push(toRepoRelative(repoRoot, full));
-    }
-  }
-}
 function buildEmitInput(repoRoot, targets, maintained, excluded = /* @__PURE__ */ new Set()) {
   const bundled = new Map(maintained.map((f) => [f.path, f.content]));
   const discovered = [.../* @__PURE__ */ new Set([...discoverOuterlayerPaths(repoRoot).filter((p) => !excluded.has(p)), ...bundled.keys()])].sort();
@@ -143,10 +121,10 @@ function walkAll(dir, repoRoot, out) {
     }
   }
 }
-function findOrphans(repoRoot, computedFiles, sourcePaths) {
+function findOrphans(repoRoot, computedFiles, sourcePaths, ignore) {
   const orphans = [];
   for (const path of discoverAllFiles(repoRoot)) {
-    if (computedFiles.has(path)) continue;
+    if (computedFiles.has(path) || ignore?.(path) === true) continue;
     let content;
     try {
       content = readFileSync(join(repoRoot, path), "utf8");
@@ -200,17 +178,20 @@ function runEmit(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   if (!existsSync(cwd)) throw new EmitError(`no such directory: ${cwd}`);
   const targets = resolveTargetsFromConfig(cwd);
-  const maintained = maintainedFilesForExistingSkills(cwd, loadMaintainedFiles());
+  const agentsMd = isAgentsMdLayout(cwd);
+  const ignoreOrphan = agentsMd ? (path) => HAND_OWNED_OUTPUT.test(path) : void 0;
+  const maintained = agentsMd ? [] : maintainedFilesForExistingSkills(cwd, loadMaintainedFiles());
+  const notice = noticeFor(cwd, targets);
   const retired = retiredSkillPaths(cwd);
   const built = buildEmitInput(cwd, targets, maintained, new Set(retired));
   const emitted = emitTree(built.input);
   const { result, kept } = withholdKept(cwd, emitted, opts.keep);
   const hasErrors = result.errors.length > 0;
   const outputs = new Set(emitted.files.map((f) => f.path));
-  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, outputs, built.sourcePaths, maintained, kept, retired);
+  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, outputs, built.sourcePaths, maintained, kept, retired, notice, ignoreOrphan);
   const written = hasErrors ? { files: [], copies: [], maintained: [] } : writeOutputs(cwd, result, maintained);
   const removed = hasErrors ? [] : removeRetiredSkills(cwd);
-  const orphaned = hasErrors ? [] : removeOrphans(cwd, findOrphans(cwd, outputs, built.sourcePaths));
+  const orphaned = hasErrors ? [] : removeOrphans(cwd, findOrphans(cwd, outputs, built.sourcePaths, ignoreOrphan));
   const exitCode = hasErrors ? 1 : 0;
   const output = opts.json ? JSON.stringify({
     targets,
@@ -232,8 +213,11 @@ function runEmit(opts = {}) {
       for (const w of result.warnings) process.stderr.write(`  ${C.yellow}!${C.reset} ${w.path}: ${w.message}
 `);
     }
+    if (notice !== void 0 && !opts.json) process.stderr.write(`${C.dim}${notice}${C.reset}
+`);
   }
   return {
+    ...notice === void 0 ? {} : { notice },
     targets,
     files: written.files,
     copies: written.copies,
@@ -247,7 +231,7 @@ function runEmit(opts = {}) {
     exitCode
   };
 }
-function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, maintained, kept, retired) {
+function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, maintained, kept, retired, notice, ignoreOrphan) {
   const drift = [];
   if (!hasErrors) {
     for (const path of retired) drift.push({ kind: "retired", path });
@@ -264,7 +248,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, m
       if (d) drift.push(d);
     }
     const retiredPaths = new Set(retired);
-    drift.push(...findOrphans(cwd, outputs, sourcePaths).filter((d) => !retiredPaths.has(d.path)));
+    drift.push(...findOrphans(cwd, outputs, sourcePaths, ignoreOrphan).filter((d) => !retiredPaths.has(d.path)));
     drift.sort((a, b) => a.path.localeCompare(b.path) || a.kind.localeCompare(b.kind));
   }
   const exitCode = hasErrors || drift.length > 0 ? 1 : 0;
@@ -279,8 +263,44 @@ function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, m
       for (const w of result.warnings) process.stderr.write(`  ${C.yellow}!${C.reset} ${w.path}: ${w.message}
 `);
     }
+    if (notice !== void 0 && !opts.json) process.stderr.write(`${C.dim}${notice}${C.reset}
+`);
+  }
+  return { ...notice === void 0 ? {} : { notice }, targets, files: [], copies: [], maintained: [], kept, retired: [], orphaned: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+}
+var REPLACED_OUTPUT = /^(?:(?:.*\/)?(?:CLAUDE|AGENTS)\.md|(?:.*\/)?\.(?:claude|agents)\/skills\/.+)$/;
+function inspectReplacedOutputs(repoRoot) {
+  let configured = [];
+  try {
+    configured = resolveTargetsFromConfig(repoRoot);
+  } catch {
+  }
+  const targets = [.../* @__PURE__ */ new Set([...configured, "claude-code", "codex"])];
+  const maintained = maintainedFilesForExistingSkills(repoRoot, loadMaintainedFiles());
+  const maintainedPaths = new Set(maintained.map((f) => f.path));
+  const built = buildEmitInput(repoRoot, targets, maintained, new Set(retiredSkillPaths(repoRoot)));
+  const emitted = emitTree(built.input);
+  const generated = [];
+  const edited = [];
+  const replacedDiffering = [];
+  const classify = (path, same) => {
+    (same ? generated : edited).push(path);
+  };
+  for (const file of emitted.files) {
+    if (!REPLACED_OUTPUT.test(file.path) || !existsSync(join(repoRoot, file.path))) continue;
+    const disk = readFileSync(join(repoRoot, file.path), "utf8");
+    const source = generatedHeaderSource(disk);
+    const stale = source !== null && maintainedPaths.has(source);
+    const same = stale ? true : disk === file.content;
+    if (stale && disk !== file.content) replacedDiffering.push(file.path);
+    classify(file.path, same);
+  }
+  for (const copy of emitted.copies) {
+    if (!REPLACED_OUTPUT.test(copy.toPath) || !existsSync(join(repoRoot, copy.toPath))) continue;
+    const source = join(repoRoot, copy.fromSourcePath);
+    classify(copy.toPath, existsSync(source) && readFileSync(join(repoRoot, copy.toPath)).equals(readFileSync(source)));
   }
-  return { targets, files: [], copies: [], maintained: [], kept, retired: [], orphaned: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+  return { generated: generated.sort(), edited: edited.sort(), replacedDiffering: replacedDiffering.sort() };
 }
 
-export { EmitError, runEmit };
+export { EMIT_NOT_NEEDED_NOTICE, EmitError, inspectReplacedOutputs, runEmit };

package/dist/chunk-WXJXHZVB.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { RELAY_PORT, BUILD_HOME } from './chunk-URWYRAIC.js';
+import { createServer, connect } from 'net';
+
+createRequire(import.meta.url);
+var BRIDGE_ADDRESS = "172.17.0.1";
+var BRIDGE_CIDR = "172.17.0.1/16";
+var TUNNEL_PORT = RELAY_PORT;
+var CONTAINER_PROXY = `http://${BRIDGE_ADDRESS}:${TUNNEL_PORT}`;
+var CONTAINER_NO_PROXY = ["localhost", "127.0.0.1", "::1", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"];
+function dockerClientConfig() {
+  const proxies = { default: { httpProxy: CONTAINER_PROXY, httpsProxy: CONTAINER_PROXY, noProxy: CONTAINER_NO_PROXY.join(",") } };
+  return `${JSON.stringify({ proxies }, null, 2)}
+`;
+}
+async function writeDockerClientConfig(run, agentUser) {
+  const dir = `${BUILD_HOME}/.docker`;
+  const script = [
+    "set -e",
+    "umask 077",
+    `mkdir -p ${dir}`,
+    `cat > ${dir}/config.json.partial`,
+    `mv ${dir}/config.json.partial ${dir}/config.json`,
+    `chown "$(id -u "$1"):$(id -g "$1")" ${dir} ${dir}/config.json`,
+    `chmod 700 ${dir}`,
+    `chmod 600 ${dir}/config.json`
+  ].join("\n");
+  const result = await run(["/bin/sh", "-c", script, "sh", agentUser], dockerClientConfig());
+  if (result.status === 0) return void 0;
+  return `the Docker client configuration could not be written in the microVM (exit ${result.status}): ${result.stderr.trim().split("\n")[0]}`;
+}
+function parseAddress(text) {
+  const match = /^(.+):(\d+)$/.exec(text);
+  const port = Number(match?.[2]);
+  if (match === null || port > 65535) throw new Error(`${JSON.stringify(text)} is not host:port`);
+  return { host: match[1], port };
+}
+async function startBridgeForward(opts) {
+  const listen = parseAddress(opts.listen);
+  const to = parseAddress(opts.to);
+  const open = /* @__PURE__ */ new Set();
+  const server = createServer({ allowHalfOpen: true }, (client) => {
+    const upstream = connect({ host: to.host, port: to.port, allowHalfOpen: true });
+    open.add(client);
+    client.on("error", () => void 0);
+    upstream.on("error", () => void 0);
+    client.on("close", () => {
+      open.delete(client);
+      upstream.destroy();
+    });
+    upstream.on("close", () => client.destroy());
+    client.pipe(upstream);
+    upstream.pipe(client);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(listen.port, listen.host, () => {
+      resolve();
+    });
+  });
+  server.on("error", (error) => process.stderr.write(`outerlayer: the bridge forwarder hit an error: ${error.message}
+`));
+  return {
+    port: server.address().port,
+    close: () => new Promise((resolve) => {
+      for (const socket of open) socket.destroy();
+      server.close(() => resolve());
+    })
+  };
+}
+
+export { BRIDGE_ADDRESS, BRIDGE_CIDR, CONTAINER_NO_PROXY, CONTAINER_PROXY, TUNNEL_PORT, dockerClientConfig, startBridgeForward, writeDockerClientConfig };

package/dist/{chunk-BOMRFYTZ.js → chunk-WY7HFY62.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { LiveUploader } from './chunk-URAKVDSI.js';
-import { spoolDir } from './chunk-QC72I5GQ.js';
-import { CaptureDaemon } from './chunk-AEKSX4EY.js';
+import { LiveUploader } from './chunk-DJYOCD65.js';
+import { spoolDir } from './chunk-XOEV4FVK.js';
+import { CaptureDaemon } from './chunk-CBCKD6DO.js';
 import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { mkdirSync, writeFileSync, rmSync } from 'fs';

package/dist/{chunk-VSUXCMMH.js → chunk-XFGL53GU.js}

@@ -1,29 +1,30 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { POLICY_CONTENT, VALIDATOR_FILES, VALIDATORS_DIR, POLICY_PATH } from './chunk-VJBFQP3H.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
-import { mcpTargetPath, INIT_STDIO_ENTRY, INIT_DOCS_ENTRY, DOCS_MCP_SERVER_NAME } from './chunk-DIB2WLBL.js';
-import { POLICY_CONTENT, VALIDATOR_FILES, VALIDATORS_DIR, POLICY_PATH } from './chunk-V7SAQ645.js';
-import { resolvePackRoot, skillDir, namesCore, loadTemplateFiles, TEMPLATE_SKILLS } from './chunk-5OCIHFGE.js';
+import { mcpTargetPath, INIT_STDIO_ENTRY, INIT_DOCS_ENTRY, DOCS_MCP_SERVER_NAME } from './chunk-YVZJ6GKF.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-W3SWJ2TD.js';
+import { hasSymlinkComponent } from './chunk-VWFOKRYS.js';
 import { cloneIsGoverned } from './chunk-YQR6E6OV.js';
-import { emitTree, ALL_TARGET_IDS, classifyTree, splitRawFile } from './chunk-WFSUUUAN.js';
+import { emitTree, ALL_TARGET_IDS, classifyTree, splitRawFile } from './chunk-RKOTJQVG.js';
 import { createHash } from 'crypto';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, realpathSync } from 'fs';
 import { join, dirname } from 'path';
 
 createRequire(import.meta.url);
 var SHIPPED_MANIFEST = "shipped.json";
-function currentStarterFiles(packRoot = resolvePackRoot(), policy = POLICY_CONTENT) {
-  const templates = loadTemplateFiles(packRoot).map((f) => ({
+function currentStarterFiles(packRoot = resolvePackRoot(), policy = POLICY_CONTENT, base = OUTERLAYER_SKILLS_BASE) {
+  const templates = loadTemplateFiles(packRoot, void 0, base).map((f) => ({
     path: f.path,
     content: f.content,
     skill: f.skill,
-    source: join(packRoot, "template", f.skill, f.path.slice(skillDir(f.skill).length + 1))
+    source: join(packRoot, "template", f.skill, f.path.slice(skillDir(f.skill, base).length + 1))
   }));
   const validators = VALIDATOR_FILES.map(({ name }) => {
     const source = join(packRoot, "validators", name);
-    return { path: `${VALIDATORS_DIR}/${name}`, content: readFileSync(source, "utf8"), source };
+    return { path: `${VALIDATORS_DIR}/${name}`, content: rewriteSkillPaths(readFileSync(source, "utf8"), base), source };
   });
   return [...templates, ...validators, { path: POLICY_PATH, content: policy }];
 }
@@ -66,12 +67,17 @@ function canonical(value) {
   }
   return JSON.stringify(value);
 }
-function fileState(root, file, manifest) {
+function shippedPath(path, base) {
+  return path.startsWith(`${base}/`) ? `${OUTERLAYER_SKILLS_BASE}/${path.slice(base.length + 1)}` : path;
+}
+function fileState(root, file, manifest, base) {
   const abs = join(root, file.path);
   if (!existsSync(abs)) return "missing";
-  const hash = contentHash(readFileSync(abs, "utf8"));
-  if (hash === contentHash(file.content)) return "current";
-  if (manifest.ok && manifest.files.get(file.path)?.has(hash) === true) return "outdated";
+  const disk = readFileSync(abs, "utf8");
+  if (contentHash(disk) === contentHash(file.content)) return "current";
+  const hash = contentHash(restoreSkillPaths(disk, base));
+  if (hash === contentHash(restoreSkillPaths(file.content, base))) return "outdated";
+  if (manifest.ok && manifest.files.get(shippedPath(file.path, base))?.has(hash) === true) return "outdated";
   return "edited";
 }
 function mcpItems(root) {
@@ -98,17 +104,18 @@ function mcpItems(root) {
     return { ...base, state: "edited" };
   });
 }
-function retiredFiles(root, shipped, manifest) {
+function retiredFiles(root, shipped, manifest, base) {
   if (!manifest.ok) return [];
-  const current = new Set(shipped.map((f) => f.path));
+  const current = new Set(shipped.map((f) => shippedPath(f.path, base)));
   const prefixes = TEMPLATE_SKILLS.map((skill) => `${skillDir(skill)}/`);
   const retired = [];
-  for (const [path, hashes] of manifest.files) {
-    if (current.has(path) || !prefixes.some((prefix) => path.startsWith(prefix))) continue;
+  for (const [known, hashes] of manifest.files) {
+    if (current.has(known) || !prefixes.some((prefix) => known.startsWith(prefix))) continue;
+    const path = base === OUTERLAYER_SKILLS_BASE ? known : `${base}/${known.slice(OUTERLAYER_SKILLS_BASE.length + 1)}`;
     const abs = join(root, path);
     if (!existsSync(abs) || hasSymlinkComponent(root, path)) continue;
     try {
-      retired.push({ path, state: hashes.has(contentHash(readFileSync(abs, "utf8"))) ? "unedited" : "edited" });
+      retired.push({ path, state: hashes.has(contentHash(restoreSkillPaths(readFileSync(abs, "utf8"), base))) ? "unedited" : "edited" });
     } catch {
     }
   }
@@ -116,13 +123,14 @@ function retiredFiles(root, shipped, manifest) {
 }
 function inspectStarterFiles(root, opts = {}) {
   const packRoot = opts.packRoot ?? resolvePackRoot();
+  const base = opts.base ?? skillsBaseFor(root);
   const manifest = readShippedManifest(packRoot);
-  const shipped = currentStarterFiles(packRoot);
-  const files = shipped.map((file) => ({ kind: "file", path: file.path, state: fileState(root, file, manifest), file }));
-  const buildEdited = files.some((f) => f.path === `${skillDir("build")}/SKILL.md` && f.state === "edited");
-  const buildPrefix = `${skillDir("build")}/`;
-  const retired = retiredFiles(root, shipped, manifest).filter((f) => !(buildEdited && f.path.startsWith(buildPrefix)));
-  return { items: [...files, ...mcpItems(root)], retired, manifest: manifest.ok ? "ok" : manifest.problem };
+  const shipped = currentStarterFiles(packRoot, void 0, base);
+  const files = shipped.map((file) => ({ kind: "file", path: file.path, state: fileState(root, file, manifest, base), file }));
+  const buildEdited = files.some((f) => f.path === `${skillDir("build", base)}/SKILL.md` && f.state === "edited");
+  const buildPrefix = `${skillDir("build", base)}/`;
+  const retired = retiredFiles(root, shipped, manifest, base).filter((f) => !(buildEdited && f.path.startsWith(buildPrefix)));
+  return { base, items: [...files, ...mcpItems(root)], retired, manifest: manifest.ok ? "ok" : manifest.problem };
 }
 function itemLabel(item) {
   return item.kind === "file" ? item.path : `${item.path} "${item.server}" server`;
@@ -132,7 +140,7 @@ function contextIsGoverned(gitCommonDir) {
 }
 var NAME = "Starter files";
 var UPDATE = `${cliInvocation()} init --update`;
-function shownPaths(items, all) {
+function shownPaths(items, all, base) {
   const shown = [];
   const whole = /* @__PURE__ */ new Set();
   for (const item of items) {
@@ -140,7 +148,7 @@ function shownPaths(items, all) {
     if (skill !== void 0) {
       const ofSkill = all.filter((i) => i.kind === "file" && i.file.skill === skill);
       if (ofSkill.every((i) => items.includes(i))) {
-        if (!whole.has(skill)) shown.push(`${skillDir(skill)}/`);
+        if (!whole.has(skill)) shown.push(`${skillDir(skill, base)}/`);
         whole.add(skill);
         continue;
       }
@@ -164,8 +172,8 @@ function checkStarterFiles(cwd, opts = {}) {
   const retired = report.retired.filter((f) => f.state === "unedited");
   const parts = [];
   if (current.length > 0) parts.push(`${current.length} current`);
-  if (outdated.length > 0) parts.push(`outdated and unedited: ${shownPaths(outdated, report.items).join(", ")}`);
-  if (missing.length > 0) parts.push(`missing: ${shownPaths(missing, report.items).join(", ")}`);
+  if (outdated.length > 0) parts.push(`outdated and unedited: ${shownPaths(outdated, report.items, report.base).join(", ")}`);
+  if (missing.length > 0) parts.push(`missing: ${shownPaths(missing, report.items, report.base).join(", ")}`);
   if (retired.length > 0) parts.push(`no longer shipped, unedited: ${retired.map((f) => f.path).join(", ")}`);
   if (edited.length > 0) parts.push(`edited by you, left as they are: ${edited.map(itemLabel).join(", ")}`);
   if (unreadable.length > 0) parts.push(`${unreadable[0].path} is not valid JSON, so its servers were not read`);
@@ -244,15 +252,25 @@ ${shortBuild()}`
       fix: `Rename each heading to a phase: ${BUILD_PHASES.join(", ")}.`
     });
   }
-  const lacking = folders.filter(
-    (folder) => namesCore(read(join(repoRoot, folder, "build", "SKILL.md")) ?? "") && !existsSync(join(repoRoot, folder, "outerlayer-build", "SKILL.md"))
-  );
+  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;
+    let key = folder;
+    try {
+      key = realpathSync(join(repoRoot, folder));
+    } catch {
+    }
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
   if (lacking.length > 0) {
     checks.push({
       name: NAME2,
       status: "warn",
       detail: `${lacking.join(", ")} holds build with no outerlayer-build beside it`,
-      fix: `Run \`${cliInvocation()} context emit\` to write outerlayer-build, then commit.`
+      fix: `Run \`${cliInvocation()} ${agentsMd ? "init --update" : "context emit"}\` to write outerlayer-build, then commit.`
     });
   }
   return checks;

package/dist/{chunk-6YBLN4TR.js → chunk-XGPC3IOR.js}

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { removeRetiredSkills } from './chunk-USWVXQIH.js';
-import { defaultFetch } from './chunk-QF7WZUU6.js';
-import { resolveGatewayCredentials } from './chunk-NTRCK4NH.js';
+import { removeRetiredSkills } from './chunk-MQ743JX3.js';
+import { defaultFetch, resolveGatewayCredentials } from './chunk-QS43O4DR.js';
 import { appendContextProvenance } from './chunk-ZJSNLVCE.js';
-import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-5OCIHFGE.js';
+import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { writeDegraded, writeSourceCache, SOURCE_CACHE_TTL_RETRY_MS, writeContextManifest, SOURCE_CACHE_TTL_SUCCESS_MS, readSourceCache, isSourceCacheFresh, clearDegraded } from './chunk-YQR6E6OV.js';
-import { normalizeRepoName, parseOuterlayerConfig, classifyTree, emitTree } from './chunk-WFSUUUAN.js';
+import { normalizeRepoName, parseOuterlayerConfig, classifyTree, emitTree } from './chunk-RKOTJQVG.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { withTokenHeader } from './chunk-URWYRAIC.js';
 import { execFileSync } from 'child_process';

package/dist/{chunk-QC72I5GQ.js → chunk-XOEV4FVK.js}

@@ -429,7 +429,7 @@ async function handleWorkLaunch(sessionId, home, env, spawnImpl = spawnDetached,
 }
 async function missingRenewalHookContext(home, cwd) {
   try {
-    const { settingsPath, readSettings, isOurHookCommand } = await import('./settings-J2652U5N.js');
+    const { settingsPath, readSettings, isOurHookCommand } = await import('./settings-AKYEOCC2.js');
     const userSettings = readSettings(settingsPath("user", { home }));
     const projectSettings = readSettings(settingsPath("project", { cwd }));
     if (userSettings === null && projectSettings === null) return void 0;
@@ -624,11 +624,11 @@ async function missingControlPlane(cwd, sessionId, home, env) {
   const dirs = findGitDirs(cwd);
   if (dirs === void 0) return void 0;
   if (existsSync(join(dirs.gitCommonDir, "outerlayer", "materialized.json")) || hasExcludeBlock(dirs.gitCommonDir)) {
-    const { cleanupEarlierCopies } = await import('./context-cleanup-DSA3HGQU.js');
+    const { cleanupEarlierCopies } = await import('./context-cleanup-LTH77FC3.js');
     cleanupEarlierCopies(dirs);
   }
   if (!contextPossiblyGoverned(cwd, home)) return void 0;
-  const { governanceOf } = await import('./control-plane-launch-OWSNH6YA.js');
+  const { governanceOf } = await import('./control-plane-launch-SEYCOZFH.js');
   if (await governanceOf({ cwd, env, home }) !== "governed") return void 0;
   recordMissingContext(dirs, sessionId, home);
   const launcher = `${cliInvocation()} claude`;