create-pmos 0.134.0 → 0.136.0

package/workspace/lib/vendor/workspace/lib/plan-tree.js

@@ -1,419 +0,0 @@
-'use strict';
-/* plan-tree.js — the stages an initiative's breakdown hangs under, and the layout the Breakdown pane draws.
- *
- * pm-os-absorb Run 1 (PRD R4, R5, R6, R18, R19). Pure apart from reading the initiative record and the
- * repository's profile: the caller passes the folded ledger (lib/plan-items.js) and the ladder
- * (lib/console-state.js `ladder()`), and this module groups them. Nothing here writes, and nothing is cached
- * (D33): every answer is derived from what the caller read on this request.
- *
- * WHY THE STAGES ARE NOT A LIST OF THEIR OWN. A stage header groups the steps `scripts/workflow-state.js`
- * derives for the initiative's lane and profile (R4). The step keys come from the engine (lane-defs
- * RUNG_RULES), and the suite asserts that STAGE_GROUPS partitions them exactly, so a rung added to the
- * engine without a stage here fails a test instead of disappearing from the tree.
- *
- * The owed row of a stage is the first step of its group that is still open — not done, n/a or unknown —
- * and it is DERIVED: it ticks itself when the ladder sees its evidence, and nobody can edit it.
- */
-const fs = require('fs');
-const path = require('path');
-const consoleState = require('./console-state');
-const factoryJoin = require('./factory-join.js');
-
-const STAGE_GROUPS = Object.freeze({
-  'product-code': [
-    { id: 'intake', label: 'Intake', steps: ['route', 'anchor', 'prototype', 'understand'] },
-    { id: 'spec', label: 'Spec', steps: ['spec', 'priors'] },
-    { id: 'contract', label: 'Contract', steps: ['contract'] },
-    { id: 'build', label: 'Build', steps: ['build', 'quality'] },
-    { id: 'evaluate', label: 'Evaluate', steps: ['review', 'explain', 'accept', 'outcome'] },
-  ],
-  'pm-artifacts': [
-    { id: 'intake', label: 'Intake', steps: ['route', 'anchor'] },
-    { id: 'brief', label: null, steps: ['brief'] },        // the lane's brief_label, capitalised: "Problem brief"
-    { id: 'draft', label: null, steps: ['draft'] },        // the lane's draft_label: "PRD", "Change specification"
-    { id: 'evaluate', label: 'Evaluate', steps: ['review', 'approved'] },
-    { id: 'handoff', label: 'Handoff', steps: ['handoff'] },   // dropped for a lane whose rungs have no handoff
-  ],
-});
-// The noun an owed row names. `brief` and `draft` read the lane's own label at run time.
-const STEP_NOUN = Object.freeze({
-  route: 'routing', anchor: 'anchor', prototype: 'prototype', understand: 'explainer', spec: 'spec', priors: 'priors',
-  contract: 'contract', build: 'build', quality: 'checks', review: 'review', explain: 'run explainer', accept: 'acceptance',
-  outcome: 'outcome check', brief: '<brief_label>', draft: '<draft_label>', approved: 'approval', handoff: 'handoff',
-});
-// Who owes the step. Everything not named here is the agent's.
-const OWED_ACTOR = Object.freeze({ accept: 'you', approved: 'you', outcome: 'you', handoff: 'you' });
-const OPEN = (s) => !['done', 'na', 'unknown'].includes(s);
-const DONE_WINDOW_MS = 14 * 86400000;
-// An initiative id is a record file name. Shared with lib/plan-items.js, which re-exports it.
-const INIT_RE = /^[A-Za-z0-9][\w.-]{0,119}$/;
-const STATE_LABEL = { todo: 'Todo', doing: 'Doing', review: 'Review', done: 'Done' };
-
-function engine() {
-  const loaded = consoleState.loadEngine();
-  if (!loaded.ok) throw new Error(loaded.error);
-  return loaded.engine;
-}
-
-/**
- * The main working tree of the repository `root` sits in. A linked worktree (an agent started by Hand to
- * agent on a new branch runs in one) has a `.git` FILE naming its gitdir, whose `commondir` leads back to the
- * main repository's `.git`. Filesystem reads only — no git process, because this runs on every poll.
- *
- * A `.git` FILE is followed ONLY for a real linked worktree of a non-bare repository whose main tree exists.
- * Everything else keeps `root`: a submodule and a `--separate-git-dir` repository have no `commondir`; a worktree
- * of a bare repository has a common directory that is not named `.git`. Following those would put the ledger
- * outside the repository (or inside a git directory), where git, CI and every other clone never see it.
- */
-function mainTree(root) {
-  const dotgit = path.join(root, '.git');
-  let st;
-  try { st = fs.statSync(dotgit); } catch { return root; }
-  if (st.isDirectory()) return root;
-  let m = null;
-  try { m = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(dotgit, 'utf8')); } catch { return root; }
-  if (!m) return root;
-  const gitdir = path.resolve(root, m[1].trim());
-  let common;
-  try { common = path.resolve(gitdir, fs.readFileSync(path.join(gitdir, 'commondir'), 'utf8').trim()); }
-  catch { return root; }                                   // a submodule or a separate git directory
-  if (path.basename(common) !== '.git') return root;       // a worktree of a bare repository
-  const main = path.dirname(common);
-  try { if (!fs.statSync(path.join(main, '.git')).isDirectory()) return root; } catch { return root; }
-  return main;
-}
-
-/** The initiative record, looked up in this tree first and then in the main tree. null when neither has it. */
-function recordPath(root, initiative) {
-  if (typeof initiative !== 'string' || !INIT_RE.test(initiative)) return null;
-  // The folder's README.md and index.md are not records: the same rule as the engine's listInitiatives().
-  if (initiative === 'README' || initiative === 'index') return null;
-  const eng = engine();
-  const roots = [root];
-  const main = mainTree(root);
-  if (main !== root) roots.push(main);
-  for (const r of roots) {
-    const file = path.join(eng.layout(r).initiatives, `${initiative}.md`);
-    try { if (fs.statSync(file).isFile()) return file; } catch { /* try the next tree */ }
-  }
-  return null;
-}
-
-/** The repository's profile, the initiative's lane (as workflow-state.js resolves it) and the lane definitions. */
-function profileAndLane(root, initiative) {
-  const eng = engine();
-  const { profile, defs } = eng.lanesFor(root);
-  const file = recordPath(root, initiative);
-  let fm = {};
-  if (file) { try { fm = eng.parseLeadingFrontmatter(fs.readFileSync(file, 'utf8')) || {}; } catch { fm = {}; } }
-  const declared = String(fm.lane || '').trim();
-  // An unknown or missing lane is the profile's strictest, exactly as workflow-state.js computes `effLane`.
-  const fallback = profile === 'pm-artifacts' ? 'prd' : 'feature';
-  const lane = declared && defs[declared] ? declared : fallback;
-  return { profile, lane, defs, record: file, group: viewGroup(defs, declared) };
-}
-
-/**
- * Whether an initiative is a work card or a document in the planning views (D86 point 4), from its DECLARED lane.
- *
- * Only a record that declares a document lane is a document. A missing or unknown lane is work: the fallback above
- * picks the strictest ladder for the gate, and in a pm-artifacts repository that fallback is `prd`, a document lane.
- * Grouping by the fallback hid every record written before lanes were declared (0.53.0: most of a kit repository's
- * initiatives were missing from Initiatives, Board and Reports).
- */
-function viewGroup(defs, declared) {
-  const d = String(declared || '').trim();
-  return d && defs && defs[d] && defs[d].group ? defs[d].group : 'work';
-}
-
-const cap = (s) => (s && /^[a-z]/.test(s) ? s[0].toUpperCase() + s.slice(1) : s);
-
-/** The stages of this initiative, in order: [{ id, label, steps }]. */
-function stagesFor(root, initiative) {
-  const { profile, lane, defs } = profileAndLane(root, initiative);
-  if (profile !== 'pm-artifacts') return STAGE_GROUPS['product-code'].map((g) => ({ ...g, steps: g.steps.slice() }));
-  const def = defs[lane] || defs.prd;
-  const out = [];
-  for (const g of STAGE_GROUPS['pm-artifacts']) {
-    if (g.id === 'handoff' && !(def.rungs || []).includes('handoff')) continue;
-    const label = g.id === 'brief' ? cap(def.brief_label) : g.id === 'draft' ? cap(def.draft_label) : g.label;
-    out.push({ id: g.id, label, steps: g.steps.slice() });
-  }
-  return out;
-}
-function stageIdsFor(root, initiative) { return stagesFor(root, initiative).map((s) => s.id); }
-
-/** A stage id from an id or a label, case- and space-insensitive. null when it names no stage of this initiative. */
-function resolveStage(root, initiative, idOrLabel) {
-  const norm = (s) => String(s == null ? '' : s).toLowerCase().replace(/\s+/g, ' ').trim();
-  const want = norm(idOrLabel);
-  if (!want) return null;
-  for (const s of stagesFor(root, initiative)) if (norm(s.id) === want || norm(s.label) === want) return s.id;
-  return null;
-}
-
-/** The noun an owed row uses for a step, with the lane's own brief and draft labels filled in. */
-function nounFor(key, def) {
-  if (key === 'brief') return (def && def.brief_label) || 'brief';
-  if (key === 'draft') return (def && def.draft_label) || 'draft';
-  return STEP_NOUN[key] || key;
-}
-
-/**
- * The owed row of a stage: the first step of its group that is still open. null when every step is done,
- * n/a or unknown — those neither block nor count as owed (R3, R4).
- */
-function owedFor(group, steps, def) {
-  const byKey = new Map((steps || []).map((s) => [s.key, s]));
-  for (const key of group.steps) {
-    const s = byKey.get(key);
-    if (!s || !OPEN(s.status)) continue;
-    const noun = nounFor(key, def);
-    const actor = OWED_ACTOR[key] || 'agent';
-    return { key, noun, actor, status: s.status, next: s.next || null, label: `Owed: ${noun} · ${actor}` };
-  }
-  return null;
-}
-
-/**
- * The index of the furthest stage with evidence (scan-consistency R2): the last stage that holds a step the ladder
- * reads `done`. -1 when no stage has one.
- *
- * WHY THE STEPPER NEEDS IT. The current stage used to be the FIRST stage with an open step. A step skipped long ago — a
- * `priors` citation nobody wrote, a contract never logged before the build — then pinned the initiative at Spec or
- * Contract for ever, while the build had merged and the PM had accepted it: 90 built initiatives read Spec on this
- * repository, and 51 accepted ones read Intake, Spec, Contract or Build. Work moves forward past a gap; the gap stays a
- * fact. So the current stage is the first stage with an open step AT OR AFTER the frontier, and an earlier stage that
- * still has an open step reads `skipped` (its owed row is kept), never `done`.
- */
-function frontierOf(stages, steps) {
-  const done = new Set((steps || []).filter((s) => s && s.status === 'done').map((s) => s.key));
-  // Accepted work is finished whatever its leftover steps (initiative-display.js rule 2): the frontier is past the end,
-  // so no stage is current and every stage with an open step reads `skipped`. A document lane is finished once it is
-  // approved and no handoff is still open.
-  const by = new Map((steps || []).filter(Boolean).map((s) => [s.key, s.status]));
-  if (by.get('accept') === 'done' || (by.get('approved') === 'done' && !OPEN(by.get('handoff') || 'na'))) return stages.length;
-  let at = -1;
-  stages.forEach((s, i) => { if (s.steps.some((k) => done.has(k))) at = i; });
-  return at;
-}
-
-/**
- * The stage an initiative is in now, from its ladder steps, by the same rule the Breakdown and the sheet's stepper use:
- * { id, label } of the first stage at or after the frontier with an open step, or null when no stage has one.
- */
-function currentStage(root, initiative, steps, def) {
-  const stages = stagesFor(root, initiative);
-  const front = frontierOf(stages, steps);
-  for (let i = Math.max(front, 0); i < stages.length; i++) {
-    if (owedFor(stages[i], steps, def) !== null) return { id: stages[i].id, label: stages[i].label };
-  }
-  return null;
-}
-
-/**
- * The progress label (R6), shared by the layout, the fold's progressOf and the CLI. Proposed and withdrawn items never
- * count; when nothing is kept yet but an agent proposed items, it says so instead of a bare "no breakdown".
- */
-function progressLabel(done, total, proposed) {
-  if (total) return `${done} of ${total}`;
-  return proposed ? `no breakdown · ${proposed} proposed` : 'no breakdown';
-}
-
-const byLabel = (by) => {
-  const s = String(by || '');
-  if (/^pm:/.test(s)) return 'you';
-  const m = /^agent:(sess-\d+)\./.exec(s);
-  if (m) return `agent · ${m[1]}`;
-  if (s === 'agent:unknown') return 'agent (unknown)';
-  return s || 'unknown';
-};
-
-/** One history entry as a sentence. `stageLabelOf(id)` names a stage. */
-function historyText(h, stageLabelOf) {
-  const lab = (id) => (stageLabelOf && stageLabelOf(id)) || id;
-  const st = (s) => STATE_LABEL[s] || s;
-  if (h.ev === 'planned') return `added in ${lab(h.stage)}`;
-  if (h.ev === 'moved') {
-    const ev = h.evidence ? ` with evidence ${h.evidence.kind}:${h.evidence.ref}` : '';
-    return `moved to ${st(h.to)}${ev}`;
-  }
-  if (h.ev === 'flagged') return h.blocked ? `blocked: ${h.reason}` : 'unblocked';
-  if (h.ev === 'withdrawn') return 'withdrawn';
-  if (h.ev === 'kept') return 'kept';
-  if (h.ev === 'set') {
-    const f = h.fields || {};
-    const parts = [];
-    for (const k of Object.keys(f)) {
-      const v = f[k];
-      if (k === 'stage') parts.push(`moved to stage ${lab(v)}`);
-      else if (k === 'order') parts.push('reordered');
-      else if (k === 'title') parts.push(`renamed to "${v}"`);
-      else if (k === 'due' || k === 'start') parts.push(v ? `${k} set to ${v}` : `${k} cleared`);
-      else if (k === 'owner') parts.push(`owner set to ${v}`);
-      else if (k === 'after') parts.push(Array.isArray(v) && v.length ? `after ${v.join(', ')}` : 'predecessors cleared');
-      else if (k === 'milestone') parts.push(v ? 'marked a milestone' : 'no longer a milestone');
-      else if (k === 'note') parts.push(v ? 'note changed' : 'note cleared');
-      else parts.push(`${k} changed`);
-    }
-    return parts.join('; ') || 'changed';
-  }
-  return h.ev;
-}
-
-const treeOrder = (a, b) => (a.order - b.order) || String(a.createdAt).localeCompare(String(b.createdAt)) || a.id.localeCompare(b.id);
-
-/** What a plan item reads when it was dragged to Done and the factory has not integrated its work item (R7). */
-const NOT_MERGED_LABEL = 'Done · your call · not merged';
-
-/**
- * The factory join applied to the items of one initiative (PRD R7, D86 point 1; pm-os-absorb Run 4).
- *
- * A plan item that a work item materializes (its `declared` line names it as `plan_item`) carries
- * `factory: { item, state, integrated, pr, notMerged, label }`. Once that work item is integrated (`pmos verify-work`
- * saw its trailer on the default branch), the plan item reads Done with no hand edit: state `done`, and its Done time
- * is the integration's unless it was already Done. A plan item moved to Done whose work item is NOT integrated stays
- * Done, the PM's call, and says so (`notMerged`, `label`). The plan-items ledger is not written: the factory's own
- * `integrated` line is the evidence (D86 point 1), so this is applied on every read. A withdrawn work item is not a
- * join. An item no work item names is returned unchanged and gains no key, so the layout's shape holds for it.
- */
-function withFactory(root, initiative, fold, items) {
-  let entry = null;
-  try { entry = factoryJoin.factoryOf(factoryJoin.joinFactory(root, { initiative, fold }), initiative); } catch { entry = null; }
-  if (!entry || !entry.items.length) return items;
-  const byPlan = new Map();
-  for (const w of entry.items) if (w.plan_item && w.state !== 'withdrawn' && !byPlan.has(w.plan_item)) byPlan.set(w.plan_item, w);
-  return items.map((it) => {
-    const w = byPlan.get(it.id);
-    if (!w) return it;
-    const notMerged = !w.integrated && it.state === 'done';
-    const factory = { item: w.id, state: w.state, integrated: !!w.integrated, pr: w.pr || null, notMerged, label: notMerged ? NOT_MERGED_LABEL : null };
-    if (!w.integrated) return { ...it, factory };
-    const doneAt = it.state === 'done' ? it.doneAt : (w.integrated_at || it.doneAt || null);
-    return { ...it, state: 'done', doneAt, noEvidence: false, late: false, factory };
-  });
-}
-
-/**
- * The Breakdown layout of one initiative (the shape the pane draws; see the Run 1 plan §2.2).
- *
- * @param {object} o
- * @param {string} o.root        the workspace root
- * @param {string} o.initiative  the initiative id
- * @param {object} o.fold        planItems.fold() result for the repository's ledger
- * @param {object|null} o.ladder consoleState.ladder() result, or null for the fast path (no owed rows)
- * @param {number} [o.now]
- */
-function layout({ root, initiative, fold, ladder, now }) {
-  const t = Number.isFinite(now) ? now : Date.now();
-  const { profile, lane, defs } = profileAndLane(root, initiative);
-  const def = profile === 'pm-artifacts' ? (defs[lane] || defs.prd) : null;
-  const stages = stagesFor(root, initiative);
-  const stageIds = stages.map((s) => s.id);
-  const labelOf = (id) => { const s = stages.find((x) => x.id === id); return s ? s.label : id; };
-  const ladderIncluded = ladder !== null && ladder !== undefined;
-  let steps = null;
-  let ladderState = null;
-  if (ladderIncluded) {
-    if (ladder && ladder.ok && ladder.row && Array.isArray(ladder.row.steps)) {
-      steps = ladder.row.steps;
-      ladderState = { ok: true, error: null };
-    } else {
-      ladderState = { ok: false, error: (ladder && (ladder.error || (ladder.empty ? `no ladder for ${initiative}` : null))) || 'the ladder could not be derived' };
-    }
-  }
-
-  const mine = withFactory(root, initiative, fold,
-    (fold.order || []).map((id) => fold.items[id]).filter((it) => it && it.initiative === initiative));
-  const gone = new Set(fold.withdrawnIds || []);
-  const items = {};
-  const flags = [];
-  for (const it of mine) {
-    const stageKnown = stageIds.includes(it.stage);
-    if (!stageKnown) flags.push({ kind: 'unknown-stage', line: null, eid: null, item: it.id, message: `${it.id} names stage "${it.stage}", which this initiative's lane does not have — shown under Other` });
-    const { movedVia, ...shown } = it;   // movedVia stays in the fold (needsFor reads it); the pane does not
-    items[it.id] = {
-      ...shown, stageKnown, byLabel: byLabel(it.updatedBy),
-      // A withdrawn predecessor is not shown: the sheet then sends the list without it, and the writer lets it go.
-      after: it.after.filter((x) => !gone.has(x)),
-      // A planned entry carries its stage in the fold so its sentence can say where it was added; the pane gets
-      // the §1.4 history keys and the sentence, not the stage.
-      history: it.history.map(({ stage, ...h }) => ({ ...h, byLabel: byLabel(h.by), text: historyText({ ...h, stage }, labelOf) })),
-    };
-  }
-  const visibleItems = mine;
-  const counted = (list) => list.filter((it) => !it.proposed);
-
-  let firstOpenSeen = false;
-  const frontier = steps ? frontierOf(stages, steps) : -1;
-  const stageRows = stages.map((s, i) => {
-    const inStage = visibleItems.filter((it) => it.stage === s.id).sort(treeOrder);
-    const real = counted(inStage);
-    const total = real.length;
-    const done = real.filter((it) => it.state === 'done').length;
-    const proposed = inStage.length - real.length;
-    const row = { id: s.id, label: s.label };
-    let owed = null;
-    if (steps) owed = owedFor(s, steps, def);
-    row.visible = total > 0 || proposed > 0 || owed !== null;
-    // A stage before the first open step is `done`; every stage after it is `later`, even one whose own steps
-    // are all done, because the work reaches it in ladder order. Without the ladder (`ladder=0`) `current`,
-    // `state` and `owed` are not derived, so they are left out: the client keeps them from its last full
-    // response. A ladder that was asked for but failed gives `current:false`, `state:null`, `owed:null`.
-    if (steps) {
-      // A stage behind the frontier with a step still open was passed over, not finished (see frontierOf).
-      const skipped = owed !== null && i < frontier;
-      const current = owed !== null && !skipped && !firstOpenSeen;
-      row.current = current;
-      row.state = current ? 'current' : skipped ? 'skipped' : (firstOpenSeen ? 'later' : 'done');
-      if (owed !== null && !skipped) firstOpenSeen = true;
-    } else if (ladderIncluded) {
-      row.current = false;
-      row.state = null;
-    }
-    Object.assign(row, { done, total, proposed, count: total > 0 ? `${done} of ${total}` : null });
-    if (ladderIncluded) row.owed = owed;
-    row.items = inStage.map((it) => it.id);
-    return row;
-  });
-  const otherItems = visibleItems.filter((it) => !stageIds.includes(it.stage)).sort(treeOrder);
-
-  const real = counted(visibleItems);
-  const pDone = real.filter((it) => it.state === 'done').length;
-  const progress = { done: pDone, total: real.length, proposed: visibleItems.length - real.length,
-    label: progressLabel(pDone, real.length, visibleItems.length - real.length) };
-
-  const stageIdx = (id) => { const i = stageIds.indexOf(id); return i === -1 ? stageIds.length : i; };
-  const boardSort = (a, b) => (stageIdx(a.stage) - stageIdx(b.stage)) || treeOrder(a, b);
-  const board = { todo: [], doing: [], review: [], done: [], doneOlder: 0 };
-  for (const st of ['todo', 'doing', 'review', 'done']) {
-    let list = visibleItems.filter((it) => it.state === st);
-    if (st === 'done') {
-      const recent = list.filter((it) => it.doneAt && Date.parse(it.doneAt) >= t - DONE_WINDOW_MS);
-      board.doneOlder = list.length - recent.length;
-      list = recent;
-    }
-    board[st] = list.sort(boardSort).map((it) => it.id);
-  }
-
-  const batches = (fold.batches || []).filter((b) => b.initiative === initiative)
-    .map((b) => ({ key: b.by, by: b.by, byLabel: b.byLabel, count: b.count, items: b.items.slice(), firstAt: b.firstAt, lastAt: b.lastAt }));
-  for (const f of fold.flags || []) {
-    if (f.initiative && f.initiative !== initiative) continue;
-    flags.push({ kind: f.kind, line: f.line, eid: f.eid, item: f.item, message: f.message });
-  }
-  const withdrawnCount = (fold.withdrawnIds || []).filter((id) => id.startsWith(initiative + '.')
-    && /^[0-9a-z]{10}$/.test(id.slice(initiative.length + 1))).length;
-
-  const out = { profile, lane, ladderIncluded };
-  if (ladderIncluded) out.ladder = ladderState;
-  Object.assign(out, {
-    progress, stages: stageRows, other: { items: otherItems.map((it) => it.id) }, items, board, batches, flags, withdrawnCount,
-  });
-  return out;
-}
-
-module.exports = {
-  STAGE_GROUPS, STEP_NOUN, OWED_ACTOR, OPEN, DONE_WINDOW_MS, INIT_RE, NOT_MERGED_LABEL, withFactory,
-  mainTree, recordPath, profileAndLane, viewGroup, stagesFor, stageIdsFor, resolveStage, owedFor, frontierOf, currentStage, nounFor, byLabel, progressLabel, layout, historyText,
-};

package/workspace/lib/vendor/workspace/lib/review-gate.js

@@ -1,39 +0,0 @@
-'use strict';
-/*
- * CANONICAL Review-Gate pass rule — the single source of truth (D64 / pivot-workspace-first, Track D2).
- *
- * The rule is:  an explicit verdict DECIDES (pass iff it starts with "pass"); the score is a
- * fallback used ONLY when no verdict was recorded (score >= 0.85).
- *
- * AMENDED 2026-07-26 (blind-plant round 2 finding). The rule was previously
- * `verdict ILIKE 'pass%' OR score >= 0.85`, and that disjunction was a real leniency hole: a run the
- * evaluator explicitly FAILED still passed the gate if its weighted score happened to clear 0.85.
- * Round 2 hit it live — specimen `be58` came back verdict=FAIL score=0.93 and the old rule counted it
- * pass-side, overriding a FAIL issued under the two-axis rule ("a FAIL on either axis cannot become a
- * PASS"). A gate whose plumbing can overturn its own judge is not a gate. See
- * planning/evals/blind-plants/2026-07-26-round2/RESULTS.md.
- *
- * Note the fix is NOT a blunt OR->AND: that would wrongly fail a legitimate `PASS` verdict carrying no
- * recorded score. Verdict-authoritative-with-score-fallback preserves every other case and changes
- * exactly the one that was broken.
- *
- * It was previously duplicated verbatim across SQL views, TS, the workspace JS, and metrics.py, so a
- * change in one place silently drifted the others. It now lives HERE and is mirrored in exactly one
- * other place — kit/scripts/metrics.py's `review_gate_pass()` — with a comment pointing back here.
- * kit/fixtures/test_parsers.py runs BOTH implementations against kit/fixtures/review-gate-pass-rule.json
- * and fails CI if they ever disagree, so the mirror can never drift unnoticed.
- */
-const PASS_VERDICT_PREFIX = 'pass';   // ILIKE 'pass%' → lowercased startsWith('pass')
-const SCORE_THRESHOLD = 0.85;
-
-// A recorded verdict is AUTHORITATIVE: the run passes iff that verdict starts with "pass"
-// (PASS / PASS-WITH-FINDINGS / …). An explicit FAIL is never overridden by a high score.
-// Only when NO verdict was recorded (null / "" / whitespace) does the numeric score decide.
-function isReviewPass(verdict, score) {
-  const v = String(verdict == null ? '' : verdict).trim().toLowerCase();
-  if (v) return v.startsWith(PASS_VERDICT_PREFIX);
-  const s = Number(score);
-  return Number.isFinite(s) && s >= SCORE_THRESHOLD;
-}
-
-module.exports = { isReviewPass, PASS_VERDICT_PREFIX, SCORE_THRESHOLD };