@outerlayer/cli 0.33.0 → 0.34.0-next.20261023233807

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

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runWorkComment } from './chunk-VY2FE5VT.js';
+import { recipeKeyFor, ownPullRequest, otherPullRequestHeads, PROOFS_DIR, SETUP_FILE, proofsCommentId, planEntries, checkEmitPath, insideRoot, kindProblem, proofsCommentBody } from './chunk-YNJUN6BB.js';
+import { resolveProofsItem, classifyProofsAt, runWorkProofs } from './chunk-NYHQF6BT.js';
+import { runEmitDemo } from './chunk-GODAKHDD.js';
+import { readNewestDemo } from './chunk-ER6KQCVJ.js';
+import { runEmitArtifact } from './chunk-2GWMYY4M.js';
+import { runSync } from './chunk-KLGYSJ3A.js';
+import './chunk-HUUYTDFV.js';
+import './chunk-ESVW4MJY.js';
+import './chunk-TBT347UY.js';
+import './chunk-2PGI6RDE.js';
+import './chunk-ES4ULBAL.js';
+import { WorkCommandError, resolveCredentials, getJson } from './chunk-J32AF6D2.js';
+import './chunk-IP7BIBXJ.js';
+import './chunk-2HCXEIJD.js';
+import './chunk-OVRNGOD2.js';
+import './chunk-MECW77XP.js';
+import { resolveRepoIdentity } from './chunk-BO42KT3D.js';
+import './chunk-TIRHZC2M.js';
+import './chunk-Y5YCX6AL.js';
+import './chunk-G2JWZDFA.js';
+import './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-SHIGGHZO.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-2O5KA67H.js';
+import './chunk-BKO6JEZI.js';
+import './chunk-HCVLP7XA.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-ZGB4ZJ5E.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-TUSYOL2O.js';
+import { parseProofRecipe, parseProofSetup } from './chunk-CQRPR4WZ.js';
+import { ARTIFACT_MAX_CAPTION_LENGTH } from './chunk-EOTMDIYC.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-HACGUL52.js';
+import './chunk-MESOOLF4.js';
+import './chunk-Z5GEFMRW.js';
+import { spawnSync, spawn } from 'child_process';
+import { mkdtempSync, rmSync, statSync, 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));
+  });
+};
+
+// src/work-proofs-record.ts
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var MTIME_SLOP_MS = 2e3;
+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 = [];
+  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" && 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 recipe is committed.");
+  }
+  const { repoRoot: root, commitSha: head } = identity;
+  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 key = recipeKeyFor(body.trackerKey ?? "");
+  if (key === void 0) {
+    throw new WorkCommandError(`the item's tracker key "${body.trackerKey ?? ""}" cannot name a recipe file.`);
+  }
+  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 heads = /* @__PURE__ */ new Set([head.toLowerCase(), ...otherPullRequestHeads(body.pullRequests ?? [], ownPr, identity.gitRepo)]);
+  const states = classifyProofsAt(body, heads);
+  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 recipePath = `${PROOFS_DIR}/${key}.yaml`;
+  const setupPath = `${PROOFS_DIR}/${SETUP_FILE}`;
+  const recipeText = showAtHead(root, recipePath);
+  const setupText = showAtHead(root, setupPath);
+  const recipeParsed = recipeText === void 0 ? { ok: true, value: { run: [], manual: [] } } : parseProofRecipe(recipeText);
+  const setupParsed = setupText === void 0 ? { ok: true, value: { setup: [] } } : parseProofSetup(setupText);
+  for (const [file, parsed] of [
+    [recipePath, recipeParsed],
+    [setupPath, setupParsed]
+  ]) {
+    if (parsed.ok) continue;
+    const problem = `${file} cannot be read: ${parsed.problems.join("; ")}`;
+    if (opts.comment) {
+      const text = `The proof recipe cannot be read at ${shortSha(head)}, so no proof was recorded. ${problem}`.slice(0, 2e3);
+      await postGeneral(text, proofsCommentId(item, head, [{ id: file, proof: "recipe", reason: problem }]));
+    }
+    throw new WorkCommandError(problem);
+  }
+  const recipe = recipeParsed.value;
+  const setup = setupParsed.value;
+  if (recipeText === void 0) say(`No recipe at ${recipePath} in the HEAD commit, so no entry runs.`);
+  const dirty = spawnSync("git", ["diff", "--quiet", "HEAD", "--", PROOFS_DIR], { cwd: root });
+  if (dirty.status === 1) say(`The working copy of ${PROOFS_DIR} differs from HEAD. Only the committed files run. Commit the change, then record again.`);
+  const declared = new Map((body.criteria?.items ?? []).map((criterion) => [criterion.id, criterion]));
+  const reasons = /* @__PURE__ */ new Map();
+  const emitted = /* @__PURE__ */ new Map();
+  const manual = new Map(recipe.manual.map((entry) => [entry.criterion, entry]));
+  const plan = planEntries(recipe, states);
+  const toRun = [];
+  for (const planned of plan) {
+    if (planned.skip !== null) continue;
+    const label = planned.entry.emit === "demo" ? "the demo entry" : `the entry for ${planned.entry.for}`;
+    const refuse = (reason) => {
+      say(`Skipped ${label}: ${reason}`);
+      for (const id of planned.criteria) reasons.set(id, reason);
+    };
+    if (planned.entry.command.trim() === "") {
+      refuse("it has no command. Fill in the recipe.");
+      continue;
+    }
+    if (planned.entry.emit !== "demo") {
+      const checked = checkEmitPath(root, planned.entry.emit);
+      if (!checked.ok) {
+        refuse(checked.reason);
+        continue;
+      }
+    }
+    toRun.push(planned);
+  }
+  const logDir = mkdtempSync(join(tmpdir(), "outerlayer-proofs-"));
+  const groups = [];
+  const runCommand = opts.runCommand ?? runShell;
+  const baseEnv = { ...process.env, ...env };
+  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 };
+  let setupStarted = false;
+  let setupFailed;
+  const stopGroups = () => {
+    for (const pid of groups) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    }
+  };
+  const onSignal = (signal) => {
+    stopGroups();
+    rmSync(logDir, { recursive: true, force: true });
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  };
+  const onInterrupt = () => onSignal("SIGINT");
+  const onTerminate = () => onSignal("SIGTERM");
+  process.once("SIGINT", onInterrupt);
+  process.once("SIGTERM", onTerminate);
+  try {
+    if (toRun.length > 0) {
+      setupStarted = true;
+      for (const command of setup.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 planned of toRun) {
+      if (setupFailed !== void 0) {
+        for (const id of planned.criteria) reasons.set(id, setupFailed);
+        continue;
+      }
+      const { entry } = planned;
+      const proofOut = mkdtempSync(join(tmpdir(), "outerlayer-proof-out-"));
+      const startedAt = Date.now();
+      try {
+        const result = await runCommand(entry.command, { cwd: root, env: { ...baseEnv, OUTERLAYER_PROOF_OUT: proofOut }, timeoutMs, logDir, groups });
+        const failure = result.timedOut ? `the command timed out after ${Math.round(timeoutMs / 1e3)} s` : result.status === 0 ? void 0 : `the command exited ${result.status}`;
+        if (entry.emit === "demo") {
+          await recordDemo({ planned, proofOut, failure, tail: result.tail });
+        } else {
+          await recordFile({ planned, failure, tail: result.tail, startedAt });
+        }
+      } finally {
+        rmSync(proofOut, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    if (setupStarted) {
+      for (const command of setup.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();
+    rmSync(logDir, { recursive: true, force: true });
+  }
+  async function recordFile(params) {
+    const { entry } = params.planned;
+    const id = entry.for;
+    const fail = (reason) => {
+      reasons.set(id, reason);
+      say(`Not recorded, ${id}: ${reason}`);
+      if (params.tail !== "" && params.failure !== void 0) say(params.tail);
+    };
+    if (params.failure !== void 0) return fail(params.failure);
+    const checked = checkEmitPath(root, entry.emit);
+    if (!checked.ok) return fail(checked.reason);
+    let modified;
+    try {
+      const stat = statSync(checked.path);
+      if (!stat.isFile()) return fail(`${entry.emit} is not a file`);
+      modified = stat.mtimeMs;
+    } catch {
+      return fail(`the command did not write ${entry.emit}`);
+    }
+    if (!insideRoot(root, checked.path)) return fail(`${entry.emit} is outside the repository: it links out of it`);
+    if (modified < params.startedAt - MTIME_SLOP_MS) return fail(`the command did not write ${entry.emit}: the file is older than this run`);
+    const problem = kindProblem(declared.get(id)?.proof ?? null, checked.path);
+    if (problem !== void 0) return fail(problem);
+    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: checked.path, caption, criterionId: id, ...ownPr === void 0 ? {} : { pr: ownPr } });
+      const artifactId = result.record?.artifactId ?? result.data?.clientArtifactId;
+      if (artifactId === void 0) return fail("the upload returned no artifact id");
+      emitted.set(id, artifactId);
+      if (spooledCount > before) spooledCriteria.add(id);
+      say(`Recorded ${id} from ${entry.emit}.`);
+    } catch (err) {
+      fail(`the upload failed: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+    }
+  }
+  async function recordDemo(params) {
+    const fail = (reason) => {
+      for (const id of params.planned.criteria) reasons.set(id, reason);
+      say(`Not recorded, the demo: ${reason}`);
+      if (params.tail !== "" && params.failure !== void 0) say(params.tail);
+    };
+    const manifests = findManifests(params.proofOut);
+    if (manifests.length !== 1) {
+      const status = params.failure === void 0 ? "" : ` (${params.failure})`;
+      return fail(manifests.length === 0 ? `the command left no demo manifest${status}` : `the command left ${manifests.length} demo manifests, so it is unclear which to store`);
+    }
+    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: manifests[0],
+        item,
+        ...ownPr === void 0 ? {} : { pr: ownPr },
+        ...replaces === void 0 ? {} : { replaces },
+        emitArtifact
+      });
+    } catch (err) {
+      return fail(`the demo was not stored: ${oneLine(String(err instanceof Error ? err.message : err))}`);
+    }
+    for (const id of params.planned.criteria) {
+      const proof = declared.get(id)?.proof;
+      const artifactId = proof === "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 reasons.set(id, result.failures.length > 0 ? `the demo failed a check: ${oneLine(result.failures[0])}` : "the demo has no passing chapter for it");
+    }
+    say(`Recorded the demo: ${params.planned.criteria.filter((id) => emitted.has(id)).length} of ${params.planned.criteria.length} proofs.`);
+    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))}`);
+    }
+  }
+  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 {
+  }
+  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) ?? manual.get(state.id)?.reason ?? "no entry in the recipe" }));
+  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-ZDIW3MVX.js → work-stop-cmd-HSGFTRIX.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { resolveCredentials, postJson, WorkCommandError } from './chunk-VSLJ6PPG.js';
+import { resolveCredentials, postJson, WorkCommandError } from './chunk-J32AF6D2.js';
 import './chunk-IP7BIBXJ.js';
-import './chunk-HLZMAJJD.js';
-import './chunk-S5CNYXUA.js';
-import './chunk-MPC2UAW2.js';
-import './chunk-NIY2UBT6.js';
-import './chunk-LYGI3T66.js';
-import './chunk-7V5GUEDU.js';
+import './chunk-2HCXEIJD.js';
+import './chunk-OVRNGOD2.js';
+import './chunk-MECW77XP.js';
+import './chunk-BO42KT3D.js';
+import './chunk-TIRHZC2M.js';
+import './chunk-Y5YCX6AL.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-44V5SD4G.js';
+import './chunk-ZGB4ZJ5E.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-6CXNWKWD.js';
-import './chunk-F2D5BSXS.js';
+import './chunk-CQRPR4WZ.js';
+import './chunk-EOTMDIYC.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",
+  "version": "0.34.0-next.20261023233807",
   "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

@@ -127,15 +127,15 @@ repository. Commit and push in each checkout you change, to its own branch only.
 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.
+9. **Record the proofs again.** Skip this step when you pushed nothing. If a
+   fix changes how a proof is made, commit the recipe edit
+   (`.outerlayer/proofs/<item key>.yaml`). Push, run
+   `outerlayer work proofs --record --comment --pr <prNumber>` per pushed checkout.
 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), 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
+   why), the lines 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>"`.

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

@@ -341,9 +341,10 @@ Run them in order.
    Watch CI until every check has concluded.
 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. Then check the proofs with `outerlayer work proofs`, as
-   that file says.
+   when the pull request opens, and run it. Write and commit the proof recipe
+   (`outerlayer work proofs --init`), then capture each proof with
+   `outerlayer work proofs --record`. 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.

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

@@ -262,23 +262,36 @@ mark the file so that CI skips it, as `apps/e2e` does.
 
 Record each criterion that declares `proof: screenshot` as a chapter of the same
 demo, with a `demo.screenshot()` call where the result shows. The frame then
-comes from the committed test, so an amend records it again at the new head. Put
-a capture in a script under `build-reports/evidence/` and run the script only
-when no demo test can reach its state. 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.
-
-Record the criteria that declare `proof: video` or `proof: screenshot` as one demo, as the
-outerlayer-evidence skill's "Record a demo" says. Write one Playwright test with
-`@outerlayer/playwright` and one chapter for each of those criteria, in the
-criteria's order. Run it, then run `outerlayer emit demo <manifest> --item
-"$OUTERLAYER_WORK" --pr <number>`. Emit each other artifact with `outerlayer
-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`, 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.
+comes from the committed test, so a later session records it again at the new head.
+
+Every proof comes from a recipe that you commit with the change. Run
+`outerlayer work proofs --init --pr <number>`. It writes
+`.outerlayer/proofs/<item key>.yaml` and, when absent, `.outerlayer/proofs/setup.yaml`.
+Fill them in:
+
+- `setup.yaml` lists the commands that seed and start the app (`setup`) and
+  stop it (`teardown`). Each setup command must return once the app is ready.
+- The one `emit: demo` entry holds the command that runs the demo test. Write
+  the test with `@outerlayer/playwright`, one chapter for each criterion in the
+  criteria's order, as the outerlayer-evidence skill's "Record a demo" says. The
+  test writes its manifest where `OUTERLAYER_PROOF_OUT` names. The entry covers
+  every screenshot and video criterion that no other entry names.
+- Every other proof is a command entry: a `command` that writes one file, the
+  repository-relative `emit` path of that file, and `for`, the criterion id.
+  The kind of the file must be the kind the criterion declares.
+- A proof that only a person can capture goes under `manual` with a `reason`.
+  Name each criterion in one place only.
+
+Commit the recipe, the setup file and the demo test. Then run
+`outerlayer work proofs --record` from the committed checkout. It runs only
+what is committed at HEAD, and emits each proof at HEAD. Never emit by hand a
+proof that a recipe entry can record, and never keep a capture script outside
+the recipe. Always pass `--pr <number>` when the item links more than one pull
+request in the repository. Record again after every later commit. It skips an
+entry whose proofs are current.
+
+Run `outerlayer sync`, then `outerlayer work proofs --item "$OUTERLAYER_WORK"`.
+For each proof it lists as out of date or missing, fix its entry and record again.
 
 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

@@ -21,24 +21,26 @@ state no demo test can reach. One that declares `proof: video` needs a video: it
 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.
 
+The evidence agent captures every proof from a recipe it commits with the
+change: `outerlayer work proofs --init` writes it, and
+`outerlayer work proofs --record` runs it at HEAD and emits each proof. A
+capture script outside the recipe is not allowed, because no later session can
+run it again.
+
 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
-code they import, a migration or schema behind them, or a test the capture is a
-log of. A sync that brings in only files the feature never reaches leaves the
-capture valid. Spawn the evidence agent again with the stale list. It reruns
-their scripts and emits each with `--replaces`. A stale video means the whole
-demo is recorded and emitted again. The final report names the
-commit and every capture with its call, kept or regenerated. A commit that
-lands after this call reopens it. Never drive the browser yourself.
+head. Commit the work, then run `outerlayer work proofs --record`: it records
+each proof that is not current and skips the rest. Run the list 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, run
+`outerlayer work proofs --record` again. It records every proof that is not
+current at the new head. The final report names the commit and the proofs it
+recorded again. A commit that lands after this call reopens it. Never drive the
+browser yourself.
 
 Re-read the pull request's evidence comment. Resolve or escalate every row that
 needs attention. A row is resolved when a re-read shows it, not when the fixing