rig-create 1.0.2 → 1.0.4

package/README.md

@@ -163,6 +163,22 @@ it fails, naming the constant, when a `*_SINCE` date is still in the future.
   are synthetic fixture records, not a person's approval
   ([why](templates/example-draft/README.md)).
 
+## Verify the installed examples
+
+From a consumer project with `@rig-c/create` installed, run:
+
+```sh
+bun node_modules/@rig-c/create/scripts/verify-example-seals.ts
+```
+
+The shipped, dependency-free script verifies every `files[]` entry and
+`project_sha256` in the six example-chain checkpoint manifests (currently
+319 checks). It names missing files and hash mismatches and exits nonzero.
+It reads installed bytes only; it does not regenerate examples or run producers.
+The CLI creates projects from empty templates; it does not copy worked examples.
+
+See [release candidate verification](https://github.com/rig-c/create/blob/main/RELEASING.md#verify-the-release-candidate).
+
 ## Licence
 
 [MIT](LICENSE).

package/docs/PROJECT.md

@@ -2515,6 +2515,16 @@ the project's next moves and whose they are from `project.json`:
   - `producer`: a command of a pinned package (`rig-parts`, `rigc`).
   - `human`: a person's act collected through the review tool (`review_act`),
     with `command: null` and never a `--by user` writer.
+- **Host and ingest human acts.** For a recorded Review subject, the human
+  move is surrounded by `job open` with its question, plan, draft or rig
+  selector, `job acts --json`, the writer with `--from-review '<actId>'`, and
+  `job close`. `job open` hosts and blocks until `job close`; keep it running
+  in a separate terminal. Fill the reviewer and exported act placeholders,
+  and follow the matching `job acts` preconditions before ingestion, including
+  its structure snapshot guidance for parts-review sign-off. Moves marked
+  `unanswered_by_record` retain their missing-field guidance.
+- **Scene writing does not plan work.** `scene write` adds no plan step.
+  Author the post plan steps through `plan add` before post-interview sign-off.
 - **Refusals come first.** When `check` reports refusals (or publication holes),
   `next` lists each in `refusals[]` with its `CHECKS.md` remedy (`fix`) before
   any forward move. A project with a blocking refusal has `moves: []` and

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "rig-create",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "Create a rig project: its folder, decision record, repository and pinned rig-c packages",
   "license": "MIT",
   "files": [
     "src/",
+    "scripts/verify-example-seals.ts",
+    "scripts/npm-json.ts",
     "templates/",
     "README.md",
     "LICENSE",

package/scripts/npm-json.ts

@@ -0,0 +1,74 @@
+/** npm 11 and 12 have different pack and view JSON envelopes. */
+import { readFileSync } from 'node:fs';
+
+export interface NpmPack {
+  filename: string;
+  entryCount: number;
+  size: number;
+  unpackedSize: number;
+}
+
+function object(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function shape(value: unknown): string {
+  if (Array.isArray(value)) return `array(length=${value.length}) ${JSON.stringify(value).slice(0, 200)}`;
+  if (object(value)) return `object(keys=${JSON.stringify(Object.keys(value))})`;
+  return `${value === null ? 'null' : typeof value} ${JSON.stringify(value)}`;
+}
+
+export function readNpmJson(text: string, command: string, kind: 'pack', expected: string): NpmPack;
+export function readNpmJson(text: string, command: string, kind: 'version', expected: string): string;
+export function readNpmJson(text: string, command: string, kind: 'e404'): string;
+export function readNpmJson(text: string, command: string, kind: 'pack' | 'version' | 'e404', expected?: string): NpmPack | string {
+  const fail = (field: string, want: string, actual: unknown): never => {
+    throw Error(`${command}: ${field}: expected ${want}; actual ${shape(actual)}`);
+  };
+  const envelope = kind === 'pack' ? `one-element array or object keyed only by ${JSON.stringify(expected)}`
+    : kind === 'version' ? 'version string or one-element array of that string' : 'object with error.code "E404"';
+  let value: unknown;
+  try { value = JSON.parse(text); }
+  catch { throw Error(`${command}: stdout: expected valid JSON (${envelope}); actual invalid JSON ${JSON.stringify(text.slice(0, 200))}`); }
+
+  if (kind === 'pack') {
+    let entry: unknown;
+    if (Array.isArray(value) && value.length === 1) entry = value[0];
+    else if (object(value) && Object.keys(value).length === 1 && Object.hasOwn(value, expected!)) entry = value[expected!];
+    else return fail('stdout', envelope, value);
+    if (!object(entry)) return fail('pack entry', 'object', entry);
+    if (entry.name !== expected) return fail('name', JSON.stringify(expected), entry.name);
+    if (typeof entry.filename !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.tgz$/.test(entry.filename)) {
+      return fail('filename', 'a .tgz basename without directory components', entry.filename);
+    }
+    for (const field of ['entryCount', 'size', 'unpackedSize'] as const) {
+      if (typeof entry[field] !== 'number' || !Number.isSafeInteger(entry[field]) || entry[field] < 0) {
+        return fail(field, 'a nonnegative safe integer', entry[field]);
+      }
+    }
+    return { filename: entry.filename, entryCount: entry.entryCount as number, size: entry.size as number, unpackedSize: entry.unpackedSize as number };
+  }
+  if (kind === 'version') {
+    const version = Array.isArray(value) && value.length === 1 ? value[0] : value;
+    if (typeof version !== 'string' || version !== expected) return fail('version', `${envelope} equal to ${JSON.stringify(expected)}`, value);
+    return version;
+  }
+  if (!object(value) || !object(value.error) || value.error.code !== 'E404') return fail('error.code', '"E404" in an error object', object(value) && object(value.error) ? value.error.code : value);
+  return 'E404';
+}
+
+if (import.meta.main) {
+  try {
+    const [kind, file, spec, version, ...extra] = process.argv.slice(2);
+    if (!file || !spec || extra.length || (kind !== 'version' && kind !== 'e404') || (kind === 'version' ? !version : version !== undefined)) {
+      throw Error('usage: bun scripts/npm-json.ts version <json-file> <package@version> <version> | e404 <json-file> <package@version>');
+    }
+    const text = readFileSync(file, 'utf8');
+    const command = `npm view ${spec} version --json`;
+    if (kind === 'version') readNpmJson(text, command, kind, version!);
+    else readNpmJson(text, command, kind);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/scripts/verify-example-seals.ts

@@ -0,0 +1,148 @@
+/** Verify installed example seals, or pack a temporary copy without nested ignore losses. */
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { readNpmJson } from './npm-json.ts';
+
+const packageRoot = resolve(import.meta.dir, '..');
+const hash = (path: string): string => createHash('sha256').update(readFileSync(path)).digest('hex');
+
+function within(root: string, path: string): string {
+  const target = resolve(root, path);
+  const rel = relative(root, target);
+  if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) throw Error(`invalid example path: ${path}`);
+  return target;
+}
+
+function files(root: string): string[] {
+  return readdirSync(root, { withFileTypes: true }).flatMap(entry => {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) return files(path);
+    if (!entry.isFile()) throw Error(`expected a regular example file: ${path}`);
+    return [path];
+  }).sort();
+}
+
+export function verifyExampleSeals(root: string): { ok: number; failures: string[]; sealedFiles: string[] } {
+  const chainRoot = join(root, 'templates/example-chain');
+  const index = JSON.parse(readFileSync(join(chainRoot, 'chain.json'), 'utf8')) as { checkpoints: { name: string }[] };
+  if (!Array.isArray(index.checkpoints) || index.checkpoints.length === 0) throw Error('example-chain/chain.json: no checkpoints to verify');
+  let ok = 0;
+  const failures: string[] = [];
+  const sealedFiles: string[] = [];
+  for (const { name } of index.checkpoints) {
+    const declaration = within(join(chainRoot, 'checkpoints'), `${name}.json`);
+    if (!existsSync(declaration)) { failures.push(`missing checkpoint declaration: ${relative(root, declaration)}`); continue; }
+    const seal = JSON.parse(readFileSync(declaration, 'utf8')) as {
+      schema: string; name: string; files: { path: string; sha256: string }[]; project_sha256: string;
+    };
+    if (seal.schema !== 'rig-create/example-checkpoint@1' || seal.name !== name || !Array.isArray(seal.files) || seal.files.length === 0) {
+      throw Error(`${relative(root, declaration)}: invalid checkpoint seal`);
+    }
+    const checkpoint = within(join(chainRoot, 'checkpoints'), name);
+    for (const entry of [...seal.files, { path: 'project.json', sha256: seal.project_sha256 }]) {
+      const path = within(checkpoint, entry.path);
+      const label = relative(root, path);
+      sealedFiles.push(path);
+      if (!existsSync(path)) failures.push(`missing sealed file: ${label}`);
+      else if (!/^[a-f0-9]{64}$/.test(entry.sha256) || hash(path) !== entry.sha256) failures.push(`sha256 mismatch: ${label}`);
+      else ok++;
+    }
+  }
+  return { ok, failures, sealedFiles };
+}
+
+function report(root: string, log: (line: string) => void): ReturnType<typeof verifyExampleSeals> {
+  const result = verifyExampleSeals(root);
+  for (const failure of result.failures) log(failure);
+  log(`checkpoint seals: ${result.ok} ok / ${result.failures.length} fail (files[] plus project_sha256)`);
+  if (result.failures.length) throw Error('example seals failed; repack the unmodified source with scripts/verify-example-seals.ts --pack <output-dir>');
+  return result;
+}
+
+function run(command: string, args: string[], cwd?: string): string {
+  const result = spawnSync(command, args, { cwd, encoding: 'utf8', timeout: 60_000, killSignal: 'SIGKILL', maxBuffer: 16 * 1024 * 1024 });
+  if (result.error || result.status !== 0) throw Error(`${command} ${args.join(' ')} failed: ${result.error?.message ?? result.status}\n${result.stderr}`);
+  return result.stdout;
+}
+
+/** Only the disposable copy gets .npmignore; every original example byte is retained. */
+function stage(root: string, destination: string): void {
+  const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as { files: string[] };
+  mkdirSync(destination);
+  cpSync(join(root, 'package.json'), join(destination, 'package.json'));
+  for (const path of manifest.files) {
+    const target = within(destination, path);
+    mkdirSync(dirname(target), { recursive: true });
+    cpSync(within(root, path), target, { recursive: true });
+  }
+  for (const path of files(join(destination, 'templates')).filter(path => path.endsWith(`${sep}.gitignore`))) {
+    const npmignore = join(dirname(path), '.npmignore');
+    if (existsSync(npmignore)) throw Error(`pack staging would overwrite ${npmignore}`);
+    writeFileSync(npmignore, '!**\n');
+  }
+}
+
+export function verifyTarball(tarball: string, sourceRoot?: string): void {
+  const scratch = mkdtempSync(join(tmpdir(), 'create-example-seals-'));
+  try {
+    run('tar', ['-xzf', resolve(tarball), '-C', scratch]);
+    const root = join(scratch, 'package');
+    const verified = report(root, console.error);
+    if (sourceRoot) {
+      const source = join(sourceRoot, 'templates');
+      const originals = files(source);
+      for (const path of originals) {
+        const target = join(root, 'templates', relative(source, path));
+        if (!existsSync(target) || hash(target) !== hash(path)) throw Error(`packed template missing or changed: templates/${relative(source, path)}`);
+      }
+      console.error(`template byte parity: ${originals.length} files match source`);
+    }
+    // Negative control operates only on the extracted tree, after the positive gate.
+    const deleted = verified.sealedFiles.find(path => path.endsWith(`${sep}.gitignore`))!;
+    unlinkSync(deleted);
+    const planted = verifyExampleSeals(root);
+    const expected = `missing sealed file: ${relative(root, deleted)}`;
+    if (planted.failures.length !== 1 || planted.failures[0] !== expected || planted.ok !== verified.ok - 1) {
+      throw Error(`planted deletion was not detected: ${expected}`);
+    }
+    console.error(`planted deletion detected: ${expected} (${planted.ok} ok / 1 fail)`);
+  } finally { rmSync(scratch, { recursive: true, force: true }); }
+}
+
+export function packExamples(output: string, stageOutput?: string): string {
+  const scratch = mkdtempSync(join(tmpdir(), 'create-example-pack-'));
+  try {
+    const destination = resolve(output);
+    mkdirSync(destination, { recursive: true });
+    const staged = stageOutput === undefined ? join(scratch, 'source') : resolve(stageOutput);
+    stage(packageRoot, staged);
+    const name = (JSON.parse(readFileSync(join(staged, 'package.json'), 'utf8')) as { name: string }).name;
+    const args = ['pack', '.', '--json', '--pack-destination', destination];
+    const packed = readNpmJson(run('npm', args, staged), `npm ${args.join(' ')}`, 'pack', name);
+    const tarball = join(destination, packed.filename);
+    console.error(`npm pack: ${packed.entryCount} files / ${packed.size} bytes compressed / ${packed.unpackedSize} bytes unpacked`);
+    verifyTarball(tarball, packageRoot);
+    return tarball;
+  } finally { rmSync(scratch, { recursive: true, force: true }); }
+}
+
+if (import.meta.main) {
+  try {
+    const [mode, path, ...extra] = process.argv.slice(2);
+    if (mode === undefined) report(packageRoot, console.log);
+    else if (path && extra.length === 0 && mode === '--pack') console.log(packExamples(path));
+    else if (path && extra.length === 0 && mode === '--tarball') verifyTarball(path);
+    else if (path && extra.length === 0 && mode === '--stage') {
+      const scratch = mkdtempSync(join(tmpdir(), 'create-example-stage-gate-'));
+      try { packExamples(scratch, path); console.log(resolve(path)); }
+      finally { rmSync(scratch, { recursive: true, force: true }); }
+    }
+    else throw Error('usage: bun scripts/verify-example-seals.ts [--pack <output-dir> | --tarball <file.tgz> | --stage <fresh-dir>]');
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/src/next.ts

@@ -53,7 +53,8 @@ import {
   stageOfStep,
 } from './stages.ts';
 import type { Json, JsonObject } from './templates.ts';
-import { sceneCurrentAt } from './scene.ts';
+import { sceneCurrentAt, sceneRig, SceneError } from './scene.ts';
+import { resolveAgentCitationSpec } from './scene-authority.ts';
 
 export const NEXT_SCHEMA = 'rig-create/next@1';
 
@@ -202,6 +203,73 @@ function optionCommand(id: string, dir: string): string {
   return `rig-create interview-options ${shellWord(id)} ${shellWord(dir)} --file '<option-set.json>'`;
 }
 
+/** The person acts in Review; the agent only hosts and ingests its exported act. */
+function reviewCommands(dir: string, project: JsonObject, move: NextMove): NextMove[] {
+  const act = move.review_act;
+  if (move.role !== 'human' || move.unanswered_by_record || move.field === 'pauses' || !act) return [move];
+  let selector: string;
+  let writer: string;
+  if (act.kind === 'interview-picks' && act.question_id) {
+    selector = `--question ${shellWord(act.question_id)}`;
+    writer = `interview-answer ${shellWord(act.question_id)}`;
+  } else if (act.kind === 'signoff' && ['interview', 'plan-approved', 'rigging-interview', 'post-interview', 'direction-review'].includes(act.stage)) {
+    selector = '--plan';
+    writer = `signoff ${act.stage}`;
+  } else if (act.kind === 'parts-verdict' && act.draft_id) {
+    selector = `--draft ${shellWord(act.draft_id)}`;
+    writer = 'parts-review';
+  } else if (act.kind === 'signoff' && act.stage === 'parts-review' && act.draft_id) {
+    selector = `--draft ${shellWord(act.draft_id)}`;
+    const structure = partsStructureSnapshot(dir, project, act.draft_id);
+    writer = `signoff parts-review --draft ${shellWord(act.draft_id)} --structure-file ${shellWord(structure.path)}`;
+  } else if (act.kind === 'signoff' && act.stage === 'rig-review' && act.version_id) {
+    selector = `--rig ${shellWord(act.version_id.slice(1))}`;
+    writer = 'signoff rig-review';
+  } else if (['rig-review', 'direction-review'].includes(act.stage) && act.kind === 'review-verdict' && act.version_id) {
+    const n = act.version_id.slice(1);
+    selector = `--rig ${shellWord(n)}`;
+    writer = `review ${shellWord(n)}`;
+  } else return [move];
+  const agent = (command: string, description: string): NextMove => ({
+    role: 'agent', field: move.field, awaits: move.awaits, command, act: description,
+  });
+  const root = shellWord(dir);
+  return [
+    agent(`rig-create job open ${root} ${selector} --reviewer '<reviewer>' --role owner`, 'host this Review page; keep the host running in a separate terminal until job close'),
+    move,
+    agent(`rig-create job acts ${root} --json`, `after the person submits in Review, list exported acts and use the matching actId below${act.stage === 'parts-review' ? '; run its reported preconditions before ingestion (parts-review signoff includes structure-snapshot)' : ''}`),
+    agent(`rig-create ${writer} ${root} --from-review '<actId>'`, 'ingest the matching exported Review act; never supply the human answer or words'),
+    agent(`rig-create job close ${root}`, 'after successful ingestion, close this job before opening the next Review page'),
+  ];
+}
+
+function sceneWriteCommand(dir: string, project: JsonObject, rigN: string): string {
+  let flags = ` --background '<background.png>'`;
+  const item = collectItems(project, { collection: loadCollection(dir) }).find(item => item.id === 'post_composition');
+  if (item && (item.state.state === 'user' || item.state.state === 'delegated')) {
+    const answer = item.state.answer;
+    const citation = { guide: 'post_composition', asks: ['post_composition'],
+      ...(item.state.state === 'delegated' ? { delegated: true } : { quote: answer.verbatim! }) };
+    try {
+      const spec = resolveAgentCitationSpec(dir, project, citation);
+      const stage = sceneRig(dir, project, Number(rigN)).stage;
+      for (const role of ['background', 'foreground'] as const) {
+        const plate = spec[role];
+        if (!plate) continue;
+        if (role === 'foreground') flags += ` --foreground '<foreground.png>'`;
+        const { x, y, width, height } = plate.rect;
+        if (x !== stage.x || y !== stage.y || width !== stage.width || height !== stage.height) {
+          flags += ` --${role}-rect ${shellWord([x, y, width, height].join(','))}`;
+        }
+      }
+    } catch (error) {
+      if (!(error instanceof SceneError)) throw error;
+      // The scene writer reports the existing named refusal for an unresolved choice.
+    }
+  }
+  return `rig-create scene write ${shellWord(dir)} --rig ${shellWord(rigN)}${flags} --citations-file '<scene-citations.json>'`;
+}
+
 function candidateAdvance(
   dir: string,
   project: JsonObject,
@@ -880,9 +948,9 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
     }
 
     const planIds = effectiveStage === 'rigging-interview' ? ['bones', 'meshes', 'constraints', 'motion']
-      : effectiveStage === 'post-interview' ? ['camera', 'timing'] : ['seethrough', 'assemble'];
+      : effectiveStage === 'post-interview' ? ['camera', 'timing', 'composition'] : ['seethrough', 'assemble'];
     const missingPlanIds = planIds.filter(id => {
-      const guide = id === 'camera' ? 'camera_depth' : id === 'timing' ? 'post_timing' : id;
+      const guide = id === 'camera' ? 'camera_depth' : id === 'timing' ? 'post_timing' : id === 'composition' ? 'post_composition' : id;
       const phase = effectiveStage === 'post-interview' ? 'post' : 'rig';
       return !steps.some(step => step.phase === phase && (step.id === id
         || phase === 'post' && asArray(step.rests_on).includes(guide)));
@@ -891,7 +959,7 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
     if (needsPlanSteps) {
       addAwait('plan.steps');
       for (const [index, id] of missingPlanIds.entries()) {
-        const guideId = id === 'camera' ? 'camera_depth' : id === 'timing' ? 'post_timing' : id;
+        const guideId = id === 'camera' ? 'camera_depth' : id === 'timing' ? 'post_timing' : id === 'composition' ? 'post_composition' : id;
         const item = stageItems.find(item => item.id === guideId);
         if (!item || item.state.state === 'silent' || (item.state.state === 'delegated' && !item.state.decided)) continue;
         const order = Math.max(0, ...steps.map(step => Number(step.order) || 0)) + index + 1;
@@ -902,6 +970,10 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
       }
     }
 
+    const missingStepNames = missingPlanIds.length === planIds.length ? '' : `${missingPlanIds.join(', ')} `;
+    const missingStepKind = effectiveStage === 'post-interview' ? 'post' : 'rig';
+    const missingPlanReason = `plan.steps has no ${missingStepNames}${missingStepKind} step${missingPlanIds.length === 1 ? '' : 's'}`;
+
     const signoffAwait = `signoffs[stage=${effectiveStage}]`;
     if (!hasLiveStageSignoff(effectiveStage) && !recordedLapseTargets.has(signoffAwait)) {
       addAwait(signoffAwait);
@@ -912,10 +984,10 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
         command: null,
         act: needsPlanSteps
           ? effectiveStage === 'rigging-interview'
-            ? 'review-tool act signoff for stage rigging-interview (unanswered by record: plan.steps has no rig steps approved at rigging-interview)'
-            : `review-tool act signoff for stage ${effectiveStage} (unanswered by record: ${effectiveStage === 'post-interview' ? 'plan.steps has no post steps' : steps.length === 0 ? 'plan.steps is empty' : 'plan.steps has uncovered parts guides'} in project.json)`
+            ? `review-tool act signoff for stage rigging-interview (unanswered by record: ${missingPlanReason} approved at rigging-interview)`
+            : `review-tool act signoff for stage ${effectiveStage} (unanswered by record: ${effectiveStage === 'post-interview' ? missingPlanReason : steps.length === 0 ? 'plan.steps is empty' : 'plan.steps has uncovered parts guides'} in project.json)`
           : effectiveStage === 'interview'
-            ? 'review-tool act signoff for stage interview on the record page with job open --plan (source-linked Review); ingest signoff interview --from-review <actId>, then advance plan-approved'
+            ? 'review-tool act signoff for stage interview on the record page with job open --plan; ingest signoff interview --from-review <actId>, then advance plan-approved'
             : `review-tool act signoff for stage ${effectiveStage}`,
         review_act: {
           kind: 'signoff',
@@ -1389,7 +1461,7 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
         } else if (currentScene === undefined) {
           addAwait('scenes[n=1]');
           moves.push({ role: 'agent', field: 'scenes', awaits: 'scenes[n=1]',
-            command: `rig-create scene write ${shellWord(dir)} --rig ${shellWord(rigN)} --background '<background.png>' --citations-file '<scene-citations.json>'`,
+            command: sceneWriteCommand(dir, project, rigN),
             act: 'author scene inputs matching the current post_composition Review choice, then write the scene' });
         } else {
           addAwait(`versions[n=${nextPostN}]`);
@@ -1432,7 +1504,7 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
             field: `versions[v${postN}].verdicts`,
             awaits: verdictAwait,
             command: null,
-            act: `review-tool act review-verdict for versions[v${postN}] (direction-review) on the post page: job open --rig ${postN}; ingest with review ${postN} --from-review <actId>; then request record-page sign-off with job open --plan (source-linked Review)`,
+            act: `review-tool act review-verdict for versions[v${postN}] (direction-review) on the post page: job open --rig ${postN}; ingest with review ${postN} --from-review <actId>; then request record-page sign-off with job open --plan`,
             review_act: {
               kind: 'review-verdict',
               stage: 'direction-review',
@@ -1454,8 +1526,8 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
           command: null,
           act:
             postN === null
-              ? `after recording the current post and accepted direction verdict, request review-tool act signoff for direction-review on the record page with job open --plan (source-linked Review; unanswered by record: ${scenes.length === 0 ? 'scenes[n=1] and ' : ''}versions[n=${nextPostN}] are not recorded in project.json)`
-              : `after ingesting the accepted direction-review verdict for v${postN}, request review-tool act signoff on the record page with job open --plan (source-linked Review), ingest signoff direction-review --from-review <actId>, then advance accepted`,
+              ? `after recording the current post and accepted direction verdict, request review-tool act signoff for direction-review on the record page with job open --plan (unanswered by record: ${scenes.length === 0 ? 'scenes[n=1] and ' : ''}versions[n=${nextPostN}] are not recorded in project.json)`
+              : `after ingesting the accepted direction-review verdict for v${postN}, request review-tool act signoff on the record page with job open --plan, ingest signoff direction-review --from-review <actId>, then advance accepted`,
           review_act: {
             kind: 'signoff',
             stage: 'direction-review',
@@ -1503,6 +1575,12 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
     });
   }
 
+  const runnableMoves = moves.flatMap(move => {
+    if (move.review_act?.stage === 'direction-review' && move.review_act.kind === 'signoff'
+      && moves.some(other => other.review_act?.stage === 'direction-review' && other.review_act.kind === 'review-verdict')) return [move];
+    return reviewCommands(dir, project, move);
+  });
+
   return {
     schema: NEXT_SCHEMA,
     project_id: String(project.name ?? ''),
@@ -1512,7 +1590,7 @@ export function nextProject(projectDirArg: string, now: number = Date.now()): Ne
     refusals,
     ...warningFields,
     awaits: awaitsList,
-    moves,
+    moves: runnableMoves,
   };
 }
 

package/templates/example-chain/.gitignore

@@ -0,0 +1,6 @@
+/derived/
+/outputs/
+/scratch/
+node_modules/
+/.rig-create-review-binding.json
+/.rig-create-review/

package/templates/example-chain/.npmignore

@@ -0,0 +1 @@
+!**

package/templates/example-chain/checkpoints/0a-interview-options/.gitignore

@@ -0,0 +1,6 @@
+/derived/
+/outputs/
+/scratch/
+node_modules/
+/.rig-create-review-binding.json
+/.rig-create-review/

package/templates/example-chain/checkpoints/0a-interview-options/.npmignore

@@ -0,0 +1 @@
+!**

package/templates/example-chain/checkpoints/0b-plan-pending/.gitignore

@@ -0,0 +1,6 @@
+/derived/
+/outputs/
+/scratch/
+node_modules/
+/.rig-create-review-binding.json
+/.rig-create-review/

package/templates/example-chain/checkpoints/0b-plan-pending/.npmignore

@@ -0,0 +1 @@
+!**

package/templates/example-chain/checkpoints/1-parts-verdict/.gitignore

@@ -0,0 +1,6 @@
+/derived/
+/outputs/
+/scratch/
+node_modules/
+/.rig-create-review-binding.json
+/.rig-create-review/

package/templates/example-chain/checkpoints/1-parts-verdict/.npmignore

@@ -0,0 +1 @@
+!**

package/templates/example-chain/checkpoints/1-parts-verdict/derived/drafts/chain/config.json

@@ -0,0 +1,88 @@
+{
+  "key": "synthetic",
+  "requirements": "interview-requirements.json",
+  "assemble": {
+    "rig_scale": 1,
+    "plan": [
+      [
+        "background",
+        "full",
+        "author:background"
+      ],
+      [
+        "torso",
+        "full",
+        "topwear"
+      ],
+      [
+        "lantern",
+        "full",
+        "author:lantern"
+      ],
+      [
+        "face",
+        "full",
+        "face"
+      ],
+      [
+        "eye_r",
+        "full",
+        "eyewhite-r"
+      ],
+      [
+        "eye_l",
+        "full",
+        "eyewhite-l"
+      ]
+    ]
+  },
+  "bones": [
+    {
+      "name": "body",
+      "parent": "root",
+      "at": [
+        64,
+        64
+      ]
+    }
+  ],
+  "meshes": {
+    "torso": {
+      "grid": 16,
+      "r": 16,
+      "segments": [
+        [
+          "body",
+          [
+            64,
+            8
+          ],
+          [
+            64,
+            72
+          ]
+        ]
+      ]
+    }
+  },
+  "regions": {
+    "background": "body",
+    "lantern": "body",
+    "face": "body",
+    "eye_r": "body",
+    "eye_l": "body"
+  },
+  "motion": {
+    "duration": 4,
+    "tracks": [
+      {
+        "bone": "body",
+        "prop": "translatey",
+        "amp": 0.9,
+        "period": 4,
+        "phase": 0,
+        "base": 0
+      }
+    ]
+  }
+}