@outerlayer/cli 0.18.0 → 0.19.0

package/dist/{chunk-6CHIYEZZ.js → chunk-XSZD4AZ6.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { WorkCommandError, postJson } from './chunk-KK4VBOH6.js';
-import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-W5VPCONO.js';
-import { readDegraded, readContextManifest, readSourceCache } from './chunk-LXAY4A2G.js';
-import { signingFetchFor } from './chunk-ZRL6HKBY.js';
-import { MAINTAINED_SKILLS } from './chunk-MNTSH4CL.js';
+import { WorkCommandError, postJson } from './chunk-HPJNLETG.js';
+import { composeDelivery } from './chunk-LLM3I5YU.js';
+import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-452TM7J4.js';
+import { signingFetchFor } from './chunk-FVMYKL6L.js';
+import { SHIM_SCRIPT } from './chunk-G2YNJIGF.js';
+import { readDegraded, readContextManifest, readSourceCache } from './chunk-YQR6E6OV.js';
 import { signerFor } from './chunk-M2ZWWTWZ.js';
 import { SHIM_DIR, stagedContextDir, contextHomeDir, deliveryDir } from './chunk-N2PXGQRL.js';
-import { SHIM_SCRIPT, rewriteControlPlanePaths, rewriteHookCommand } from './chunk-G2YNJIGF.js';
-import { fstatSync, existsSync, readdirSync, mkdirSync, writeFileSync, chmodSync, rmSync, copyFileSync, lstatSync, readFileSync } from 'fs';
+import { fstatSync, mkdirSync, writeFileSync, chmodSync, rmSync, lstatSync } from 'fs';
 import { relative, join, dirname } from 'path';
 
 createRequire(import.meta.url);
@@ -300,82 +300,8 @@ var BuildTokens = class {
     );
   }
 };
-function deliverySection(dir) {
-  return `This repository's control plane is not in the checkout. Its files are in \`${dir}\`. When an instruction or skill names a path under \`.outerlayer/\` or \`.claude/\`, read it under \`${dir}\`.`;
-}
-function isFile(path) {
-  try {
-    return lstatSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-function filesUnder(dir, base = dir) {
-  if (!existsSync(dir) || !lstatSync(dir).isDirectory()) return [];
-  const out = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const abs = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...filesUnder(abs, base));
-    else if (entry.isFile()) out.push(abs.slice(base.length + 1));
-  }
-  return out.sort();
-}
-function readText(path) {
-  if (!isFile(path)) return void 0;
-  const content = readFileSync(path);
-  return content.includes(0) ? void 0 : content.toString("utf8");
-}
-function deliveredSettings(raw, dir) {
-  if (raw === void 0) return "{}\n";
-  const rewrite = (value) => {
-    if (typeof value === "string") return rewriteHookCommand(value, dir);
-    if (Array.isArray(value)) return value.map(rewrite);
-    if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, rewrite(inner)]));
-    return value;
-  };
-  try {
-    return `${JSON.stringify(rewrite(JSON.parse(raw)), null, 2)}
-`;
-  } catch {
-    return rewriteHookCommand(raw, dir);
-  }
-}
-function composeDelivery(input) {
-  const { tree, dir } = input;
-  const added = [];
-  const put = (rel, content) => {
-    mkdirSync(dirname(join(tree, rel)), { recursive: true });
-    writeFileSync(join(tree, rel), content);
-    added.push(rel);
-  };
-  for (const skill of MAINTAINED_SKILLS) {
-    for (const rel of filesUnder(join(tree, ".outerlayer/skills", skill))) {
-      const target = `.claude/skills/${skill}/${rel}`;
-      if (existsSync(join(tree, target))) continue;
-      mkdirSync(dirname(join(tree, target)), { recursive: true });
-      copyFileSync(join(tree, ".outerlayer/skills", skill, rel), join(tree, target));
-      added.push(target);
-    }
-  }
-  for (const rel of [...filesUnder(join(tree, ".claude/skills"), tree), ...filesUnder(join(tree, ".claude/agents"), tree)]) {
-    const text = readText(join(tree, rel));
-    if (text === void 0) continue;
-    const rewritten = rewriteControlPlanePaths(text, dir);
-    if (rewritten !== text) writeFileSync(join(tree, rel), rewritten);
-  }
-  const agents = readText(join(tree, "AGENTS.md"));
-  put("CLAUDE.md", agents === void 0 ? `${deliverySection(dir)}
-` : `${deliverySection(dir)}
 
-${rewriteControlPlanePaths(agents, dir)}`);
-  put("settings.json", deliveredSettings(readText(join(tree, ".claude/settings.json")), dir));
-  return added;
-}
-function sharedSkillNames(tree) {
-  const dir = join(tree, ".claude/skills");
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-}
+// src/runner/control-plane-delivery.ts
 function shimScript() {
   return SHIM_SCRIPT;
 }
@@ -561,4 +487,4 @@ async function imageTargetFor(input) {
   return { ok: true, repository: resolved.source.repository, pinned: { commit: resolved.source.sha, ref: resolved.source.ref } };
 }
 
-export { BuildTokens, classifyRefusal, commandWithShim, controlPlaneTokenFailure, createRunnerLog, describeCallFailure, formatClock, formatDuration, imageTargetFor, pinnedSourceOf, refusalCode, relativeToRunner, removeStagedContext, resolveGoverningSource, retrySend, sharedSkillNames, shimScript, shortClaim, stageGovernedContext };
+export { BuildTokens, classifyRefusal, commandWithShim, controlPlaneTokenFailure, createRunnerLog, describeCallFailure, formatClock, formatDuration, imageTargetFor, logStamp, pinnedSourceOf, refusalCode, relativeToRunner, removeStagedContext, resolveGoverningSource, retrySend, shimScript, shortClaim, stageGovernedContext };

package/dist/{chunk-LXAY4A2G.js → chunk-YQR6E6OV.js}

@@ -1,34 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-X5N6KC6V.js';
-import { readFileSync, existsSync, writeFileSync, mkdirSync, utimesSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
+import { unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { isAbsolute, join, dirname } from 'path';
 
 createRequire(import.meta.url);
-function pinPath(workpieceRoot) {
-  return join(workpieceRoot, CONTEXT_PIN_FILENAME);
-}
-function readPin(workpieceRoot) {
-  try {
-    const parsed = JSON.parse(readFileSync(pinPath(workpieceRoot), "utf8"));
-    if (typeof parsed === "object" && parsed !== null && typeof parsed.sha === "string" && typeof parsed.schemaVersion === "number") {
-      return parsed;
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-function pinExists(workpieceRoot) {
-  return existsSync(pinPath(workpieceRoot));
-}
-function writePinIfChanged(workpieceRoot, sha) {
-  const existing = readPin(workpieceRoot);
-  if (existing?.sha === sha && existing.schemaVersion === CONTEXT_PIN_SCHEMA_VERSION) return false;
-  const pin = { schemaVersion: CONTEXT_PIN_SCHEMA_VERSION, sha };
-  writeFileSync(pinPath(workpieceRoot), JSON.stringify(pin) + "\n");
-  return true;
-}
 function stateDir(gitCommonDir) {
   return join(gitCommonDir, "outerlayer");
 }
@@ -56,19 +31,9 @@ function readContextManifest(gitCommonDir) {
 function writeContextManifest(gitCommonDir, manifest) {
   writeJson(manifestPath(gitCommonDir), manifest);
 }
-function manifestFilesPresent(workpieceRoot, manifest) {
-  return manifest.files.every((f) => existsSync(join(workpieceRoot, f)));
-}
-function lastCheckPath(gitCommonDir) {
-  return join(stateDir(gitCommonDir), "last-check");
-}
-function touchLastCheck(gitCommonDir, now) {
-  const path = lastCheckPath(gitCommonDir);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, String(now));
-  const seconds = now / 1e3;
+function removeContextManifest(gitCommonDir) {
   try {
-    utimesSync(path, seconds, seconds);
+    unlinkSync(manifestPath(gitCommonDir));
   } catch {
   }
 }
@@ -107,18 +72,38 @@ function writeSourceCache(gitCommonDir, cache) {
 function isSourceCacheFresh(cache, now) {
   return now - Date.parse(cache.checkedAt) < cache.ttlMs;
 }
-function buildHoldPath(gitCommonDir) {
-  return join(stateDir(gitCommonDir), "build-hold.json");
-}
-function readBuildHold(gitCommonDir) {
-  const parsed = readJson(buildHoldPath(gitCommonDir));
-  if (parsed && typeof parsed.sha === "string" && typeof parsed.repository === "string" && typeof parsed.ref === "string" && typeof parsed.at === "string") {
-    return parsed;
+function deliveryRecordPath(gitCommonDir) {
+  return join(stateDir(gitCommonDir), "delivery.json");
+}
+function readDeliveryRecord(gitCommonDir) {
+  const parsed = readJson(deliveryRecordPath(gitCommonDir));
+  if (typeof parsed?.dir === "string" && isAbsolute(parsed.dir) && typeof parsed.repository === "string" && typeof parsed.sha === "string") {
+    return {
+      ...typeof parsed.schemaVersion === "number" ? { schemaVersion: parsed.schemaVersion } : {},
+      repository: parsed.repository,
+      ...typeof parsed.ref === "string" ? { ref: parsed.ref } : {},
+      sha: parsed.sha,
+      dir: parsed.dir,
+      ...parsed.launcher === true ? { launcher: true } : {}
+    };
   }
   return void 0;
 }
-function writeBuildHold(gitCommonDir, hold) {
-  writeJson(buildHoldPath(gitCommonDir), hold);
+function removeLauncherDeliveryRecord(gitCommonDir) {
+  if (readDeliveryRecord(gitCommonDir)?.launcher !== true) return;
+  try {
+    unlinkSync(deliveryRecordPath(gitCommonDir));
+  } catch {
+  }
+}
+function deliveryRecordExists(gitCommonDir) {
+  return existsSync(deliveryRecordPath(gitCommonDir));
+}
+function writeDeliveryRecord(gitCommonDir, record) {
+  writeJson(deliveryRecordPath(gitCommonDir), record);
+}
+function cloneIsGoverned(gitCommonDir) {
+  return readSourceCache(gitCommonDir)?.status === "governed" || deliveryRecordExists(gitCommonDir);
 }
 
-export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, isSourceCacheFresh, manifestFilesPresent, pinExists, readBuildHold, readContextManifest, readDegraded, readPin, readSourceCache, touchLastCheck, writeBuildHold, writeContextManifest, writeDegraded, writePinIfChanged, writeSourceCache };
+export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, cloneIsGoverned, isSourceCacheFresh, readContextManifest, readDegraded, readDeliveryRecord, readSourceCache, removeContextManifest, removeLauncherDeliveryRecord, writeContextManifest, writeDegraded, writeDeliveryRecord, writeSourceCache };

package/dist/{chunk-47TTLEDX.js → chunk-ZHAUSEEN.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { C } from './chunk-ANPNT6PM.js';
-import { retiredSkillPaths, removeRetiredSkills } from './chunk-T4Y6SCG3.js';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-MNTSH4CL.js';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-X5N6KC6V.js';
+import { retiredSkillPaths, removeRetiredSkills } from './chunk-IXYZUUYQ.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-NNLA7LLQ.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-WFSUUUAN.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, unlinkSync, rmdirSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';
 
 createRequire(import.meta.url);
@@ -32,6 +32,9 @@ function discoverOuterlayerPaths(repoRoot) {
   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 {
@@ -44,7 +47,7 @@ function walk(dir, repoRoot, insideOuterlayer, out) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!insideOuterlayer && SKIP_DIRS.has(entry.name)) continue;
-      if (!insideOuterlayer && existsSync(join(full, CONTEXT_PIN_FILENAME))) continue;
+      if (!insideOuterlayer && isForeignTree(full)) continue;
       walk(full, repoRoot, insideOuterlayer || entry.name === ".outerlayer", out);
     } else if (entry.isFile() && insideOuterlayer) {
       out.push(toRepoRelative(repoRoot, full));
@@ -82,13 +85,14 @@ function writeOutputs(repoRoot, result, maintained) {
   }
   return { files, copies, maintained: [...changedMaintained.created, ...changedMaintained.rewritten] };
 }
-function renderSuccess(targets, files, copies, maintained, retired) {
+function renderSuccess(targets, files, copies, maintained, retired, orphaned) {
   const copySuffix = copies.length > 0 ? `, ${copies.length} ${copies.length === 1 ? "copy" : "copies"}` : "";
   const lines = [
     `${C.green}\u2713${C.reset} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${C.dim}${targets.join(", ")}${C.reset}`
   ];
   for (const path of maintained) lines.push(`  ${C.dim}updated ${path} to this CLI's version${C.reset}`);
   for (const path of retired) lines.push(`  ${C.dim}removed ${path}: this skill has a new name${C.reset}`);
+  for (const path of orphaned) lines.push(`  ${C.dim}removed ${path}: its source is gone${C.reset}`);
   return lines.join("\n");
 }
 function renderFailure(errors) {
@@ -132,7 +136,7 @@ function walkAll(dir, repoRoot, out) {
     if (entry.isSymbolicLink()) continue;
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (SKIP_DIRS.has(entry.name) || entry.name === ".outerlayer") continue;
+      if (SKIP_DIRS.has(entry.name) || entry.name === ".outerlayer" || isForeignTree(full)) continue;
       walkAll(full, repoRoot, out);
     } else if (entry.isFile()) {
       out.push(toRepoRelative(repoRoot, full));
@@ -155,6 +159,21 @@ function findOrphans(repoRoot, computedFiles, sourcePaths) {
   }
   return orphans;
 }
+function removeOrphans(repoRoot, orphans) {
+  const removed = [];
+  for (const { path } of orphans) {
+    unlinkSync(join(repoRoot, path));
+    removed.push(path);
+    for (let dir = dirname(path); dir !== "."; dir = dirname(dir)) {
+      try {
+        rmdirSync(join(repoRoot, dir));
+      } catch {
+        break;
+      }
+    }
+  }
+  return removed;
+}
 function withholdKept(repoRoot, result, keep) {
   if (keep === void 0) return { result, kept: [] };
   const kept = [];
@@ -187,9 +206,11 @@ function runEmit(opts = {}) {
   const emitted = emitTree(built.input);
   const { result, kept } = withholdKept(cwd, emitted, opts.keep);
   const hasErrors = result.errors.length > 0;
-  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, built.sourcePaths, maintained, kept, retired);
+  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);
   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 exitCode = hasErrors ? 1 : 0;
   const output = opts.json ? JSON.stringify({
     targets,
@@ -197,9 +218,10 @@ function runEmit(opts = {}) {
     copies: written.copies,
     maintained: written.maintained,
     retired: removed,
+    orphaned,
     warnings: result.warnings,
     errors: result.errors
-  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained, removed);
+  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained, removed, orphaned);
   if (!opts.quiet) {
     if (opts.json) {
       process.stdout.write(output + "\n");
@@ -218,13 +240,14 @@ function runEmit(opts = {}) {
     maintained: written.maintained,
     kept,
     retired: removed,
+    orphaned,
     warnings: result.warnings,
     errors: result.errors,
     output,
     exitCode
   };
 }
-function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained, kept, retired) {
+function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, maintained, kept, retired) {
   const drift = [];
   if (!hasErrors) {
     for (const path of retired) drift.push({ kind: "retired", path });
@@ -232,7 +255,6 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
       const d = compareFile(cwd, file.path, file.content);
       if (d) drift.push(d);
     }
-    const computedFiles = new Set(result.files.map((f) => f.path));
     for (const file of result.files) {
       const d = compareFile(cwd, file.path, file.content);
       if (d) drift.push(d);
@@ -242,7 +264,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
       if (d) drift.push(d);
     }
     const retiredPaths = new Set(retired);
-    drift.push(...findOrphans(cwd, computedFiles, sourcePaths).filter((d) => !retiredPaths.has(d.path)));
+    drift.push(...findOrphans(cwd, outputs, sourcePaths).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;
@@ -258,7 +280,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
 `);
     }
   }
-  return { targets, files: [], copies: [], maintained: [], kept, retired: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+  return { targets, files: [], copies: [], maintained: [], kept, retired: [], orphaned: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
 }
 
 export { EmitError, runEmit };

package/dist/{claude-launcher-YVXI76NX.js → claude-launcher-FPPHZPMR.js}

@@ -2,6 +2,7 @@
 import { createRequire } from 'node:module';
 import { versionAtLeast, MINIMUM_CLAUDE_VERSION, SHIM_SCRIPT, CONTROL_PLANE_DIR_VARIABLE } from './chunk-G2YNJIGF.js';
 export { MINIMUM_CLAUDE_VERSION } from './chunk-G2YNJIGF.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import './chunk-Z5GEFMRW.js';
 import { spawnSync, execFileSync, spawn } from 'child_process';
 import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
@@ -20,7 +21,7 @@ function readDeliveryRecord(cwd) {
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
     if (typeof parsed.dir === "string" && isAbsolute(parsed.dir) && typeof parsed.repository === "string" && typeof parsed.sha === "string") {
-      return { kind: "found", record: { repository: parsed.repository, sha: parsed.sha, dir: parsed.dir } };
+      return { kind: "found", record: { repository: parsed.repository, sha: parsed.sha, dir: parsed.dir, launcher: parsed.launcher === true } };
     }
   } catch {
   }
@@ -72,17 +73,29 @@ async function runClaudeLauncher(args, deps = {}) {
     return 127;
   }
   const found = readDeliveryRecord(cwd);
-  if (found.kind === "none") return run(claude, args, env, cwd, stderr);
-  if (found.kind === "invalid") {
+  const build = found.kind === "found" && found.record.launcher !== true ? found.record : void 0;
+  if (found.kind === "invalid" && env.OUTERLAYER_JOB_DIR !== void 0) {
     stderr(`outerlayer claude: ${found.path} is not a readable delivery record, so the control plane cannot be attached
 `);
     return 1;
   }
-  const { dir } = found.record;
-  if (!existsSync(dir)) {
-    stderr(`outerlayer claude: the control plane of ${found.record.repository} is not at ${dir}, so it cannot be attached
+  let dir;
+  if (build !== void 0) {
+    dir = build.dir;
+    if (!existsSync(dir)) {
+      stderr(`outerlayer claude: the control plane of ${build.repository} is not at ${dir}, so it cannot be attached
 `);
-    return 1;
+      return 1;
+    }
+  } else {
+    const { resolveLaunchPlane } = await import('./control-plane-launch-NYVDJESK.js');
+    const plane = await resolveLaunchPlane({ cwd, env, home: homeFromEnv(env), fetchImpl: deps.fetchImpl, stderr });
+    if (plane.kind === "none") return run(claude, args, env, cwd, stderr);
+    if (plane.kind === "refused") {
+      stderr(plane.message);
+      return 1;
+    }
+    dir = plane.dir;
   }
   const reported = spawnSync(claude, ["--version"], { env, encoding: "utf8", timeout: 15e3, stdio: ["ignore", "pipe", "ignore"] }).stdout ?? "";
   if (/\d+\.\d+\.\d+/.test(reported) && !versionAtLeast(reported)) {