@outerlayer/cli 0.33.0-next.20261023003700 → 0.33.0-next.20261023030517

package/dist/work-proofs-cmd-R25HT6WP.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { WorkCommandError, resolveCredentials, getJson } from './chunk-5FSVA3CO.js';
+import './chunk-IP7BIBXJ.js';
+import './chunk-CCOU4NXE.js';
+import './chunk-VJGQEASF.js';
+import { sanitizeTerminal } from './chunk-E4F7YE7P.js';
+import { resolveRepoIdentity } from './chunk-QQXNS4G2.js';
+import './chunk-PJI5D2XT.js';
+import './chunk-X37GC7DM.js';
+import './chunk-G2JWZDFA.js';
+import { C } from './chunk-ANPNT6PM.js';
+import { defaultFetch } from './chunk-6RKD7YZ6.js';
+import './chunk-PJDQPF5N.js';
+import './chunk-SOI6K5DY.js';
+import './chunk-PA6CK6WQ.js';
+import './chunk-BALIE3BA.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-M24H6JQW.js';
+import './chunk-5BHIBJDA.js';
+import './chunk-CDDED64E.js';
+import './chunk-RA3O54FC.js';
+import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';
+import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
+import './chunk-CRB3POP4.js';
+import './chunk-PNIFQX73.js';
+import './chunk-V7Q5OKN7.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-HACGUL52.js';
+import './chunk-MESOOLF4.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);
+
+// src/work-proofs-cmd.ts
+function classifyProofs(data, checkoutHead) {
+  const heads = /* @__PURE__ */ new Set();
+  if (checkoutHead !== void 0 && checkoutHead !== "") heads.add(checkoutHead.toLowerCase());
+  data.pullRequests?.forEach((pr) => {
+    if ((pr.state === "open" || pr.state === "merged") && typeof pr.headSha === "string" && pr.headSha !== "") {
+      heads.add(pr.headSha.toLowerCase());
+    }
+  });
+  const entries = [];
+  for (const criterion of data.criteria?.items ?? []) {
+    if (criterion.proof === null || criterion.proof === "test") continue;
+    const newest = criterion.newestProof;
+    if (newest === null || newest === void 0) {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "missing", commit: null });
+    } else if (newest.commitSha !== null && heads.has(newest.commitSha.toLowerCase())) {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "current", commit: newest.commitSha });
+    } else {
+      entries.push({ id: criterion.id, proof: criterion.proof, state: "out-of-date", commit: newest.commitSha });
+    }
+  }
+  return entries;
+}
+var STATE_LABEL = { current: "current", "out-of-date": "out of date", missing: "missing" };
+function render(entries, json) {
+  if (json) return JSON.stringify(entries);
+  if (entries.length === 0) return "No criterion declares a proof other than test.";
+  return entries.map((e) => `${sanitizeTerminal(e.id)}  ${sanitizeTerminal(e.proof)}  ${STATE_LABEL[e.state]}  ${sanitizeTerminal(e.commit ?? "no commit")}`).join("\n");
+}
+async function runWorkProofs(opts) {
+  const env = opts.env ?? process.env;
+  let item;
+  if (opts.item !== void 0) {
+    item = parseTrackerNumber(opts.item);
+    if (item === void 0) throw new WorkCommandError(trackerNumberError("--item", opts.item));
+  } else if (env.OUTERLAYER_WORK !== void 0) {
+    const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
+    if (!("number" in parsed)) throw new WorkCommandError(parsed.reason);
+    item = parsed.number;
+  }
+  if (item === void 0) {
+    throw new WorkCommandError("no work item. Pass --item <number>, or set OUTERLAYER_WORK to the item's number.");
+  }
+  const creds = resolveCredentials(opts);
+  const { data } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, opts.fetchImpl ?? defaultFetch);
+  const body = data;
+  const items = body.criteria?.items ?? [];
+  if (items.some((c) => c.proof !== null && c.proof !== "test" && !("newestProof" in c))) {
+    throw new WorkCommandError(
+      "the gateway does not report each criterion's newest proof. Update the gateway, then run this again."
+    );
+  }
+  const checkoutHead = opts.checkoutHead ?? resolveRepoIdentity(opts.cwd ?? process.cwd()).commitSha;
+  if (!checkoutHead) {
+    throw new WorkCommandError("cannot read the checkout's HEAD. Run this inside the git checkout, or pass the head explicitly.");
+  }
+  const entries = classifyProofs(body, checkoutHead);
+  const output = render(entries, opts.json === true);
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { entries, output, exitCode: entries.every((e) => e.state === "current") ? 0 : 1 };
+}
+async function runWorkProofsCommand(opts) {
+  try {
+    const result = await runWorkProofs(opts);
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    if (err instanceof WorkCommandError) {
+      process.stderr.write(`${C.red}\u2717${C.reset} ${err.message}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    throw err;
+  }
+}
+
+export { classifyProofs, runWorkProofs, runWorkProofsCommand };

package/dist/{work-stop-cmd-3BJLXUJ3.js → work-stop-cmd-C52JPZ4E.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { resolveCredentials, postJson, WorkCommandError } from './chunk-VT4TTJPG.js';
+import { resolveCredentials, postJson, WorkCommandError } from './chunk-5FSVA3CO.js';
 import './chunk-IP7BIBXJ.js';
-import './chunk-B2JURP6A.js';
-import './chunk-2WMZPJVE.js';
-import './chunk-EWVYQLD3.js';
-import './chunk-5DNCFOXA.js';
-import './chunk-HJYBWJAS.js';
-import './chunk-NSPRS7WK.js';
+import './chunk-CCOU4NXE.js';
+import './chunk-VJGQEASF.js';
+import './chunk-E4F7YE7P.js';
+import './chunk-QQXNS4G2.js';
+import './chunk-PJI5D2XT.js';
+import './chunk-X37GC7DM.js';
 import './chunk-G2JWZDFA.js';
 import './chunk-ANPNT6PM.js';
 import { defaultFetch } from './chunk-6RKD7YZ6.js';
@@ -16,14 +16,14 @@ import './chunk-SOI6K5DY.js';
 import './chunk-PA6CK6WQ.js';
 import './chunk-BALIE3BA.js';
 import './chunk-BJ3KTMDH.js';
-import './chunk-G63KT5I5.js';
+import './chunk-M24H6JQW.js';
 import './chunk-5BHIBJDA.js';
 import './chunk-CDDED64E.js';
 import './chunk-RA3O54FC.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
 import './chunk-CRB3POP4.js';
-import './chunk-LJG6EMLJ.js';
-import './chunk-E6CO3MJE.js';
+import './chunk-PNIFQX73.js';
+import './chunk-V7Q5OKN7.js';
 import './chunk-VNVZDWO3.js';
 import './chunk-HACGUL52.js';
 import './chunk-MESOOLF4.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outerlayer/cli",
-  "version": "0.33.0-next.20261023003700",
+  "version": "0.33.0-next.20261023030517",
   "description": "OuterLayer CLI — commands: init, claude, connect, doctor, login, logout, sync, daemon (alias: watch), emit, 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.",

package/skill-pack/maintained/outerlayer-amend/SKILL.md

@@ -6,7 +6,7 @@ description: >
   reply on the thread with a replacement artifact or a sentence, and push. Also resolve a
   merge conflict with the base branch. Use when a work item has threads waiting on an
   agent or a conflicting pull request, or when asked to "answer the review" or "fix what
-  the reviewer failed". Invoke with /outerlayer-amend.
+  the reviewer failed".
 ---
 
 Run the CLI as `outerlayer`. If that command is not on PATH, run `npx -y @outerlayer/cli` with the same arguments. Every `outerlayer ...` command below follows this rule. Write the full command each time. Do not put it in a shell variable: zsh runs `$VAR args` as one command name, not as a command with arguments.
@@ -22,7 +22,7 @@ or fails a thread. A session can only reply.
 A session never records a pass or fail on an artifact.
 
 `OUTERLAYER_WORK` is the work item's number. Check out the pull request's
-branch first if the working tree is not already on it.
+branch first, unless the working tree is on it.
 
 ## Arguments
 
@@ -31,17 +31,16 @@ branch first if the working tree is not already on it.
 
 ## Builds and local sessions
 
-A session a runner started is a build: `OUTERLAYER_JOB_DIR` is set there and
-nowhere else. A build's GitHub token cannot comment on the issue or the pull
-request, and its pushes go through the runner. A local session uses the
-person's own git remote and `gh` login.
+A runner build sets `OUTERLAYER_JOB_DIR`; no other session does. A build's
+GitHub token cannot comment on the issue or the pull request, and its pushes
+go through the runner. A local session uses the person's own git remote and
+`gh` login.
 
 ## Several repositories
 
-`OUTERLAYER_REPOSITORIES` lists a build's repositories, each with its `path`,
-`branch` and whether it is `primary`. Fix each thread in the checkout of the
-repository its pull request is in. Commit and push in each checkout you
-change, to its own branch only.
+`OUTERLAYER_REPOSITORIES` lists a build's repositories, each with `path`,
+`branch` and `primary`. Fix each thread in the checkout of its pull request's
+repository. Commit and push in each checkout you change, to its own branch only.
 
 ## Steps
 
@@ -59,7 +58,7 @@ change, to its own branch only.
    **Hand off a conflict you cannot resolve.** If the resolution needs a
    product decision, or the gate stays red after one fix, abort the merge.
    Push nothing. Post on the general thread with `--ready`. Name the
-   conflicting files, the base commits behind them and the decision needed.
+   conflicting files, their base commits and the decision needed.
    Tell the person to fail the general thread with their answer.
 2. **Read the threads.**
    `outerlayer work threads --item "$OUTERLAYER_WORK" --json` prints
@@ -69,26 +68,24 @@ change, to its own branch only.
    `body`, `action` and `artifact`. Keep the threads whose `waitingOn` is
    `agent`.
    If none is waiting and step 1 resolved no conflict, say so and stop. Take
-   the pull request (`repository`, `prNumber`) from the step 1 status JSON's
-   `pullRequests`.
+   the pull request (`repository`, `prNumber`) from step 1's `pullRequests`.
 3. **Re-orient.** The status JSON's `issue.body` is OuterLayer's copy of the
    issue. It is the spec: find each thread's criterion there. Read the pull
-   request, with its evidence comment, through the git host. Read every person's comment since the last agent
-   comment on the thread. Read them literally.
+   request and its evidence comment through the git host. Read every person's
+   comment since the last agent comment, literally.
    Then read `checks` in the status JSON. A failing check lists its check
-   items under `items`, one per thing it judged, each with a `result` and a
-   `reason`. When a person asks you to fix failing checks or criteria, fix
-   each failing check item by its reason.
+   items under `items`, each with a `result` and a `reason`. When a person asks you to fix failing
+   checks or criteria, fix each failing check item by its reason.
 4. **Decide each thread.** Reply on every criterion thread waiting on an
    agent, with `--criterion`. Read each note and pick one:
-   - **Answer it.** A question gets an answer. Reply with the answer and
-     change nothing. Say which file or test you looked at.
+   - **Answer it.** A question gets an answer. Change nothing. Say which
+     file or test you looked at.
    - **Fix it.** A requested change gets a fix. Change the code, tests, docs or
-     evidence so the criterion is met as written, and attach new proof when the
-     criterion declares one.
+     evidence so the criterion is met as written, and attach new proof when it
+     declares one.
    - **The spec is wrong.** The criterion cannot be met as written, for
-     example because it names a path a repository rule forbids. Never rewrite
-     a criterion: hand it off (step 7) with the wording change to make.
+     example one that names a path a repository rule forbids. Never rewrite it:
+     hand it off (step 7) with the wording change.
    - **Cannot tell.** Hand an ambiguous comment off with `--ready`: quote it
      and ask one question.
 5. **Fix, prove, reply.** An answer needs no commit: reply on its criterion
@@ -107,13 +104,12 @@ change, to its own branch only.
      Note the id it prints. Run `outerlayer sync`, so the attach can find the
      artifact. Then reply, which supersedes the old proof:
      `outerlayer work comment --item "$OUTERLAYER_WORK" --criterion <criterion> --body "<what changed>" --artifact <uuid> --attach`.
-     A replacement whose bytes match the current proof is flagged `unchanged`,
-     so the thread still waits on you.
+     A replacement with the current proof's bytes is flagged `unchanged`, and
+     the thread still waits on you.
    - **A check the factory host records**, such as `acceptance-criteria`, is
      judged again after this session ends. Name each failing check item and
      your fix. Never claim the check passes.
-   - **Otherwise** (the general thread, or a fix that needs no new proof),
-     reply with a sentence naming what changed and the commit:
+   - **Otherwise**, reply with a sentence naming what changed and the commit:
      `outerlayer work comment --item "$OUTERLAYER_WORK" [--criterion <criterion>] --body "<what changed>" --ready`.
      Omit `--criterion` on the general thread.
 6. **Watch CI.** Skip this step when you pushed nothing. Run
@@ -128,14 +124,20 @@ change, to its own branch only.
    sentence of fact, then the decision a person must make. For a spec problem,
    quote the criterion and give the replacement wording. `--ready` hands the
    thread back to a person.
-8. **Check nothing is left waiting.** Read the threads again. A thread you
-   started with that still waits on an agent has a reply that did not land or
-   was flagged `unchanged`. Fix that, or report it.
-9. **Report.** Write one line per thread: the criterion (or the general
+8. **Check nothing is left waiting.** Reread threads. A thread still waiting
+   on an agent has a reply that did not land or was flagged `unchanged`. Fix
+   or report it. Then run `outerlayer sync` and `outerlayer work proofs`.
+9. **Record the demo again.** Skip this step when you pushed nothing. With
+   the app running, run in each pushed checkout
+   `node .outerlayer/skills/outerlayer-amend/scripts/rerecord-demo.mjs --item "$OUTERLAYER_WORK" --pr <prNumber> --repository <owner/name>`.
+   It prints the demo line for the report.
+10. **Report.** Write one line per thread: the criterion (or the general
    thread), and fixed (with the replacement) or handed off (with the reason).
    Add a line for a merge conflict (merged with the base sha, or handed off
-   with the reason), and a CI line when you pushed: green, or each red check
-   and why. Post the lines once on the general thread:
+   with the reason), a CI line when you pushed (green, or each red check and
+   why), the demo line from step 9, and a line naming each proof missing or
+   out of date.
+   Post the lines once on the general thread:
    `outerlayer work comment --item "$OUTERLAYER_WORK" --body "<the lines>"`.
    A plain comment from an agent leaves the general thread waiting on a person.
    A local session also posts them on the pull request. End with the same lines.

package/skill-pack/maintained/outerlayer-amend/scripts/rerecord-demo.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+// Records an item's demo again at the pull request's new head, after an
+// amend pushed. It reads the item's newest demo record, and records again
+// only a demo that was recorded at an earlier commit and names the test that
+// recorded it. Needs only Node.
+//
+//   node rerecord-demo.mjs --item <number> --pr <number> [--repository <owner/name>] [--project <playwright project>]
+//
+// Run it after the amend's last push, with the app running as the
+// repository's instructions say. It prints one line for the amend's report:
+// recorded again, current, or why not. It posts one comment on the item's
+// general thread when the demo is out of date and cannot be recorded again,
+// when a chapter failed its checks, or when the recording failed. It posts
+// nothing when the item has no demo, or the demo is current.
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const USAGE = "usage: rerecord-demo.mjs --item <number> --pr <number> [--repository <owner/name>] [--project <playwright project>]";
+const CONFIG_NAMES = ["ts", "js", "mjs", "cjs", "mts", "cts"].map((extension) => `playwright.config.${extension}`);
+
+/** The `spawnSync` that runs a program in `cwd`; tests pass a stand-in. */
+function runProgram(command, args, options) {
+  return spawnSync(command, args, { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, ...options });
+}
+
+/** `owner/name` of a repository in any spelling the factory stores, lower-case. */
+function repositoryName(repository) {
+  return repository
+    .replace(/\.git$/, "")
+    .split("/")
+    .filter((part) => part !== "")
+    .slice(-2)
+    .join("/")
+    .toLowerCase();
+}
+
+/** A test path inside the repository, or `null` when the path is absolute or leaves it. */
+function insidePath(test) {
+  if (typeof test !== "string" || test === "" || isAbsolute(test) || test.split("/").includes("..")) return null;
+  return test;
+}
+
+/** The nearest folder from the test's own up to the root that holds a Playwright config, else the root. */
+function configFolder(root, testFile) {
+  let folder = dirname(testFile);
+  while (folder.startsWith(root)) {
+    if (CONFIG_NAMES.some((name) => existsSync(join(folder, name)))) return folder;
+    if (folder === root) break;
+    folder = dirname(folder);
+  }
+  return root;
+}
+
+/** Every `demo/manifest.json` under `folder`. */
+function findManifests(folder) {
+  const found = [];
+  for (const entry of readdirSync(folder, { withFileTypes: true })) {
+    const path = join(folder, entry.name);
+    if (entry.isDirectory()) found.push(...findManifests(path));
+    else if (entry.name === "manifest.json" && basename(folder) === "demo") found.push(path);
+  }
+  return found;
+}
+
+/** The last line of a command's output that parses as a JSON object, or `null`. */
+function lastJson(text) {
+  for (const line of String(text).split("\n").reverse()) {
+    try {
+      const value = JSON.parse(line);
+      if (value !== null && typeof value === "object") return value;
+    } catch {
+      // not the JSON line
+    }
+  }
+  return null;
+}
+
+/**
+ * Records the demo again when it is out of date and names its test.
+ * `spawn(command, args, { cwd })` returns `{ status, stdout, stderr }`.
+ * Returns the outcome and the line for the amend's report.
+ */
+export function rerecordDemo({ item, pr, repository, project, cwd, spawn = runProgram }) {
+  const cli = (args) => {
+    const result = spawn("outerlayer", args, { cwd });
+    // Without `outerlayer` on PATH, the CLI runs through npx.
+    return result.error?.code === "ENOENT" ? spawn("npx", ["-y", "@outerlayer/cli", ...args], { cwd }) : result;
+  };
+  // The line for the amend's report says so when a comment did not post, so nobody waits for it.
+  const comment = (body) => (cli(["work", "comment", "--item", String(item), "--body", body]).status === 0 ? "" : " The comment on the item's thread was not posted.");
+
+  const read = cli(["work", "demo", "--item", String(item), "--json"]);
+  const answer = read.status === 0 ? lastJson(read.stdout) : null;
+  if (answer === null) {
+    const detail = String(read.stderr ?? "").trim();
+    return { outcome: "error", line: `Demo: could not read the item's demo${detail === "" ? "" : ` (${detail})`}.` };
+  }
+  const demo = answer.demo ?? null;
+  if (demo === null) return { outcome: "none", line: "Demo: the item has no demo to record again." };
+  if (repository !== undefined && repositoryName(String(demo.repository ?? "")) !== repositoryName(repository)) {
+    return { outcome: "other-repository", line: `Demo: the item's demo is in ${demo.repository}, not ${repository}.` };
+  }
+
+  const head = String(spawn("git", ["rev-parse", "HEAD"], { cwd }).stdout ?? "").trim();
+  const short = (sha) => (sha === "" ? "an unknown commit" : sha.slice(0, 7));
+  if (demo.commitSha === head) return { outcome: "current", line: `Demo: current, recorded at ${short(head)}.` };
+
+  const byHand = `outerlayer emit demo <manifest> --item ${item} --pr ${pr} --replaces ${demo.artifactId}`;
+  const stale = `The demo is out of date: it was recorded at ${short(String(demo.commitSha ?? ""))}, and the branch is now at ${short(head)}.`;
+  const root = String(spawn("git", ["rev-parse", "--show-toplevel"], { cwd }).stdout ?? "").trim() || cwd;
+  if (demo.record === null) {
+    const why = "Its record cannot be read, so the amend cannot tell which test to run.";
+    const unposted = comment(`${stale} ${why} To record it again, run the demo test, then run \`${byHand}\`.`);
+    return { outcome: "not-recorded", line: `Demo: out of date at ${short(String(demo.commitSha ?? ""))}; ${why.charAt(0).toLowerCase()}${why.slice(1)}${unposted}` };
+  }
+  const test = insidePath(demo.record?.test);
+  const testFile = test === null ? null : join(root, test);
+
+  if (test === null || !existsSync(testFile)) {
+    const why =
+      demo.record?.test === undefined || demo.record?.test === null
+        ? "Its record names no test, so the amend cannot record it again."
+        : `The test ${demo.record.test} is not in the checkout, so the amend cannot record it again.`;
+    const unposted = comment(`${stale} ${why} To record it again, run the demo test, then run \`${byHand}\`.`);
+    return { outcome: "not-recorded", line: `Demo: out of date at ${short(String(demo.commitSha ?? ""))}; ${why.charAt(0).toLowerCase()}${why.slice(1)}${unposted}` };
+  }
+
+  const output = mkdtempSync(join(tmpdir(), "outerlayer-rerecord-"));
+  try {
+    const folder = configFolder(root, testFile);
+    // Playwright reads the filter as a regular expression, so a path such as app/[id]/x.spec.ts needs its characters escaped.
+    const filter = relative(folder, testFile).split("\\").join("/").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const run = spawn("npx", ["playwright", "test", filter, "--output", output, ...(project === undefined ? [] : ["--project", project])], { cwd: folder });
+    // A failed check still writes the manifest, and emit demo reports the failed chapter. Only a missing manifest stops here.
+    const manifests = existsSync(output) ? findManifests(output) : [];
+    if (manifests.length !== 1) {
+      const why =
+        manifests.length === 0
+          ? `Running ${test} left no demo manifest (exit ${run.status}).`
+          : `Running ${test} left ${manifests.length} demo manifests, so the amend cannot tell which to store. Pass --project <name> so the test runs once.`;
+      const unposted = comment(`${stale} ${why} To record it again, run the demo test, then run \`${byHand}\`.`);
+      return { outcome: "error", line: `Demo: out of date at ${short(String(demo.commitSha ?? ""))}; ${why}${unposted}` };
+    }
+
+    const emit = cli(["emit", "demo", manifests[0], "--item", String(item), "--pr", String(pr), "--replaces", demo.artifactId, "--json"]);
+    const result = emit.status === 0 || emit.status === 1 ? lastJson(emit.stdout) : null;
+    if (result === null) {
+      const why = `Storing the new demo failed: ${String(emit.stderr ?? "").trim().split("\n")[0] || `exit ${emit.status}`}.`;
+      const unposted = comment(`${stale} ${why} To record it again, run \`${byHand}\` on the manifest of a new run.`);
+      return { outcome: "error", line: `Demo: out of date at ${short(String(demo.commitSha ?? ""))}; ${why}${unposted}` };
+    }
+    const synced = cli(["sync"]);
+    const unsynced = synced.status === 0 ? "" : ` The sync failed (exit ${synced.status}), so the new demo is stored but the session record is not uploaded. Run \`outerlayer sync\`.`;
+    const failures = Array.isArray(result.failures) ? result.failures : [];
+    if (failures.length > 0) {
+      const unposted = comment(`The demo was recorded again at ${short(head)}, but a chapter failed its checks. A failed chapter is stored but not bound to its criterion:\n${failures.map((line) => `- ${line}`).join("\n")}`);
+      return { outcome: "failed-chapters", line: `Demo: recorded again at ${short(head)}, but ${failures.join("; ")}.${unsynced}${unposted}` };
+    }
+    if (unsynced !== "") return { outcome: "sync-failed", line: `Demo: recorded again at ${short(head)}.${unsynced}` };
+    return { outcome: "recorded", line: `Demo: recorded again at ${short(head)}.` };
+  } finally {
+    rmSync(output, { recursive: true, force: true });
+  }
+}
+
+/** The value after `flag`, or `undefined`. */
+function flagValue(argv, flag) {
+  const at = argv.indexOf(flag);
+  return at === -1 ? undefined : argv[at + 1];
+}
+
+function main(argv) {
+  const item = Number(flagValue(argv, "--item"));
+  const pr = Number(flagValue(argv, "--pr"));
+  if (!Number.isInteger(item) || item <= 0 || !Number.isInteger(pr) || pr <= 0) {
+    process.stderr.write(`${USAGE}\n`);
+    return 2;
+  }
+  const { line } = rerecordDemo({ item, pr, repository: flagValue(argv, "--repository"), project: flagValue(argv, "--project"), cwd: process.cwd() });
+  process.stdout.write(`${line}\n`);
+  return 0;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) process.exitCode = main(process.argv.slice(2));

package/skill-pack/maintained/outerlayer-build/SKILL.md

@@ -334,7 +334,8 @@ Run them in order.
 6. **Evidence.** Run `outerlayer emit step "Evidence" --item "$OUTERLAYER_WORK"`,
    then apply the team's changes for this phase. Read [references/evidence.md](references/evidence.md)
    when the pull request opens, and run it. Capture the proof each criterion
-   declares, emit it.
+   declares, emit it. Then check the proofs with `outerlayer work proofs`, as
+   that file says.
 
 Optional steps a team may turn off: the manual test and screenshots in the
 Evidence phase, for a repository with no user interface.
@@ -342,7 +343,11 @@ Evidence phase, for a repository with no user interface.
 ## Ending the run
 
 Run this last, after the pull request is open and the evidence is emitted, and
-run no other tool call after it:
+run no other tool call after it. Before it, run `outerlayer sync` and then
+`outerlayer work proofs --item "$OUTERLAYER_WORK"`. End the run only when it
+exits 0, or when `build-reports/evidence.md` names each proof it still lists
+and the reason. Exit 2 means it could not decide: fix the reason it prints and
+run it again:
 
     outerlayer work release --item "$OUTERLAYER_WORK"
 

package/skill-pack/maintained/outerlayer-build/references/agent-briefs.md

@@ -253,7 +253,14 @@ application's own paths. When a state cannot be reached that way, the criterion
 is not evidenced, and `evidence.md` says why. Before emitting, look at each
 capture: it shows the application's navigation and real rows.
 
-For each criterion, put the capture in a script under
+Write the demo, when a criterion needs one, as a Playwright test that is part
+of the change. Put it where the repository keeps its Playwright tests, in the
+folder the instructions name, else in `e2e/demo/`. Name it `*.demo.spec.ts`.
+Commit it in the pull request. The demo record names this test, so an amend
+can run it again at a new head. If the repository's CI cannot start the app,
+mark the file so that CI skips it, as `apps/e2e` does.
+
+For each other capture, put the capture in a script under
 `build-reports/evidence/` and run the script. A later fix can invalidate what
 you captured, and regenerating it must be one command. The scripts go when the
 run's report directory goes. The emitted artifacts outlive the run.
@@ -266,7 +273,9 @@ criteria's order. Run it, then run `outerlayer emit demo <manifest> --item
 emit artifact ... --for <criterion id> --pr <number>`. Always pass `--pr`.
 When the tree invalidates a video, record and emit the whole demo again: the
 newer demo replaces the older one. Regenerate any other invalidated evidence
-with `--replaces`. Then run `outerlayer sync`.
+with `--replaces`. Then run `outerlayer sync`, and run `outerlayer work
+proofs --item "$OUTERLAYER_WORK"`. For each proof it lists as out of date or
+missing, capture and emit that criterion again, and run the command once more.
 
 Write `build-reports/evidence.md` naming every criterion with its artifact, or
 with the reason none could be produced. A criterion you could not evidence is

package/skill-pack/maintained/outerlayer-build/references/evidence.md

@@ -19,6 +19,14 @@ id. One that declares `proof: video` needs a video: its chapter of the
 item's one demo. A screenshot never satisfies `proof: video`. A criterion with no proof form is proven by its
 test, and needs no artifact.
 
+After the evidence agent returns, and after every later commit, run
+`outerlayer sync`, then `outerlayer work proofs --item "$OUTERLAYER_WORK"`. It
+lists each declared proof as current, out of date or missing at the checkout's
+head. For each criterion it lists as out of date or missing, run the evidence
+step again for that criterion only, then run the command once more before the
+run ends. A criterion still listed goes in `build-reports/evidence.md` with the
+reason. The command leaves out criteria that declare a test proof.
+
 When a commit lands on the branch after the evidence agent captured, decide for
 each capture from that commit's diff. A capture is stale when the diff touches
 a file the capture's subject runs through: the feature's own files, the shared

package/skill-pack/maintained/outerlayer-build/references/release.md

@@ -90,8 +90,9 @@ report. With several judges, run it on the merged report:
 Then run `outerlayer sync`. List every unsatisfied criterion in the final
 report. A criterion that declares a proof form such as a screenshot or video is
 proven only by an artifact bound to it on the pull request. The judge cannot
-see that, so confirm each has an artifact of the declared kind, and emit any
-that is missing in the evidence phase.
+see that. Run `outerlayer work proofs --item "$OUTERLAYER_WORK"`, as the
+evidence phase says, and emit again any proof it lists as out of date or
+missing.
 
 ## The criteria verdict
 

package/skill-pack/maintained/outerlayer-evidence/SKILL.md

@@ -16,7 +16,7 @@ spec asks for — a reviewer should see the change working, not a gallery.
 
 ## When to capture
 
-Capture AFTER the state exists, never before: run the app, the test, or the
+Capture AFTER the state exists: run the app, the test, or the
 flow first, and shoot the working result. A screenshot of code is not
 evidence; a screenshot of the rendered page is. If the state takes setup
 (seed data, a logged-in user), finish the setup, verify by eye, then capture.
@@ -24,14 +24,14 @@ evidence; a screenshot of the rendered page is. If the state takes setup
 ## Per-kind mechanics
 
 Kind is inferred from the file's media type — name files honestly. Every
-artifact shares one upload cap of 8 MiB, whatever its kind:
+artifact shares one upload cap of 8 MiB:
 
 - **screenshot** (`.png`, `.jpg`) — one focused window or region showing the
   proven state. Crop noise; keep enough chrome (URL bar, test summary line)
   to show it is real.
 - **video** (`.webm`, `.mp4`) — a recording of the flow, start to outcome.
-  Record it as a demo chapter (see "Record a demo"). Video is the kind most
-  likely to hit the 8 MiB cap: trim dead time.
+  Record it as a demo chapter (see "Record a demo"). Video most likely
+  hits the 8 MiB cap: trim dead time.
 - **report** (`.html`, `.pdf`) — generated reports: coverage, benchmark,
   audit output. Emit the file the tool produced, unedited.
 - **log** (`.txt`, `.log`) — command output proving a run happened: test
@@ -99,6 +99,8 @@ for each criterion:
       });
     });
 
+Commit the test, so an amend can run it again.
+
 Install it with `npm install --save-dev @outerlayer/playwright`. Use the
 recorded criterion id as the first argument, or `null` for an opening scene.
 Keep each narration line short enough to say in the chapter's time. Put the