@outerlayer/cli 0.22.2 → 0.24.0

package/dist/{chunk-4OYKJJ2V.js → chunk-WH2QV3UL.js}

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runEmit } from './chunk-XCRZTXRL.js';
-import { resolveGitCommonDir, defaultGitRunner } from './chunk-SNVXHNU7.js';
-import { addStdioMcpEntryIfAbsent, addDocsMcpEntryIfAbsent, DOCS_MCP_SERVER_NAME } from './chunk-DIB2WLBL.js';
-import { installStarterPack } from './chunk-V7SAQ645.js';
-import { loadTemplateFiles, loadMaintainedFiles, skillDir } from './chunk-5OCIHFGE.js';
+import { runEmit } from './chunk-WX2WEERU.js';
+import { installStarterPack } from './chunk-VJBFQP3H.js';
+import { resolveGitCommonDir, defaultGitRunner } from './chunk-E4OUL7ZP.js';
+import { addStdioMcpEntryIfAbsent, addDocsMcpEntryIfAbsent, DOCS_MCP_SERVER_NAME } from './chunk-YVZJ6GKF.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';
-import { generatedHeaderSource } from './chunk-WFSUUUAN.js';
+import { generatedHeaderSource } from './chunk-RKOTJQVG.js';
 import { execFileSync } from 'child_process';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
@@ -19,6 +21,18 @@ var MCP_OUTPUT_PATH = ".mcp.json";
 var POLICY_PATH = ".outerlayer/policy.yaml";
 var DEFAULT_CONFIG = `${JSON.stringify({ targets: ["claude-code"] }, null, 2)}
 `;
+var AGENTS_MD_CONFIG = `${JSON.stringify({ targets: ["claude-code"], layout: AGENTS_MD_LAYOUT }, null, 2)}
+`;
+var STARTER_AGENTS_MD = `# Agent instructions
+
+Write here what an agent needs to work in this repository: how to build and test it, the rules it follows, and what to check before it opens a pull request.
+
+Claude Code and Codex read this file as it is. Skills are in \`.agents/skills/\`.
+`;
+function inTodaysLayout(repoRoot) {
+  if (isAgentsMdLayout(repoRoot)) return false;
+  return existsSync(join(repoRoot, CONFIG_PATH)) || holdsTodaysLayoutSources(discoverOuterlayerPaths(repoRoot));
+}
 var errorMessage = (err) => err instanceof Error ? err.message : String(err);
 var skipped = (reason) => ({
   outcome: "skipped",
@@ -75,6 +89,7 @@ function runAgentSetup(opts) {
   } catch (err) {
     return failed(errorMessage(err), /* @__PURE__ */ new Set(), []);
   }
+  if (!inTodaysLayout(repoRoot)) return runAgentsMdSetup(repoRoot, opts.skillsLink !== false);
   const written = /* @__PURE__ */ new Set();
   const kept = [];
   const problems = [];
@@ -142,6 +157,71 @@ function runAgentSetup(opts) {
     kept: keptPaths
   };
 }
+function runAgentsMdSetup(repoRoot, skillsLink) {
+  const written = /* @__PURE__ */ new Set();
+  const kept = [];
+  const problems = [];
+  const linked = linkedAgentsPath(repoRoot);
+  if (linked !== void 0) return failed(`${linked} is a link, and a write there would land outside the repository; replace it with a folder and run this again`, written, kept);
+  try {
+    const pack = installStarterPack({ repoRoot, base: AGENTS_SKILLS_BASE });
+    for (const file of loadTemplateFiles(void 0, void 0, AGENTS_SKILLS_BASE).filter((f) => pack.copied.includes(f.skill))) written.add(file.path);
+    for (const path of pack.maintained) written.add(path);
+    for (const skill of pack.kept) kept.push(`${skillDir(skill, AGENTS_SKILLS_BASE)}/`);
+    if (pack.policy === "written") written.add(POLICY_PATH);
+    else kept.push(POLICY_PATH);
+    for (const path of pack.validatorsWritten) written.add(path);
+    kept.push(...pack.validatorsKept);
+    if (existsSync(join(repoRoot, "AGENTS.md")) || existsSync(join(repoRoot, "CLAUDE.md"))) {
+      kept.push(existsSync(join(repoRoot, "AGENTS.md")) ? "AGENTS.md" : "CLAUDE.md");
+    } else {
+      writeFileSync(join(repoRoot, "AGENTS.md"), STARTER_AGENTS_MD);
+      written.add("AGENTS.md");
+    }
+    if (existsSync(join(repoRoot, CONFIG_PATH))) {
+      kept.push(CONFIG_PATH);
+    } else {
+      mkdirSync(dirname(join(repoRoot, CONFIG_PATH)), { recursive: true });
+      writeFileSync(join(repoRoot, CONFIG_PATH), AGENTS_MD_CONFIG);
+      written.add(CONFIG_PATH);
+    }
+    declareAgentsMdLayout(repoRoot);
+  } catch (err) {
+    return failed(`could not install the skills: ${errorMessage(err)}`, written, kept);
+  }
+  try {
+    const mcp = addStdioMcpEntryIfAbsent(repoRoot);
+    if (mcp.added) written.add(mcp.path);
+    else kept.push(`${mcp.path} (already has an outerlayer server)`);
+    const docs = addDocsMcpEntryIfAbsent(repoRoot);
+    if (docs.added) written.add(docs.path);
+    else kept.push(`${docs.path} (already has an ${DOCS_MCP_SERVER_NAME} server)`);
+  } catch (err) {
+    problems.push(errorMessage(err));
+  }
+  let linkNote = "";
+  if (skillsLink) {
+    const link = linkClaudeSkills(repoRoot);
+    if (link.status === "linked") written.add(SKILLS_LINK_PATH);
+    linkNote = describeSkillsLink(link);
+  }
+  if (problems.length > 0) return failed(problems.join("; "), written, kept);
+  const paths = [...written].sort();
+  const lines = [
+    `${C.green}\u2713${C.reset} Agent setup: ${paths.length === 0 ? "already in place, nothing changed" : "instructions in AGENTS.md, skills in .agents/skills/"}`,
+    renderPaths(paths, kept).trimEnd()
+  ];
+  if (linkNote !== "") lines.push(`  ${linkNote}`);
+  if (paths.length > 0) lines.push(`  ${C.dim}Commit AGENTS.md, .agents/ and .mcp.json with .outerlayer/. Nothing is generated, so there is no emit step.${C.reset}`);
+  return {
+    outcome: "done",
+    reason: paths.length === 0 ? "already set up" : `${paths.length} files written`,
+    text: `${lines.join("\n")}
+`,
+    paths,
+    kept: []
+  };
+}
 function writtenBeforeFailure(repoRoot, pending, keep) {
   if (pending === void 0 || pending.length === 0) return [];
   try {

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-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-EAQSOE62.js → chunk-XSPA5ODY.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { revokeTokenOnDashboard } from './chunk-F35VMF5M.js';
+import { revokeTokenOnDashboard } from './chunk-GOSFARMS.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
-import { readCloudConfig, writeCloudConfig, cloudConfigPath } from './chunk-EABW6AJQ.js';
 import { C } from './chunk-ANPNT6PM.js';
+import { readCloudConfig, writeCloudConfig, cloudConfigPath } from './chunk-EABW6AJQ.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
+import { CLI_LOGIN_MACHINE_NAME_MAX, CliLoginPollResponseSchema, CLI_LOGIN_KIND, CliLoginRefusalSchema, CliLoginStartedSchema } from './chunk-QZBXLLTV.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { generateKeyPairSync, privateDecrypt, constants, createPrivateKey } from 'crypto';
 import { spawn } from 'child_process';
@@ -45,7 +46,6 @@ var PIPED_KEY_GIVE_UP_MS = 3e4;
 var REQUEST_TIMEOUT_MS = 15e3;
 var MAX_POLL_FAILURES = 5;
 var DEFAULT_POLL_INTERVAL_S = 3;
-var MACHINE_NAME_MAX = 255;
 function realLoginDeps() {
   return {
     fetchImpl: fetch,
@@ -74,7 +74,7 @@ function openInBrowser(url) {
 }
 function sanitizeMachineName(raw) {
   const cleaned = raw.replace(/[^\w\s\-().]/g, "").trim();
-  return (cleaned.length > 0 ? cleaned : "machine").slice(0, MACHINE_NAME_MAX);
+  return (cleaned.length > 0 ? cleaned : "machine").slice(0, CLI_LOGIN_MACHINE_NAME_MAX);
 }
 function stdinKind(stdin) {
   if (stdin.isTTY) return "terminal";
@@ -168,16 +168,13 @@ function purgeExpiredPending(home, now, keepId) {
     }
   }
 }
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : {};
-}
 async function startLogin(deps, dashboard, publicKey, machineName) {
   let res;
   try {
     res = await deps.fetchImpl(`${dashboard}/api/cli/login`, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ public_key: publicKey, machine_name: machineName, kind: "account" }),
+      body: JSON.stringify({ public_key: publicKey, machine_name: machineName, kind: CLI_LOGIN_KIND }),
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
   } catch (err) {
@@ -189,16 +186,18 @@ async function startLogin(deps, dashboard, publicKey, machineName) {
       `${dashboard} is limiting logins from this address` + (wait > 0 ? `; try again in ${wait} seconds` : "; try again shortly")
     );
   }
-  const body = asRecord(await res.json().catch(() => null));
+  const body = await res.json().catch(() => null);
   if (!res.ok) {
-    const reason = typeof body.message === "string" ? `: ${body.message}` : "";
+    const refusal = CliLoginRefusalSchema.safeParse(body);
+    const reason = refusal.success && refusal.data.message !== void 0 ? `: ${refusal.data.message}` : "";
     throw new LoginError(`${dashboard} refused to start a login (HTTP ${res.status})${reason}`);
   }
-  if (typeof body.id !== "string" || typeof body.code !== "string" || typeof body.expires_at !== "string") {
+  const started = CliLoginStartedSchema.safeParse(body);
+  if (!started.success) {
     throw new LoginError(`${dashboard} answered with something that is not a login; is --dashboard the dashboard's address?`);
   }
-  const interval = typeof body.interval === "number" && body.interval > 0 ? body.interval : DEFAULT_POLL_INTERVAL_S;
-  return { id: body.id, code: body.code, interval, expiresAt: body.expires_at };
+  const { id, code, interval, expires_at: expiresAt } = started.data;
+  return { id, code, interval: interval ?? DEFAULT_POLL_INTERVAL_S, expiresAt };
 }
 async function pollLogin(deps, dashboard, id) {
   let res;
@@ -215,13 +214,16 @@ async function pollLogin(deps, dashboard, id) {
   if (res.status === 202) return { kind: "pending" };
   if (res.status >= 500) return { kind: "unavailable", message: `HTTP ${res.status}` };
   if (!res.ok) return { kind: "error", message: `HTTP ${res.status}` };
-  const body = asRecord(await res.json().catch(() => null));
-  if (body.status === "pending") return { kind: "pending" };
-  if (body.status === "denied") return { kind: "denied" };
-  if (body.status === "approved" && typeof body.encrypted_token === "string" && typeof body.gateway_url === "string" && typeof body.email === "string") {
-    return { kind: "approved", encryptedToken: body.encrypted_token, gatewayUrl: body.gateway_url, email: body.email };
+  const answer = CliLoginPollResponseSchema.safeParse(await res.json().catch(() => null));
+  if (!answer.success) return { kind: "error", message: "unexpected answer" };
+  switch (answer.data.status) {
+    case "pending":
+      return { kind: "pending" };
+    case "denied":
+      return { kind: "denied" };
+    case "approved":
+      return { kind: "approved", encryptedToken: answer.data.encrypted_token, gatewayUrl: answer.data.gateway_url, email: answer.data.email };
   }
-  return { kind: "error", message: "unexpected answer" };
 }
 function decryptToken(privateKeyPem, encryptedToken) {
   try {

package/dist/{chunk-QZX6DAAW.js → chunk-ZFLOFAUG.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { checkStarterFiles, contextIsGoverned, checkBuildSkill } from './chunk-VSUXCMMH.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-FQE5RDHI.js';
-import { isLinkedRepository } from './chunk-EMUNEAQK.js';
-import { sanitizeTerminal } from './chunk-G3IJ3N6F.js';
-import { checkFormerSkillNames } from './chunk-USWVXQIH.js';
-import { resolveGatewayCredentials, defaultFetch } from './chunk-QS43O4DR.js';
-import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-HWZCE745.js';
+import { checkStarterFiles, contextIsGoverned, checkBuildSkill } from './chunk-XFGL53GU.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-RVYOOYOA.js';
+import { isLinkedRepository } from './chunk-V5Q3S4NM.js';
+import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
+import { checkFormerSkillNames } from './chunk-MQ743JX3.js';
+import { resolveGatewayCredentials, defaultFetch } from './chunk-FKXGQOF5.js';
+import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-755WXDBI.js';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-DXDF43YG.js';
 import { hookCommandEscapesControlPlane, CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
-import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-AEKSX4EY.js';
+import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-D4AMAEZ7.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { readSettings, settingsPath, isOurStatuslineSlot, statuslineWrappedOriginal, REGISTERED_EVENTS, isOurHookCommand, ourCommandBins, cliBinResolvable, ourDirectScriptBins, wrappedOriginalCommand } from './chunk-GNPTU4BM.js';
@@ -1174,7 +1174,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-H4QS332G.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-7Z5DHSGY.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-BRN4BGMA.js');
+    const { runnerHostChecks } = await import('./doctor-DOAFZV4O.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1221,7 +1221,7 @@ async function gatherDoctorChecks() {
       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-SFACZU7E.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-ORQC26ZE.js');
       const { dirname: dirname2 } = await import('path');
       return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
     })();

package/dist/{claude-launcher-QD3C427Y.js → claude-launcher-JCPSHDZQ.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { sharedSkillNames } from './chunk-ZNPE7FW5.js';
+import { sharedSkillNames } from './chunk-VPEGE3QZ.js';
 import { GOVERNANCE_VARIABLE, versionAtLeast, MINIMUM_CLAUDE_VERSION, SHIM_SCRIPT, CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
 export { MINIMUM_CLAUDE_VERSION } from './chunk-HCVLP7XA.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
-import './chunk-5OCIHFGE.js';
-import './chunk-WFSUUUAN.js';
-import './chunk-7VUK5RFS.js';
+import './chunk-HBISTTG3.js';
+import './chunk-RKOTJQVG.js';
+import './chunk-QZBXLLTV.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import './chunk-RA3O54FC.js';
 import './chunk-Z5GEFMRW.js';
@@ -236,7 +236,7 @@ async function runClaudeLauncher(args, deps = {}) {
       return 1;
     }
   } else {
-    const { resolveLaunchPlane } = await import('./control-plane-launch-HE6OSWKO.js');
+    const { resolveLaunchPlane } = await import('./control-plane-launch-GKGI6HJA.js');
     const plane = env[GOVERNANCE_VARIABLE] === "self" ? { kind: "none" } : await resolveLaunchPlane({ cwd, env, home, fetchImpl: deps.fetchImpl, stderr });
     if (plane.kind === "none") {
       const own2 = ownSkillsDirFor(cwd, home, [], stderr);