@outerlayer/cli 0.34.0-next.20261028010245 → 0.34.0-next.20261028122415

package/dist/{work-pr-cmd-DYSYOP74.js → work-pr-cmd-XETSFFM2.js}

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { WorkPrCommandError, itemLabel, runWorkPr } from './chunk-SWCOWG2C.js';
+export { WorkPrCommandError, itemLabel, runWorkPr } from './chunk-3EU4MWCE.js';
 import './chunk-IP7BIBXJ.js';
-import './chunk-BTDBDTUY.js';
-import './chunk-4J5GRWAY.js';
+import './chunk-GJHOU5V3.js';
+import './chunk-N6V4ZHI7.js';
 import './chunk-NWHU5G6R.js';
 import './chunk-G2JWZDFA.js';
 import './chunk-ANPNT6PM.js';
 import './chunk-IXPH4EXK.js';
 import './chunk-LYCJQOO2.js';
-import './chunk-PAGB3DCI.js';
+import './chunk-IZKUPAXF.js';
 import './chunk-PJDQPF5N.js';
-import './chunk-VKYU4HHW.js';
+import './chunk-VJQQVTCS.js';
 import './chunk-BJ3KTMDH.js';
 import './chunk-OVNF4LLC.js';
-import './chunk-A6PJSNP6.js';
+import './chunk-A2KLVZBU.js';
 import './chunk-5BHIBJDA.js';
 import './chunk-CDDED64E.js';
 import './chunk-RA3O54FC.js';
@@ -24,8 +24,8 @@ import './chunk-CRB3POP4.js';
 import './chunk-XFJ7YOPD.js';
 import './chunk-DINRXUQA.js';
 import './chunk-VNVZDWO3.js';
-import './chunk-AJTGTSNA.js';
-import './chunk-L2OARQKP.js';
+import './chunk-2CW2QMSG.js';
+import './chunk-4N7BQBO4.js';
 import './chunk-MESOOLF4.js';
 import './chunk-Z5GEFMRW.js';
 

package/dist/{work-proofs-cmd-DS2VX4E4.js → work-proofs-cmd-RYQ7Y6KO.js}

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { classifyProofs, classifyProofsAt, otherPullRequestHeads, resolveProofsItem, runWorkProofs, runWorkProofsCommand } from './chunk-NCKH3KCM.js';
-import './chunk-6CK2OC4Q.js';
-import './chunk-GJYGOFF3.js';
+export { classifyProofs, classifyProofsAt, otherPullRequestHeads, resolveProofsItem, runWorkProofs, runWorkProofsCommand } from './chunk-UKEIJKCH.js';
+import './chunk-BEGMZKMG.js';
+import './chunk-72N7GOLM.js';
 import './chunk-IP7BIBXJ.js';
-import './chunk-BTDBDTUY.js';
-import './chunk-4J5GRWAY.js';
+import './chunk-GJHOU5V3.js';
+import './chunk-N6V4ZHI7.js';
 import './chunk-NWHU5G6R.js';
 import './chunk-G2JWZDFA.js';
 import './chunk-ANPNT6PM.js';
 import './chunk-IXPH4EXK.js';
 import './chunk-LYCJQOO2.js';
-import './chunk-PAGB3DCI.js';
+import './chunk-IZKUPAXF.js';
 import './chunk-PJDQPF5N.js';
-import './chunk-VKYU4HHW.js';
+import './chunk-VJQQVTCS.js';
 import './chunk-BJ3KTMDH.js';
 import './chunk-OVNF4LLC.js';
-import './chunk-A6PJSNP6.js';
+import './chunk-A2KLVZBU.js';
 import './chunk-5BHIBJDA.js';
 import './chunk-CDDED64E.js';
 import './chunk-RA3O54FC.js';
@@ -27,8 +27,8 @@ import './chunk-YQR6E6OV.js';
 import './chunk-XFJ7YOPD.js';
 import './chunk-DINRXUQA.js';
 import './chunk-VNVZDWO3.js';
-import './chunk-AJTGTSNA.js';
-import './chunk-L2OARQKP.js';
+import './chunk-2CW2QMSG.js';
+import './chunk-4N7BQBO4.js';
 import './chunk-MESOOLF4.js';
 import './chunk-Z5GEFMRW.js';
 

package/dist/work-proofs-record-IC3RWDDQ.js

@@ -0,0 +1,509 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { resolveProofsItem, ownPullRequest, proofsCommentId, otherPullRequestHeads, classifyProofsAt, kindProblem, proofsCommentBody, runWorkProofs } from './chunk-UKEIJKCH.js';
+import { runWorkComment } from './chunk-H5YUWLIY.js';
+import { runnerMatcher } from './chunk-BEGMZKMG.js';
+import { runEmitDemo } from './chunk-6CQXOTNL.js';
+import { readNewestDemo } from './chunk-ER6KQCVJ.js';
+import { runEmitArtifact } from './chunk-AXKSVN4U.js';
+import { runSync } from './chunk-C2E4PWEN.js';
+import './chunk-ZIXLG6EQ.js';
+import './chunk-ESVW4MJY.js';
+import './chunk-TBT347UY.js';
+import './chunk-2PGI6RDE.js';
+import './chunk-D3CT6XQ4.js';
+import { WorkCommandError, resolveCredentials, getJson } from './chunk-72N7GOLM.js';
+import './chunk-IP7BIBXJ.js';
+import './chunk-GJHOU5V3.js';
+import './chunk-N6V4ZHI7.js';
+import './chunk-NWHU5G6R.js';
+import './chunk-G2JWZDFA.js';
+import './chunk-ANPNT6PM.js';
+import './chunk-IXPH4EXK.js';
+import './chunk-LYCJQOO2.js';
+import { defaultFetch } from './chunk-IZKUPAXF.js';
+import './chunk-PJDQPF5N.js';
+import './chunk-VJQQVTCS.js';
+import './chunk-D7MWJM2G.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-2O5KA67H.js';
+import './chunk-BKO6JEZI.js';
+import './chunk-HCVLP7XA.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-OVNF4LLC.js';
+import { resolveRepoIdentity } from './chunk-A2KLVZBU.js';
+import './chunk-5BHIBJDA.js';
+import './chunk-CDDED64E.js';
+import './chunk-RA3O54FC.js';
+import './chunk-T2Q7ISPE.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-CRB3POP4.js';
+import './chunk-URIZRCRY.js';
+import './chunk-YQR6E6OV.js';
+import './chunk-TUSYOL2O.js';
+import { parseProofsConfig } from './chunk-XFJ7YOPD.js';
+import { ARTIFACT_MAX_CAPTION_LENGTH } from './chunk-DINRXUQA.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-2CW2QMSG.js';
+import './chunk-4N7BQBO4.js';
+import './chunk-MESOOLF4.js';
+import './chunk-Z5GEFMRW.js';
+import { spawnSync, spawn } from 'child_process';
+import { mkdtempSync, rmSync, openSync, closeSync, readdirSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var runShell = (command, params) => {
+  const logPath = join(params.logDir, `${params.groups.length}-${Date.now()}.log`);
+  const fd = openSync(logPath, "w");
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", command], { cwd: params.cwd, env: params.env, detached: true, stdio: ["ignore", fd, fd] });
+    closeSync(fd);
+    if (child.pid !== void 0) params.groups.push(child.pid);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+    }, params.timeoutMs);
+    const finish = (status) => {
+      clearTimeout(timer);
+      let text = "";
+      try {
+        text = readFileSync(logPath, "utf8");
+      } catch {
+      }
+      resolve({ status, timedOut, tail: text.trimEnd().split("\n").slice(-8).join("\n") });
+    };
+    child.on("error", () => finish(null));
+    child.on("exit", (status) => finish(status));
+  });
+};
+var ID_CHARACTER = "A-Za-z0-9_-";
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function containsId(text, id) {
+  return new RegExp(`(?<![${ID_CHARACTER}])${escapeRegExp(id)}(?![${ID_CHARACTER}])`).test(text);
+}
+function planRuns(files, runners) {
+  const plan = /* @__PURE__ */ new Map();
+  const runnerFor = runnerMatcher(runners);
+  for (const file of [...files].sort()) {
+    const index = runnerFor(file);
+    if (index === void 0) continue;
+    plan.set(index, [...plan.get(index) ?? [], file]);
+  }
+  return new Map([...plan].sort(([a], [b]) => a - b));
+}
+function shellQuote(text) {
+  const path = text.startsWith("-") ? `./${text}` : text;
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(path)) return path;
+  return `'${path.replace(/'/g, `'\\''`)}'`;
+}
+function fillFiles(command, files) {
+  const quoted = files.map(shellQuote).join(" ");
+  return command.split("{files}").join(quoted);
+}
+function proofFileCriterion(name, declared) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return void 0;
+  const stem = name.slice(0, dot);
+  return declared.has(stem) ? stem : void 0;
+}
+function git(root, args, accepted = [0]) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 268435456 });
+  if (result.error !== void 0 || !accepted.includes(result.status)) {
+    throw new WorkCommandError(`git ${args[0]} failed (${result.error?.message ?? `exit status ${result.status}`}), so the tests that name a proof cannot be found.`);
+  }
+  return result.stdout;
+}
+function discoverTestFiles(root, ids, runners) {
+  const found = /* @__PURE__ */ new Map();
+  if (ids.length === 0 || runners.length === 0) return found;
+  const grep = git(root, ["grep", "-z", "-l", "-I", "-F", ...ids.flatMap((id) => ["-e", id]), "HEAD", "--"], [0, 1]);
+  const runnerFor = runnerMatcher(runners);
+  const paths = grep.split("\0").filter((entry) => entry !== "").map((entry) => entry.slice("HEAD:".length)).filter((path) => runnerFor(path) !== void 0).sort();
+  for (const path of paths) {
+    const shown = git(root, ["show", `HEAD:${path}`]);
+    for (const id of ids) {
+      if (containsId(shown, id)) found.set(id, [...found.get(id) ?? [], path]);
+    }
+  }
+  return found;
+}
+
+// src/work-proofs-record.ts
+var CONFIG_FILE = ".outerlayer-proofs.yaml";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEMO_PROOFS = /* @__PURE__ */ new Set(["screenshot", "video"]);
+var NO_TEST = "no test at HEAD names this criterion";
+function changedTrackedFiles(root) {
+  const status = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=no"], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  if (status.error !== void 0 || status.status !== 0) {
+    throw new WorkCommandError(`git cannot say whether the working copy matches HEAD (${status.error?.message ?? `exit status ${status.status}`}), so nothing was recorded.`);
+  }
+  const fields = status.stdout.split("\0").filter((field) => field !== "");
+  const paths = [];
+  for (let i = 0; i < fields.length; i += 1) {
+    const field = fields[i];
+    paths.push(field.slice(3));
+    if (/[RC]/.test(field.slice(0, 2))) i += 1;
+  }
+  return paths;
+}
+function topLevelFiles(folder) {
+  try {
+    return readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function chapterCriteria(manifestPath) {
+  const ids = /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    for (const chapter of parsed.chapters ?? []) {
+      if (typeof chapter?.criterionId === "string") ids.add(chapter.criterionId);
+    }
+  } catch {
+  }
+  return ids;
+}
+function showAtHead(root, path) {
+  const shown = spawnSync("git", ["show", `HEAD:${path}`], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  return shown.status === 0 ? shown.stdout : void 0;
+}
+function findManifests(folder) {
+  const found = [];
+  let entries = [];
+  try {
+    entries = readdirSync(folder, { withFileTypes: true });
+  } catch {
+  }
+  for (const entry of entries) {
+    const path = join(folder, entry.name);
+    if (entry.isDirectory()) found.push(...findManifests(path));
+    else if (entry.name === "manifest.json" && folder.split("/").pop() === "demo") found.push(path);
+  }
+  return found;
+}
+function unstoredUploads(result, spooled) {
+  if (typeof result !== "object" || result === null) return [];
+  const { artifactsDropped, artifactsHeld, rejected, uploadedArtifacts } = result;
+  if (Array.isArray(uploadedArtifacts)) {
+    const stored = new Set(uploadedArtifacts.map((a) => a?.artifactId));
+    return spooled.filter((id) => !stored.has(id));
+  }
+  const lost = typeof artifactsDropped === "number" && artifactsDropped > 0 || typeof artifactsHeld === "number" && artifactsHeld > 0 || Array.isArray(rejected) && rejected.length > 0;
+  return lost ? "all" : [];
+}
+function shortSha(sha) {
+  return sha.slice(0, 7);
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+async function runWorkProofsRecord(opts) {
+  const env = opts.env ?? process.env;
+  const item = resolveProofsItem({ item: opts.item, env });
+  const cwd = opts.cwd ?? process.cwd();
+  const identity = resolveRepoIdentity(cwd);
+  if (identity.repoRoot === void 0 || identity.commitSha === void 0) {
+    throw new WorkCommandError("this is not a git checkout with a commit. Run this inside the repository, after the tests are committed.");
+  }
+  const { repoRoot: root, commitSha: head } = identity;
+  const changed = changedTrackedFiles(root);
+  if (changed.length > 0) {
+    throw new WorkCommandError(
+      `the working copy differs from HEAD in ${changed.join(", ")}. Only the committed files run, so nothing was recorded. Commit or discard the change, then record again.`
+    );
+  }
+  const fetchImpl = opts.fetchImpl ?? defaultFetch;
+  const creds = resolveCredentials({ ...opts, env });
+  const home = opts.home;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const lines = [];
+  const say = (line) => void lines.push(line);
+  const { data } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
+  const body = data;
+  const own = ownPullRequest(body.pullRequests ?? [], opts.pr, identity.gitRepo);
+  if ("ambiguous" in own) {
+    throw new WorkCommandError(`the item links several open pull requests (${own.ambiguous.map((n) => `#${n}`).join(", ")}). Pass --pr <number> to name this checkout's.`);
+  }
+  const ownPr = own.pr;
+  const postGeneral = async (text, clientCommentId) => {
+    try {
+      await runWorkComment({ ...creds, item, body: text, clientCommentId, cwd, home, env, fetchImpl, quiet: true });
+    } catch (err) {
+      if (!(err instanceof WorkCommandError && err.code === "comment_conflict")) {
+        say(`The comment on the item's thread was not posted: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+      }
+    }
+  };
+  const configText = showAtHead(root, CONFIG_FILE);
+  const parsed = configText === void 0 ? void 0 : parseProofsConfig(configText);
+  if (parsed === void 0 || !parsed.ok) {
+    const problem = parsed === void 0 ? `${CONFIG_FILE} is missing at HEAD. Commit it at the repository root, with the setup, teardown and runners that run the tests.` : `${CONFIG_FILE} cannot be read: ${parsed.problems.join("; ")}`;
+    if (opts.comment) {
+      const text = `No proof was recorded at ${shortSha(head)}. ${problem}`.slice(0, 2e3);
+      await postGeneral(text, proofsCommentId(item, head, [{ id: CONFIG_FILE, proof: "setup file", reason: problem }]));
+    }
+    throw new WorkCommandError(problem);
+  }
+  const config = parsed.value;
+  const heads = /* @__PURE__ */ new Set([head.toLowerCase(), ...otherPullRequestHeads(body.pullRequests ?? [], ownPr, identity.gitRepo)]);
+  const states = classifyProofsAt(body, heads);
+  const todo = states.filter((state) => state.state !== "current").map((state) => state.id);
+  const declared = new Map((body.criteria?.items ?? []).map((criterion) => [criterion.id, criterion]));
+  const proofOf = (id) => declared.get(id).proof;
+  const reasons = /* @__PURE__ */ new Map();
+  const emitted = /* @__PURE__ */ new Map();
+  const found = discoverTestFiles(root, todo, config.runners);
+  for (const id of todo) {
+    if (!found.has(id)) reasons.set(id, NO_TEST);
+  }
+  const plan = planRuns([...new Set([...found.values()].flat())], config.runners);
+  const logDir = mkdtempSync(join(tmpdir(), "outerlayer-proofs-"));
+  const proofOuts = [];
+  const groups = [];
+  const runCommand = opts.runCommand ?? runShell;
+  const baseEnv = { ...process.env, ...env };
+  delete baseEnv.OUTERLAYER_PROOF_OUT;
+  let spooledCount = 0;
+  const spooledCriteria = /* @__PURE__ */ new Set();
+  const emitArtifact = async (emitOpts) => {
+    const result = await (opts.emitArtifact ?? runEmitArtifact)(emitOpts);
+    if (result.spooled) spooledCount += 1;
+    return result;
+  };
+  const common = { url: creds.url, apiKey: creds.apiKey, appId: creds.appId, cwd: root, home, env, fetchImpl, quiet: true };
+  const stopGroups = () => {
+    for (const pid of groups) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    }
+  };
+  const cleanUp = () => {
+    rmSync(logDir, { recursive: true, force: true });
+    for (const folder of proofOuts) rmSync(folder, { recursive: true, force: true });
+  };
+  const onSignal = (signal) => {
+    stopGroups();
+    cleanUp();
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  };
+  const onInterrupt = () => onSignal("SIGINT");
+  const onTerminate = () => onSignal("SIGTERM");
+  process.once("SIGINT", onInterrupt);
+  process.once("SIGTERM", onTerminate);
+  const runs = [];
+  try {
+    let setupStarted = false;
+    try {
+      let setupFailed;
+      if (plan.size > 0) {
+        setupStarted = true;
+        for (const command of config.setup) {
+          const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
+          if (result.status !== 0) {
+            setupFailed = `setup failed: "${oneLine(command)}" ${result.timedOut ? `timed out after ${Math.round(timeoutMs / 1e3)} s` : `exited with status ${result.status}`}`;
+            say(setupFailed);
+            if (result.tail !== "") say(result.tail);
+            break;
+          }
+        }
+      }
+      for (const [index, files] of plan) {
+        const runner = config.runners[index];
+        const criteria = todo.filter((id) => found.get(id)?.some((file) => files.includes(file)));
+        if (setupFailed !== void 0) {
+          for (const id of criteria) reasons.set(id, setupFailed);
+          continue;
+        }
+        const proofOut = mkdtempSync(join(tmpdir(), "outerlayer-proof-out-"));
+        proofOuts.push(proofOut);
+        const result = await runCommand(fillFiles(runner.command, files), { cwd: root, env: { ...baseEnv, OUTERLAYER_PROOF_OUT: proofOut }, timeoutMs, logDir, groups });
+        const failure = result.timedOut ? `the runner for ${runner.files} timed out after ${Math.round(timeoutMs / 1e3)} s` : result.status === 0 ? void 0 : `the runner for ${runner.files} exited with status ${result.status}`;
+        if (failure !== void 0) {
+          say(failure);
+          if (result.tail !== "") say(result.tail);
+        }
+        runs.push({ glob: runner.files, proofOut, criteria, failure, tail: result.tail });
+      }
+    } finally {
+      if (setupStarted) {
+        for (const command of config.teardown) {
+          const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
+          if (result.status !== 0) say(`teardown failed: "${oneLine(command)}" ${result.timedOut ? "timed out" : `exited with status ${result.status}`}`);
+        }
+      }
+      process.off("SIGINT", onInterrupt);
+      process.off("SIGTERM", onTerminate);
+      stopGroups();
+    }
+    if (plan.size > 0) {
+      let left = [];
+      try {
+        left = changedTrackedFiles(root);
+      } catch {
+      }
+      if (left.length > 0) {
+        say(`The run changed tracked files: ${left.join(", ")}. The next --record records nothing until they match HEAD. Make setup, the tests and teardown leave them unchanged.`);
+      }
+    }
+    await emitProofs();
+  } finally {
+    cleanUp();
+  }
+  async function emitProofs() {
+    const notCurrent2 = new Set(todo);
+    const manifests = runs.flatMap((run) => findManifests(run.proofOut));
+    const chapters = /* @__PURE__ */ new Set();
+    if (manifests.length > 1) {
+      say(`Not recorded, the demo: the runners left ${manifests.length} demo manifests, so it is unclear which to store`);
+    } else if (manifests.length === 1) {
+      for (const id of chapterCriteria(manifests[0])) chapters.add(id);
+      await recordDemo(manifests[0], chapters);
+    }
+    for (const run of runs) {
+      const names = topLevelFiles(run.proofOut);
+      for (const name of names) {
+        const id = proofFileCriterion(name, new Set(declared.keys()));
+        if (id === void 0) {
+          say(`Ignored ${name}: its name is not the id of a declared criterion.`);
+          continue;
+        }
+        if (!notCurrent2.has(id)) {
+          say(`Ignored ${name}: the proof for ${id} is current, or no proof is declared for it.`);
+          continue;
+        }
+        if (DEMO_PROOFS.has(proofOf(id)) && chapters.has(id)) {
+          say(`Ignored ${name}: a demo chapter proves ${id}.`);
+          continue;
+        }
+        if (emitted.has(id)) continue;
+        const fail = (reason) => {
+          reasons.set(id, reason);
+          say(`Not recorded, ${id}: ${reason}`);
+        };
+        if (run.failure !== void 0) {
+          fail(`${run.failure}, so its files are not recorded`);
+          continue;
+        }
+        const problem = kindProblem(proofOf(id), name);
+        if (problem !== void 0) {
+          fail(problem);
+          continue;
+        }
+        try {
+          const caption = (declared.get(id).text ?? `Proof for ${id}`).slice(0, ARTIFACT_MAX_CAPTION_LENGTH);
+          const before = spooledCount;
+          const result = await emitArtifact({ ...common, file: join(run.proofOut, name), caption, criterionId: id, ...ownPr === void 0 ? {} : { pr: ownPr } });
+          const artifactId = result.record?.artifactId ?? result.data?.clientArtifactId;
+          if (artifactId === void 0) {
+            fail("the upload returned no artifact id");
+            continue;
+          }
+          emitted.set(id, artifactId);
+          if (spooledCount > before) spooledCriteria.add(id);
+        } catch (err) {
+          fail(`the upload failed: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+        }
+      }
+    }
+    for (const run of runs) {
+      for (const id of run.criteria) {
+        if (emitted.has(id) || reasons.has(id)) continue;
+        reasons.set(id, run.failure ?? `the tests ran and wrote no ${id}.<ext> file under OUTERLAYER_PROOF_OUT`);
+      }
+    }
+  }
+  async function recordDemo(manifest, chapters) {
+    const demoCriteria = todo.filter((id) => DEMO_PROOFS.has(proofOf(id)));
+    let replaces;
+    try {
+      replaces = (await readNewestDemo({ url: creds.url, apiKey: creds.apiKey, appId: creds.appId, item, fetchImpl }))?.artifactId;
+    } catch (err) {
+      replaces = void 0;
+      say(`The previous demo could not be read, so the new demo does not replace it: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+    }
+    const before = spooledCount;
+    let result;
+    try {
+      result = await (opts.emitDemo ?? runEmitDemo)({
+        ...common,
+        manifest,
+        item,
+        ...ownPr === void 0 ? {} : { pr: ownPr },
+        ...replaces === void 0 ? {} : { replaces },
+        emitArtifact
+      });
+    } catch (err) {
+      const reason = `the demo was not stored: ${oneLine(String(err instanceof Error ? err.message : err))}`;
+      for (const id of demoCriteria) reasons.set(id, reason);
+      say(`Not recorded, the demo: ${reason}`);
+      return;
+    }
+    for (const id of demoCriteria) {
+      const artifactId = proofOf(id) === "screenshot" ? result.screenshots.find((shot) => shot.criterionId === id && shot.artifactId !== void 0)?.artifactId : result.clips.find((clip) => clip.criterionId === id && clip.bound)?.clipArtifactId;
+      if (artifactId !== void 0) {
+        emitted.set(id, artifactId);
+        if (spooledCount > before) spooledCriteria.add(id);
+      } else if (chapters.has(id)) {
+        reasons.set(id, result.failures.length > 0 ? `the demo failed a check: ${oneLine(result.failures[0])}` : "the demo has no passing chapter for it");
+      }
+    }
+    for (const failure of result.failures) say(`Demo check failed: ${oneLine(failure)}`);
+  }
+  if (spooledCount > 0) {
+    try {
+      const synced = await (opts.sync ?? (() => runSync({ ...common })))();
+      const unstored = unstoredUploads(
+        synced,
+        [...spooledCriteria].map((id) => emitted.get(id))
+      );
+      const lostIds = unstored === "all" ? [...spooledCriteria] : [...spooledCriteria].filter((id) => unstored.includes(emitted.get(id)));
+      for (const id of lostIds) {
+        emitted.delete(id);
+        reasons.set(id, "the sync did not store the upload, so the proof is stored only in the session record");
+      }
+      if (lostIds.length > 0) say("The sync did not store an upload. The proofs that went through the session record are not stored.");
+    } catch (err) {
+      for (const id of spooledCriteria) {
+        emitted.delete(id);
+        reasons.set(id, "the sync failed, so the proof is stored only in the session record");
+      }
+      say(`The sync failed, so the new proofs are stored only in the session record: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+    }
+  }
+  for (const [criterion, artifactId] of emitted) say(`Recorded ${criterion}: ${artifactId}`);
+  let finalStates = states;
+  try {
+    const { data: fresh } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
+    finalStates = classifyProofsAt(fresh, heads);
+  } catch (err) {
+    say(`The item could not be read again, so the list below may be out of date: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+  }
+  const notCurrent = finalStates.filter((state) => state.state !== "current" && !emitted.has(state.id)).map((state) => ({ id: state.id, proof: state.proof, reason: reasons.get(state.id) ?? "it was not recorded in this run" }));
+  if (opts.comment && notCurrent.length > 0) {
+    await postGeneral(proofsCommentBody(head, notCurrent), proofsCommentId(item, head, notCurrent));
+  }
+  for (const proof of notCurrent) say(`Not current, ${proof.id} (${proof.proof}): ${proof.reason}`);
+  const closing = await runWorkProofs({ ...opts, item, env, quiet: true, checkoutHead: head, fetchImpl });
+  const output = [...lines, closing.output].join("\n");
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return {
+    exitCode: closing.exitCode,
+    output,
+    emitted: [...emitted].map(([criterion, artifactId]) => ({ criterion, artifactId })),
+    notCurrent
+  };
+}
+
+export { runWorkProofsRecord };

package/dist/{work-stop-cmd-HYQTDNUY.js → work-stop-cmd-4BE2B7TY.js}

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { resolveCredentials, postJson, WorkCommandError } from './chunk-GJYGOFF3.js';
+import { resolveCredentials, postJson, WorkCommandError } from './chunk-72N7GOLM.js';
 import './chunk-IP7BIBXJ.js';
-import './chunk-BTDBDTUY.js';
-import './chunk-4J5GRWAY.js';
+import './chunk-GJHOU5V3.js';
+import './chunk-N6V4ZHI7.js';
 import './chunk-NWHU5G6R.js';
 import './chunk-G2JWZDFA.js';
 import './chunk-ANPNT6PM.js';
 import './chunk-IXPH4EXK.js';
 import './chunk-LYCJQOO2.js';
-import { defaultFetch } from './chunk-PAGB3DCI.js';
+import { defaultFetch } from './chunk-IZKUPAXF.js';
 import './chunk-PJDQPF5N.js';
-import './chunk-VKYU4HHW.js';
+import './chunk-VJQQVTCS.js';
 import './chunk-BJ3KTMDH.js';
 import './chunk-OVNF4LLC.js';
-import './chunk-A6PJSNP6.js';
+import './chunk-A2KLVZBU.js';
 import './chunk-5BHIBJDA.js';
 import './chunk-CDDED64E.js';
 import './chunk-RA3O54FC.js';
@@ -23,8 +23,8 @@ import './chunk-CRB3POP4.js';
 import './chunk-XFJ7YOPD.js';
 import './chunk-DINRXUQA.js';
 import './chunk-VNVZDWO3.js';
-import './chunk-AJTGTSNA.js';
-import './chunk-L2OARQKP.js';
+import './chunk-2CW2QMSG.js';
+import './chunk-4N7BQBO4.js';
 import './chunk-MESOOLF4.js';
 import './chunk-Z5GEFMRW.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outerlayer/cli",
-  "version": "0.34.0-next.20261028010245",
+  "version": "0.34.0-next.20261028122415",
   "description": "OuterLayer CLI — commands: init, claude, connect, doctor, login, logout, sync, daemon (alias: watch), emit, demo, findings, work, spec, runner, hooks, mcp, context. Capture and sync coding-agent sessions, and record proof of factory work.",
   "license": "Apache-2.0",
   "author": "Magu Studios, Inc.",