@outerlayer/cli 0.22.1 → 0.23.0

package/dist/init-update-UZIJ2FMU.js

@@ -0,0 +1,529 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { contextIsGoverned, inspectStarterFiles, readShippedManifest, skillsFolders, contentHash, canonical } from './chunk-XFGL53GU.js';
+import { keepHandWritten } from './chunk-ZKWKQIJU.js';
+import { runEmit, inspectReplacedOutputs } from './chunk-WX2WEERU.js';
+import './chunk-VJBFQP3H.js';
+import { COMMIT_LINE } from './chunk-GXV73IIS.js';
+import './chunk-BUP5N3X6.js';
+import './chunk-XSPA5ODY.js';
+import './chunk-GOSFARMS.js';
+import './chunk-XGPC3IOR.js';
+import { retiredSkillPaths, removeRetiredSkills } from './chunk-MQ743JX3.js';
+import './chunk-QS43O4DR.js';
+import './chunk-ZJSNLVCE.js';
+import { findGitDirs } from './chunk-BJ3KTMDH.js';
+import './chunk-CBCKD6DO.js';
+import { setMcpEntry } from './chunk-YVZJ6GKF.js';
+import { C } from './chunk-ANPNT6PM.js';
+import './chunk-EABW6AJQ.js';
+import { skillsBaseFor, isAgentsMdLayout, holdsTodaysLayoutSources, discoverOuterlayerPaths, declareAgentsMdLayout, linkClaudeSkills, SKILLS_LINK_PATH, readConfigObject, filesBelow, describeSkillsLink, FIRST_VERSION_READING_AGENTS_SKILLS } from './chunk-JKNYTNYD.js';
+import { writeMaintainedFiles, maintainedFilesForExistingSkills, loadMaintainedFiles, AGENTS_SKILLS_BASE, OUTERLAYER_SKILLS_BASE } from './chunk-HBISTTG3.js';
+import { cliInvocation } from './chunk-CRB3POP4.js';
+import { linkedAgentsPath, hasSymlinkComponent } from './chunk-VWFOKRYS.js';
+import './chunk-YQR6E6OV.js';
+import './chunk-TUSYOL2O.js';
+import { parseOuterlayerConfig } from './chunk-RKOTJQVG.js';
+import './chunk-QZBXLLTV.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-RA3O54FC.js';
+import './chunk-OW52QLK3.js';
+import './chunk-IHNQWF6F.js';
+import './chunk-URWYRAIC.js';
+import './chunk-GISNHSYL.js';
+import './chunk-Z5GEFMRW.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, readdirSync, rmdirSync, renameSync, lstatSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+function removeFile(root, path) {
+  if (hasSymlinkComponent(root, path)) return false;
+  unlinkSync(join(root, path));
+  for (let dir = dirname(path); dir !== "."; dir = dirname(dir)) {
+    try {
+      if (readdirSync(join(root, dir)).length > 0) break;
+      rmdirSync(join(root, dir));
+    } catch {
+      break;
+    }
+  }
+  return true;
+}
+var exists = (root, rel) => {
+  try {
+    lstatSync(join(root, rel));
+    return true;
+  } catch {
+    return false;
+  }
+};
+function scopesOf(paths) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const at = path.split("/").indexOf(".outerlayer");
+    if (at !== -1) scopes.add(path.split("/").slice(0, at).join("/"));
+  }
+  return [...scopes].sort();
+}
+function configuredTargets(root) {
+  try {
+    const parsed = parseOuterlayerConfig(readFileSync(join(root, ".outerlayer", "config.json"), "utf8"));
+    return parsed.config?.targets ?? [];
+  } catch {
+    return [];
+  }
+}
+function readJson(root, rel) {
+  try {
+    const doc = JSON.parse(readFileSync(join(root, rel), "utf8"));
+    return doc !== null && typeof doc === "object" && !Array.isArray(doc) ? doc : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var serversOf = (doc) => {
+  const value = doc.mcpServers;
+  if (value === void 0) return {};
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+};
+function controlPlaneNote() {
+  return `A CLI or runner older than ${FIRST_VERSION_READING_AGENTS_SKILLS}, the first that reads .agents/skills/, delivers none of these skills. Keeping .claude/skills/ as an identical copy of .agents/skills/ until they upgrade keeps them working. Until then, make every edit in both folders. To make the copy now, run \`cp -R .agents/skills/. .claude/skills/\`, and commit it.`;
+}
+function migrateToAgentsMdLayout(root, opts) {
+  const outerlayerPaths = discoverOuterlayerPaths(root);
+  const retired = retiredSkillPaths(root);
+  const inspected = inspectReplacedOutputs(root);
+  const edited = inspected.edited;
+  const generated = inspected.generated.filter(
+    (path) => !hasSymlinkComponent(root, path) && !(opts.controlPlane && (path === SKILLS_LINK_PATH || path.startsWith(`${SKILLS_LINK_PATH}/`) || path.includes(`/${SKILLS_LINK_PATH}/`)))
+  );
+  const removedSet = /* @__PURE__ */ new Set([...retired, ...generated]);
+  const survives = (rel) => {
+    if (!exists(root, rel)) return false;
+    if (!lstatSync(join(root, rel)).isDirectory()) return !removedSet.has(rel);
+    return filesBelow(root, rel).some((file) => !removedSet.has(file));
+  };
+  if (exists(root, ".outerlayer/config.json") && readConfigObject(root) === void 0) {
+    return {
+      dryRun: opts.dryRun,
+      removed: [],
+      editedKept: edited,
+      removedDiffering: [],
+      moved: [],
+      notMoved: [{ path: ".outerlayer/config.json", because: "it is not a JSON object, so the layout cannot be declared; fix it first and nothing has moved" }],
+      mcp: { moved: [], merged: [], conflicts: [], keptForCursor: false },
+      link: { status: "skipped", reason: "nothing moved" },
+      layoutDeclared: false,
+      commandsKept: false
+    };
+  }
+  const linkedSkills = linkedAgentsPath(root);
+  if (linkedSkills !== void 0) {
+    return {
+      dryRun: opts.dryRun,
+      removed: [],
+      editedKept: edited,
+      removedDiffering: [],
+      moved: [],
+      notMoved: [{ path: linkedSkills, because: "it is a link, and a write there would land outside the repository; nothing has moved" }],
+      mcp: { moved: [], merged: [], conflicts: [], keptForCursor: false },
+      link: { status: "skipped", reason: "nothing moved" },
+      layoutDeclared: false,
+      commandsKept: false
+    };
+  }
+  const moves = [];
+  const notMoved = [];
+  for (const scope of scopesOf(outerlayerPaths)) {
+    const at = (rel) => scope === "" ? rel : `${scope}/${rel}`;
+    const instructions = at(".outerlayer/AGENTS.md");
+    if (exists(root, instructions)) {
+      if (hasSymlinkComponent(root, instructions) || hasSymlinkComponent(root, at("AGENTS.md"))) {
+        notMoved.push({ path: instructions, because: "it or its destination is a link, and a move would follow it" });
+      } else if (survives(at("AGENTS.md"))) notMoved.push({ path: instructions, because: `${at("AGENTS.md")} exists and is not a file \`context emit\` generated` });
+      else moves.push({ from: instructions, to: at("AGENTS.md") });
+    }
+    const skills = at(".outerlayer/skills");
+    if (exists(root, skills) && hasSymlinkComponent(root, skills)) {
+      notMoved.push({ path: skills, because: "it is a link, and a move would take files out of the folder it points to" });
+    } else if (exists(root, skills)) {
+      for (const name of readdirSync(join(root, skills)).sort()) {
+        const from = `${skills}/${name}`;
+        if (!survives(from)) continue;
+        const to = at(`.agents/skills/${name}`);
+        if (hasSymlinkComponent(root, from) || hasSymlinkComponent(root, to)) {
+          notMoved.push({ path: from, because: `it or ${to} is a link, and a move would follow it` });
+        } else if (survives(to)) notMoved.push({ path: from, because: `${to} exists and is not a file \`context emit\` generated` });
+        else moves.push({ from, to });
+      }
+    }
+  }
+  const keptForCursor = configuredTargets(root).includes("cursor");
+  const mcpPlan = keptForCursor ? [] : scopesOf(outerlayerPaths).map((scope) => ({ src: scope === "" ? ".outerlayer/mcp.json" : `${scope}/.outerlayer/mcp.json`, dst: scope === "" ? ".mcp.json" : `${scope}/.mcp.json` })).filter((m) => exists(root, m.src));
+  const linkedMcp = mcpPlan.filter((m) => hasSymlinkComponent(root, m.src) || hasSymlinkComponent(root, m.dst));
+  for (const m of linkedMcp) notMoved.push({ path: m.src, because: `it or ${m.dst} is a link, and a move would follow it` });
+  mcpPlan.splice(0, mcpPlan.length, ...mcpPlan.filter((m) => !linkedMcp.includes(m)));
+  const result = {
+    dryRun: opts.dryRun,
+    removed: [.../* @__PURE__ */ new Set([...retired, ...generated])].sort(),
+    editedKept: edited,
+    removedDiffering: inspected.replacedDiffering.filter((path) => removedSet.has(path)),
+    moved: moves,
+    notMoved,
+    mcp: { moved: [], merged: [], conflicts: [], keptForCursor },
+    link: { status: "skipped", reason: "not planned" },
+    layoutDeclared: false,
+    commandsKept: outerlayerPaths.some((p) => /(^|\/)\.outerlayer\/commands\//.test(p))
+  };
+  const mcpMoves = [];
+  for (const { src, dst } of mcpPlan) {
+    const source = readJson(root, src);
+    if (source === void 0 || serversOf(source) === void 0) {
+      result.notMoved.push({ path: src, because: "it is not a JSON object with an mcpServers object" });
+      continue;
+    }
+    if (!exists(root, dst)) {
+      result.mcp.moved.push({ from: src, to: dst });
+      mcpMoves.push({ src, dst });
+      continue;
+    }
+    const target = readJson(root, dst);
+    const targetServers = target === void 0 ? void 0 : serversOf(target);
+    if (target === void 0 || targetServers === void 0) {
+      result.notMoved.push({ path: src, because: `${dst} is not a JSON object with an mcpServers object` });
+      continue;
+    }
+    const sourceServers = serversOf(source);
+    const conflicts = Object.keys(sourceServers).filter((name) => name in targetServers && canonical(targetServers[name]) !== canonical(sourceServers[name]));
+    if (conflicts.length > 0) {
+      result.mcp.conflicts.push(...conflicts.map((name) => `${dst} "${name}"`));
+      result.notMoved.push({ path: src, because: `${dst} defines ${conflicts.map((n) => `"${n}"`).join(", ")} differently` });
+      continue;
+    }
+    const missing = Object.keys(sourceServers).filter((name) => !(name in targetServers));
+    if (missing.length > 0) {
+      result.mcp.merged.push(dst);
+      mcpMoves.push({ src, dst, merge: { doc: { ...source, ...target, mcpServers: { ...sourceServers, ...targetServers } } } });
+    } else {
+      result.mcp.moved.push({ from: src, to: dst });
+      mcpMoves.push({ src, dst });
+    }
+  }
+  const skillsStay = moves.some((m) => m.to === ".agents/skills" || m.to.startsWith(".agents/skills/")) || survives(".agents/skills");
+  if (opts.controlPlane) {
+    result.link = { status: "skipped", reason: "this control plane keeps .claude/skills/ as a copy for older CLIs" };
+  } else if (!opts.skillsLink) {
+    result.link = { status: "skipped", reason: "--no-skills-link" };
+  } else if (!skillsStay) {
+    result.link = { status: "skipped", reason: "there are no skills in .agents/skills/" };
+  } else {
+    const blocking = opts.dryRun ? filesBelow(root, SKILLS_LINK_PATH).filter((file) => !removedSet.has(file)) : [];
+    result.link = blocking.length > 0 ? { status: "blocked", blocking } : { status: "linked" };
+  }
+  if (result.moved.some((m) => m.to.startsWith(".agents/skills/")) && opts.controlPlane) result.controlPlaneNote = controlPlaneNote();
+  result.layoutDeclared = result.notMoved.length === 0;
+  if (opts.dryRun) return result;
+  removeRetiredSkills(root, (path) => hasSymlinkComponent(root, path));
+  for (const path of generated) removeFile(root, path);
+  result.removed = result.removed.filter((path) => !exists(root, path));
+  for (const { from, to } of moves) {
+    mkdirSync(join(root, dirname(to)), { recursive: true });
+    renameSync(join(root, from), join(root, to));
+  }
+  for (const scope of scopesOf(outerlayerPaths)) {
+    const outerlayer = scope === "" ? ".outerlayer" : `${scope}/.outerlayer`;
+    for (const dir of [`${outerlayer}/skills`, outerlayer]) {
+      try {
+        rmdirSync(join(root, dir));
+      } catch {
+      }
+    }
+  }
+  for (const m of mcpMoves) {
+    if (m.merge !== void 0) writeFileSync(join(root, m.dst), `${JSON.stringify(m.merge.doc, null, 2)}
+`);
+    else if (!exists(root, m.dst)) renameSync(join(root, m.src), join(root, m.dst));
+    if (exists(root, m.src)) unlinkSync(join(root, m.src));
+  }
+  if (result.link.status === "linked" || result.link.status === "blocked") result.link = linkClaudeSkills(root);
+  result.layoutDeclared = result.notMoved.length === 0 && declareAgentsMdLayout(root);
+  return result;
+}
+function describeMigration(m, color) {
+  const { green, yellow, dim, reset } = color;
+  const lines = [];
+  const verb = (done, planned) => m.dryRun ? planned : `${green}${done}${reset}`;
+  lines.push(m.dryRun ? "Move to the AGENTS.md layout (nothing written):" : "Moved to the AGENTS.md layout:");
+  for (const path of m.removed) lines.push(`  ${verb("removed", "would remove")} ${path} ${dim}(generated by emit)${reset}`);
+  for (const path of m.removedDiffering) {
+    lines.push(`  ${dim}${path} differed from this CLI's copy of the skill; its header says an edit is overwritten, so it ${m.dryRun ? "would be removed" : "was removed"} with the others${reset}`);
+  }
+  for (const { from, to } of m.moved) lines.push(`  ${verb("moved", "would move")} ${from} to ${to}`);
+  for (const { from, to } of m.mcp.moved) lines.push(`  ${verb("moved", "would move")} ${from} to ${to}`);
+  for (const path of m.mcp.merged) lines.push(`  ${verb("added", "would add")} the servers of an .outerlayer/mcp.json to ${path}`);
+  if (m.mcp.keptForCursor) lines.push(`  ${dim}kept .outerlayer/mcp.json: the cursor target compiles it into .cursor/mcp.json${reset}`);
+  for (const path of m.editedKept) {
+    lines.push(`  ${yellow}kept${reset} ${path} ${dim}(differs from what emit generates, so it is yours; delete it by hand if you do not need it)${reset}`);
+  }
+  for (const { path, because } of m.notMoved) lines.push(`  ${yellow}left${reset} ${path} ${dim}(${because})${reset}`);
+  if (m.commandsKept) {
+    lines.push(`  ${dim}kept .outerlayer/commands/ and the commands compiled from it: run \`${cliInvocation()} context emit\` after you change a command${reset}`);
+  }
+  if (m.link.status === "skipped") lines.push(`  ${dim}no .claude/skills link (${m.link.reason})${reset}`);
+  else if (m.dryRun) {
+    lines.push(
+      m.link.status === "linked" ? `  would link ${SKILLS_LINK_PATH} to ../.agents/skills` : `  ${yellow}would leave${reset} ${SKILLS_LINK_PATH}/ as it is: it still holds ${m.link.blocking.join(", ")}`
+    );
+  } else {
+    const text = describeSkillsLink(m.link);
+    if (text !== "") lines.push(`  ${m.link.status === "linked" ? `${green}\u2713${reset}` : `${yellow}!${reset}`} ${text}`);
+  }
+  if (m.notMoved.length > 0 || !m.layoutDeclared) {
+    lines.push(`  ${yellow}!${reset} The layout is not declared yet. Resolve the files listed as left, then run \`${cliInvocation()} init --update\` again.`);
+  } else {
+    lines.push(`  ${verb("declared", "would declare")} "layout": 2 in .outerlayer/config.json`);
+  }
+  if (m.controlPlaneNote !== void 0) lines.push("", m.controlPlaneNote);
+  return lines;
+}
+
+// src/init-update.ts
+var NOT_COMPILED = `There is no .outerlayer/config.json, so \`${cliInvocation()} context emit\` did not run.`;
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+function actionFor(item) {
+  if (item.state === "outdated") return "update";
+  if (item.state === "missing") return "write";
+  if (item.state === "current") return "none";
+  return "keep";
+}
+function removals(root, report, packRoot) {
+  const manifest = readShippedManifest(packRoot);
+  const planned = [];
+  const add = (path) => planned.push({ path, state: "retired", action: "remove" });
+  const skillsDir = `${report.base}/`;
+  for (const file of report.retired.filter((f) => f.state === "unedited")) {
+    add(file.path);
+    const rel = file.path.slice(skillsDir.length);
+    if (report.base !== OUTERLAYER_SKILLS_BASE || !manifest.ok || !/^[^/]+\/scripts\//.test(rel)) continue;
+    for (const folder of skillsFolders().filter((f) => `${f}/` !== skillsDir)) {
+      const native = `${folder}/${rel}`;
+      if (hasSymlinkComponent(root, native)) continue;
+      try {
+        if (manifest.files.get(file.path)?.has(contentHash(readFileSync(join(root, native), "utf8"))) === true) add(native);
+      } catch {
+      }
+    }
+  }
+  return planned;
+}
+function plan(report) {
+  return report.items.map((item) => {
+    const planned = { path: item.path, state: item.state, action: actionFor(item) };
+    if (item.kind === "mcp") planned.server = item.server;
+    if (item.kind === "file" && item.state === "edited" && item.file.source !== void 0) {
+      planned.compare = `git diff --no-index ${item.file.source} ${item.path}`;
+    }
+    return planned;
+  });
+}
+function apply(root, item) {
+  if (item.kind === "file") {
+    const abs = join(root, item.path);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, item.file.content);
+  } else {
+    setMcpEntry(root, item.server, { ...item.entry });
+  }
+}
+var CLASHING_FLAGS = ["remove", "org", "local", "template", "factory"];
+function updateFlagProblem(flags) {
+  if (flags.update !== true) return flags.dryRun === true ? "--dry-run only applies to --update." : void 0;
+  const clash = CLASHING_FLAGS.find((name) => flags[name] !== void 0 && flags[name] !== false);
+  return clash === void 0 ? void 0 : `--update changes only the files init wrote, so it cannot be combined with --${clash}.`;
+}
+var MCP_SOURCE = ".outerlayer/mcp.json";
+function sameJson(a, b) {
+  try {
+    return b !== void 0 && canonical(JSON.parse(a)) === canonical(JSON.parse(b));
+  } catch {
+    return false;
+  }
+}
+function keepUnlessCompiled(keep, mcpSourceBefore) {
+  return (output) => {
+    if (output.kind === "file" && sameJson(output.existing, mcpSourceBefore)) return false;
+    return keep(output);
+  };
+}
+function maintainedDrift(root, packRoot, base) {
+  return maintainedFilesForExistingSkills(root, loadMaintainedFiles(packRoot, void 0, base), base).filter((file) => !existsSync(join(root, file.path)) || readFileSync(join(root, file.path), "utf8") !== file.content).map((file) => {
+    const present = existsSync(join(root, file.path));
+    return { item: { path: file.path, state: present ? "outdated" : "missing", action: present ? "update" : "write" }, file };
+  });
+}
+function runStarterUpdate(opts) {
+  const dryRun = opts.dryRun === true;
+  const empty = { dryRun, items: [], emitted: [], kept: [], manifest: "ok" };
+  const dirs = findGitDirs(opts.cwd);
+  if (dirs === void 0) return { ...empty, status: "skipped", reason: "not a git repository" };
+  const root = dirs.repoRoot;
+  if (contextIsGoverned(dirs.gitCommonDir)) {
+    return { ...empty, status: "skipped", reason: "this repository's context comes from a control plane and arrives at session start" };
+  }
+  const skillsBase = opts.base ?? skillsBaseFor(root);
+  const agentsMd = skillsBase === AGENTS_SKILLS_BASE;
+  const linked = agentsMd ? linkedAgentsPath(root) : void 0;
+  if (linked !== void 0) return { ...empty, status: "failed", reason: `${linked} is a link, and a write there would land outside the repository; replace it with a folder and run this again` };
+  const report = inspectStarterFiles(root, { packRoot: opts.packRoot, base: skillsBase });
+  const dropped = removals(root, report, opts.packRoot);
+  const refreshed = agentsMd ? maintainedDrift(root, opts.packRoot, skillsBase) : [];
+  const items = [...plan(report), ...refreshed.map((r) => r.item), ...dropped];
+  const base = { dryRun, items, emitted: [], kept: [], manifest: report.manifest };
+  const changes = report.items.filter((i) => i.state === "outdated" || i.state === "missing");
+  const nothing = changes.length === 0 && dropped.length === 0 && refreshed.length === 0;
+  if (dryRun || nothing) return { ...base, status: "done", reason: nothing ? "nothing to update" : "dry run" };
+  const created = new Set(changes.filter((i) => i.kind === "file" && i.state === "missing").map((i) => i.path));
+  const mcpSource = join(root, MCP_SOURCE);
+  const mcpSourceBefore = existsSync(mcpSource) ? readFileSync(mcpSource, "utf8") : void 0;
+  try {
+    for (const item of changes) apply(root, item);
+    for (const item of dropped) if (!removeFile(root, item.path)) item.action = "keep";
+    if (agentsMd) writeMaintainedFiles(root, refreshed.map((r) => ({ ...r.file, skill: "", skillClass: "maintained" })));
+  } catch (err) {
+    return { ...base, status: "failed", reason: `could not write the files: ${errorMessage(err)}` };
+  }
+  if (agentsMd) return { ...base, status: "done", reason: "updated" };
+  if (!existsSync(join(root, ".outerlayer", "config.json"))) {
+    try {
+      writeMaintainedFiles(root, maintainedFilesForExistingSkills(root, loadMaintainedFiles(opts.packRoot)));
+    } catch (err) {
+      return { ...base, status: "failed", reason: `could not write the files: ${errorMessage(err)}` };
+    }
+    return { ...base, status: "done", reason: NOT_COMPILED };
+  }
+  try {
+    const keep = keepUnlessCompiled(keepHandWritten(created), mcpSourceBefore);
+    const pending = runEmit({ cwd: root, check: true, quiet: true, keep }).drift ?? [];
+    const emitted = runEmit({ cwd: root, quiet: true, keep });
+    if (emitted.exitCode !== 0) throw new Error(emitted.errors.map((e) => `${e.path}: ${e.message}`).join("; "));
+    return {
+      ...base,
+      status: "done",
+      reason: "updated",
+      emitted: pending.filter((d) => d.kind !== "orphaned").map((d) => d.path),
+      kept: emitted.kept
+    };
+  } catch (err) {
+    return { ...base, status: "failed", reason: `context emit failed: ${errorMessage(err)}` };
+  }
+}
+var TEXT_FILE = /\.(md|ya?ml|json|mjs|cjs|js|ts|sh|py|txt)$/;
+var OLD_SKILLS_PATH = ".outerlayer/skills/";
+function staleSkillReferences(root) {
+  const candidates = ["AGENTS.md", ".outerlayer/policy.yaml"];
+  for (const dir of [".outerlayer/validators", ".agents/skills"]) {
+    const walk = (rel) => {
+      let entries;
+      try {
+        entries = readdirSync(join(root, rel), { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) walk(`${rel}/${entry.name}`);
+        else if (entry.isFile() && TEXT_FILE.test(entry.name)) candidates.push(`${rel}/${entry.name}`);
+      }
+    };
+    walk(dir);
+  }
+  return candidates.filter((rel) => {
+    try {
+      return readFileSync(join(root, rel), "utf8").includes(OLD_SKILLS_PATH);
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+function runInitUpdate(opts) {
+  const dryRun = opts.dryRun === true;
+  const dirs = findGitDirs(opts.cwd);
+  if (dirs === void 0 || contextIsGoverned(dirs.gitCommonDir)) return runStarterUpdate(opts);
+  const root = dirs.repoRoot;
+  const todays = !isAgentsMdLayout(root) && (existsSync(join(root, ".outerlayer", "config.json")) || holdsTodaysLayoutSources(discoverOuterlayerPaths(root)));
+  if (!todays) {
+    if (!isAgentsMdLayout(root) && !dryRun && linkedAgentsPath(root) === void 0) declareAgentsMdLayout(root);
+    return runStarterUpdate({ ...opts, base: AGENTS_SKILLS_BASE });
+  }
+  let migration;
+  try {
+    migration = migrateToAgentsMdLayout(root, { dryRun, skillsLink: opts.skillsLink !== false, controlPlane: opts.controlPlane === true });
+  } catch (err) {
+    return { status: "failed", reason: `could not move the files: ${errorMessage(err)}`, dryRun, items: [], emitted: [], kept: [], manifest: "ok" };
+  }
+  if (dryRun) return { status: "done", reason: "dry run", dryRun, items: [], emitted: [], kept: [], manifest: "ok", migration };
+  if (migration.notMoved.length > 0 || !migration.layoutDeclared) {
+    return { status: "done", reason: "the move is not finished, so the starter files are left as they are", dryRun, items: [], emitted: [], kept: [], manifest: "ok", migration };
+  }
+  const starter = runStarterUpdate({ cwd: opts.cwd, packRoot: opts.packRoot });
+  if (migration.link.status === "skipped" && migration.link.reason.startsWith("there are no skills") && existsSync(join(root, ".agents", "skills"))) {
+    migration.link = linkClaudeSkills(root);
+  }
+  const staleReferences = isAgentsMdLayout(root) ? staleSkillReferences(root) : [];
+  return { ...starter, migration, ...staleReferences.length > 0 ? { staleReferences } : {} };
+}
+var VERB = {
+  update: { done: "updated", planned: "would update" },
+  write: { done: "wrote", planned: "would write" },
+  remove: { done: "removed", planned: "would remove" }
+};
+function formatInitUpdate(result) {
+  if (result.status === "skipped") return `${C.dim}- Nothing to update: ${result.reason}${C.reset}
+`;
+  const lines = [];
+  const label = (p) => p.server === void 0 ? p.path : `${p.path} "${p.server}" server`;
+  const changed = result.items.filter((p) => p.action === "update" || p.action === "write" || p.action === "remove");
+  const kept = result.items.filter((p) => p.action === "keep" && p.state !== "retired");
+  const current = result.items.filter((p) => p.action === "none");
+  if (result.migration !== void 0) lines.push(...describeMigration(result.migration, C), "");
+  if (result.migration?.dryRun === true) {
+    lines.push(`${C.dim}The starter files are checked after the move.${C.reset}`);
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push(result.dryRun ? `Plan for \`${cliInvocation()} init --update\` (nothing written):` : "Starter files:");
+  for (const p of changed) {
+    const verb = VERB[p.action];
+    const why = p.action === "update" ? "outdated, unedited" : p.action === "remove" ? "no longer shipped, unedited" : "missing";
+    lines.push(`  ${result.dryRun ? verb.planned : `${C.green}${verb.done}${C.reset}`} ${label(p)} ${C.dim}(${why})${C.reset}`);
+  }
+  for (const p of kept) {
+    const why = p.state === "unreadable" ? "not valid JSON" : "edited by you";
+    lines.push(`  ${C.yellow}kept${C.reset} ${label(p)} ${C.dim}(${why}, left as it is)${C.reset}`);
+    if (p.compare !== void 0) lines.push(`       ${C.dim}compare: ${p.compare}${C.reset}`);
+  }
+  if (current.length > 0) lines.push(`  ${C.dim}${current.length} already current${C.reset}`);
+  if (result.manifest !== "ok") {
+    lines.push(
+      `  ${C.yellow}!${C.reset} This CLI's record of earlier versions is ${result.manifest}, so every changed file counts as edited and is left as it is.`
+    );
+  }
+  if (result.emitted.length > 0) {
+    lines.push("", `Recompiled by \`${cliInvocation()} context emit\`:`, ...result.emitted.map((p) => `  ${p}`));
+  }
+  for (const p of result.kept) lines.push(`  ${C.dim}kept ${p} (written by hand, not replaced)${C.reset}`);
+  if (result.staleReferences !== void 0) {
+    lines.push("", `These files still name .outerlayer/skills/, which no longer holds the skills. Change each path to .agents/skills/:`);
+    lines.push(...result.staleReferences.map((p) => `  ${p}`));
+  }
+  const migrated = result.migration !== void 0 && !result.dryRun;
+  if (result.status === "failed") lines.push("", `${C.red}\u2717${C.reset} ${result.reason}`);
+  else if (!result.dryRun && (changed.length > 0 || migrated)) {
+    if (result.reason === NOT_COMPILED) lines.push("", `${C.dim}${NOT_COMPILED}${C.reset}`);
+    lines.push("", "The changes are left uncommitted.", COMMIT_LINE);
+    if (migrated) lines.push("Commit the removed and moved files too: AGENTS.md, .agents/, .mcp.json and .claude/skills.");
+  } else if (changed.length === 0) lines.push("", `${C.green}\u2713${C.reset} Nothing to update.`);
+  return `${lines.join("\n")}
+`;
+}
+
+export { formatInitUpdate, runInitUpdate, runStarterUpdate, updateFlagProblem };

package/dist/layout-UOJQGEPW.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { AGENTS_MD_LAYOUT, FIRST_VERSION_READING_AGENTS_SKILLS, SKILLS_LINK_PATH, declareAgentsMdLayout, describeSkillsLink, filesBelow, holdsTodaysLayoutSources, isAgentsMdLayout, linkClaudeSkills, readConfigObject, skillsBaseFor } from './chunk-JKNYTNYD.js';
+import './chunk-HBISTTG3.js';
+import './chunk-RKOTJQVG.js';
+import './chunk-QZBXLLTV.js';
+import './chunk-RA3O54FC.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/{login-browser-BN5UKPHS.js → login-browser-4OMZFP3U.js}

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { DEFAULT_DASHBOARD, readPipedKey, realLoginDeps, runLoginCommand, sanitizeMachineName, stdinKind } from './chunk-EAQSOE62.js';
-import './chunk-F35VMF5M.js';
+export { DEFAULT_DASHBOARD, readPipedKey, realLoginDeps, runLoginCommand, sanitizeMachineName, stdinKind } from './chunk-XSPA5ODY.js';
+import './chunk-GOSFARMS.js';
 import './chunk-BJ3KTMDH.js';
-import './chunk-EABW6AJQ.js';
 import './chunk-ANPNT6PM.js';
+import './chunk-EABW6AJQ.js';
 import './chunk-CRB3POP4.js';
+import './chunk-QZBXLLTV.js';
 import './chunk-VNVZDWO3.js';
 import './chunk-Z5GEFMRW.js';
 

package/dist/{logout-cmd-RZFWTNYD.js → logout-cmd-5V5MMBSY.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { realLogoutDeps, revokeTokenOnDashboard, runLogoutCommand } from './chunk-F35VMF5M.js';
-import './chunk-EABW6AJQ.js';
+export { realLogoutDeps, revokeTokenOnDashboard, runLogoutCommand } from './chunk-GOSFARMS.js';
 import './chunk-ANPNT6PM.js';
+import './chunk-EABW6AJQ.js';
 import './chunk-CRB3POP4.js';
 import './chunk-VNVZDWO3.js';
 import './chunk-Z5GEFMRW.js';