pincer-workflow 0.4.0 → 0.5.0

package/template/scripts/pincer-runtime.cjs

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+'use strict';
+// PINCER runtime — the local command entry point (docs/runtime-contracts.md).
+//
+//   node scripts/pincer-runtime.cjs validate <file>... [--digests]
+//   node scripts/pincer-runtime.cjs register --prd .prd/prd-vN.md [--change <id>] [--authorization <text>] [--replace] [--rebind]
+//   node scripts/pincer-runtime.cjs snapshot [--json] [--store]
+//   node scripts/pincer-runtime.cjs recover
+//   node scripts/pincer-runtime.cjs status [--json]
+//   node scripts/pincer-runtime.cjs ready [T-NN]
+//   node scripts/pincer-runtime.cjs start|verify|done T-NN · bind T-NN .prd/prd-vN.md
+//   node scripts/pincer-runtime.cjs migrate --preview|--apply --prd .prd/prd-vN.md [--change <id>] [--authorization <text>]
+//   node scripts/pincer-runtime.cjs check C-NN --candidate <sha> [--timeout <seconds>] -- <command...>
+//   node scripts/pincer-runtime.cjs evidence export --candidate <sha> --base <sha> --prd .prd/prd-vN.md --draft <file>
+//
+// Exit codes: 0 ok · 1 failed/not ready/refused · 2 usage · 3 state busy ·
+// 4 invalid input or state · 124 timed out · 130 interrupted.
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const parse = require('./pincer-runtime/parse.cjs');
+const identity = require('./pincer-runtime/identity.cjs');
+const source = require('./pincer-runtime/source.cjs');
+const state = require('./pincer-runtime/state.cjs');
+const status = require('./pincer-runtime/status.cjs');
+const runner = require('./pincer-runtime/runner.cjs');
+const sanitize = require('./pincer-runtime/sanitize.cjs');
+const lifecycle = require('./pincer-runtime/lifecycle.cjs');
+const migrate = require('./pincer-runtime/migrate.cjs');
+const evidence = require('./pincer-runtime/evidence.cjs');
+const { atomicWrite, nowIso, tryGit } = require('./pincer-runtime/fsutil.cjs');
+const EXIT = { OK: 0, FAILED: 1, USAGE: 2, BUSY: 3, INVALID: 4, TIMED_OUT: 124, INTERRUPTED: 130 };
+
+function repoRoot() {
+  if (process.env.CLAUDE_PROJECT_DIR) return path.resolve(process.env.CLAUDE_PROJECT_DIR);
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+function usage(message) {
+  if (message) process.stderr.write(`pincer: ${message}\n`);
+  process.stderr.write('usage: pincer-runtime.cjs validate <file>... [--digests]\n' +
+    '       pincer-runtime.cjs register --prd .prd/prd-vN.md [--change <id>] [--authorization <text>] [--replace] [--rebind]\n' +
+    '       pincer-runtime.cjs snapshot [--json] [--store]\n' +
+    '       pincer-runtime.cjs recover\n' +
+    '       pincer-runtime.cjs status [--json]\n' +
+    '       pincer-runtime.cjs ready [T-NN]\n' +
+    '       pincer-runtime.cjs start|verify|done T-NN\n' +
+    '       pincer-runtime.cjs bind T-NN .prd/prd-vN.md\n' +
+    '       pincer-runtime.cjs migrate --preview|--apply --prd .prd/prd-vN.md [--change <id>] [--authorization <text>]\n' +
+    '       pincer-runtime.cjs check C-NN --candidate <sha> [--timeout <seconds>] -- <command...>\n' +
+    '       pincer-runtime.cjs evidence export --candidate <sha> --base <sha> --prd .prd/prd-vN.md --draft <file>\n');
+  process.exit(EXIT.USAGE);
+}
+
+// The clean-view precondition for candidate checks and exports: HEAD is the
+// candidate and nothing is dirty outside NOTES.md and the candidate's evidence
+// directory. Never stashes, resets or commits.
+function requireCandidateView(root, candidate, prd) {
+  const head = identity.head(root);
+  if (!head) fail('pincer', 'not a git repository with commits', EXIT.INVALID);
+  const version = prd.match(parse.PRD_REF)[1];
+  const allowed = p => p === 'NOTES.md' || p.startsWith(`.prd/evidence/prd-v${version}/${candidate}/`);
+  if (head !== candidate) {
+    // A descendant that only adds NOTES.md and the candidate's evidence (the
+    // evaluate commit) is still a clean view of the candidate's source.
+    const ancestor = tryGit(root, ['merge-base', '--is-ancestor', candidate, 'HEAD']);
+    const diff = ancestor.error ? { error: 'not an ancestor' } : tryGit(root, ['diff', '--name-only', candidate, 'HEAD']);
+    const differing = diff.error ? null : diff.out.split('\n').filter(Boolean).filter(p => !allowed(p));
+    if (!differing || differing.length) {
+      fail('pincer', `HEAD is ${head.slice(0, 7)}, not the candidate ${candidate.slice(0, 7)}${differing ? ` and differs from it in: ${differing.slice(0, 5).join(', ')}` : ' (the candidate is not an ancestor of HEAD)'}; check out the committed candidate first (no stash, reset or commit is made for you)`, EXIT.FAILED);
+    }
+  }
+  const dirty = tryGit(root, ['status', '--porcelain', '--untracked-files=all']);
+  if (dirty.error) fail('pincer', `git status failed: ${dirty.error}`, EXIT.INVALID);
+  const offending = dirty.out.split('\n').filter(Boolean).map(l => l.slice(3).replace(/^"(.*)"$/, '$1')).filter(p => !allowed(p));
+  if (offending.length) fail('pincer', `the working tree is not a clean view of the candidate: ${offending.slice(0, 5).join(', ')}${offending.length > 5 ? ` (+${offending.length - 5})` : ''}; only NOTES.md and .prd/evidence/prd-v${version}/${candidate}/ may differ`, EXIT.FAILED);
+}
+
+async function cmdCheck(root, args) {
+  const o = parseOptions(args, { valued: ['--candidate', '--timeout'] });
+  const [checkId, ...command] = o.positional;
+  if (!checkId || !evidence.CHECK_ID.test(checkId)) usage('check requires a check ID such as C-01');
+  if (!o.candidate || !parse.HEX40.test(o.candidate)) usage('check requires --candidate <full 40-hex commit ID>');
+  if (!command.length) usage('check requires the command after --');
+  const timeout = o.timeout === undefined ? parse.DEFAULT_TIMEOUT : Number(o.timeout);
+  if (!Number.isInteger(timeout) || timeout <= 0) usage('--timeout must be a positive integer number of seconds');
+  const bind = identity.loadBinding(root);
+  if (bind.code) fail('pincer', `${bind.code}: ${bind.problem}`, EXIT.INVALID);
+  const b = bind.binding;
+  requireCandidateView(root, o.candidate, b.prd);
+  const line = command.join(' ');
+  const secretLine = sanitize.inlineSecretLine([line]);
+  if (secretLine) fail('pincer', 'the check command assigns a secret-like literal; reference it from the environment instead', EXIT.INVALID);
+  process.stdout.write(`── ${checkId} candidate ${o.candidate.slice(0, 7)} ──\n  $ ${sanitize.sanitizeText(line).text}\n`);
+  const context = { kind: 'candidate', change: b.change, prd: b.prd, prd_revision: b.prd_revision, base: b.base, candidate: o.candidate, check: checkId };
+  const result = await runner.runAttempt({ root, context, commands: [line], timeoutSeconds: timeout, command: `check ${checkId}` });
+  if (result.code) fail('pincer', `${result.code}: ${result.problem}`, problemExit(result.code));
+  const a = result.attempt;
+  const logs = `${state.RUNTIME_DIR}/attempts/${a.id}/`;
+  if (a.outcome === 'passed') process.stdout.write(`✓ ${checkId} passed — attempt ${a.id} (source ${a.source.after.slice(0, 12)}, logs ${logs})\n`);
+  else process.stderr.write(`✗ ${checkId} ${a.outcome}${a.exit_code !== null ? ` (exit ${a.exit_code})` : ''}${a.error ? `: ${a.error}` : ''} — attempt ${a.id} (logs ${logs})\n`);
+  process.exit(runner.exitFor(a));
+}
+
+function cmdEvidence(root, args) {
+  const [sub, ...rest] = args;
+  if (sub !== 'export') usage('evidence supports: export');
+  const o = parseOptions(rest, { valued: ['--candidate', '--base', '--prd', '--draft'] });
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  for (const key of ['candidate', 'base']) if (!o[key] || !parse.HEX40.test(o[key])) usage(`evidence export requires --${key} <full 40-hex commit ID>`);
+  if (!o.prd || !parse.PRD_REF.test(o.prd)) usage('evidence export requires --prd .prd/prd-vN.md');
+  if (!o.draft) usage('evidence export requires --draft <file>');
+  const bind = identity.loadBinding(root, { prd: o.prd });
+  if (bind.code) fail('pincer', `${bind.code}: ${bind.problem}`, EXIT.INVALID);
+  requireCandidateView(root, o.candidate, o.prd);
+  let draft;
+  try { draft = JSON.parse(fs.readFileSync(path.resolve(root, o.draft), 'utf8')); } catch (error) { fail('pincer', `cannot read draft ${o.draft}: ${error.message}`, EXIT.INVALID); }
+  const indexRead = state.exists(root) ? state.readIndex(root) : { index: null };
+  if (indexRead.error) fail('pincer', indexRead.error, EXIT.INVALID);
+  const attemptsFor = checkId => {
+    if (!indexRead.index) return { attempt: null, pointed: null };
+    const key = state.contextKey({ kind: 'candidate', candidate: o.candidate, check: checkId });
+    return { attempt: state.latestAttempt(root, key, indexRead.index), pointed: indexRead.index.current[key] || null };
+  };
+  const os = require('node:os');
+  const result = evidence.exportEvidence(root, {
+    candidate: o.candidate, base: o.base, prd: o.prd, draft, binding: bind.binding, attemptsFor,
+    environment: { os: `${os.platform()} ${os.release()}`, node: process.version }, now: nowIso(), atomicWrite,
+  });
+  if (result.problems.length) {
+    for (const p of result.problems) process.stderr.write(`evidence: ${result.manifest || o.draft}: ${p}\n`);
+    process.exit(EXIT.FAILED);
+  }
+  process.stdout.write(`exported ${result.manifest} (schema 2) — validate: node scripts/pincer-evidence.cjs validate ${result.manifest} --candidate ${o.candidate} --prd ${o.prd}\n`);
+  process.exit(EXIT.OK);
+}
+
+function cmdMigrate(root, args) {
+  const o = parseOptions(args, { valued: ['--prd', '--change', '--authorization'], switches: ['--preview', '--apply'] });
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  if (!o.prd) usage('migrate requires --prd .prd/prd-vN.md');
+  if (Boolean(o.preview) === Boolean(o.apply)) usage('migrate requires exactly one of --preview or --apply');
+  const options = { prd: o.prd, change: o.change, authorization: o.authorization ?? null };
+  if (o.preview) {
+    const p = migrate.plan(root, options);
+    process.stdout.write(migrate.renderPlan(p));
+    process.exit(p.conflicts.length ? EXIT.FAILED : EXIT.OK);
+  }
+  const result = migrate.apply(root, options);
+  if (result.plan.conflicts.length) { process.stdout.write(migrate.renderPlan(result.plan)); process.exit(EXIT.FAILED); }
+  if (result.already) { process.stdout.write(`already migrated: ${o.prd} is bound as change ${result.plan.change}; nothing changed\n`); process.exit(EXIT.OK); }
+  if (result.error) { process.stderr.write(`pincer: migration stopped before the binding was written: ${result.error}\n`); process.exit(EXIT.INVALID); }
+  const b = result.binding;
+  process.stdout.write(`migrated ${o.prd} → change ${b.change} (revision ${b.prd_revision.slice(0, 12)}, base ${b.base.slice(0, 7)}, ${Object.keys(result.plan.tickets.length ? b.legacy_receipts : {}).length || result.plan.tickets.length} ticket(s) rewritten)\n`);
+  if (result.backupDir) process.stdout.write(`backups: ${result.backupDir} (${result.backups.length} file(s)); rollback per docs/runtime-contracts.md\n`);
+  if (!o.authorization) process.stderr.write('pincer: note: no --authorization recorded; migration does not prove human approval\n');
+  process.exit(EXIT.OK);
+}
+
+const fail = (prefix, message, code = EXIT.INVALID) => { process.stderr.write(`${prefix}: ${message}\n`); process.exit(code); };
+
+// start | verify | done | bind — both modes; refusals carry their prefix and exit code.
+async function cmdLifecycle(root, command, args) {
+  const usageLine = { start: 'start T-NN', verify: 'verify T-NN', done: 'done T-NN', bind: 'bind T-NN .prd/prd-vN.md' }[command];
+  const expected = command === 'bind' ? 2 : 1;
+  const o = parseOptions(args, {});
+  if (o.positional.length !== expected) usage(`usage: pincer-runtime.cjs ${usageLine}`);
+  try {
+    const result = command === 'bind' ? lifecycle.bind(root, o.positional[0], o.positional[1])
+      : command === 'start' ? lifecycle.start(root, o.positional[0])
+        : command === 'verify' ? await lifecycle.verify(root, o.positional[0])
+          : await lifecycle.done(root, o.positional[0]);
+    if (result.out) process.stdout.write(result.out);
+    process.exit(result.exit ?? EXIT.OK);
+  } catch (error) {
+    if (error instanceof lifecycle.Refusal) fail(error.prefix, error.message, error.exit);
+    throw error;
+  }
+}
+
+function cmdStatus(root, args) {
+  const o = parseOptions(args, { switches: ['--json'] });
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  const budget = process.env.PINCER_BUILD_BUDGET_MIN || '';
+  const result = status.render(root, { budget });
+  if (o.json) process.stdout.write(`${JSON.stringify(result.json, null, 2)}\n`);
+  else process.stdout.write(result.text);
+  process.exit(result.exit);
+}
+
+// Read-only readiness gate: a ticket, or the candidate when no ticket is named.
+function cmdReady(root, args) {
+  const o = parseOptions(args, {});
+  if (o.positional.length > 1) usage('ready takes at most one ticket ID');
+  const result = status.render(root, {});
+  if (result.exit !== 0) { process.stderr.write(result.text); process.exit(result.exit); }
+  const j = result.json;
+  if (o.positional.length === 1) {
+    const id = parse.normalizeId(o.positional[0]);
+    const ticket = id && j.tickets.find(t => t.id === id);
+    if (!ticket) { process.stderr.write(`pincer: no ticket ${o.positional[0]} is associated with the selected PRD\n`); process.exit(EXIT.INVALID); }
+    if (ticket.readiness.ready) { process.stdout.write(`ready ${id}\n`); process.exit(EXIT.OK); }
+    for (const r of ticket.readiness.reasons) process.stdout.write(`not ready ${id}: ${r.code} ${r.detail}\n`);
+    process.stdout.write(`next: ${ticket.readiness.next}\n`);
+    process.exit(EXIT.FAILED);
+  }
+  const blockers = [];
+  const localUnavailable = j.candidate && j.candidate.local_attempts === 'unavailable';
+  for (const t of j.tickets) {
+    if (t.status !== 'done') blockers.push({ code: 'EVIDENCE_MISSING', detail: `${t.id} is ${t.status}, not done` });
+    else for (const r of t.readiness.reasons) {
+      // A fresh clone validates the saved candidate record only; missing local attempts are its stated limit, not a blocker.
+      if (localUnavailable && r.code === 'EVIDENCE_MISSING') continue;
+      blockers.push({ code: r.code, detail: `${t.id}: ${r.detail}` });
+    }
+  }
+  if (!j.prd) blockers.push({ code: 'INPUT_INVALID', detail: 'no PRD' });
+  else if (j.prd.status !== 'built') blockers.push({ code: 'CANDIDATE_STALE', detail: `PRD status is '${j.prd.status}', expected 'built'` });
+  if (j.candidate) blockers.push(...j.candidate.reasons);
+  if (!blockers.length) { process.stdout.write(`ready candidate ${j.candidate.candidate}\n`); process.exit(EXIT.OK); }
+  for (const b of blockers) process.stdout.write(`not ready: ${b.code} ${b.detail}\n`);
+  process.stdout.write(`next: ${j.next}\n`);
+  process.exit(EXIT.FAILED);
+}
+
+// Run a state operation, mapping the contracted failures to exit codes.
+function guarded(fn) {
+  try { return fn(); } catch (error) {
+    if (error && error.code === 'STATE_BUSY') { process.stderr.write(`pincer: STATE_BUSY: ${error.message}\n`); process.exit(EXIT.BUSY); }
+    if (error && error.code === 'INVALID') { process.stderr.write(`pincer: ${error.message}\n`); process.exit(EXIT.INVALID); }
+    throw error;
+  }
+}
+
+function cmdRecover(root, args) {
+  const o = parseOptions(args, {});
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  if (!state.exists(root)) { process.stdout.write('nothing to recover: no local runtime state\n'); process.exit(EXIT.OK); }
+  const report = guarded(() => state.recover(root));
+  for (const id of report.finalized) process.stdout.write(`finalized ${id} as interrupted (owner no longer running)\n`);
+  for (const { id, owner } of report.live) process.stdout.write(`still running ${id} (pid ${owner.pid} is alive)\n`);
+  for (const { id, owner } of report.foreign) process.stdout.write(`still running ${id} (owned by ${owner.host}; not reclaimed from another host)\n`);
+  for (const id of report.missing) process.stdout.write(`dropped ${id} from running: record missing\n`);
+  for (const file of report.journal) process.stdout.write(`removed stray journal file ${file}\n`);
+  if (!Object.values(report).some(list => list.length)) process.stdout.write('nothing to recover\n');
+  process.exit(EXIT.OK);
+}
+
+// `--flag value` and `--switch` options; positional arguments keep their order.
+function parseOptions(args, { valued = [], switches = [] } = {}) {
+  const options = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--') { options.positional.push(...args.slice(i + 1)); break; }
+    if (valued.includes(arg)) {
+      const value = args[++i];
+      if (value === undefined) usage(`${arg} requires a value`);
+      options[arg.slice(2)] = value;
+    } else if (switches.includes(arg)) options[arg.slice(2)] = true;
+    else if (arg.startsWith('--')) usage(`unknown option ${arg}`);
+    else options.positional.push(arg);
+  }
+  return options;
+}
+const problemExit = code => (code === 'STATE_BUSY' ? EXIT.BUSY : EXIT.INVALID);
+
+function cmdRegister(root, args) {
+  const o = parseOptions(args, { valued: ['--prd', '--change', '--authorization'], switches: ['--replace', '--rebind'] });
+  if (!o.prd) usage('register requires --prd .prd/prd-vN.md');
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  const result = identity.register(root, { prd: o.prd, change: o.change, authorization: o.authorization ?? null, replace: Boolean(o.replace), rebind: Boolean(o.rebind) });
+  if (result.code) { process.stderr.write(`pincer: ${result.problem}\n`); process.exit(problemExit(result.code)); }
+  for (const note of result.notes) process.stderr.write(`pincer: note: ${note}\n`);
+  const b = result.binding;
+  process.stdout.write(`${result.action} change ${b.change} → ${b.prd} revision ${b.prd_revision.slice(0, 12)} base ${b.base.slice(0, 7)} (${result.file})\n`);
+  process.exit(EXIT.OK);
+}
+
+function cmdSnapshot(root, args) {
+  const o = parseOptions(args, { switches: ['--json', '--store'] });
+  if (o.positional.length) usage(`unexpected argument ${o.positional[0]}`);
+  const manifest = source.snapshot(root);
+  for (const problem of manifest.problems) process.stderr.write(`pincer: ${problem.code}: ${problem.detail}\n`);
+  if (manifest.problems.length) process.exit(EXIT.INVALID);
+  if (o.store) source.storeManifest(root, manifest);
+  if (o.json) process.stdout.write(`${JSON.stringify(manifest, null, 2)}\n`);
+  else {
+    process.stdout.write(`digest ${manifest.digest}\nfiles ${manifest.files.length}\nexcluded ${manifest.excluded.length}\n`);
+    for (const l of manifest.limitations) process.stderr.write(`pincer: limitation: ${l}\n`);
+  }
+  process.exit(EXIT.OK);
+}
+
+function cmdValidate(root, args) {
+  const digests = args.includes('--digests');
+  const files = args.filter(arg => arg !== '--digests');
+  if (files.some(arg => arg.startsWith('--'))) usage(`unknown option ${files.find(arg => arg.startsWith('--'))}`);
+  if (files.length === 0) usage('validate requires at least one file');
+  let invalid = false;
+  const report = (prefix, file, problems) => { for (const p of problems) process.stderr.write(`${prefix}: ${file}: ${p}\n`); invalid ||= problems.length > 0; };
+  for (const file of files) {
+    const relative = path.isAbsolute(file) ? path.relative(root, file) : file;
+    const base = path.basename(relative);
+    if (/^T-[0-9]+.*\.md$/.test(base)) {
+      let text;
+      try { text = fs.readFileSync(path.resolve(root, relative), 'utf8'); } catch { report('pincer-ticket', relative, ['no such file']); continue; }
+      const result = parse.validateTicket(relative, text);
+      report('pincer-ticket', relative, result.problems);
+      if (result.ok && digests) {
+        process.stdout.write(`ticket ${parse.ticketDigest(text)}\n`);
+        process.stdout.write(`check ${parse.checkDigest(text, result.timeout)}\n`);
+      }
+    } else if (parse.PRD_REF.test(relative)) {
+      const result = parse.validatePrd(root, relative);
+      report('pincer', relative, result.problems);
+      if (result.ok && digests) process.stdout.write(`prd ${parse.prdDigest(result.text)}\n`);
+    } else {
+      let text;
+      try { text = fs.readFileSync(path.resolve(root, relative), 'utf8'); } catch { report('pincer', relative, ['no such file']); continue; }
+      report('pincer', relative, parse.validateMetadata(text).problems);
+    }
+  }
+  process.exit(invalid ? EXIT.INVALID : EXIT.OK);
+}
+
+function main(argv) {
+  const [command, ...rest] = argv;
+  const root = repoRoot();
+  if (command === 'validate') return cmdValidate(root, rest);
+  if (command === 'register') return cmdRegister(root, rest);
+  if (command === 'snapshot') return cmdSnapshot(root, rest);
+  if (command === 'recover') return cmdRecover(root, rest);
+  if (command === 'status') return cmdStatus(root, rest);
+  if (command === 'ready') return cmdReady(root, rest);
+  if (['start', 'verify', 'done', 'bind'].includes(command)) return cmdLifecycle(root, command, rest);
+  if (command === 'migrate') return cmdMigrate(root, rest);
+  if (command === 'check') return cmdCheck(root, rest);
+  if (command === 'evidence') return cmdEvidence(root, rest);
+  usage(command ? `unknown command ${command}` : undefined);
+}
+
+Promise.resolve(main(process.argv.slice(2))).catch(error => {
+  process.stderr.write(`pincer: unexpected error: ${error && error.stack ? error.stack : error}\n`);
+  process.exit(EXIT.INVALID);
+});

package/template/scripts/pincer-status.sh

@@ -2,167 +2,16 @@
 # PINCER status — where the workflow stands, read from the artifacts on disk.
 # Read-only. Every playbook runs this first; /pincer-status wraps it.
 #
-#   scripts/pincer-status.sh
+#   scripts/pincer-status.sh [--json]
 #
-# Elapsed times come from the `started` / `finished` stamps that
-# scripts/pincer-ticket.sh writes, i.e. from the wall clock — never estimated
-# and never a measure of active execution time. The build-wide elapsed line is
-# printed only while a ticket is in progress or an explicit budget is set.
-# Optional build budget: PINCER_BUILD_BUDGET_MIN.
-set -uo pipefail
-
-source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/pincer-ticket-lib.sh"
-ROOT=${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}
-cd "$ROOT"
-BUDGET=${PINCER_BUILD_BUDGET_MIN:-}
-NOW=$(date -u +%s)
-
-to_epoch() { # ISO-8601 UTC -> seconds (GNU date, then BSD date)
-  date -u -d "$1" +%s 2>/dev/null || date -u -j -f '%Y-%m-%dT%H:%M:%SZ' "$1" +%s 2>/dev/null || echo 0
+# Compatibility wrapper: the report is computed by scripts/pincer-runtime.cjs
+# (`status`), which prints the PRD state and profile, every ticket with its
+# state and clock-based elapsed time, the wall-clock elapsed build line while a
+# ticket is in progress or PINCER_BUILD_BUDGET_MIN is set, the evidence verdict,
+# readiness warnings, and the next command. Exit codes follow
+# docs/runtime-contracts.md (0 inspected, 4 invalid input).
+command -v node >/dev/null 2>&1 || {
+  echo 'pincer-status: Node.js 18+ is required — the runtime is scripts/pincer-runtime.cjs' >&2
+  exit 4
 }
-mins() { echo "$(( ($2 - $1) / 60 ))m"; }
-hhmm() { [ -n "$1" ] && printf '%s' "$1" | cut -c12-16 || printf '—'; }
-
-echo "PINCER status · $(date -u +%Y-%m-%dT%H:%MZ) · $ROOT"
-
-# ── PRD ──
-if ! prd=$(latest_prd 2>&1); then
-  printf 'WARN     invalid PRD: %s\n' "$prd"
-  echo 'Next     repair PRD input before continuing'
-  exit 1
-fi
-prd_status=""
-if [ -z "$prd" ]; then
-  echo "PRD      none"
-else
-  prd_status=$(fm_get "$prd" status)
-  echo "PRD      $prd · status: ${prd_status:-?} · profile: $(prd_profile "$prd") · date: $(fm_get "$prd" date)"
-fi
-
-# Reject malformed/ambiguous tickets instead of treating unknown states as open.
-if ! errors=$(validate_ticket_set 2>&1); then
-  printf 'WARN     invalid tickets: %s\n' "$errors"
-  echo "Next     repair ticket input before continuing"
-  exit 1
-fi
-
-# ── Tickets ──
-n_open=0; n_prog=0; n_done=0; first_start=""; in_prog=""; next_open=""; warn=""; reverify=""
-files=""; historical=0; unresolved=0
-for f in tickets/T-*.md; do
-  [ -e "$f" ] || continue
-  if ! associated=$(ticket_prd "$f" 2>&1); then
-    printf 'WARN     unresolved ticket PRD: %s\n' "$associated"
-    unresolved=$((unresolved + 1)); continue
-  fi
-  if [ "$associated" = "$prd" ]; then
-    files="$files$f
-"
-  else
-    historical=$((historical + 1))
-  fi
-done
-[ "$historical" -eq 0 ] || echo "History  $historical ticket(s) associated with other PRDs"
-if [ -z "$files" ]; then
-  echo "Tickets  none"
-else
-  rows=""
-  while IFS= read -r f; do
-    [ -n "$f" ] || continue
-    id=$(fm_get "$f" ticket); [ -n "$id" ] || id=$(basename "$f" | cut -c1-4)
-    st=$(fm_get "$f" status); size=$(fm_get "$f" size)
-    started=$(fm_get "$f" started); verified=$(fm_get "$f" verified); finished=$(fm_get "$f" finished)
-    attempt=$(fm_get "$f" last_check)
-    # Done tickets report through ticket_readiness below, so each problem is printed once.
-    if [ "$st" != done ] && [ -n "$attempt" ] && ! printf '%s' "$attempt" | grep -q ' passed '; then
-      warn="$warn  WARN $id latest verification: $attempt — re-run verify\n"
-    fi
-    deps=$(fm_get "$f" depends_on | grep -oE 'T-[0-9]+' | tr '\n' ' ' || true)
-    if [ -n "$started" ]; then
-      se=$(to_epoch "$started")
-      [ -z "$first_start" ] || [ "$se" -lt "$first_start" ] && first_start=$se
-    fi
-    case "$st" in
-      done)
-        n_done=$((n_done + 1))
-        detail="started $(hhmm "$started") · finished $(hhmm "$finished")"
-        [ -n "$started" ] && [ -n "$finished" ] && detail="$detail ($(mins "$(to_epoch "$started")" "$(to_epoch "$finished")"))"
-        if ! readiness=$(ticket_readiness "$f"); then
-          warn="$warn  WARN $id $readiness\n"
-          reverify="$reverify $id"
-        fi
-        ;;
-      in_progress)
-        n_prog=$((n_prog + 1)); in_prog="$in_prog $id"
-        detail="started $(hhmm "$started")"
-        [ -n "$started" ] && detail="$detail · elapsed $(mins "$(to_epoch "$started")" "$NOW")"
-        if [ -n "$verified" ]; then detail="$detail · receipt ✓"; else detail="$detail · no receipt yet"; fi
-        ;;
-      *)
-        n_open=$((n_open + 1)); st=${st:-open}
-        blocked=""
-        for d in $deps; do
-          df=$(ticket_file "$d" 2>/dev/null || true)
-          dep_prd=""
-          [ -z "$df" ] || dep_prd=$(ticket_prd "$df" 2>/dev/null || true)
-          if [ -z "$df" ] || [ "$(fm_get "$df" status)" != done ] ||
-             [ "$dep_prd" != "$prd" ] || ! usable_ticket_prd "$df" >/dev/null 2>&1 ||
-             ! ticket_readiness "$df" >/dev/null; then
-            blocked="$blocked $d"
-          fi
-        done
-        if [ -n "$blocked" ]; then detail="blocked by${blocked}"; else detail="ready"; [ -n "$next_open" ] || next_open=$id; fi
-        ;;
-    esac
-    rows="$rows$(printf '  %-5s %-12s %-2s %s' "$id" "$st" "${size:-?}" "$detail")\n"
-  done <<< "$files"
-  echo "Tickets  $((n_open + n_prog + n_done)) total · $n_done done · $n_prog in progress · $n_open open"
-  printf '%b' "$rows"
-  printf '%b' "$warn"
-  # Wall-clock elapsed is shown only while work is active or against an explicit
-  # budget; on a finished build it is noise and it never measures execution time.
-  if [ -n "$first_start" ] && { [ "$n_prog" -gt 0 ] || [ -n "$BUDGET" ]; }; then
-    build="Build    wall-clock elapsed $(mins "$first_start" "$NOW") since the first ticket started (not active execution time)"
-    [ -z "$BUDGET" ] || build="$build · budget ${BUDGET}m"
-    echo "$build"
-  fi
-fi
-
-notes_valid=no
-if notes=$(notes_current "$prd"); then notes_valid=yes; fi
-echo "Notes    NOTES.md: $notes"
-# The evidence line reports the shared validator's verdict for the manifest the
-# notes name, independent of whether the candidate is still current.
-manifest=""
-[ -f NOTES.md ] && validate_metadata NOTES.md >/dev/null 2>&1 && manifest=$(fm_get NOTES.md evidence)
-if [ -n "$manifest" ]; then
-  if ev=$(evidence_validate "$manifest" "$(fm_get NOTES.md candidate)" "$(fm_get NOTES.md base)" "$prd"); then
-    echo "Evidence $manifest · ok"
-  else
-    echo "Evidence $manifest · $(evidence_reason "$ev")"
-  fi
-fi
-
-# ── Next action ──
-if [ -z "$prd" ]; then
-  next="/pincer-plan <brief> — no PRD yet"
-elif [ "$unresolved" -gt 0 ]; then
-  next="resolve PRD association with pincer-ticket.sh bind T-NN .prd/prd-vN.md before continuing"
-elif [ "$prd_status" = draft ]; then
-  next="/pincer-narrow — current PRD is draft; earlier tickets and notes do not complete it"
-elif [ -z "$files" ]; then
-  next="/pincer-narrow — PRD exists, no tickets yet"
-elif [ -n "$in_prog" ]; then
-  next="resume${in_prog}: /pincer-code${in_prog} (check git status for uncommitted work; then verify → done)"
-elif [ "$n_open" -gt 0 ]; then
-  next="/pincer-code — next ready ticket: ${next_open:-none (all remaining are blocked — check depends_on)}"
-elif [ -n "$reverify" ]; then
-  next="/pincer-code — re-run verify for${reverify}; resolve readiness warnings before evaluation or release"
-elif [ "$notes_valid" = no ] || [ "$prd_status" != built ]; then
-  next="/pincer-evaluate — all tickets done"
-  [ "$prd_status" = built ] || next="$next (PRD status is '${prd_status:-?}', expected 'built')"
-else
-  next="/pincer-release — evaluation matches the current PRD and candidate; audit the artifacts"
-fi
-echo "Next     $next"
-[ "$unresolved" -eq 0 ] || exit 1
+exec node "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/pincer-runtime.cjs" status "$@"