@aperant/framework 0.17.0 → 0.20.0

package/dist/cli/gate/gates/index.mjs

@@ -17,6 +17,7 @@ import './verify-approved.mjs';
 import './review-clean.mjs';
 import './followups-adjudicated.mjs';
 import './gitignore-in-sync.mjs';
+import './features-reconciled.mjs';
 import './consistency-check.mjs';
 import './tdd-iron-law.mjs';
 import './r-persona-alignment.mjs';

package/dist/cli/gate/gates/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/cli/gate/gates/index.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,yBAAyB,CAAA;AAChC,OAAO,6BAA6B,CAAA;AACpC,OAAO,mBAAmB,CAAA;AAC1B,OAAO,6BAA6B,CAAA;AACpC,OAAO,uBAAuB,CAAA;AAC9B,OAAO,oBAAoB,CAAA;AAC3B,OAAO,6BAA6B,CAAA;AACpC,OAAO,yBAAyB,CAAA;AAChC,OAAO,yBAAyB,CAAA;AAChC,OAAO,oBAAoB,CAAA;AAC3B,OAAO,2BAA2B,CAAA"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/cli/gate/gates/index.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,yBAAyB,CAAA;AAChC,OAAO,6BAA6B,CAAA;AACpC,OAAO,mBAAmB,CAAA;AAC1B,OAAO,6BAA6B,CAAA;AACpC,OAAO,uBAAuB,CAAA;AAC9B,OAAO,oBAAoB,CAAA;AAC3B,OAAO,6BAA6B,CAAA;AACpC,OAAO,yBAAyB,CAAA;AAChC,OAAO,2BAA2B,CAAA;AAClC,OAAO,yBAAyB,CAAA;AAChC,OAAO,oBAAoB,CAAA;AAC3B,OAAO,2BAA2B,CAAA"}

package/dist/cli/help.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"help.d.mts","sourceRoot":"","sources":["../../src/cli/help.mjs"],"names":[],"mappings":"AAMA,kCA+IC"}
+{"version":3,"file":"help.d.mts","sourceRoot":"","sources":["../../src/cli/help.mjs"],"names":[],"mappings":"AAMA,kCA6KC"}

package/dist/cli/help.mjs

@@ -27,6 +27,7 @@ Commands:
   risk-check <dir> --paths <p1> [--operation <type>]  Classify file paths by risk level
 
   task create <dir> --description <text> [--scope <s>] [--milestone <id>] [--phase <id>] [--roadmap-ref-url <url>] [--depends-on <refs>] [--track <T>] [--autonomy <N>]  Create isolated task
+  task ensure <dir> --description <text> --intent <create-new|require-existing|self-managed|none> [--track <T>] [--autonomy <N>] [--scope <s>] [--id <id>]  Deterministic idempotent allocator: create-new provisions a per-task worktree (idempotent on re-run), require-existing resolves the active task without minting, none/self-managed allocate nothing
   task list <dir> [--scope <s>] [--blocked-by <id>]  List active tasks (optionally filtered)
   task get <dir> --id <task-id>         Get task details and artifacts
   task update <dir> --id <id> [--lifecycle-phase <p>] [--pr-url <url>] [--subtasks-total <N>] [--depends-on <refs>]  Update non-linkage task state; --pr-url may arm ci-watch per ci_watch.after_ship
@@ -35,7 +36,7 @@ Commands:
   task close-merged <dir> [--task <id>] [--narrate-only] [--dry-run]   Sweep shipped-pending-merge tasks for confirmed merges (--narrate-only returns pending_narration[] entries read-only without closing).
   task narration-drain <dir> --task <task-id>     Remove a row from state.pending_narration[] under withFileLock (called by /apt:close-task --narrate-only after a successful narrator spawn)
   task complete-subtask <dir> --task-id <id> --subtask-id <sid|a+b+c> [--commit <sha>] [--notes <text>]  Atomic plan ↔ build-progress sync
-  features-audit <dir> [--task-id <id>] [--no-worktree-redirect] [--diff-files <csv>|--since <ref>] [--apply-stubs] [--format json|md]  Audit features registry for unregistered feature-qualifying files (BUG-025b: --task-id redirects writes to active task's worktree)
+  features-reconcile <dir> (--draft|--write|--check|--gc) [--task-id <id>] [--subtask-id <id>] [--base <ref>] [--dry-run] [--warn-only] [--max-age-days <n>] [--no-worktree-redirect]  Feature-registry delta ledger: --draft scaffolds a per-writer delta from the base..HEAD diff, --write materializes deltas into area JSONs + a receipt, --check verifies coverage/schema/integrity/orphans, --gc prunes merged receipts (BUG-025b: --task-id redirects writes to active task's worktree)
   docs-audit <dir> [--diff-files <csv>|--since <ref>|--dry-run] [--policy <path>] [--format json|md]  Audit documented surfaces for docs-drift
 
   lock claim <dir> --subtask <id>       Claim exclusive lock on a subtask
@@ -134,6 +135,35 @@ Commands:
   ci-watch start|stop|status|tick <dir> [--pr <N>] [...]   /apt:watch-ci primitives — see SKILL.md for full flag matrix
   ci-watch sweep <dir> --orphaned [--dry-run]              BUG-027: enumerate ci-watches state files, query gh per PR, remove terminal-state (MERGED|CLOSED) entries (manual GC; rate-limited)
 
+  produce start <dir> --outcome "<o>" [--run-id <id>]      /apt:produce M1 — freeze an immutable acceptance setpoint under .aperant/produce/<run-id>/ (idempotent-reuse on --run-id, never overwrites); emits produce.run.started + produce.setpoint.frozen
+  produce add-milestone <dir> --run-id <id> --title "<t>" [--id <mid>]   Append produce.roadmap.milestone_added + refresh the derived roadmap.json projection cache
+  produce set-milestone-status <dir> --run-id <id> --milestone <mid> --status <planned|in_progress|done> [--verdict-path <p>]   Append produce.roadmap.milestone_status_changed; --status done is the M2 two-gate adjudication (visible oracle AND blind probe)
+  produce status <dir> --run-id <id>                       Re-project the roadmap from the append-only event log (no in-memory authority)
+  produce tick <dir> --run-id <id>                         Run exactly ONE wake tick — re-project from disk, emit produce.tick, compute next_action + next_tick_hint, then exit (no loop)
+  produce record-implementer <dir> --run-id <id> --milestone <mid> --implementer-family <fam>   /apt:produce M2 — record the implementer family (the cross-family disjointness anchor)
+  produce resolve-probe-family <dir> --run-id <id> [--milestone <mid>] [--implementer-family <fam>] [--host-family <fam>] [--available-families a,b,c]   M2 — resolve a probe/oracle family DISJOINT from the implementer + a LIVE model (never hardcoded); available:false when none
+  produce oracle prepare <dir> --run-id <id> --milestone <mid> --verdict-path <p>   M2 — extract verify-proof's v2 verdict (must be approved) + tests[] evidence into a cross-family judge payload
+  produce oracle record <dir> --run-id <id> --milestone <mid> --verdict <pass|fail> --oracle-family <fam>   M2 — record produce.oracle.judged (refused when oracle_family === implementer)
+  produce probe freeze <dir> --run-id <id> --milestone <mid> --probe-file <p> --author-family <fam>   M2 — freeze an immutable held-out probe set (hash + family only; refused when author_family === implementer)
+  produce probe record <dir> --run-id <id> --milestone <mid> --result <pass|fail> --probe-family <fam> --head-sha <sha>   M2 — record produce.probe.run (result/family/sha only; refused when probe_family === implementer)
+  produce probe sweep <dir> --run-id <id> [--sample N]     M2 — deterministic rotating sample of already-done milestones to blind-re-probe against HEAD
+  produce canary <dir> --run-id <id>                       M2 — green-on-visible MINUS green-on-blind + per-milestone breakdown (the reward-hacking canary)
+  produce declare-criteria <dir> --run-id <id> --milestone <mid> --criterion "<text>" [--criterion-id <cid>] [--scope-change "<reason>"]   /apt:produce M3 — open one acceptance criterion (V += 1); rejected after descent unless --scope-change justifies the increase (anti-windup)
+  produce progress <dir> --run-id <id>                     M3 — re-read the Lyapunov V-series from the log: open-criteria count strictly decreasing across shipped milestones + any un-sanctioned-increase violations (flags, never rejects)
+  produce saga enter <dir> --run-id <id> --milestone <mid> --phase <plan|execute|verify|review|ship>   /apt:produce M4 — append produce.saga.phase_entered (separate fold from the roadmap projection)
+  produce saga complete <dir> --run-id <id> --milestone <mid> --phase <plan|execute|verify|review|ship>   M4 — append produce.saga.phase_completed
+  produce saga compensate <dir> --run-id <id> --milestone <mid> --phase <p> [--reason "<r>"]   M4 — fire the FORWARD compensator (verify|review|ship ships a revert + reopens + re-plans; NEVER rolls back a merged PR); records the descriptor, does not execute it
+  produce saga resolve-reviewer <dir> --run-id <id> --milestone <mid> [--host-family <fam>] [--available-families a,b,c]   M4 — resolve a REVIEW-phase reviewer family DISJOINT from the implementer + a LIVE model (reuses resolveProbeFamily; never hardcoded); available:false when none
+  produce saga review <dir> --run-id <id> --milestone <mid> --verdict <pass|fail> --reviewer-family <fam>   M4 — record produce.saga.reviewed (refused when reviewer_family === implementer)
+  produce saga status <dir> --run-id <id>                  M4 — re-project per-milestone saga phase state + pending compensation from the log (no roadmap status mutation)
+  produce ttl select <dir> --run-id <id> --head-sha <sha> [--sample N]   M4 — deterministic rotating sample of OLD done milestones STALE against HEAD (reuses the M2 rotation; a milestone re-verified against current HEAD is excluded as fresh)
+  produce ttl reverify <dir> --run-id <id> --milestone <mid> --result <pass|fail> --probe-family <fam> --head-sha <sha>   M4 — cross-family re-verify; --result fail appends ttl.reverified + ttl.regression_detected + fires the FORWARD compensator (ships a revert, not a rollback)
+  produce schedule <dir> --run-id <id> [--wip N]           /apt:produce M5 — WSJF-rank the ready milestones (cost-of-delay / job-size) + a WIP-limited pick; dependency-aware readiness (blocked / cycle), M4-regression re-entry; read-only
+  produce claim declare <dir> --run-id <id> --profile <p> --claim-file <path> [--claim-id <id>]   /apt:produce M6 — validate + freeze an immutable Claim Envelope to claims/<claim-id>.json (interop, not a 4th store); rejects a global/unbounded scope, empty preconditions, or missing expiry fail-closed; logs produce.claim.declared (content_hash only)
+  produce claim list <dir> --run-id <id>                   M6 — re-project the claim ledger (declared − expired) folded from the append-only log; produce.claim.* never enters the roadmap projection
+  produce claim expire <dir> --run-id <id> --claim-id <id> [--reason "<r>"]   M6 — append produce.claim.expired; the claim drops out of the ledger's active set (anti-corrosion manual expiry)
+  produce claim consume <dir> --run-id <id> [--milestone <mid>]   M6 — emit the STRUCTURED delta {claim_id, targets:[{kind, requirement, ref?}]} derived from resolution_verifier (never a lesson-text paste); skips expired / HEAD-invalidated / precondition-unmatched claims
+
   followups check <dir> --task-id <id>                      G45: derive the expected follow-up universe (Out of Scope ∪ raw review rows ∪ qa findings) + report missing/unadjudicated/unfixed/undispositioned rows; exit 1 when the ledger is dishonest
   followups disposition <dir> --task-id <id> --row <row-id> --kind <filed_task|executed_commit|parked_note|dropped_by_user> --ref <ref> [--reason <text>]   G45: flip a ledger row to dispositioned (atomic; dropped_by_user requires --reason)
   followups policy <dir> --task-id <id>                     G45: effective disposition policy (ask|file|chain + max_chain_depth) from config.followups when set, else autonomy-derived

package/dist/cli/help.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"help.mjs","sourceRoot":"","sources":["../../src/cli/help.mjs"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE1C,MAAM,UAAU,SAAS;IACxB,MAAM,IAAI,GAAG,GAAG,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA2IT,CAAA;IAEnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAA;AAClC,CAAC"}
+{"version":3,"file":"help.mjs","sourceRoot":"","sources":["../../src/cli/help.mjs"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE1C,MAAM,UAAU,SAAS;IACxB,MAAM,IAAI,GAAG,GAAG,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAyKT,CAAA;IAEnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAA;AAClC,CAAC"}

package/dist/cli/install/legacy-paths.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"legacy-paths.d.mts","sourceRoot":"","sources":["../../../src/cli/install/legacy-paths.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;GAMG;AAEH,gDAAgD;AAChD,mCADW,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAsJ1C;;kBA5JY,MAAM;kBACN,MAAM;;;;;qBAEN,aAAa,CAAC,MAAM,CAAC"}
+{"version":3,"file":"legacy-paths.d.mts","sourceRoot":"","sources":["../../../src/cli/install/legacy-paths.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;GAMG;AAEH,gDAAgD;AAChD,mCADW,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAwJ1C;;kBA9JY,MAAM;kBACN,MAAM;;;;;qBAEN,aAAa,CAAC,MAAM,CAAC"}

package/dist/cli/install/legacy-paths.mjs

@@ -106,6 +106,7 @@ export const LEGACY_INSTALL_PATHS = Object.freeze({
             'agents/apt-personas.md',
             'agents/apt-plan.md',
             'agents/apt-pr-review.md',
+            'agents/apt-produce.md',
             'agents/apt-prototype.md',
             'agents/apt-quick.md',
             'agents/apt-release-notes.md',
@@ -151,6 +152,7 @@ export const LEGACY_INSTALL_PATHS = Object.freeze({
             'commands/apt-personas.md',
             'commands/apt-plan.md',
             'commands/apt-pr-review.md',
+            'commands/apt-produce.md',
             'commands/apt-prototype.md',
             'commands/apt-quick.md',
             'commands/apt-release-notes.md',

package/dist/cli/install/legacy-paths.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"legacy-paths.mjs","sourceRoot":"","sources":["../../../src/cli/install/legacy-paths.mjs"],"names":[],"mappings":"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"}
+{"version":3,"file":"legacy-paths.mjs","sourceRoot":"","sources":["../../../src/cli/install/legacy-paths.mjs"],"names":[],"mappings":"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"}

package/dist/cli/produce/blind-probe.d.mts

@@ -0,0 +1,85 @@
+/** The probes/<milestone>.json path for a run + milestone. */
+export function probeSetPathFor(projectDir: any, runId: any, milestoneId: any): string;
+/** Read + parse a frozen probe set. Returns null when absent or malformed. */
+export function readProbeSet(projectDir: any, runId: any, milestoneId: any): any;
+/**
+ * Freeze a blind-probe set for a milestone, idempotently. REFUSES fail-closed
+ * when the author family equals the implementer family (a held-out probe an
+ * implementer authored is not held out — ID-06) or when no implementer family
+ * is recorded (ID-M2-02). On a FRESH freeze appends `produce.probe.frozen`
+ * carrying ONLY the hash + author family (never the content). A second freeze
+ * returns the byte-identical stored set (`reused: true`) and never re-logs.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {string} milestoneId
+ * @param {{ content: unknown, authorFamily: string, implementerFamily: string }} args
+ * @param {Date} [now]
+ * @returns {{ ok: true, reused: boolean, probe_set_hash: string, author_family: string }
+ *   | { ok: false, reason: string }}
+ */
+export function freezeProbeSet(projectDir: string, runId: string, milestoneId: string, { content, authorFamily, implementerFamily }: {
+    content: unknown;
+    authorFamily: string;
+    implementerFamily: string;
+}, now?: Date): {
+    ok: true;
+    reused: boolean;
+    probe_set_hash: string;
+    author_family: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Record a blind-probe RUN result. REFUSES fail-closed when the probe family
+ * equals the implementer family (a probe run BY the implementer family is not
+ * cross-family — ID-08) or when no implementer family is recorded. On
+ * acceptance appends `produce.probe.run {run_id, milestone_id, result,
+ * probe_family, head_sha}` — result/family/head_sha only, never content.
+ *
+ * @param {string} projectDir
+ * @param {{ runId: string, milestoneId: string, result: string, probeFamily: string, headSha: string }} args
+ * @returns {{ ok: true, result: string, probe_family: string, head_sha: string }
+ *   | { ok: false, reason: string }}
+ */
+export function recordProbeRun(projectDir: string, { runId, milestoneId, result, probeFamily, headSha }: {
+    runId: string;
+    milestoneId: string;
+    result: string;
+    probeFamily: string;
+    headSha: string;
+}): {
+    ok: true;
+    result: string;
+    probe_family: string;
+    head_sha: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Select a DETERMINISTIC rotating sample of already-`done` milestones for blind
+ * re-probing against HEAD (US-6). Rotates by fewest prior probe runs first,
+ * then oldest last-probe-run first (a never-probed done milestone sorts first),
+ * then first-seen roadmap order — so two folds of the same log select the same
+ * sample.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {{ sample?: number }} [opts]
+ * @returns {{ run_id: string, sample_size: number, selected: Array<{ milestone_id: string, title: string, probe_run_count: number, last_probe_run_at: string | null }> }}
+ */
+export function selectSweepSample(projectDir: string, runId: string, { sample }?: {
+    sample?: number;
+}): {
+    run_id: string;
+    sample_size: number;
+    selected: Array<{
+        milestone_id: string;
+        title: string;
+        probe_run_count: number;
+        last_probe_run_at: string | null;
+    }>;
+};
+//# sourceMappingURL=blind-probe.d.mts.map

package/dist/cli/produce/blind-probe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blind-probe.d.mts","sourceRoot":"","sources":["../../../src/cli/produce/blind-probe.mjs"],"names":[],"mappings":"AA4CA,8DAA8D;AAC9D,uFAEC;AAED,8EAA8E;AAC9E,iFAQC;AAkBD;;;;;;;;;;;;;;;GAeG;AACH,2CARW,MAAM,SACN,MAAM,eACN,MAAM,gDACN;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,QACrE,IAAI,GACF;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAClF;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAgEnC;AAED;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,wDACN;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1F;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAqBnC;AAED;;;;;;;;;;;GAWG;AACH,8CALW,MAAM,SACN,MAAM,eACN;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;CAAE,CA6CxK"}

package/dist/cli/produce/blind-probe.mjs

@@ -0,0 +1,217 @@
+/**
+ * @internal
+ * produce/blind-probe.mjs — the held-out cross-family blind-probe set (M2, AC4-6).
+ *
+ * A fixed 10–20 behavioral probe set the implementer/Showrunner NEVER sees
+ * (probe-blindness, US-4 / ID-06), authored + run by a provider family DISJOINT
+ * from the implementer's, re-run on a rotating sample of already-done milestones
+ * against HEAD (US-6).
+ *
+ * The probe SET is a frozen immutable artifact at
+ * `.aperant/produce/<run-id>/probes/<milestone>.json`, written ONCE via
+ * `openSync(path, 'wx')` exclusive-create — a second freeze throws EEXIST and
+ * returns the byte-identical stored set (mirrors setpoint.mjs::freezeSetpoint).
+ * Its CONTENT never enters the event log or the roadmap projection the
+ * Showrunner re-reads each tick (structural probe-blindness, ID-M2-03): the
+ * `produce.probe.frozen` event carries ONLY `{probe_set_hash, author_family}`
+ * and `produce.probe.run` carries ONLY `{result, probe_family, head_sha}`.
+ */
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, writeSync, } from 'node:fs';
+import { join } from 'node:path';
+import { appendProduceEvent, readImplementerFamily, readProduceRunEventsMatching, } from './events.mjs';
+import { normalizeFamily } from './probe-family.mjs';
+import { projectRoadmap } from './projection.mjs';
+import { resolveRunDir } from './run-id.mjs';
+/** sha256 of the canonical JSON of the probe content (the immutable hash stamp). */
+function computeProbeSetHash(content) {
+    return createHash('sha256').update(JSON.stringify(content)).digest('hex');
+}
+/** The probes/<milestone>.json path for a run + milestone. */
+export function probeSetPathFor(projectDir, runId, milestoneId) {
+    return join(resolveRunDir(projectDir, runId), 'probes', `${milestoneId}.json`);
+}
+/** Read + parse a frozen probe set. Returns null when absent or malformed. */
+export function readProbeSet(projectDir, runId, milestoneId) {
+    const p = probeSetPathFor(projectDir, runId, milestoneId);
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Exclusive-create write of the frozen probe set on the FINAL path (NOT
+ * tmp+rename), so a SECOND write throws EEXIST — the set is immutable.
+ */
+function writeProbeSetExclusive(probePath, probeSet) {
+    mkdirSync(join(probePath, '..'), { recursive: true });
+    const payload = `${JSON.stringify(probeSet, null, 2)}\n`;
+    const fd = openSync(probePath, 'wx'); // throws EEXIST when already frozen
+    try {
+        writeSync(fd, payload, 0, 'utf-8');
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Freeze a blind-probe set for a milestone, idempotently. REFUSES fail-closed
+ * when the author family equals the implementer family (a held-out probe an
+ * implementer authored is not held out — ID-06) or when no implementer family
+ * is recorded (ID-M2-02). On a FRESH freeze appends `produce.probe.frozen`
+ * carrying ONLY the hash + author family (never the content). A second freeze
+ * returns the byte-identical stored set (`reused: true`) and never re-logs.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {string} milestoneId
+ * @param {{ content: unknown, authorFamily: string, implementerFamily: string }} args
+ * @param {Date} [now]
+ * @returns {{ ok: true, reused: boolean, probe_set_hash: string, author_family: string }
+ *   | { ok: false, reason: string }}
+ */
+export function freezeProbeSet(projectDir, runId, milestoneId, { content, authorFamily, implementerFamily }, now = new Date()) {
+    if (!authorFamily)
+        return { ok: false, reason: 'no_author_family' };
+    if (!implementerFamily)
+        return { ok: false, reason: 'no_implementer_family' };
+    // Cross-family enforcement (normalized so claude-code === claude).
+    if (normalizeFamily(authorFamily) === normalizeFamily(implementerFamily))
+        return { ok: false, reason: 'same_family_author' };
+    const probePath = probeSetPathFor(projectDir, runId, milestoneId);
+    const existing = readProbeSet(projectDir, runId, milestoneId);
+    if (existing)
+        return {
+            ok: true,
+            reused: true,
+            probe_set_hash: existing.probe_set_hash,
+            author_family: existing.author_family,
+        };
+    const probeSetHash = computeProbeSetHash(content ?? null);
+    const probeSet = {
+        run_id: runId,
+        milestone_id: milestoneId,
+        author_family: authorFamily,
+        frozen_at: now.toISOString(),
+        probe_set_hash: probeSetHash,
+        // The probe CONTENT lives in the frozen file (blind to the projection) —
+        // it NEVER enters the event log.
+        probes: content ?? null,
+    };
+    try {
+        writeProbeSetExclusive(probePath, probeSet);
+    }
+    catch (e) {
+        // Lost a concurrent race — the winner's file is authoritative; re-read it
+        // byte-identically rather than overwriting (mirrors freezeSetpoint).
+        if (e && e.code === 'EEXIST') {
+            const winner = readProbeSet(projectDir, runId, milestoneId);
+            if (winner)
+                return {
+                    ok: true,
+                    reused: true,
+                    probe_set_hash: winner.probe_set_hash,
+                    author_family: winner.author_family,
+                };
+        }
+        throw e;
+    }
+    // Announce by hash + author family ONLY — never the content (ID-M2-03).
+    appendProduceEvent(projectDir, 'produce.probe.frozen', {
+        run_id: runId,
+        milestone_id: milestoneId,
+        probe_set_hash: probeSetHash,
+        author_family: authorFamily,
+    });
+    return { ok: true, reused: false, probe_set_hash: probeSetHash, author_family: authorFamily };
+}
+/**
+ * Record a blind-probe RUN result. REFUSES fail-closed when the probe family
+ * equals the implementer family (a probe run BY the implementer family is not
+ * cross-family — ID-08) or when no implementer family is recorded. On
+ * acceptance appends `produce.probe.run {run_id, milestone_id, result,
+ * probe_family, head_sha}` — result/family/head_sha only, never content.
+ *
+ * @param {string} projectDir
+ * @param {{ runId: string, milestoneId: string, result: string, probeFamily: string, headSha: string }} args
+ * @returns {{ ok: true, result: string, probe_family: string, head_sha: string }
+ *   | { ok: false, reason: string }}
+ */
+export function recordProbeRun(projectDir, { runId, milestoneId, result, probeFamily, headSha }) {
+    if (result !== 'pass' && result !== 'fail')
+        return { ok: false, reason: 'invalid_result' };
+    if (!probeFamily)
+        return { ok: false, reason: 'no_probe_family' };
+    if (!headSha)
+        return { ok: false, reason: 'no_head_sha' };
+    const implementerFamily = readImplementerFamily(projectDir, runId, milestoneId);
+    if (!implementerFamily)
+        return { ok: false, reason: 'no_recorded_implementer' };
+    if (normalizeFamily(probeFamily) === normalizeFamily(implementerFamily))
+        return { ok: false, reason: 'same_family_probe' };
+    appendProduceEvent(projectDir, 'produce.probe.run', {
+        run_id: runId,
+        milestone_id: milestoneId,
+        result,
+        probe_family: probeFamily,
+        head_sha: headSha,
+    });
+    return { ok: true, result, probe_family: probeFamily, head_sha: headSha };
+}
+/**
+ * Select a DETERMINISTIC rotating sample of already-`done` milestones for blind
+ * re-probing against HEAD (US-6). Rotates by fewest prior probe runs first,
+ * then oldest last-probe-run first (a never-probed done milestone sorts first),
+ * then first-seen roadmap order — so two folds of the same log select the same
+ * sample.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {{ sample?: number }} [opts]
+ * @returns {{ run_id: string, sample_size: number, selected: Array<{ milestone_id: string, title: string, probe_run_count: number, last_probe_run_at: string | null }> }}
+ */
+export function selectSweepSample(projectDir, runId, { sample = 1 } = {}) {
+    const roadmap = projectRoadmap(projectDir, runId);
+    const done = roadmap.milestones.filter((m) => m.status === 'done');
+    const runEvents = readProduceRunEventsMatching(projectDir, runId, (op) => op === 'produce.probe.run');
+    const stats = new Map();
+    for (const e of runEvents) {
+        const id = e.data && typeof e.data.milestone_id === 'string' ? e.data.milestone_id : null;
+        if (!id)
+            continue;
+        const s = stats.get(id) || { count: 0, last: null };
+        s.count += 1;
+        if (typeof e.t === 'string' && (s.last === null || e.t > s.last))
+            s.last = e.t;
+        stats.set(id, s);
+    }
+    const withOrder = done.map((m, idx) => {
+        const s = stats.get(m.id) || { count: 0, last: null };
+        return { milestone: m, order: idx, count: s.count, last: s.last };
+    });
+    withOrder.sort((a, b) => {
+        if (a.count !== b.count)
+            return a.count - b.count; // fewest probe runs first
+        // oldest last-probe-run first — a never-probed done milestone (null) sorts
+        // ahead of any dated one.
+        const al = a.last ?? '';
+        const bl = b.last ?? '';
+        if (al !== bl)
+            return al < bl ? -1 : 1;
+        return a.order - b.order; // first-seen roadmap order (stable tiebreak)
+    });
+    const n = Number.isFinite(sample) && sample > 0 ? Math.floor(sample) : 1;
+    const selected = withOrder.slice(0, n).map((w) => ({
+        milestone_id: w.milestone.id,
+        title: w.milestone.title,
+        probe_run_count: w.count,
+        last_probe_run_at: w.last,
+    }));
+    return { run_id: runId, sample_size: selected.length, selected };
+}
+//# sourceMappingURL=blind-probe.mjs.map

package/dist/cli/produce/blind-probe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"blind-probe.mjs","sourceRoot":"","sources":["../../../src/cli/produce/blind-probe.mjs"],"names":[],"mappings":"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"}

package/dist/cli/produce/claim.d.mts

@@ -0,0 +1,188 @@
+/**
+ * Validate a Claim Envelope by dispatching on `envelope.profile` through the
+ * REGISTRY (never a hardcoded profile branch — ID-M6-02). An unknown/absent
+ * profile fails closed (`{ ok:false, reason:'unknown_profile' }`). Never throws.
+ *
+ * @param {Record<string, unknown>} envelope
+ * @param {{ profiles?: Record<string, { validate: (env: Record<string, unknown>) => { ok: boolean, reason?: string } }> }} [opts]
+ * @returns {{ ok: true } | { ok: false, reason: string }}
+ */
+export function validateClaimEnvelope(envelope: Record<string, unknown>, { profiles }?: {
+    profiles?: Record<string, {
+        validate: (env: Record<string, unknown>) => {
+            ok: boolean;
+            reason?: string;
+        };
+    }>;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Mint a claim id: `<slug-of-text>-<rand>`. Reuses `slugFromOutcome` + a short
+ * random suffix (mirrors ledger.mjs::mintCriterionId) so two claims minted from
+ * the same text never collide. Falls back to the profile when text is empty.
+ *
+ * @param {string} profile
+ * @param {string} text
+ * @returns {string}
+ */
+export function mintClaimId(profile: string, text: string): string;
+/** The claims/<claim-id>.json path for a run + claim. */
+export function claimPathFor(projectDir: any, runId: any, claimId: any): string;
+/** Read + parse a frozen claim record. Returns null when absent or malformed. */
+export function readClaim(projectDir: any, runId: any, claimId: any): any;
+/**
+ * Freeze a Claim Envelope, idempotently. VALIDATES first (refuses to freeze an
+ * invalid envelope — fail-closed), computes `content_hash = sha256(envelope)`,
+ * writes `claims/<claim-id>.json` exclusive-create, and on a FRESH freeze appends
+ * `produce.claim.declared {run_id, profile, claim_id, content_hash}` (content_hash
+ * only — the full envelope lives in the frozen file, ID-M6-07). A second freeze
+ * of the same claim id returns the byte-identical stored record (`reused: true`)
+ * and never re-logs. The resolved `profile` (explicit arg or `envelope.profile`)
+ * is authoritative for validation dispatch + the stored/logged profile.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {{ profile?: string, envelope: Record<string, unknown>, claimId?: string }} args
+ * @param {{ profiles?: object, now?: Date }} [opts]
+ * @returns {{ ok: true, reused: boolean, claim_id: string, profile: string | null, content_hash: string }
+ *   | { ok: false, reason: string }}
+ */
+export function freezeClaim(projectDir: string, runId: string, { profile, envelope, claimId }?: {
+    profile?: string;
+    envelope: Record<string, unknown>;
+    claimId?: string;
+}, { profiles, now }?: {
+    profiles?: object;
+    now?: Date;
+}): {
+    ok: true;
+    reused: boolean;
+    claim_id: string;
+    profile: string | null;
+    content_hash: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Fold the run's claim ledger from the append-only log — a SEPARATE fold parallel
+ * to `ledger.mjs::projectLedger` / `saga.mjs::projectSaga` (the roadmap projection
+ * still folds `produce.roadmap.*` ONLY, so claim ops never enter the roadmap the
+ * Showrunner re-reads). A `produce.claim.declared` seeds an ACTIVE claim (in
+ * first-seen order); a `produce.claim.expired` advances it to `expired`;
+ * `produce.claim.consumed` is a forensic-only event that does NOT change status.
+ * Deterministic — two folds of the same log yield the identical ledger.
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @returns {{
+ *   run_id: string,
+ *   claims: Array<{ claim_id: string, profile: string | null, content_hash: string | null, status: 'active' | 'expired' }>,
+ *   active_count: number,
+ *   expired_count: number,
+ *   updated_at: string | null,
+ * }}
+ */
+export function projectClaims(projectDir: string, runId: string): {
+    run_id: string;
+    claims: Array<{
+        claim_id: string;
+        profile: string | null;
+        content_hash: string | null;
+        status: "active" | "expired";
+    }>;
+    active_count: number;
+    expired_count: number;
+    updated_at: string | null;
+};
+/**
+ * Decide whether a claim may be consumed against a ctx (ID-M6-04, anti-corrosion).
+ * DETERMINISTIC (no LLM). SKIPS with a reason when: the claim is time-expired
+ * (`now() > expiry.expires_at` → `expired`); the claim's `revalidate_against_head`
+ * check no longer matches HEAD (`headCheck(check) === false` → `head_invalidated`);
+ * or the preconditions don't match ctx (`precondition_unmatched`). Otherwise
+ * `{ consume: true }`. `now` + `headCheck` are INJECTED (default now = new Date,
+ * default headCheck = the working-tree path-exists/grep).
+ *
+ * @param {Record<string, unknown>} claim — the claim ENVELOPE (carries expiry + preconditions).
+ * @param {Record<string, unknown>} [ctx]
+ * @param {{ now?: () => Date, headCheck?: (check: unknown) => boolean }} [deps]
+ * @returns {{ consume: true } | { consume: false, reason: string }}
+ */
+export function evaluateClaimForConsumption(claim: Record<string, unknown>, ctx?: Record<string, unknown>, deps?: {
+    now?: () => Date;
+    headCheck?: (check: unknown) => boolean;
+}): {
+    consume: true;
+} | {
+    consume: false;
+    reason: string;
+};
+/**
+ * Consume the run's ACTIVE claims against a ctx (ID-M6-06 — THE M6 invariant).
+ * For each active claim, evaluate it; a consumable claim emits ONE bounded delta
+ * `{ claim_id, profile, targets: [{ kind, requirement, ref? }] }` where every
+ * `targets[].kind ∈ CLAIM_TARGET_KINDS` and `requirement` is derived FROM
+ * `resolution_verifier` — a projection DOWN. The output MUST NOT carry the claim's
+ * `provenance` / `negative_evidence` / `preconditions` / body (never a context
+ * paste). Skipped claims (expired / head_invalidated / precondition_unmatched /
+ * unreadable) surface under `skipped[]` with a reason. PURE — appends no event
+ * (the CLI records `produce.claim.consumed` per target for the forensic trail).
+ *
+ * @param {string} projectDir
+ * @param {string} runId
+ * @param {Record<string, unknown>} [ctx]
+ * @param {{ now?: () => Date, headCheck?: (check: unknown) => boolean }} [deps]
+ * @returns {{
+ *   consumed: Array<{ claim_id: string, profile: string | null, targets: Array<{ kind: string, requirement: string, ref?: string }> }>,
+ *   skipped: Array<{ claim_id: string, reason: string }>,
+ * }}
+ */
+export function consumeClaims(projectDir: string, runId: string, ctx?: Record<string, unknown>, deps?: {
+    now?: () => Date;
+    headCheck?: (check: unknown) => boolean;
+}): {
+    consumed: Array<{
+        claim_id: string;
+        profile: string | null;
+        targets: Array<{
+            kind: string;
+            requirement: string;
+            ref?: string;
+        }>;
+    }>;
+    skipped: Array<{
+        claim_id: string;
+        reason: string;
+    }>;
+};
+export namespace CLAIM_PROFILES {
+    namespace lesson {
+        export let requiredFields: string[];
+        export { validateLessonEnvelope as validate };
+    }
+}
+/** The closed set of consumption-delta target kinds (mirrors ALLOWED_CLAIM_TARGET_KINDS). */
+export const CLAIM_TARGET_KINDS: string[];
+/**
+ * The `lesson` profile validator (ID-M6-03). REQUIRES all 6 AC15 fields and
+ * REJECTS fail-closed (never throws): missing provenance; empty preconditions
+ * (unconditional rule — bounded-critic clamp); global/unbounded scope
+ * (anti-windup); missing expiry (anti-corrosion); missing negative_evidence
+ * field; empty resolution_verifier. Returns `{ ok:false, reason }`.
+ *
+ * @param {Record<string, unknown>} env
+ * @returns {{ ok: true } | { ok: false, reason: string }}
+ */
+declare function validateLessonEnvelope(env: Record<string, unknown>): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export {};
+//# sourceMappingURL=claim.d.mts.map

package/dist/cli/produce/claim.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.mts","sourceRoot":"","sources":["../../../src/cli/produce/claim.mjs"],"names":[],"mappings":"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"}