@lumoai/cli 1.47.0 → 1.48.0

package/assets/skill/SKILL.md

@@ -31,6 +31,7 @@ The command catalog below is a **map**: it lists every command grouped by domain
 | `task criteria set/list`, drafting the acceptance contract                              | [references/criteria.md](references/criteria.md)               |
 | `verify`, `task status` — machine verification loop, claim-done flow, self-check/resume | [references/verify.md](references/verify.md)                   |
 | `cost` — per-operation (per-tool) token cost read-out; `task lineage` Top-5             | [references/task-context.md](references/task-context.md)       |
+| `outcome show/record/rate` — post-hoc outcome well (falsifier oracle, rejection-only)   | [references/outcome.md](references/outcome.md)                 |
 | `project list`, `milestone*`                                                            | [references/milestones.md](references/milestones.md)           |
 | `doc create/update/list/move/bind/share/import` (CRUD)                                  | [references/docs.md](references/docs.md)                       |
 | `doc show --raw/--section`, `doc patch/append/diff/rebuild-source` (editing live docs)  | [references/doc-editing.md](references/doc-editing.md)         |
@@ -92,6 +93,16 @@ The command catalog below is a **map**: it lists every command grouped by domain
 
 - `lumo cost [--task <id>|--session <id>|--since <date>] [--by tool|model|member|session] [--json]` — per-operation token cost read-out, attributing each model step's token delta to the tool(s) it ran. Scope is mutually exclusive (default = workspace last-30-days). For the per-task Top-5 inline, see `lumo task lineage`.
 
+**Criteria audit** — workspace-level referent-kind analytics
+
+- `lumo criteria audit` — workspace-level read-out: count of acceptance criteria by effective referent kind (EXTERNAL_FACT / AGENT_CONSTRUCTED_STATE / PENDING_OUTCOME / UNVERIFIED_ASSERTION / UNCLASSIFIED) + the self-confirming-green ratio
+
+**Outcome well (post-hoc oracle)** — see [outcome.md](references/outcome.md)
+
+- `lumo outcome show <task>` — read the post-hoc outcome well: the **falsifier** verdict (`REJECTED` | `INCONCLUSIVE` — never a "pass") plus its backing rejection signals. `INCONCLUSIVE` = no rejection on record, **not** "satisfied".
+- `lumo outcome record <task> --note "<what reality did>" [--kind <kind>]` — record a human-observed post-hoc **rejection** of a delivery (revert / rollback / CI regression / downstream redirect / bypass). Append-only; **there is no "mark satisfied" counterpart** — the well only asserts rejection. `--note` is required (the observed referent).
+- `lumo outcome rate [--min N] [--json]` — workspace **trust × post-hoc-fate** join (LUM-603): per delivery-time forecast-confidence bracket (high/medium/low), the post-hoc REJECTED rate from the well. Honest by construction — thin brackets read `insufficient` (no fabricated rate), the high-vs-low comparison stays `inconclusive` until CIs separate, and the rate is a **lower bound** (no signal = INCONCLUSIVE, never satisfied). Under-sampled today by design — the skeleton produces real strata once the well fills.
+
 **Artifacts & Figma** — see [artifacts-figma.md](references/artifacts-figma.md)
 
 - `lumo task artifact add/update/list/show/rm` — record spec/plan products on a task
@@ -146,6 +157,25 @@ The command catalog below is a **map**: it lists every command grouped by domain
 - `lumo worktree rm <LUM-N> --yes` — remove a worktree (keeps the branch unless `--delete-branch`)
 - `lumo worktree list` — list `.worktrees/` worktrees (task id, branch, dirty, node_modules link)
 
+## Criteria audit
+
+```bash
+lumo criteria audit
+```
+
+`lumo criteria audit` — workspace-level acceptance-criteria analytics. Calls `GET /api/criteria/audit` and prints two things:
+
+1. **Declared-kind distribution** — count of criteria by effective referent kind:
+   - `EXTERNAL_FACT` — declared as externally observable (git SHA, CI status, DB row) and the checkpointer invokes real external tooling
+   - `AGENT_CONSTRUCTED_STATE` — passes by checking output the agent itself produced
+   - `PENDING_OUTCOME` — deferred to post-hoc falsifier
+   - `UNVERIFIED_ASSERTION` — declared `EXTERNAL_FACT` but the checkpointer does **not** actually invoke external tooling (git/CI/HTTP); downgraded by the audit
+   - `UNCLASSIFIED` — legacy rows predating the `referentKind` field (null in DB)
+
+2. **Self-confirming-green headline ratio** — `(AGENT_CONSTRUCTED_STATE + UNVERIFIED_ASSERTION) / classified`. Criteria in these two buckets pass by confirming only the agent's own work, not an independent external state.
+
+**When to suggest**: when the user wants to audit how much of the workspace's "green" criteria are self-confirming vs externally anchored; when diagnosing whether acceptance criteria have real external hooks or are circular.
+
 ## Commands & flags that do NOT exist (common mistakes)
 
 Don't guess these:

package/assets/skill/references/outcome.md

@@ -0,0 +1,65 @@
+# Outcome well (post-hoc oracle) — `lumo outcome`
+
+The **post-hoc outcome well** (LUM-598) is the single external oracle for correctness + fidelity. It records the real-world fate a delivery met **after** it shipped — facts the agent cannot construct and that occur post-delivery (a revert, a rollback, CI turning red, a reopen, a downstream redirect of the design).
+
+## The one invariant: falsifier, not verifier
+
+The well **only** ever produces a rejection. Its verdict space is exactly:
+
+- `REJECTED` — the well holds ≥1 rejection signal (reality revoked / redid / bypassed the delivery).
+- `INCONCLUSIVE` — no rejection on record.
+
+There is **no `SATISFIED` / `PASS`**. "N sprints and nobody touched it" is the _absence_ of a rejection — satisfied, merely-tolerated, and never-noticed are externally indistinguishable — so it reads `INCONCLUSIVE`, never a pass. Treat `INCONCLUSIVE` as "could not confirm a rejection", not as approval.
+
+## Collection (where signals come from)
+
+- **Automatic** — a DONE task reopened (the lineage `REWORKED` transition) is folded into the well as a `REOPENED` signal. No action needed; it happens server-side.
+- **Manual** — a human who observed reality reject a delivery records it with `lumo outcome record`. The `--note` is mandatory: it is the observed referent, frozen as evidence.
+
+## `lumo outcome show <task>`
+
+Read the well for a task — the verdict plus its backing signals.
+
+```bash
+lumo outcome show LUM-42
+```
+
+An empty well prints `INCONCLUSIVE` with the reminder that silence is not a pass. A non-empty well prints `REJECTED` and lists each signal (date, kind, source, note).
+
+## `lumo outcome record <task> --note "<what reality did>" [--kind <kind>]`
+
+Record one human-observed post-hoc rejection. Append-only — every call inserts a new signal; nothing is ever mutated or cleared.
+
+```bash
+lumo outcome record LUM-42 --note "reverted in #812 after a prod incident" --kind reverted
+lumo outcome record LUM-42 --note "downstream rewrote the API shape this task introduced" --kind downstream_redirect
+```
+
+- `--kind` (case-insensitive, default `manual`): `reverted | rolled_back | ci_regression | downstream_redirect | bypassed | manual`. `reopened` is **not** a manual kind — it is owned by the automatic lineage fold.
+- `--occurred-at <iso>` — when the event actually happened (defaults to now).
+
+## `lumo outcome rate [--min N] [--json]`
+
+The workspace-level **trust × post-hoc-fate** join (LUM-603). For every delivery that has a frozen forecast snapshot, it buckets the delivery by its **delivery-time forecast-confidence** (high / medium / low — the only trust axis frozen at delivery, recomputed from the snapshot's `cohortSize` / `tokenCostBasis`) and reports each bracket's post-hoc **REJECTED** rate from the well. The question it answers once data is sufficient: _do high-trust deliveries get rejected by reality less often than low-trust ones?_
+
+```bash
+lumo outcome rate
+lumo outcome rate --min 20 --json
+```
+
+This is the falsifier discipline applied at the **query layer** — it refuses to manufacture a finding off a thin sample:
+
+- A bracket with fewer than `--min` (default 10) deliveries reads **`insufficient`** with the rate withheld — the raw `rejected/delivered` counts are still shown, but never divided into a believable proportion.
+- The per-bracket rate is an explicit **lower bound** on true failure: the well only records rejections, so a zero-signal delivery is `INCONCLUSIVE` (counted in the denominator), never "satisfied".
+- The headline **high-vs-low** comparison asserts a direction **only** when both brackets are measured _and_ their 95% confidence intervals are disjoint; otherwise it stays **`inconclusive`**.
+
+**Expect `inconclusive` today.** The well is freshly wired and under-sampled — that is the designed state, not a bug. The same command produces real strata once enough post-hoc signals accumulate (the deferred outcome the skeleton exists to read).
+
+> Scope note (debt-a): the trust axis is **task-level** forecast confidence only. Fragment-level trust is not frozen at delivery and drifts, so it is deliberately **not** joined here — doing so would read a post-hoc value against a past delivery. Freezing fragment trust is a separate follow-up.
+
+## When to suggest
+
+- A teammate says a shipped task **was reverted / rolled back / broke prod / got redone / was bypassed** — record it with `lumo outcome record` so the well carries reality's verdict.
+- Auditing whether a "done" task actually held up — `lumo outcome show <task>` reads the well.
+- Asking whether **higher-confidence deliveries actually fail less** (does delivery-time trust predict post-hoc fate?) — `lumo outcome rate`. Expect `inconclusive` until the well fills; it will never print a correlation the sample can't support.
+- **Never** use it to mark something good: the well has no positive verdict by design. To assert a delivery met its contract, that is the acceptance loop (`lumo verify` / `lumo task status`), not the well.

package/dist/cli/src/commands/criteria-audit.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAuditReport = formatAuditReport;
+exports.criteriaAudit = criteriaAudit;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const KIND_ORDER = [
+    'EXTERNAL_FACT',
+    'AGENT_CONSTRUCTED_STATE',
+    'PENDING_OUTCOME',
+    'UNVERIFIED_ASSERTION',
+    'UNCLASSIFIED',
+];
+function formatAuditReport(r) {
+    const lines = ['Criteria referent-kind audit (workspace)', ''];
+    for (const k of KIND_ORDER) {
+        const n = r.byEffectiveKind[k] ?? 0;
+        const pct = r.total === 0 ? 0 : Math.round((n / r.total) * 100);
+        lines.push(`  ${k.padEnd(24)} ${String(n).padStart(4)}  (${pct}%)`);
+    }
+    lines.push('');
+    const pct = Math.round(r.selfConfirmingGreenRatio * 100);
+    lines.push(`  self-confirming green: ${pct}% of ${r.classified} classified criteria`);
+    lines.push(`  (AGENT_CONSTRUCTED_STATE + UNVERIFIED_ASSERTION — green that confirms only the agent's own work)`);
+    return lines.join('\n') + '\n';
+}
+/** `lumo criteria audit` — workspace-level referent-kind distribution. */
+async function criteriaAudit() {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const base = (0, api_1.trimTrailingSlash)((0, api_1.resolveAuthedApiUrl)(creds.apiUrl));
+    let res;
+    try {
+        res = await fetch(`${base}/api/criteria/audit`, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API (${msg})`);
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: criteria audit failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const report = (await res.json());
+    process.stdout.write(formatAuditReport(report));
+}

package/dist/cli/src/commands/outcome.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outcomeRecord = outcomeRecord;
+exports.outcomeShow = outcomeShow;
+exports.outcomeRate = outcomeRate;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+/**
+ * `lumo outcome` — the post-hoc outcome well (LUM-598).
+ *
+ * The well is the single external oracle for correctness + fidelity: it records
+ * the real-world fate a delivery met AFTER it shipped. It is a FALSIFIER, not a
+ * verifier — it only ever reads REJECTED (reality revoked/redid/bypassed the
+ * work) or INCONCLUSIVE (no rejection on record). There is deliberately no
+ * "mark satisfied": the absence of a rejection is not a pass.
+ */
+const MANUAL_KINDS = [
+    'REVERTED',
+    'ROLLED_BACK',
+    'CI_REGRESSION',
+    'DOWNSTREAM_REDIRECT',
+    'BYPASSED',
+    'MANUAL',
+];
+function authBase() {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds)
+        return { error: 'not logged in. Run `lumo auth login` first.' };
+    const base = (0, api_1.trimTrailingSlash)((0, api_1.resolveAuthedApiUrl)(creds.apiUrl));
+    const headers = {
+        Authorization: `Bearer ${creds.token}`,
+    };
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    if (sessionId)
+        headers['X-Lumo-Session-Id'] = sessionId;
+    return { base, headers };
+}
+/**
+ * `lumo outcome record <task> --note "<what reality did>" [--kind <kind>]` —
+ * record a human-observed post-hoc REJECTION of a delivery. Append-only. The
+ * note is mandatory (the observed referent); the default kind is MANUAL.
+ */
+async function outcomeRecord(taskId, options = {}) {
+    if (!taskId || taskId.trim() === '') {
+        console.error('Error: a task is required: lumo outcome record <task> --note "…"');
+        return 1;
+    }
+    const note = options.note?.trim();
+    if (!note) {
+        console.error('Error: --note "<what reality did>" is required (the observed rejection, e.g. "reverted in #812 after prod incident").');
+        return 1;
+    }
+    const kind = (options.kind?.trim().toUpperCase() ||
+        'MANUAL');
+    if (!MANUAL_KINDS.includes(kind)) {
+        console.error(`Error: --kind must be one of: ${MANUAL_KINDS.map(k => k.toLowerCase()).join(', ')}`);
+        return 1;
+    }
+    const auth = authBase();
+    if ('error' in auth) {
+        console.error(`Error: ${auth.error}`);
+        return 1;
+    }
+    const payload = { kind, note };
+    if (options.occurredAt?.trim())
+        payload.occurredAt = options.occurredAt.trim();
+    let res;
+    try {
+        res = await fetch(`${auth.base}/api/tasks/${encodeURIComponent(taskId)}/outcome-signals`, {
+            method: 'POST',
+            headers: { ...auth.headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        const errBody = (await res.json().catch(() => null));
+        const detail = errBody && typeof errBody.error === 'string'
+            ? (0, sanitize_1.sanitizeField)(errBody.error)
+            : '';
+        console.error(`Error: outcome not recorded (HTTP ${res.status})${detail ? ` — ${detail}` : ''}`);
+        return 1;
+    }
+    process.stdout.write(`✓ Recorded a ${(0, sanitize_1.sanitizeField)(kind.toLowerCase())} rejection on ${(0, sanitize_1.sanitizeField)(taskId)}.\n` +
+        '  The well is a falsifier — this marks the delivery REJECTED by reality; ' +
+        'it is append-only and there is no "satisfied" counterpart.\n');
+    return;
+}
+/**
+ * `lumo outcome show <task>` — read the well for a task: the falsifier verdict
+ * plus its backing rejection signals.
+ */
+async function outcomeShow(taskId) {
+    if (!taskId || taskId.trim() === '') {
+        console.error('Error: a task is required: lumo outcome show <task>');
+        return 1;
+    }
+    const auth = authBase();
+    if ('error' in auth) {
+        console.error(`Error: ${auth.error}`);
+        return 1;
+    }
+    let res;
+    try {
+        res = await fetch(`${auth.base}/api/tasks/${encodeURIComponent(taskId)}/outcome-signals`, { headers: auth.headers });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: could not read the well (HTTP ${res.status}).`);
+        return 1;
+    }
+    const well = (await res.json());
+    const mark = well.verdict === 'REJECTED' ? '✗' : '·';
+    process.stdout.write(`${mark} Outcome well — ${(0, sanitize_1.sanitizeField)(taskId)}: ${well.verdict}\n`);
+    if (well.verdict === 'INCONCLUSIVE') {
+        process.stdout.write('  No rejection on record. INCONCLUSIVE ≠ satisfied — the well only ' +
+            'asserts rejection; silence is not a pass.\n');
+        return;
+    }
+    for (const s of well.signals) {
+        const when = (s.occurredAt ?? s.detectedAt).slice(0, 10);
+        const note = s.evidence?.note ? ` — ${(0, sanitize_1.sanitizeField)(s.evidence.note)}` : '';
+        process.stdout.write(`  ${when}  ${(0, sanitize_1.sanitizeField)(s.kind)} (${(0, sanitize_1.sanitizeField)(s.source)})${note}\n`);
+    }
+    return;
+}
+/** Render the report client-side (same pattern as `lumo cost` / `outcome show`). */
+function formatRate(report) {
+    const lines = [];
+    lines.push('Trust × post-hoc fate — delivery-time forecast confidence vs the outcome well');
+    lines.push('  (rejection rate is a LOWER BOUND: the well only records rejections; ' +
+        'no signal = INCONCLUSIVE, never "satisfied")');
+    lines.push(`  ${report.totalDeliveries} snapshotted deliveries · min ${report.minSamples} per bracket`);
+    if (report.totalDeliveries === 0) {
+        lines.push('  (no delivery has a forecast snapshot yet — nothing to join)');
+        return lines.join('\n') + '\n';
+    }
+    for (const b of report.brackets) {
+        if (b.status === 'measured') {
+            const pct = ((b.rejectionRate ?? 0) * 100).toFixed(1);
+            const lo = ((b.interval?.lower ?? 0) * 100).toFixed(1);
+            const hi = ((b.interval?.upper ?? 0) * 100).toFixed(1);
+            lines.push(`  ${b.bracket.padEnd(6)} ≥${pct}% rejected (${b.rejected}/${b.delivered}, 95% CI ${lo}–${hi}%)`);
+        }
+        else {
+            lines.push(`  ${b.bracket.padEnd(6)} insufficient (${b.rejected}/${b.delivered} deliveries < ${report.minSamples} — rate withheld)`);
+        }
+    }
+    const verdict = report.comparison.status === 'measured'
+        ? `→ ${(0, sanitize_1.sanitizeField)(report.comparison.reason)}`
+        : `→ inconclusive: ${(0, sanitize_1.sanitizeField)(report.comparison.reason)}`;
+    lines.push(`  ${verdict}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * `lumo outcome rate [--min N] [--json]` — read the workspace trust × post-hoc-
+ * fate join: per delivery-time forecast-confidence bracket, the post-hoc
+ * REJECTED rate from the outcome well. Honest by construction — thin brackets
+ * read `insufficient` (no fabricated rate) and the high-vs-low comparison stays
+ * `inconclusive` until the well has enough signal to tell the brackets apart.
+ */
+async function outcomeRate(options = {}) {
+    const auth = authBase();
+    if ('error' in auth) {
+        console.error(`Error: ${auth.error}`);
+        return 1;
+    }
+    let min;
+    if (options.min !== undefined && options.min.trim() !== '') {
+        const n = Number(options.min);
+        if (!Number.isInteger(n) || n < 1) {
+            console.error('Error: --min must be a positive integer');
+            return 1;
+        }
+        min = n;
+    }
+    const qs = min !== undefined ? `?min=${min}` : '';
+    let res;
+    try {
+        res = await fetch(`${auth.base}/api/outcome/rate${qs}`, {
+            headers: auth.headers,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: could not read the outcome rate (HTTP ${res.status}).`);
+        return 1;
+    }
+    const report = (await res.json());
+    if (options.json) {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+        return;
+    }
+    process.stdout.write(formatRate(report));
+    return;
+}

package/dist/cli/src/commands/task-criteria-list.js

@@ -5,6 +5,7 @@ exports.taskCriteriaList = taskCriteriaList;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const referent_kind_1 = require("../../../shared/src/referent-kind");
 /**
  * Render criteria rows for stdout. One line per criterion —
  * `<id>  [TYPE]  SOURCE@rN  statement` — plus an indented checkpointer line
@@ -16,7 +17,13 @@ function formatCriteriaRows(criteria) {
     for (const c of criteria) {
         const provenance = `${c.source}@r${c.addedAtRound}`;
         const evidence = c.evidenceRequired ? '  [evidence]' : '';
-        lines.push(`${c.id}  [${c.verifierType}]  ${provenance}${evidence}  ${(0, sanitize_1.sanitizeField)(c.statement)}`);
+        const eff = (0, referent_kind_1.effectiveReferentKind)({
+            declared: c.referentKind ?? null,
+            verifierType: c.verifierType,
+            checkpointer: c.checkpointer,
+        });
+        const kindTag = ` ⟨${eff}⟩`;
+        lines.push(`${c.id}  [${c.verifierType}]  ${provenance}${evidence}${kindTag}  ${(0, sanitize_1.sanitizeField)(c.statement)}`);
         if (c.checkpointer) {
             lines.push(`  ↳ check: ${(0, sanitize_1.sanitizeField)(c.checkpointer)}`);
         }

package/dist/cli/src/commands/task-criteria-set.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyReadback = verifyReadback;
 exports.taskCriteriaSet = taskCriteriaSet;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
@@ -7,6 +8,31 @@ const doc_input_1 = require("../lib/doc-input");
 const path_guard_1 = require("../lib/path-guard");
 const sanitize_1 = require("../lib/sanitize");
 const task_criteria_list_1 = require("./task-criteria-list");
+/**
+ * Landing-integrity read-back (LUM-602): a 200 OK proves absence of error,
+ * not presence of correct content. Compare what the server stored (echoed in
+ * the PUT response) field-by-field against what we submitted; any divergence
+ * means the value was corrupted in transport/landing.
+ */
+function verifyReadback(submitted, stored) {
+    const issues = [];
+    const storedByStatement = new Map(stored.map(c => [c.statement, c]));
+    for (const s of submitted) {
+        const got = storedByStatement.get(s.statement);
+        if (!got) {
+            issues.push(`criterion not found after write: "${s.statement.slice(0, 60)}"`);
+            continue;
+        }
+        const wantCk = s.checkpointer ?? null;
+        if ((got.checkpointer ?? null) !== wantCk) {
+            issues.push(`checkpointer corrupted in landing for "${s.statement.slice(0, 40)}": sent ${JSON.stringify(wantCk)}, stored ${JSON.stringify(got.checkpointer ?? null)}`);
+        }
+        if (s.referentKind != null && got.referentKind !== s.referentKind) {
+            issues.push(`referentKind corrupted in landing for "${s.statement.slice(0, 40)}": sent ${s.referentKind}, stored ${got.referentKind}`);
+        }
+    }
+    return issues;
+}
 const CAUSE_TAGS = [
     'NEW_INFO',
     'SCOPE_CHANGE',
@@ -28,7 +54,7 @@ function parseCriteriaJson(raw) {
     if (!Array.isArray(parsed) || parsed.length === 0) {
         return {
             ok: false,
-            error: 'expected a non-empty JSON array of criteria, e.g. [{"statement":"…","verifierType":"MACHINE","checkpointer":"npx jest …"}]',
+            error: 'expected a non-empty JSON array of criteria, e.g. [{"statement":"…","verifierType":"MACHINE","checkpointer":"npx jest …","referentKind":"AGENT_CONSTRUCTED_STATE"}]',
         };
     }
     return { ok: true, items: parsed };
@@ -171,4 +197,12 @@ async function taskCriteriaSet(identifier, options) {
     if (data.judgeStepsWarning) {
         process.stdout.write(`⚠ ${(0, sanitize_1.sanitizeField)(data.judgeStepsWarning)}\n`);
     }
+    const readbackIssues = verifyReadback(criteriaItems, data.criteria);
+    if (readbackIssues.length > 0) {
+        for (const issue of readbackIssues) {
+            console.error(`⚠ landing-integrity: ${(0, sanitize_1.sanitizeField)(issue)}`);
+        }
+        console.error('Error: stored contract does not match what was submitted — do not trust the success receipt. Re-run and verify.');
+        return 1;
+    }
 }

package/dist/cli/src/index.js

@@ -47,9 +47,11 @@ const session_attach_1 = require("./commands/session-attach");
 const session_status_1 = require("./commands/session-status");
 const next_1 = require("./commands/next");
 const cost_1 = require("./commands/cost");
+const criteria_audit_1 = require("./commands/criteria-audit");
 const verify_1 = require("./commands/verify");
 const verdict_1 = require("./commands/verdict");
 const crossing_explain_1 = require("./commands/crossing-explain");
+const outcome_1 = require("./commands/outcome");
 const task_context_1 = require("./commands/task-context");
 const task_create_1 = require("./commands/task-create");
 const task_update_1 = require("./commands/task-update");
@@ -242,6 +244,26 @@ crossing
     .description('Append an agent self-explanation ("申辩") to a boundary crossing (LUM-542). Append-only and for the human reviewer — it never clears the crossing or unblocks Done (a human dispositions that). Targets a crossing on the session-bound task.')
     .requiredOption('--note <text>', 'The explanation to record (the rationale for the action / why it may be a false positive)')
     .action(wrap((id, options) => (0, crossing_explain_1.crossingExplain)(id, options)));
+const outcome = program
+    .command('outcome')
+    .description('Read / record the post-hoc outcome well (LUM-598)');
+outcome
+    .command('show <task>')
+    .description('Read the post-hoc outcome well for a task: the falsifier verdict (REJECTED | INCONCLUSIVE — never a "pass") plus its backing rejection signals. INCONCLUSIVE means no rejection on record, NOT satisfied.')
+    .action(wrap((task) => (0, outcome_1.outcomeShow)(task)));
+outcome
+    .command('record <task>')
+    .description('Record a human-observed post-hoc REJECTION of a delivery (revert / rollback / CI regression / downstream redirect / bypass). Append-only; there is no "mark satisfied" counterpart — the well only asserts rejection.')
+    .requiredOption('--note <text>', 'What reality did (the observed referent), e.g. "reverted in #812 after a prod incident"')
+    .option('--kind <kind>', 'reverted | rolled_back | ci_regression | downstream_redirect | bypassed | manual (case-insensitive; default: manual)')
+    .option('--occurred-at <iso>', 'When the event happened (ISO 8601; defaults to now)')
+    .action(wrap((task, options) => (0, outcome_1.outcomeRecord)(task, options)));
+outcome
+    .command('rate')
+    .description('Trust × post-hoc fate: per delivery-time forecast-confidence bracket, the post-hoc REJECTED rate from the outcome well. Honest by construction — thin brackets read "insufficient" and the high-vs-low comparison stays "inconclusive" until the well has enough signal. The rate is a LOWER BOUND (no signal = INCONCLUSIVE, never satisfied).')
+    .option('--min <N>', 'Per-bracket sample floor below which a rate is withheld (default 10)')
+    .option('--json', 'Emit the report as JSON')
+    .action(wrap(options => (0, outcome_1.outcomeRate)(options)));
 program
     .command('next')
     .description('Recommend the next task(s) to work on, ranked by priority, active sprint, and due date. Prints top N (default 3); pick one and run `session attach` + `task context`.')
@@ -256,6 +278,13 @@ program
     .option('--by <dim>', 'Headline grouping: tool | model | member | session (case-insensitive; default tool)')
     .option('--json', 'Emit the versioned payload as JSON')
     .action(wrap(options => (0, cost_1.cost)(options)));
+const criteria = program
+    .command('criteria')
+    .description('Workspace-level acceptance-criteria analytics');
+criteria
+    .command('audit')
+    .description('Show the workspace referent-kind distribution + self-confirming-green ratio (GET /api/criteria/audit)')
+    .action(wrap(() => (0, criteria_audit_1.criteriaAudit)()));
 const session = program
     .command('session')
     .description('Manage per-terminal coding-session context');

package/dist/shared/src/referent-kind.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFERENT_KIND_DECLARABLE = void 0;
+exports.classifyCheckpointerGrounding = classifyCheckpointerGrounding;
+exports.effectiveReferentKind = effectiveReferentKind;
+/**
+ * referentKind (LUM-602): what a criterion anchors — the only dimension that
+ * determines independence. Dependency-light (no @prisma/client) so both the
+ * Next.js server and the CLI can import it; the Prisma `ReferentKind` enum
+ * mirrors REFERENT_KIND_DECLARABLE exactly.
+ */
+exports.REFERENT_KIND_DECLARABLE = [
+    'EXTERNAL_FACT',
+    'AGENT_CONSTRUCTED_STATE',
+    'PENDING_OUTCOME',
+];
+/** Tools whose output the agent cannot author — external facts. */
+const EXTERNAL_TOOLS = [
+    'git',
+    'gh',
+    'curl',
+    'wget',
+    'http',
+    'https',
+    'psql',
+    'dig',
+    'nc',
+];
+/** Agent's own test/type/build harness — green here is self-confirming. */
+const HARNESS_TOOLS = [
+    'jest',
+    'vitest',
+    'mocha',
+    'pytest',
+    'tsc',
+    'node',
+    'ts-node',
+    'tsx',
+];
+/**
+ * `prisma migrate status` is EXTERNAL (queries DB/migration history); a bare
+ * `prisma generate` is harness. Matched as a two-word phrase before the
+ * single-word scan.
+ */
+const EXTERNAL_PHRASES = ['prisma migrate status'];
+function wordMatches(word, tools) {
+    // exact tool, or a tool-prefixed filename like jest-t.ts / vitest.config
+    return tools.some(t => word === t || word.startsWith(`${t}-`) || word.startsWith(`${t}.`));
+}
+/**
+ * Given a raw command word (possibly `npx jest`, `npm run build`, etc.),
+ * normalize to the effective tool name. Returns null for pure wrapper tokens
+ * (npx, sudo, command) that should cause us to advance to the next word.
+ */
+function normalizeCommandWord(word) {
+    // strip a leading path: scripts/jest-t.ts → jest-t.ts (keep basename)
+    const slash = word.lastIndexOf('/');
+    return slash >= 0 ? word.slice(slash + 1) : word;
+}
+/**
+ * Extract command-position words from a shell script string.
+ *
+ * Algorithm:
+ * 1. Strip `#` comments (everything from # to end of line).
+ * 2. Extract `$(...)` and backtick substitutions — they are command
+ *    lists; recurse into them and add their command-position words.
+ * 3. For `bash -c '...'` / `sh -c '...'` tokens, extract the quoted
+ *    payload and recurse into it as a command list.
+ * 4. Split the remaining text on command separators (|, &&, ||, ;, \n)
+ *    to get individual command segments.
+ * 5. From each segment, take the first meaningful word as the command.
+ *    Skip wrapper words (npx, sudo, command) and "npm run" pairs.
+ */
+function collectCommandWords(script) {
+    const result = [];
+    // Step 1: strip # comments (not inside quotes — simple heuristic: strip
+    // from # that is preceded by whitespace or start-of-line to end of line)
+    const noComments = script.replace(/(^|\s)#[^\n]*/gm, ' ');
+    // Step 2: recurse into $(...) substitutions
+    // We use a simple balanced-paren extractor.
+    let remaining = noComments;
+    remaining = remaining.replace(/\$\(([^)]*)\)/g, (_match, inner) => {
+        result.push(...collectCommandWords(inner));
+        return ' ';
+    });
+    // Recurse into backtick substitutions
+    remaining = remaining.replace(/`([^`]*)`/g, (_match, inner) => {
+        result.push(...collectCommandWords(inner));
+        return ' ';
+    });
+    // Step 3: handle bash -c / sh -c with a single-quoted payload.
+    // Pattern: (bash|sh) ... -c '...' or (bash|sh) ... -c "..."
+    // We do this BEFORE splitting on separators so the payload content
+    // doesn't pollute the segment split.
+    remaining = remaining.replace(/\b(?:bash|sh)\b[^'"]*-c\s+'([^']*)'/g, (_match, payload) => {
+        result.push(...collectCommandWords(payload));
+        return ' ';
+    });
+    remaining = remaining.replace(/\b(?:bash|sh)\b[^'"]*-c\s+"([^"]*)"/g, (_match, payload) => {
+        result.push(...collectCommandWords(payload));
+        return ' ';
+    });
+    // Step 4: split on command separators to get segments.
+    // Split on |, &&, ||, ;, newlines. Note: || must be checked before |.
+    const segments = remaining.split(/\|\||&&|[|;\n]/);
+    // Step 5: from each segment extract the command word.
+    for (const seg of segments) {
+        // Strip leading/trailing whitespace and any residual shell chars
+        // (quotes, $, brackets not already consumed).
+        const cleaned = seg
+            .replace(/['"]/g, ' ') // remove remaining quotes (string args)
+            .replace(/\[|\]/g, ' ') // remove [ ] test brackets
+            .replace(/\$\{?[^}]*}?/g, ' ') // remove remaining $VAR references
+            .trim();
+        if (!cleaned)
+            continue;
+        const tokens = cleaned.split(/\s+/).filter(Boolean);
+        // Walk tokens to find the effective command, skipping wrappers.
+        let i = 0;
+        while (i < tokens.length) {
+            const tok = tokens[i];
+            const lower = tok.toLowerCase();
+            if (lower === 'npx' || lower === 'sudo' || lower === 'command') {
+                i++;
+                continue;
+            }
+            if (lower === 'npm' && tokens[i + 1]?.toLowerCase() === 'run') {
+                // "npm run <script>" — script name is the command
+                i += 2;
+                continue;
+            }
+            // This is the effective command
+            const word = normalizeCommandWord(lower);
+            if (word)
+                result.push(word);
+            break;
+        }
+    }
+    return result;
+}
+function classifyCheckpointerGrounding(checkpointer) {
+    if (!checkpointer || checkpointer.trim() === '')
+        return 'NONE';
+    const lower = checkpointer.toLowerCase();
+    // Fast path for known two-word external phrases (e.g. prisma migrate status)
+    if (EXTERNAL_PHRASES.some(p => lower.includes(p)))
+        return 'EXTERNAL';
+    const words = collectCommandWords(checkpointer.toLowerCase());
+    if (words.length === 0)
+        return 'NONE';
+    // Strongest signal wins: EXTERNAL > AGENT_HARNESS > ASSERTION_ONLY
+    if (words.some(w => wordMatches(w, EXTERNAL_TOOLS)))
+        return 'EXTERNAL';
+    if (words.some(w => wordMatches(w, HARNESS_TOOLS)))
+        return 'AGENT_HARNESS';
+    return 'ASSERTION_ONLY';
+}
+function effectiveReferentKind(args) {
+    const { declared, verifierType, checkpointer } = args;
+    if (declared === null)
+        return 'UNCLASSIFIED';
+    if (declared === 'EXTERNAL_FACT' && verifierType === 'MACHINE') {
+        if (classifyCheckpointerGrounding(checkpointer) !== 'EXTERNAL') {
+            return 'UNVERIFIED_ASSERTION';
+        }
+    }
+    return declared;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.47.0",
+  "version": "1.48.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",