@lumoai/cli 1.65.0 → 1.68.0

package/dist/cli/src/index.js

@@ -92,6 +92,7 @@ const memory_fold_1 = require("./commands/memory-fold");
 const task_artifact_add_1 = require("./commands/task-artifact-add");
 const task_criteria_set_1 = require("./commands/task-criteria-set");
 const task_criteria_list_1 = require("./commands/task-criteria-list");
+const task_criteria_confirm_1 = require("./commands/task-criteria-confirm");
 const task_artifact_list_1 = require("./commands/task-artifact-list");
 const task_artifact_show_1 = require("./commands/task-artifact-show");
 const task_artifact_rm_1 = require("./commands/task-artifact-rm");
@@ -102,6 +103,7 @@ const task_figma_context_1 = require("./commands/task-figma-context");
 const task_comment_list_1 = require("./commands/task-comment-list");
 const task_deps_1 = require("./commands/task-deps");
 const task_pr_show_1 = require("./commands/task-pr-show");
+const pr_scan_1 = require("./commands/pr-scan");
 const task_lineage_1 = require("./commands/task-lineage");
 const project_list_1 = require("./commands/project-list");
 const milestone_list_1 = require("./commands/milestone-list");
@@ -434,6 +436,16 @@ priorityCmd
     .command('list')
     .description('Print the team priority append history, newest-first (the current declaration is marked with *).')
     .action(wrap(() => (0, priority_1.priorityList)()));
+const pr = program
+    .command('pr')
+    .description('Inspect pull requests by number — linked to a task or not');
+pr.command('scan <number>')
+    .description('Security scans of one PR in the workspace, by PR number (LUM-788): the latest head by default — layer states (same labels as task status / the GitHub summary), every finding incl. dispositioned ones with disposition + source, and the hunt coverage line. Read-only; disposition is web-only.')
+    .option('--repo <owner/repo>', 'Narrow to one repo when the same PR number exists in several (the error lists the candidates)')
+    .option('--all', "Every pushed head's scan, newest first, instead of the latest only")
+    .option('--full', 'Append the per-task hunt detail: commands (with gate refusals), step trace, stop arithmetic, wrap-up, sites, model, diff sizing')
+    .option('--json', 'Emit the versioned machine-readable payload ({ pullRequest, scans[].stages / findings[] / hunt.tasks[] })')
+    .action(wrap((number, options) => (0, pr_scan_1.prScan)(number, options)));
 const criteria = program
     .command('criteria')
     .description('Workspace-level acceptance-criteria analytics');
@@ -625,6 +637,12 @@ taskCriteria
     .command('list <task>')
     .description('List a task\u2019s acceptance criteria (id, type, provenance, checkpointer)')
     .action(wrap((taskId) => (0, task_criteria_list_1.taskCriteriaList)(taskId)));
+taskCriteria
+    .command('confirm <task>')
+    .description('Record the USER\u2019s confirmation of the acceptance contract (LUM-789). Gated: without --confirm it prints a confirmation envelope listing every criterion and exits 4, writing nothing. Confirming never blocks DONE \u2014 an unconfirmed contract still closes normally.')
+    .option('--confirm', 'The user has approved this contract')
+    .option('--yes', 'Legacy alias of --confirm')
+    .action(wrap((taskId, options) => (0, task_criteria_confirm_1.taskCriteriaConfirm)(taskId, options)));
 const taskArtifact = task
     .command('artifact')
     .description('Record spec-engineering artifacts (spec / plan / design …) on a task');

package/dist/cli/src/lib/redaction-notice.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRedactionNotice = printRedactionNotice;
+/**
+ * LUM-784 — the tier-2 retrieval commands (`task|idea slack show`,
+ * `task|idea web show`) print stored bodies straight into the agent's
+ * context. The server redacts every registry secret on the way out and
+ * reports how many; this prints the one-line notice so the agent knows the
+ * `AKIA…(len 20)` tokens it sees are redactions, not the source text.
+ *
+ * Silent when the count is absent (older server) or zero — output for clean
+ * content is byte-identical to before.
+ */
+function printRedactionNotice(redactedSecrets) {
+    if (!redactedSecrets || redactedSecrets <= 0)
+        return;
+    const noun = redactedSecrets === 1 ? 'credential' : 'credentials';
+    const verb = redactedSecrets === 1 ? 'was' : 'were';
+    console.log(`⚠ ${redactedSecrets} suspected ${noun} ${verb} redacted before injection (shown as first 4 chars + length; the original never reached this context)`);
+}

package/dist/cli/src/lib/scan-format.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatScanLayerTail = formatScanLayerTail;
+exports.formatHuntCoverageLine = formatHuntCoverageLine;
+const sanitize_1 = require("./sanitize");
+const security_scan_1 = require("../../../shared/src/security-scan");
+const EXTERNAL_ERROR_TAIL = 200;
+function tail(s, max) {
+    return s.length > max ? `…${s.slice(-max)}` : s;
+}
+/**
+ * ` · Secrets: checked · Code scan: checked (2 external findings) ·
+ * Dependencies: checked (1 dependency finding, 1 already on main) ·
+ * AI review: checked · Exploit paths: checked · partial · 3 left the queue
+ * (2 resolved on main, 1 merged unreviewed) — <scrubbed reason>`, or `''`
+ * when the scan carries no stage at all. The caller prefixes its own head
+ * (`  PR #945 · scan CLEAN` / `Scan abc1234 · FINDINGS`).
+ *
+ * Stage segments only for keys present, in secrets/external/supplyChain/
+ * judge/hunt order; the `(N external findings)` count only decorates the
+ * Code scan segment, the dependency count (with its already-on-main share)
+ * only the Dependencies segment, and each only when N > 0.
+ */
+function formatScanLayerTail(s) {
+    const segments = [];
+    for (const key of security_scan_1.SCAN_STAGE_KEYS) {
+        const state = s.stages[key];
+        if (!state)
+            continue;
+        const head = `${(0, security_scan_1.scanStageLabel)(key)}: ${(0, security_scan_1.scanStageStateLabel)(state)}`;
+        if (key === 'external' && s.externalFindings > 0) {
+            const noun = s.externalFindings === 1 ? 'finding' : 'findings';
+            segments.push(`${head} (${s.externalFindings} external ${noun})`);
+        }
+        else if (key === 'supplyChain' && (s.dependencyFindings ?? 0) > 0) {
+            const n = s.dependencyFindings ?? 0;
+            const noun = n === 1 ? 'finding' : 'findings';
+            const persisting = s.persistingFindings ?? 0;
+            const tail = persisting > 0 ? `, ${persisting} already on main` : '';
+            segments.push(`${head} (${n} dependency ${noun}${tail})`);
+        }
+        else {
+            segments.push(head);
+        }
+    }
+    let line = '';
+    if (segments.length > 0)
+        line += ` · ${segments.join(' · ')}`;
+    if (s.partial)
+        line += ' · partial';
+    // LUM-775: what left the queue because the PR merged / closed, and why —
+    // so a merged PR's line explains where its findings went instead of
+    // silently listing fewer open rows than the scan found.
+    const exits = (0, security_scan_1.formatQueueExits)(s.queueExits);
+    if (exits)
+        line += ` · ${exits}`;
+    // LUM-756 (P8): only the prefixed, scrubbed scanner reason is printed, and
+    // only the text after the prefix (the caller has already applied the rule).
+    if (s.externalFailureReason) {
+        line += ` — ${(0, sanitize_1.sanitizeField)(tail(s.externalFailureReason, EXTERNAL_ERROR_TAIL))}`;
+    }
+    return line;
+}
+/**
+ * LUM-762 — the hunt's per-task read-out, one line under its scan:
+ * `Exploit paths 2/3 done · t1 idor 41.2s done · t2 injection 72.0s done
+ * (2 attempts) · t3 race skipped`. Headed by the same display label as the
+ * layer's own segment (LUM-763) — the detail line and the line above it
+ * must not name the layer two different ways. Elapsed time is summed over a
+ * task's attempts; a skipped task has none to print.
+ *
+ * LUM-758: a plan may hold two tasks of the same category, so the row is led
+ * by its task id. Pre-task-graph audits carry no id — the row then prints
+ * exactly as it always did.
+ */
+function formatHuntCoverageLine(hunt) {
+    const parts = hunt.categories.map(c => {
+        const attempts = c.attempts > 1 ? ` (${c.attempts} attempts)` : '';
+        const spent = c.stopped === 'skipped' ? '' : `${(c.elapsedMs / 1000).toFixed(1)}s `;
+        const id = c.taskId === undefined ? '' : `${(0, sanitize_1.sanitizeField)(c.taskId)} `;
+        return `${id}${(0, sanitize_1.sanitizeField)(c.category)} ${spent}${(0, sanitize_1.sanitizeField)(c.stopped)}${attempts}`;
+    });
+    return `${(0, security_scan_1.scanStageLabel)('hunt')} ${hunt.done}/${hunt.total} done · ${parts.join(' · ')}`;
+}

package/dist/lib/acceptance/unmet-display.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnmetForDisplay = isUnmetForDisplay;
+/** PASS 与 PASS_WITH_FOLLOWUP 都算通过（与 verification-run 仓库的
+ *  isPassVerdict 同义；这里本地实现以保持本模块零依赖）。 */
+function isPass(verdict) {
+    return verdict === 'PASS' || verdict === 'PASS_WITH_FOLLOWUP';
+}
+/**
+ * LUM-789 渲染口径：一条 criterion 是否该呈现为「未满足」。
+ *
+ * 未裁定的 HUMAN 项是 **tacit pass** —— 没人送回就是默认通过，与 DONE 闸
+ * 早已采用的口径一致（task-state.service.ts 的 assertNoUnresolvedSendBack
+ * 只对明确 FAIL 返回 409）。把它呈现成待办是纯摩擦：一个总会通过的闸产出
+ * 的不是信号，是伪装成信号的噪音。
+ *
+ * ⚠️ 这是 **渲染** 口径，不是裁决口径。裁决用的是
+ * task-human-verdict.service.ts 的 `allMet`（every criterion isPassVerdict），
+ * 它必须保持「未裁定 ≠ 通过」，否则在 web 上点一条 PASS 会把整个任务推成
+ * DONE。两者不得合并。
+ */
+function isUnmetForDisplay(criterion, latest) {
+    if (isPass(latest?.verdict))
+        return false;
+    if (latest === undefined && criterion.verifierType === 'HUMAN')
+        return false;
+    return true;
+}

package/dist/shared/src/hunt-audit.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * LUM-788 — the per-task hunt read-out, shared by the CLI (`lumo pr scan
+ * --full`) and the lum739 analysis script. One implementation: the CLI is a
+ * separate package that cannot import `lib/` or `scripts/`, and a second copy
+ * of this printer is exactly how the audit lost four fields to "computed,
+ * carried, never read" before LUM-758.
+ *
+ * Pure formatting over the raw `PrSecurityScan.huntAudit.tasks[]` rows. Every
+ * field is optional by construction: the column is Json written by past
+ * versions of the workflow, and a row written before a field existed prints
+ * exactly as it always did — nothing is guessed, nothing is thrown over.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHuntTaskDetail = formatHuntTaskDetail;
+exports.formatShellDetail = formatShellDetail;
+/** One line of prose, flattened, for a fixed-width read-out. */
+function oneLine(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max)}…` : flat;
+}
+/**
+ * The per-task listing for EVERY task handed in, idle ones included — the
+ * `lumo pr scan --full` shape. A task that never asked the shell for anything
+ * still has a stop line, a model and the sites it was briefed on, and "this
+ * task ran two steps and submitted nothing" is a fact the reader came for.
+ *
+ * Lines per task: a header (`t1 done · <model> · 3 sites · 2 cmds (gate
+ * refused …)`), one line per command (`✗` = the gate refused it, with its
+ * reason), one line per trace step, then the stop arithmetic and the
+ * wrap-up outcome — each only when the row carries it.
+ */
+function formatHuntTaskDetail(tasks, maxTasks) {
+    const out = [];
+    for (const t of tasks.slice(0, maxTasks)) {
+        const sh = t.shell;
+        // LUM-787 — the model and the sites print only when the row carries them;
+        // the clip count likewise: an older row, and a row from a search that
+        // never hit the ceiling, read as before.
+        const cmds = sh?.calls
+            ? `${sh.calls} cmds (gate refused ${sh.refused ?? 0}, sandbox failed ${sh.failed ?? 0}, not found ${sh.notFound ?? 0}, empty ${sh.empty ?? 0}${sh.stepClipped ? `, step-clipped ${sh.stepClipped}` : ''})`
+            : 'no shell commands';
+        out.push(`${String(t.taskId)} ${String(t.stopped)}${t.model ? ` · ${t.model}` : ''}${typeof t.sites === 'number' ? ` · ${t.sites} sites` : ''} · ${cmds}`);
+        for (const c of sh?.commands ?? []) {
+            const cost = typeof c.chars === 'number'
+                ? `  [${c.chars} chars${c.compressed ? ', compressed' : ''}${c.clipped ? ', clipped' : ''}]`
+                : '';
+            out.push(`    ${c.denied ? '✗' : ' '} ${c.cmd ?? ''}${cost}${c.reason ? `   ← ${c.reason}` : ''}`);
+        }
+        // LUM-781 — the model's side, step by step, then how it ended. Only when
+        // the row carries them: an older row prints exactly as before.
+        for (const st of t.trace ?? []) {
+            out.push(`    #${st.i ?? '?'} tool=${st.tool ?? '(none)'} in=${st.inputTokens ?? '?'} out=${st.outputTokens ?? '?'}${st.reasoningTokens ? ` reasoning=${st.reasoningTokens}` : ''}${st.elidedChars ? ` elided=${st.elidedChars}` : ''}${st.finishReason ? ` finish=${st.finishReason}` : ''}${st.text ? ` "${oneLine(st.text, 160)}"` : ''}`);
+        }
+        if (t.stop) {
+            const s = t.stop;
+            out.push(`    stop: ${s.by ?? '?'} · spent ${s.spent ?? '?'}/${s.budget ?? '?'} · reserve ${s.reserve ?? 0} · last step ${s.lastStep ?? '?'}${typeof s.next === 'number' ? ` · next ${s.next}` : ''} · ${s.steps ?? '?'} steps`);
+        }
+        if (t.wrapUp) {
+            const w = t.wrapUp;
+            out.push(w.ran
+                ? `    wrap-up: ran · submitted ${w.submitted ?? 0} · ${w.tokens ?? '?'} tokens${w.finishReason ? ` · finish=${w.finishReason}` : ''}${w.text ? ` · "${oneLine(w.text, 200)}"` : ''}`
+                : w.error
+                    ? `    wrap-up: attempted, failed — ${oneLine(w.error, 160)}`
+                    : `    wrap-up: not made (${w.skipped ?? 'unknown'})`);
+        }
+    }
+    return out;
+}
+/**
+ * The per-task, command-by-command listing of the lum739 audit report —
+ * only tasks that actually asked the shell for something.
+ *
+ * The run-level `shell:` line says HOW MUCH; only this says WHAT — and telling
+ * "mapped the repo and ran out" from "the gate rejected everything" from
+ * "looked and found nothing" is the entire reason the field exists. Extracted
+ * as a pure function so it can be tested: a read-out nothing exercises is the
+ * same "computed, carried, never read" shape this layer has already lost four
+ * fields to.
+ */
+function formatShellDetail(tasks, maxTasks) {
+    return formatHuntTaskDetail(tasks.filter(x => x.shell?.calls), maxTasks);
+}