@outerlayer/cli 0.12.0 → 0.14.0

package/dist/{chunk-ANW7VHMH.js → chunk-HFKQIZXL.js}

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { checkStarterFiles } from './chunk-MTF3PHVZ.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-SWHQ4LUM.js';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-F47JBIAW.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-6FH2AHJY.js';
-import { isLinkedRepository } from './chunk-C7N4TDHW.js';
-import { sanitizeTerminal } from './chunk-JOXYKGUV.js';
-import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-3ZPYPFNM.js';
+import { isLinkedRepository } from './chunk-YDSMROTB.js';
+import { sanitizeTerminal } from './chunk-WUYTWNMA.js';
+import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-JXYVA45C.js';
 import { C } from './chunk-YRYMNBGQ.js';
 import { readSettings, settingsPath, isOurStatuslineSlot, statuslineWrappedOriginal, REGISTERED_EVENTS, isOurHookCommand, ourCommandBins, cliBinResolvable, ourDirectScriptBins, wrappedOriginalCommand } from './chunk-5QRP3MVS.js';
-import { readPin, readContextManifest, readDegraded, readSourceCache } from './chunk-G5IEVZGI.js';
+import { readPin, readContextManifest, readDegraded, readSourceCache } from './chunk-LCEXHCHD.js';
 import { defaultFetch } from './chunk-YO4PSLVB.js';
 import { resolveGatewayCredentials } from './chunk-PLMTLGYH.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';
-import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-YEQL54G5.js';
+import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-PQUM37BK.js';
 import { deadHooksState, preparePackageManagerCommand, contextExcludesPresent } from './chunk-XCCLFVXM.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { readFileSync, mkdirSync, writeFileSync, renameSync, existsSync, accessSync, constants, statSync, readdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { readFileSync, mkdirSync, writeFileSync, renameSync, existsSync, accessSync, constants, statSync, readdirSync, realpathSync } from 'fs';
+import { join, dirname, resolve, delimiter } from 'path';
 import { execFileSync } from 'child_process';
 
 createRequire(import.meta.url);
@@ -113,6 +114,57 @@ function recordStatusline(home, settingsPath2, outcome, original, now = Date.now
     };
   });
 }
+var NAME = "MCP server";
+var SERVER = "outerlayer";
+var NPX_FIX = 'Change the "outerlayer" entry in .mcp.json to run `npx -y @outerlayer/cli mcp serve`, or install the CLI with `npm install -g @outerlayer/cli`.';
+function expand(value, env) {
+  return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => env[name] ?? "");
+}
+function isExecutableFile(path, platform) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    if (platform !== "win32") accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveCommand(command, root, env, platform) {
+  if (/[\\/]/.test(command)) {
+    const path = resolve(root, command);
+    return isExecutableFile(path, platform) ? path : void 0;
+  }
+  const exts = platform === "win32" ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    for (const ext of exts) {
+      const candidate = join(dir, command + ext);
+      if (isExecutableFile(candidate, platform)) return candidate;
+    }
+  }
+  return void 0;
+}
+function checkMcpCommand(cwd, env = process.env, platform = process.platform) {
+  const root = findGitDirs(cwd ?? process.cwd())?.repoRoot;
+  if (root === void 0) return [];
+  const path = join(root, ".mcp.json");
+  if (!existsSync(path)) return [];
+  let entry;
+  try {
+    entry = JSON.parse(readFileSync(path, "utf8")).mcpServers?.[SERVER];
+  } catch {
+    return [{ name: NAME, status: "warn", detail: ".mcp.json is not valid JSON, so the agent starts none of its servers", fix: "Fix the JSON syntax in .mcp.json." }];
+  }
+  const command = entry?.command;
+  if (typeof command !== "string") return [];
+  const shown = sanitizeTerminal(command);
+  const resolved = resolveCommand(expand(command, env), root, env, platform);
+  if (resolved === void 0) {
+    return [{ name: NAME, status: "warn", detail: `the "outerlayer" server runs \`${shown}\`, which is not on PATH here, so the agent has no OuterLayer tools`, fix: NPX_FIX }];
+  }
+  return [{ name: NAME, status: "pass", detail: `the "outerlayer" server runs ${sanitizeTerminal(resolved)}` }];
+}
+
+// src/doctor.ts
 var LAPTOP_CHECKS_NOT_APPLICABLE = {
   name: "Laptop checks",
   status: "skipped",
@@ -123,6 +175,7 @@ function runDoctor(env = {}) {
   const now = env.now ?? Date.now;
   const laptop = env.runnerHost !== true;
   const transcripts = laptop ? scanTranscripts(home) : void 0;
+  const starter = laptop ? checkStarterFiles(env.cwd) : void 0;
   return [
     ...laptop ? [checkClaudeDir(home), checkTranscripts(transcripts, now), ...checkHooks(home, env.cwd, transcripts, now)] : [LAPTOP_CHECKS_NOT_APPLICABLE],
     ...checkDeadHooksState(env.cwd),
@@ -135,6 +188,8 @@ function runDoctor(env = {}) {
     checkSettingsValid(home, env.cwd),
     ...laptop ? checkStatusline(home, now, env.cwd) : [],
     ...checkInstalls(env),
+    ...starter?.checks ?? [],
+    ...starter !== void 0 && !starter.mcpOutdated ? checkMcpCommand(env.cwd, env.processEnv) : [],
     ...checkContextSource(home, env.cwd),
     ...checkInstalledCli(home, env.cwd ?? process.cwd())
   ];
@@ -462,7 +517,9 @@ function checkDeadHooksState(cwd) {
 function checkSpoolWritable(home) {
   const dir = spoolDir(home);
   try {
-    if (!existsSync(dir)) return { name: "Spool writable", status: "warn", detail: "spool not created yet", fix: "Run `outerlayer init` (creates the spool on first hook)." };
+    if (!existsSync(dir)) {
+      return { name: "Spool writable", status: "warn", detail: "spool not created yet", fix: "The first hook run creates it: start a Claude Code session in the repository." };
+    }
     accessSync(dir, constants.W_OK);
     return { name: "Spool writable", status: "pass", detail: dir };
   } catch {
@@ -561,10 +618,25 @@ function checkSettingsValid(home, cwd) {
   }
   return { name: "Settings JSON valid", status: "pass", detail: "all settings files parse" };
 }
+function distinctInstalls(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const path of paths) {
+    let real = path;
+    try {
+      real = realpathSync(path);
+    } catch {
+    }
+    if (seen.has(real)) continue;
+    seen.add(real);
+    out.push(path);
+  }
+  return out;
+}
 function checkInstalls(env) {
   let installs;
   try {
-    installs = (env.claudeInstalls ?? defaultClaudeInstalls)();
+    installs = distinctInstalls((env.claudeInstalls ?? defaultClaudeInstalls)());
   } catch {
     return [];
   }
@@ -708,7 +780,14 @@ async function githubAppChecks(options = {}) {
     return [{ name: "GitHub App", status: "warn", detail: "the gateway's answer listed no repositories", fix: "Update the outerlayer CLI and the gateway to the same release." }];
   }
   if (data.length === 0) {
-    return [{ name: "GitHub App", status: "pass", detail: "the factory has no connected repositories" }];
+    return [
+      {
+        name: "GitHub App",
+        status: "warn",
+        detail: "the factory has no connected repositories, so it cannot build or check any work",
+        fix: `On the factory's Work page, choose Connect GitHub repository, then Link repository: ${CONNECT_REPOSITORY_DOCS}`
+      }
+    ];
   }
   return data.map(repositoryAccessCheck);
 }
@@ -1004,7 +1083,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-MKBX2ZQD.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-N3C6DFQA.js');
   const configPath = defaultRunnerConfigPath();
   const checks = runDoctor({ runnerHost: hasRunnerBlock(configPath) });
   const credential = await credentialChecks();
@@ -1016,7 +1095,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-4FFXTQJ2.js');
+    const { runnerHostChecks } = await import('./doctor-H7REBSLQ.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1048,10 +1127,10 @@ async function gatherDoctorChecks() {
       }
     })();
     const service = await (async () => {
-      const { existsSync: existsSync2 } = await import('fs');
-      if (process.platform !== "linux" || !existsSync2("/run/systemd/system")) return void 0;
+      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-VXXI7UR6.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-HDBIPHTX.js');
       const { dirname: dirname2 } = await import('path');
       return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
     })();

package/dist/{chunk-325272HM.js → chunk-J5M7BSJQ.js}

@@ -22273,9 +22273,14 @@ var ArtifactTombstoneRecordSchema = external_exports.looseObject({
 });
 external_exports.union([ArtifactSpoolRecordSchema, ArtifactTombstoneRecordSchema]);
 var EMITTED_RESULTS = ["pass", "fail"];
-var RESERVED_EMIT_NAMES = ["criteria"];
-var EmittedNameSchema = external_exports.string().regex(/^[a-z][a-z0-9._-]{0,63}$/).refine((name) => !RESERVED_EMIT_NAMES.includes(name), {
-  message: "is reserved: `outerlayer emit criteria` records a work item's acceptance criteria"
+var RESERVED_EMIT_NAMES = ["artifact", "criteria", "finding", "findings"];
+var EmittedNameSchema = external_exports.string().regex(/^[a-z][a-z0-9._-]{0,63}$/).superRefine((name, ctx) => {
+  if (RESERVED_EMIT_NAMES.includes(name)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `is reserved: \`outerlayer emit ${name}\` is a subcommand, so a check cannot be recorded under that name`
+    });
+  }
 });
 var EMITTED_RESULT_MAX_LINK_LENGTH = 500;
 var EMITTED_RESULT_MAX_BODY_LENGTH = 2e3;
@@ -22292,6 +22297,7 @@ var CriterionSchema = external_exports.object({
   proof: external_exports.enum(ARTIFACT_KINDS).nullable()
 }).strict();
 var CriteriaArraySchema = external_exports.array(CriterionSchema).min(1).max(CRITERIA_MAX);
+var DraftedSchema = external_exports.boolean().optional();
 function refuseDuplicateIds(criteria, ctx) {
   const seen = /* @__PURE__ */ new Set();
   criteria.forEach((criterion, index) => {
@@ -22305,9 +22311,10 @@ function refuseDuplicateIds(criteria, ctx) {
     seen.add(criterion.id);
   });
 }
-var CriteriaListSchema = external_exports.object({ criteria: CriteriaArraySchema }).strict().superRefine((list, ctx) => refuseDuplicateIds(list.criteria, ctx));
+var CriteriaListSchema = external_exports.object({ criteria: CriteriaArraySchema, drafted: DraftedSchema }).strict().superRefine((list, ctx) => refuseDuplicateIds(list.criteria, ctx));
 external_exports.object({
   criteria: CriteriaArraySchema,
+  drafted: DraftedSchema,
   item: external_exports.object({ number: external_exports.number().int().positive() }).optional(),
   sessionId: external_exports.string().optional()
 }).superRefine((request, ctx) => refuseDuplicateIds(request.criteria, ctx));

package/dist/{chunk-NPXQXYVA.js → chunk-JJEGKEFV.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { autoConnect } from './chunk-GATMPAMK.js';
+import { autoConnect } from './chunk-NPQWKGUA.js';
 import { detectActiveSession } from './chunk-IP7BIBXJ.js';
-import { resolveRepoIdentity } from './chunk-3ZPYPFNM.js';
+import { resolveRepoIdentity } from './chunk-JXYVA45C.js';
+import { C } from './chunk-YRYMNBGQ.js';
 import { parseWorkItemEnv } from './chunk-GQD22KKN.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
 import { defaultFetch } from './chunk-YO4PSLVB.js';
@@ -12,9 +13,6 @@ import { homeFromEnv } from './chunk-VNVZDWO3.js';
 createRequire(import.meta.url);
 
 // src/work-pr-cmd.ts
-var GREEN = "\x1B[32m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
 var WorkPrCommandError = class extends Error {
 };
 function resolveCredentials(opts) {
@@ -43,7 +41,7 @@ function sessionNotOnItemMessage(error, sessionId) {
 }
 function itemLabel(data) {
   if (data.workItemNumber == null) return data.workItemId;
-  return data.workItemTitle ? `item ${data.workItemNumber} ${DIM}\xB7${RESET} ${data.workItemTitle}` : `item ${data.workItemNumber}`;
+  return data.workItemTitle ? `item ${data.workItemNumber} ${C.dim}\xB7${C.reset} ${data.workItemTitle}` : `item ${data.workItemNumber}`;
 }
 async function runWorkPrWithdraw(opts, ctx) {
   const itemNumber = parseTrackerNumber(opts.item);
@@ -88,7 +86,7 @@ async function runWorkPrWithdraw(opts, ctx) {
     throw new WorkPrCommandError(json.error?.message ?? `request failed (${response.status})`);
   }
   const data = json.data;
-  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} withdrawn ${DIM}\xB7${RESET} ${data.repository}#${data.prNumber} ${DIM}from${RESET} item ${itemNumber}`;
+  const output = opts.json ? JSON.stringify(data) : `${C.green}\u2713${C.reset} withdrawn ${C.dim}\xB7${C.reset} ${data.repository}#${data.prNumber} ${C.dim}from${C.reset} item ${itemNumber}`;
   if (!opts.quiet) process.stdout.write(output + "\n");
   return { data, output };
 }
@@ -170,7 +168,7 @@ async function runWorkPr(opts) {
   }
   const data = json.data;
   const verb = data.created ? "declared" : "already declared";
-  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} ${verb} ${DIM}\xB7${RESET} ${data.repository}#${data.prNumber} ${DIM}\u2192${RESET} ${itemLabel(data)}`;
+  const output = opts.json ? JSON.stringify(data) : `${C.green}\u2713${C.reset} ${verb} ${C.dim}\xB7${C.reset} ${data.repository}#${data.prNumber} ${C.dim}\u2192${C.reset} ${itemLabel(data)}`;
   if (!opts.quiet) process.stdout.write(output + "\n");
   return { data, output };
 }

package/dist/{chunk-3ZPYPFNM.js → chunk-JXYVA45C.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { EVENT_TYPES, isHumanUserTurn, parseAgentSession, SCHEMA_VERSION, SPEED_MAX_LENGTH, inputBandOf, BUCKET_MODEL_MAX_LENGTH } from './chunk-325272HM.js';
+import { EVENT_TYPES, isHumanUserTurn, parseAgentSession, SCHEMA_VERSION, SPEED_MAX_LENGTH, inputBandOf, BUCKET_MODEL_MAX_LENGTH } from './chunk-J5M7BSJQ.js';
 import { createHash } from 'crypto';
 import { readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, renameSync, unlinkSync, writeFileSync, stat as stat$1, unwatchFile, watchFile, watch as watch$1 } from 'fs';
 import { type, homedir } from 'os';

package/dist/{chunk-IBB4D4KE.js → chunk-JYIEHQIF.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { MIN_ENGINE_MAJOR } from './chunk-SKHN72JO.js';
+import { MIN_ENGINE_MAJOR } from './chunk-RBKIH5ST.js';
 import { firecrackerArch, MICROVM_ARCHES, guestAssetsPinned } from './chunk-CX22S5BA.js';
 import { spawnSync } from 'child_process';
 import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';

package/dist/{chunk-5TGQHOUX.js → chunk-KFRM23WD.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { LiveUploader } from './chunk-27Y7AX2O.js';
-import { CaptureDaemon } from './chunk-3ZPYPFNM.js';
+import { LiveUploader } from './chunk-MSASO5O4.js';
+import { CaptureDaemon } from './chunk-JXYVA45C.js';
 import { parseWorkItemEnv } from './chunk-GQD22KKN.js';
-import { spoolDir } from './chunk-YEQL54G5.js';
+import { spoolDir } from './chunk-PQUM37BK.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { mkdirSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';

package/dist/{chunk-GGMRZPEA.js → chunk-KMDLFI4P.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { RecipeError } from './chunk-QOZKPLVJ.js';
-import { trackImageBuild, isOutOfMemory, ensureBuilder } from './chunk-QEESCZ26.js';
+import { trackImageBuild, isOutOfMemory, ensureBuilder } from './chunk-4NPZVMJU.js';
 import { spawn } from 'child_process';
 import { existsSync, mkdirSync, createWriteStream, rmSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';

package/dist/{chunk-G5IEVZGI.js → chunk-LCEXHCHD.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-AHZQBGD2.js';
+import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-2M63GG56.js';
 import { readFileSync, existsSync, writeFileSync, mkdirSync, utimesSync, statSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 

package/dist/{chunk-27Y7AX2O.js → chunk-MSASO5O4.js}

@@ -4,17 +4,17 @@ import { LaunchFilter } from './chunk-HHJDN6AU.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
 import { hookExecSpoolPath } from './chunk-F7CU5ABH.js';
 import { applyReportedCost } from './chunk-BKO6JEZI.js';
-import { migrateLegacyArtifactSidecars, planArtifactUpload, artifactsStatePath, sanitizeTerminal, acquireArtifactSpoolLock, artifactBlobsDir, resolveArtifactTurnIndex, isArtifactTombstoned, ARTIFACT_RETRY_MAX_AGE_MS, writeArtifactSpoolState, reclaimUnneededArtifactBlobs, neededArtifactShas } from './chunk-JOXYKGUV.js';
-import { setCustomScrubbers, setLocalIdentity, tailTranscript, enrichSessionRepo, scanAll, setRepoRoot, resolveRepoIdentity, sessionIdFromPath, scrubDeep, SOURCE_ADAPTERS } from './chunk-3ZPYPFNM.js';
+import { migrateLegacyArtifactSidecars, planArtifactUpload, artifactsStatePath, sanitizeTerminal, acquireArtifactSpoolLock, artifactBlobsDir, resolveArtifactTurnIndex, isArtifactTombstoned, ARTIFACT_RETRY_MAX_AGE_MS, writeArtifactSpoolState, reclaimUnneededArtifactBlobs, neededArtifactShas } from './chunk-WUYTWNMA.js';
+import { setCustomScrubbers, setLocalIdentity, tailTranscript, enrichSessionRepo, scanAll, setRepoRoot, resolveRepoIdentity, sessionIdFromPath, scrubDeep, SOURCE_ADAPTERS } from './chunk-JXYVA45C.js';
 import { C } from './chunk-YRYMNBGQ.js';
 import { readLaunchSpoolState, launchStatusIsDecisive, launchedItemsBySession, launchesPath } from './chunk-GQD22KKN.js';
 import { readLatestProvenanceForSession, readContextProvenance } from './chunk-ZJSNLVCE.js';
 import { defaultFetch } from './chunk-YO4PSLVB.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-PLMTLGYH.js';
-import { CAPTURE_TIERS, inferArtifactKind, bannedPathsForTier, downconvertSession, isHumanUserTurn, turnCountBound, EVENT_TYPES } from './chunk-325272HM.js';
+import { CAPTURE_TIERS, inferArtifactKind, bannedPathsForTier, downconvertSession, isHumanUserTurn, turnCountBound, EVENT_TYPES } from './chunk-J5M7BSJQ.js';
 import { readCloudConfig, cloudConfigPath, writeCloudConfig } from './chunk-EABW6AJQ.js';
 import { signerFor, signRunnerRequest } from './chunk-V7NIVOFD.js';
-import { writeSyncStatus, spoolDir } from './chunk-YEQL54G5.js';
+import { writeSyncStatus, spoolDir } from './chunk-PQUM37BK.js';
 import { removeJournalHooks } from './chunk-XCCLFVXM.js';
 import { readRepoConnection, findGitDirs } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
@@ -928,6 +928,21 @@ var NEVER_REACHED_SERVER_ERROR_CODES = /* @__PURE__ */ new Set([
   "payload_too_large",
   "unreadable_test_results"
 ]);
+async function readUploadedIdentity(response) {
+  let data;
+  try {
+    data = (await response.json()).data;
+  } catch {
+  }
+  return {
+    id: typeof data?.id === "string" ? data.id : null,
+    url: typeof data?.url === "string" ? data.url : null
+  };
+}
+function uploadedArtifactLine(artifact) {
+  const where = artifact.url !== null ? sanitizeTerminal(artifact.url) : artifact.id !== null ? `id ${sanitizeTerminal(artifact.id)} ${C.dim}(the gateway returned no link)${C.reset}` : `${C.dim}(the gateway returned no link)${C.reset}`;
+  return `  ${C.green}\u2191${C.reset} ${sanitizeTerminal(artifact.filename)} ${C.dim}\xB7${C.reset} ${sanitizeTerminal(artifact.caption)} ${C.dim}\xB7${C.reset} ${where}`;
+}
 function splitPayload(payload) {
   const mid = Math.ceil(payload.sessions.length / 2);
   const first = payload.sessions.slice(0, mid);
@@ -1553,10 +1568,12 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
     }
     let artifactsUploaded;
     let artifactsHeld;
+    let uploadedArtifacts;
     const artifactLock = combinedRecords.length > 0 || artifactPlan.held.length > 0 ? await acquireArtifactSpoolLock(home, { waitMs: opts.artifactLockWaitMs }) : void 0;
     if (artifactLock !== void 0 && !artifactLock.ok) {
       artifactsUploaded = 0;
       artifactsHeld = combinedRecords.length + artifactPlan.held.length;
+      uploadedArtifacts = [];
       if (!opts.quiet) {
         process.stderr.write(
           `${C.yellow}!${C.reset} artifacts not attempted: ${artifactLock.reason} \u2014 ${artifactsHeld} record(s) stay queued for the next sync
@@ -1575,6 +1592,7 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
       let uploadedCount = 0;
       let heldCount = livePlan.held.length;
       let droppedCount = 0;
+      const uploadedThisRun = [];
       const warn = (message) => {
         if (!opts.quiet) process.stderr.write(`${C.yellow}!${C.reset} ${message}
 `);
@@ -1651,6 +1669,7 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
         let status;
         let errorCode = "";
         let serverMessage = "";
+        let accepted;
         try {
           const response = await fetchImpl(artifactEndpoint, {
             method: "POST",
@@ -1670,19 +1689,31 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
               if (typeof body.error?.message === "string") serverMessage = body.error.message;
             } catch {
             }
+          } else {
+            accepted = response;
           }
         } catch (err) {
           failure = String(err);
         }
-        if (!failure) {
+        if (accepted !== void 0) {
+          const identity = await readUploadedIdentity(accepted);
           state.set(record.artifactId, {
             state: "uploaded",
             attempts: (existing?.attempts ?? 0) + 1,
             firstSeen: firstSeenIso,
             sha256: record.sha256,
-            reachedServer: true
+            reachedServer: true,
+            ...identity.id !== null ? { serverId: identity.id } : {},
+            ...identity.url !== null ? { url: identity.url } : {}
           });
           uploadedCount += 1;
+          uploadedThisRun.push({
+            artifactId: record.artifactId,
+            filename: record.filename,
+            caption: record.caption,
+            id: identity.id,
+            url: identity.url
+          });
           continue;
         }
         if (status === 401) {
@@ -1739,11 +1770,15 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
         artifactsUploaded = uploadedCount;
         artifactsHeld = heldCount;
         artifactsDropped = droppedCount;
+        uploadedArtifacts = uploadedThisRun;
         if (!opts.quiet) {
           process.stderr.write(
             `${C.dim}artifacts${C.reset} ${uploadedCount} uploaded \xB7 ${heldCount} held \xB7 ${droppedCount} dropped
 `
           );
+          if (!opts.json) {
+            for (const uploaded of uploadedThisRun) process.stdout.write(uploadedArtifactLine(uploaded) + "\n");
+          }
         }
       }
       const persisted = writeArtifactSpoolState(state, home);
@@ -1776,6 +1811,7 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
         );
       }
     }
+    const artifactReport = artifactsUploaded !== void 0 ? { artifactsUploaded, artifactsHeld, uploadedArtifacts } : {};
     let output;
     if (opts.json) {
       output = JSON.stringify({
@@ -1787,7 +1823,7 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
         artifactsDropped,
         tier,
         url,
-        ...artifactsUploaded !== void 0 ? { artifactsUploaded, artifactsHeld } : {}
+        ...artifactReport
       });
     } else {
       const lines = [];
@@ -1826,7 +1862,7 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
       url,
       dryRun: false,
       watermarkMs,
-      ...artifactsUploaded !== void 0 ? { artifactsUploaded, artifactsHeld } : {},
+      ...artifactReport,
       output
     };
   }

package/dist/chunk-MTF3PHVZ.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mcpTargetPath, INIT_STDIO_ENTRY, INIT_DOCS_ENTRY, DOCS_MCP_SERVER_NAME } from './chunk-XCK2YAY5.js';
+import { POLICY_CONTENT, VALIDATOR_FILES, VALIDATORS_DIR, POLICY_PATH } from './chunk-FOJGZYFC.js';
+import { pinExists, readContextManifest } from './chunk-LCEXHCHD.js';
+import { resolvePackRoot, loadTemplateFiles, skillDir } from './chunk-ZA5CHAFY.js';
+import { findGitDirs } from './chunk-BJ3KTMDH.js';
+import { createHash } from 'crypto';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var SHIPPED_MANIFEST = "shipped.json";
+function currentStarterFiles(packRoot = resolvePackRoot(), policy = POLICY_CONTENT) {
+  const templates = loadTemplateFiles(packRoot).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))
+  }));
+  const validators = VALIDATOR_FILES.map(({ name }) => {
+    const source = join(packRoot, "validators", name);
+    return { path: `${VALIDATORS_DIR}/${name}`, content: readFileSync(source, "utf8"), source };
+  });
+  return [...templates, ...validators, { path: POLICY_PATH, content: policy }];
+}
+function contentHash(content) {
+  return createHash("sha256").update(content.replace(/\r\n/g, "\n")).digest("hex");
+}
+function readShippedManifest(packRoot = resolvePackRoot()) {
+  const path = join(packRoot, SHIPPED_MANIFEST);
+  if (!existsSync(path)) return { ok: false, problem: "missing" };
+  try {
+    const doc = JSON.parse(readFileSync(path, "utf8"));
+    if (doc.schemaVersion !== 1 || doc.files === null || typeof doc.files !== "object" || Array.isArray(doc.files)) {
+      return { ok: false, problem: "unreadable" };
+    }
+    const files = /* @__PURE__ */ new Map();
+    for (const [file, hashes] of Object.entries(doc.files)) {
+      if (!Array.isArray(hashes) || !hashes.every((h) => typeof h === "string" && /^[0-9a-f]{64}$/.test(h))) {
+        return { ok: false, problem: "unreadable" };
+      }
+      files.set(file, new Set(hashes));
+    }
+    return { ok: true, files };
+  } catch {
+    return { ok: false, problem: "unreadable" };
+  }
+}
+function mcpItemsInit() {
+  return [
+    // Through 0.12.0 `init` wrote a command that needs a global install on every teammate's machine.
+    { name: "outerlayer", current: INIT_STDIO_ENTRY, shipped: [{ type: "stdio", command: "outerlayer", args: ["mcp", "serve"] }] },
+    { name: DOCS_MCP_SERVER_NAME, current: INIT_DOCS_ENTRY, shipped: [] }
+  ];
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function fileState(root, file, manifest) {
+  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";
+  return "edited";
+}
+function mcpItems(root) {
+  const path = mcpTargetPath(root);
+  let servers;
+  let unreadable = false;
+  if (existsSync(join(root, path))) {
+    try {
+      const doc = JSON.parse(readFileSync(join(root, path), "utf8"));
+      const value = doc.mcpServers;
+      if (value !== void 0 && (value === null || typeof value !== "object" || Array.isArray(value))) unreadable = true;
+      else servers = value ?? {};
+    } catch {
+      unreadable = true;
+    }
+  }
+  return mcpItemsInit().map((item) => {
+    const base = { kind: "mcp", path, server: item.name, entry: item.current };
+    if (unreadable) return { ...base, state: "unreadable" };
+    if (servers === void 0 || !(item.name in servers)) return { ...base, state: "missing" };
+    const have = canonical(servers[item.name]);
+    if (have === canonical(item.current)) return { ...base, state: "current" };
+    if (item.shipped.some((entry) => canonical(entry) === have)) return { ...base, state: "outdated" };
+    return { ...base, state: "edited" };
+  });
+}
+function inspectStarterFiles(root, opts = {}) {
+  const packRoot = opts.packRoot ?? resolvePackRoot();
+  const manifest = readShippedManifest(packRoot);
+  const files = currentStarterFiles(packRoot).map(
+    (file) => ({ kind: "file", path: file.path, state: fileState(root, file, manifest), file })
+  );
+  return { items: [...files, ...mcpItems(root)], manifest: manifest.ok ? "ok" : manifest.problem };
+}
+function itemLabel(item) {
+  return item.kind === "file" ? item.path : `${item.path} "${item.server}" server`;
+}
+function contextIsGoverned(root, gitCommonDir) {
+  return pinExists(root) || readContextManifest(gitCommonDir) !== void 0;
+}
+var NAME = "Starter files";
+var UPDATE = "outerlayer init --update";
+function shownPaths(items, all) {
+  const shown = [];
+  const whole = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const skill = item.kind === "file" ? item.file.skill : void 0;
+    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)}/`);
+        whole.add(skill);
+        continue;
+      }
+    }
+    shown.push(itemLabel(item));
+  }
+  return shown;
+}
+function checkStarterFiles(cwd, opts = {}) {
+  const none = { checks: [], mcpOutdated: false };
+  const dirs = findGitDirs(cwd ?? process.cwd());
+  if (dirs === void 0 || contextIsGoverned(dirs.repoRoot, dirs.gitCommonDir)) return none;
+  const report = inspectStarterFiles(dirs.repoRoot, opts);
+  if (report.items.every((i) => i.kind === "mcp" || i.state === "missing")) return none;
+  const by = (state) => report.items.filter((i) => i.state === state);
+  const current = by("current");
+  const outdated = by("outdated");
+  const missing = by("missing");
+  const edited = by("edited");
+  const unreadable = by("unreadable");
+  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 (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`);
+  if (report.manifest !== "ok") {
+    parts.push(`this CLI's record of earlier versions is ${report.manifest}, so an outdated file cannot be told from an edited one`);
+  }
+  const mcpOutdated = outdated.some((i) => i.kind === "mcp" && i.server === "outerlayer");
+  const actionable = outdated.length + missing.length > 0;
+  const compare = edited.length > 0 ? ` Compare an edited file with this CLI's version: \`${UPDATE} --dry-run\`.` : "";
+  if (!actionable && report.manifest === "ok") {
+    return { checks: [{ name: NAME, status: "pass", detail: parts.join("; ") + (compare === "" ? "" : `.${compare}`) }], mcpOutdated };
+  }
+  const fix = actionable ? `Run \`${UPDATE}\` to update the outdated files and write the missing ones. It never changes a file you edited.${compare}` : "Reinstall the CLI: `npm install -g @outerlayer/cli`, or run it with `npx -y @outerlayer/cli`.";
+  return { checks: [{ name: NAME, status: "warn", detail: parts.join("; "), fix }], mcpOutdated };
+}
+
+export { canonical, checkStarterFiles, contextIsGoverned, inspectStarterFiles };