@lumoai/cli 1.46.0 → 1.48.0

package/dist/cli/src/commands/task-status.js

@@ -229,19 +229,35 @@ function pushClaimVsVerification(lines, data) {
     lines.push('  ▸ Claim — what the agent says it did');
     lines.push('    (agent self-report · estimated, not verification):');
     const claim = data.claim;
-    if (claim && claim.text) {
+    if (claim && claim.source === 'AGENT' && claim.text) {
+        // LUM-597: the agent's OWN self-report (attached to verify) — the
+        // authoritative claim faithfulness judges, not a summarizer paraphrase.
         for (const cl of (0, sanitize_1.sanitizeField)(claim.text).split('\n')) {
             lines.push(`      ${cl}`);
         }
-        lines.push(claim.source === 'RUN_SUMMARY'
-            ? '      ↳ source: LLM run summary'
-            : '      ↳ source: raw turn digest — no LLM summary yet');
+        lines.push('      ↳ source: agent self-report (verify --note)');
+    }
+    else if (claim && claim.source === 'RUN_SUMMARY' && claim.text) {
+        for (const cl of (0, sanitize_1.sanitizeField)(claim.text).split('\n')) {
+            lines.push(`      ${cl}`);
+        }
+        lines.push('      ↳ source: synthesized run summary (no self-report)');
+    }
+    else if (claim && claim.source === 'DIGEST') {
+        // LUM-583 ③ / LUM-574: a raw turn digest is not a claim — withhold it and
+        // say the formal summary is still generating, same-source with the web card.
+        lines.push('      generating — the formal run summary is still being synthesized');
     }
     else {
         // Fail-closed: no run summary → say so, never invent a claim. Run summaries
         // are synthesized when the bound task reaches DONE (LUM-481).
         lines.push('      not generated yet — the agent run summary is synthesized when the task reaches DONE');
     }
+    // ── Faithfulness (LUM-583): the third state — is the claim itself true? Read
+    // from the persisted LUM-582 verdict; PENDING (not yet judged) is distinct
+    // from UNJUDGEABLE (a real verdict), STALE keeps the verdict but flags a
+    // pending re-check. Skipped only when the server didn't emit it (older server).
+    pushFaithfulness(lines, data.faithfulness);
     // ── Verification (核验): the measured verdict — machine-verified vs override.
     lines.push('  ▸ Verification — what was actually confirmed (measured):');
     const mv = data.machineVerification;
@@ -257,6 +273,54 @@ function pushClaimVsVerification(lines, data) {
         lines.push(`      ${met} of ${data.criteria.length} criteria met by their latest verdict`);
     }
 }
+/**
+ * Append the "Faithfulness" conclusion (LUM-583) — the third state over the
+ * 声称/核验 columns: whether the agent's CLAIM is itself TRUE, judged
+ * independently against the delivery (LUM-582). Same read model the web honest
+ * report renders, so the two surfaces cannot drift. Fail-closed: PENDING (not
+ * yet judged) reads distinctly from UNJUDGEABLE (a real verdict), and STALE
+ * keeps the prior verdict while flagging a pending re-check. Skipped only when
+ * the server didn't emit the field (older server) — never fabricated.
+ */
+function pushFaithfulness(lines, f) {
+    if (!f)
+        return; // older server: field absent → don't fabricate a conclusion.
+    const verdictPhrase = (v) => {
+        switch (v) {
+            case 'FAITHFUL':
+                return 'faithful — the claim matches the delivery';
+            case 'OVERSTATED':
+                return 'overstated — the claim says more than the diff/PR shows';
+            case 'UNDERREPORT':
+                return 'under-reported — the claim says less than the diff/PR shows';
+            default:
+                return "unjudgeable — couldn't decide from the diff/PR";
+        }
+    };
+    let body;
+    if (f.state === 'PENDING') {
+        body =
+            'not yet judged — the faithfulness check runs in a batch after delivery';
+    }
+    else if (f.state === 'STALE') {
+        body = `${f.verdict ? verdictPhrase(f.verdict) : 'judged'} (stale — re-checked on the next batch)`;
+    }
+    else {
+        body = verdictPhrase(f.state);
+    }
+    const ev = [];
+    if (f.prNumbers.length > 0) {
+        ev.push(`PR ${f.prNumbers.map(n => `#${n}`).join(', ')}`);
+    }
+    if (f.diffShas.length > 0) {
+        ev.push(f.diffShas
+            .slice(0, 3)
+            .map(s => (0, sanitize_1.sanitizeField)(s).slice(0, 7))
+            .join(' '));
+    }
+    lines.push('  ▸ Faithfulness — does the claim match the delivery (LUM-583):');
+    lines.push(`      ${body}${ev.length > 0 ? ` · evidence: ${ev.join(' · ')}` : ''}`);
+}
 /**
  * Append the honest "Cost" section (LUM-560) — 规律 1: surface the costs a human
  * should weigh (token spend, active time, machine rework) on the same report as

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

@@ -144,6 +144,19 @@ async function verify(identifier, options = {}) {
             `The contract is HUMAN-only; finish your work and hand off for human review (lumo task update ${taskId} --status in_review).\n`);
         return;
     }
+    // ── Require the self-report (LUM-597) ────────────────────────────────────
+    // Requesting acceptance is a structured action; `--note` is the agent's
+    // mandatory self-report. It is captured deterministically here (the agent
+    // can't be made to phrase it well, but it can be made to provide one); its
+    // truthfulness is the faithfulness audit's job downstream. No note → no round
+    // is posted (no round burned), so re-running with one is free.
+    const note = options.note?.trim();
+    if (!note) {
+        console.error('Error: --note is required — state what you did and why it is ready, e.g.\n' +
+            `  lumo verify ${taskId} --note "implemented X in foo.ts because Y; tests + tsc pass"\n` +
+            'This self-report is recorded as your claim and checked against the diff for faithfulness.');
+        return 1;
+    }
     // ── Execute every checkpointer locally ───────────────────────────────────
     process.stdout.write(`Verifying ${taskId} — ${machine.length} MACHINE criteria\n`);
     const results = [];
@@ -165,7 +178,7 @@ async function verify(identifier, options = {}) {
         res = await fetch(`${base}/api/tasks/${encodeURIComponent(taskId)}/verify`, {
             method: 'POST',
             headers: { ...headers, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ results }),
+            body: JSON.stringify({ results, note }),
         });
     }
     catch (err) {

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");
@@ -223,6 +225,7 @@ program
     .command('verify [task]')
     .description('Machine verification loop (LUM-343): run every MACHINE criterion checkpointer locally, report structured verdicts to the server (round cap 3), and print next actions. All-pass moves the task to IN_REVIEW. Defaults to the session-bound task.')
     .option('--timeout <seconds>', 'Per-checkpointer timeout in seconds (default 600)')
+    .option('--note <text>', 'Required self-report — what you did and why it is ready (LUM-597). Recorded as your claim (source AGENT) when the round passes into IN_REVIEW, and checked against the diff for faithfulness.')
     .action(wrap((task, options) => (0, verify_1.verify)(task, options)));
 program
     .command('verdict [task]')
@@ -241,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`.')
@@ -255,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.46.0",
+  "version": "1.48.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",