@lumoai/cli 1.58.0 → 1.60.0

package/dist/cli/src/commands/crossing-disposition.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCrossingDisposition = describeCrossingDisposition;
+exports.describeRulingConfirmation = describeRulingConfirmation;
+exports.crossingDisposition = crossingDisposition;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+const confirmation_1 = require("../lib/confirmation");
+const bound_task_1 = require("../lib/bound-task");
+const open_crossings_1 = require("../lib/open-crossings");
+/**
+ * The changes[] block of the read envelope (step 1, exit 4): what ruling is
+ * about to be recorded, on which crossing, with everything the user needs to
+ * judge it — severity, category, detail, recurrence, and the agent's own
+ * explanations (labelled as an unverified self-report). The ⚠ lines carry
+ * the consequence: approving clears this crossing's block on DONE.
+ */
+function describeCrossingDisposition(crossing, target, ctx) {
+    const lines = [
+        `Will disposition crossing ${(0, sanitize_1.sanitizeField)(crossing.id)} on ${ctx.taskIdentifier} as ${target}`,
+        `Disposition: ${crossing.disposition ?? 'OPEN'} → ${target}`,
+    ];
+    const detail = (0, sanitize_1.sanitizeField)(crossing.detail).replace(/\s+/g, ' ').trim();
+    lines.push(`[${crossing.severity}] ${(0, sanitize_1.sanitizeField)(crossing.category)}${detail ? ` — ${detail}` : ''}`);
+    if ((crossing.occurrenceCount ?? 1) > 1) {
+        lines.push(`Seen ×${crossing.occurrenceCount} while open`);
+    }
+    const explanations = crossing.explanations ?? [];
+    if (explanations.length === 0) {
+        lines.push('Agent explanations: none recorded');
+    }
+    else {
+        lines.push(`Agent explanations (${explanations.length}, agent self-report · unverified):`);
+        for (const e of explanations) {
+            lines.push(`  - ${(0, sanitize_1.sanitizeField)(e.note).replace(/\s+/g, ' ').trim()}`);
+        }
+    }
+    if (ctx.note)
+        lines.push(`Note to record: ${(0, sanitize_1.sanitizeField)(ctx.note)}`);
+    if (crossing.advisory) {
+        lines.push('Advisory crossing — it never blocked DONE; the ruling is for the record only');
+    }
+    else {
+        lines.push(`⚠ Approving clears this crossing's block on moving ${ctx.taskIdentifier} to DONE`);
+    }
+    if (crossing.severity === 'HIGH') {
+        lines.push('⚠ HIGH severity — this class always needs a human decision; make sure the user has read the detail above');
+    }
+    if (crossing.reversible === false) {
+        lines.push('⚠ Irreversible category — the action reached outside the repo; a false-positive ruling should rest on the detail, not on the explanation alone');
+    }
+    return lines;
+}
+/**
+ * The changes[] block of the ruling envelope (step 2, exit 4): the read is
+ * acknowledged and recorded; what remains is the ruling itself.
+ */
+function describeRulingConfirmation(crossing, target, ctx) {
+    const lines = [
+        `Read acknowledged for crossing ${(0, sanitize_1.sanitizeField)(crossing.id)} (shown ${ctx.readAt}, acknowledged ${ctx.readAcknowledgedAt}) — recorded with the ruling`,
+        `Step 2 of 2 — record the ruling: ${crossing.disposition ?? 'OPEN'} → ${target} on ${ctx.taskIdentifier}`,
+    ];
+    if (ctx.note)
+        lines.push(`Note to record: ${(0, sanitize_1.sanitizeField)(ctx.note)}`);
+    lines.push(crossing.advisory
+        ? 'Advisory crossing — it never blocked DONE; the ruling is for the record only'
+        : `⚠ Approving clears this crossing's block on moving ${ctx.taskIdentifier} to DONE`);
+    return lines;
+}
+/**
+ * `lumo crossing disposition <id> --false-positive | --confirmed [--note …]
+ * [--task LUM-N] [--receipt <token>] [--confirm-read | --confirm]` — rule on
+ * a boundary crossing from the terminal (LUM-769), through a THREE-step
+ * confirmation handshake the server enforces:
+ *
+ *   1. no step flag: read the crossing, obtain a stage-1 READ RECEIPT
+ *      (bound to crossing, ruling, caller and the crossing's current state),
+ *      print the read envelope (exit 4), write nothing. Its confirmCommand
+ *      carries `--receipt <r1> --confirm-read`;
+ *   2. `--confirm-read --receipt <r1>`: the user confirmed they read it. The
+ *      server verifies r1 and issues the stage-2 receipt; the CLI prints the
+ *      ruling envelope (exit 4), write nothing. Its confirmCommand carries
+ *      `--receipt <r2> --confirm`;
+ *   3. `--confirm --receipt <r2>`: the user approved the ruling. The server
+ *      verifies r2 — a stage-1 receipt is refused with "confirm read first",
+ *      as is anything forged, expired, foreign or stale — then writes, with
+ *      the shown / acknowledged / confirmed timestamps on the audit row.
+ *
+ * Skipping or reordering a step is refused at the CLI before any request
+ * where it can be told locally (no receipt, a stage-1 receipt with --confirm,
+ * a stage-2 receipt with --confirm-read) and by the server otherwise. The
+ * agent relays each envelope and never supplies a step flag on its own.
+ * Server-side the ruling is stamped `channel: 'CLI'` so the audit trail keeps
+ * it apart from a web-panel click. What stays web-only: reverting to OPEN and
+ * the repository suppression rule — neither exists on this path.
+ */
+async function crossingDisposition(crossingId, options = {}) {
+    if (!crossingId || crossingId.trim() === '') {
+        console.error('Error: a crossing id is required: lumo crossing disposition <id> --false-positive | --confirmed');
+        return 1;
+    }
+    const target = pickTarget(options);
+    if (!target) {
+        console.error('Error: pass exactly one of --false-positive or --confirmed (the ruling to record).');
+        return 1;
+    }
+    if (options.confirmRead && options.confirm) {
+        console.error('Error: --confirm-read and --confirm are separate steps — run them one at a time, each from the envelope the previous step printed.');
+        return 1;
+    }
+    const note = options.note?.trim() || undefined;
+    const receipt = options.receipt?.trim() || undefined;
+    // Local ordering checks — cheap, and they name the missing step before any
+    // request goes out. The server re-checks all of them.
+    if (options.confirm) {
+        if (!receipt) {
+            console.error('Error: --confirm requires the stage-2 read receipt (--receipt <token>) from the --confirm-read step. Run the command without any step flag first, relay the envelope, confirm the read, relay that envelope, then re-run its confirmCommand verbatim.');
+            return 1;
+        }
+        if (receipt.startsWith('r1.')) {
+            console.error('Error: read not yet acknowledged — this is the stage-1 receipt. Run the command with --confirm-read --receipt <this token> first (after the user confirms they read the envelope); only the receipt that step returns is accepted with --confirm.');
+            return 1;
+        }
+    }
+    if (options.confirmRead) {
+        if (!receipt) {
+            console.error('Error: --confirm-read requires the read receipt (--receipt <token>) from the envelope. Run the command without any step flag first and relay the envelope.');
+            return 1;
+        }
+        if (receipt.startsWith('r2.')) {
+            console.error('Error: this receipt already acknowledges the read — the next step is --confirm with this same receipt (after the user approves the ruling).');
+            return 1;
+        }
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    const headers = {
+        Authorization: `Bearer ${creds.token}`,
+    };
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    if (sessionId)
+        headers['X-Lumo-Session-Id'] = sessionId;
+    const bound = await (0, bound_task_1.resolveBoundTask)({
+        base,
+        headers,
+        explicit: options.task,
+        sessionId,
+    });
+    if (!bound.ok) {
+        console.error(bound.message);
+        return 1;
+    }
+    const taskId = bound.taskIdentifier;
+    // Read the crossing first, on every path: the envelopes need it, and a
+    // confirmed write against a crossing that can't be read must not go out
+    // (fail closed — a read hiccup never turns into a blind ruling).
+    const read = await readCrossing(base, headers, taskId, crossingId);
+    if (read.status === 'error') {
+        console.error(`Error: could not confirm the crossing (${read.reason}) — nothing was written.`);
+        return 1;
+    }
+    const crossing = read.crossing;
+    if (!crossing) {
+        console.error(`Error: crossing ${(0, sanitize_1.sanitizeField)(crossingId)} not found on ${taskId}. Ids are listed by \`lumo task status ${taskId}\`.`);
+        return 1;
+    }
+    if (crossing.disposition === target) {
+        process.stdout.write(`Crossing ${(0, sanitize_1.sanitizeField)(crossing.id)} is already ${target} — nothing to do.\n`);
+        return;
+    }
+    // Step 1 — read envelope.
+    if (!options.confirmRead && !options.confirm) {
+        const issued = await requestReceipt(base, headers, taskId, crossingId, {
+            disposition: target,
+        });
+        if (issued.status === 'error') {
+            console.error(`Error: could not obtain a read receipt for the crossing (${issued.reason}) — nothing was written and no envelope can be issued.`);
+            return 1;
+        }
+        return (0, confirmation_1.emitConfirmation)({
+            command: 'crossing disposition',
+            changes: [
+                ...describeCrossingDisposition(crossing, target, {
+                    taskIdentifier: taskId,
+                    note,
+                }),
+                `Step 1 of 2 — read receipt issued for this crossing as read above (valid until ${issued.expiresAt}; void if the crossing changes). Next: the user confirms they have READ it, then run the command below; the ruling itself is confirmed in a second envelope`,
+            ],
+            confirmFlag: '--confirm-read',
+            receipt: { token: issued.receipt, expiresAt: issued.expiresAt },
+        });
+    }
+    // Step 2 — acknowledge the read, get the stage-2 receipt, ruling envelope.
+    if (options.confirmRead) {
+        const issued = await requestReceipt(base, headers, taskId, crossingId, {
+            disposition: target,
+            acknowledge: receipt,
+        });
+        if (issued.status === 'error') {
+            console.error(`Error: read acknowledgement rejected (${issued.reason}) — nothing was written.`);
+            return 1;
+        }
+        return (0, confirmation_1.emitConfirmation)({
+            command: 'crossing disposition',
+            changes: describeRulingConfirmation(crossing, target, {
+                taskIdentifier: taskId,
+                note,
+                readAt: issued.readAt,
+                readAcknowledgedAt: issued.readAcknowledgedAt ?? issued.readAt,
+            }),
+            confirmFlag: '--confirm',
+            receipt: { token: issued.receipt, expiresAt: issued.expiresAt },
+        });
+    }
+    // Step 3 — the write.
+    let res;
+    try {
+        res = await fetch(`${base}/api/tasks/${encodeURIComponent(taskId)}/boundary-crossings/${encodeURIComponent(crossingId)}/disposition`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                disposition: target,
+                ...(note ? { dispositionNote: note } : {}),
+                receipt,
+            }),
+        });
+    }
+    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: disposition rejected (HTTP ${res.status})${detail ? ` — ${detail}` : ''}`);
+        return 1;
+    }
+    const outcome = (await res.json());
+    const url = (0, open_crossings_1.dispositionUrl)(apiUrl, creds.workspaceSlug ?? '', taskId);
+    process.stdout.write(`✓ Dispositioned crossing ${(0, sanitize_1.sanitizeField)(outcome.crossingId)} as ${outcome.disposition ?? 'OPEN'} (read acknowledged and ruling approved via CLI).\n` +
+        (crossing.advisory
+            ? ''
+            : `  This clears its block on moving ${taskId} to DONE. `) +
+        `The ruling is audited on the task timeline as a CLI-channel disposition with the shown / read-acknowledged / confirmed times; it can be corrected in the web panel: ${url}\n`);
+    return;
+}
+function pickTarget(options) {
+    if (options.falsePositive && options.confirmed)
+        return null;
+    if (options.falsePositive)
+        return 'FALSE_POSITIVE';
+    if (options.confirmed)
+        return 'CONFIRMED';
+    return null;
+}
+/** The handshake's server call (LUM-769): stage 1 without `acknowledge`,
+ *  stage 2 with the stage-1 receipt in it. Fails closed — without a receipt
+ *  no envelope is issued, because its confirmCommand could never be accepted. */
+async function requestReceipt(base, headers, taskId, crossingId, body) {
+    let res;
+    try {
+        res = await fetch(`${base}/api/tasks/${encodeURIComponent(taskId)}/boundary-crossings/${encodeURIComponent(crossingId)}/disposition/receipt`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            reason: err instanceof Error ? err.message : 'network error',
+        };
+    }
+    if (!res.ok) {
+        const errBody = (await res.json().catch(() => null));
+        const detail = errBody && typeof errBody.error === 'string'
+            ? ` — ${(0, sanitize_1.sanitizeField)(errBody.error)}`
+            : '';
+        return { status: 'error', reason: `HTTP ${res.status}${detail}` };
+    }
+    let data;
+    try {
+        data = (await res.json());
+    }
+    catch {
+        return { status: 'error', reason: 'invalid response body' };
+    }
+    if (typeof data.receipt !== 'string' || data.receipt.length === 0) {
+        return { status: 'error', reason: 'no receipt in response' };
+    }
+    const str = (v) => (typeof v === 'string' ? v : '');
+    return {
+        status: 'ok',
+        receipt: data.receipt,
+        expiresAt: str(data.expiresAt),
+        readAt: str(data.readAt),
+        readAcknowledgedAt: typeof data.readAcknowledgedAt === 'string'
+            ? data.readAcknowledgedAt
+            : null,
+    };
+}
+/** One task-scoped read of the LUM-435 view; the crossing picked by id. Fails
+ *  closed: transport / non-ok / unparseable → error, never "not found". */
+async function readCrossing(base, headers, taskId, crossingId) {
+    let res;
+    try {
+        res = await fetch(`${base}/api/tasks/${encodeURIComponent(taskId)}/boundary-crossings`, { headers });
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            reason: err instanceof Error ? err.message : 'network error',
+        };
+    }
+    if (res.status === 401) {
+        return { status: 'error', reason: 'API key invalid or revoked' };
+    }
+    if (!res.ok)
+        return { status: 'error', reason: `HTTP ${res.status}` };
+    let data;
+    try {
+        data = (await res.json());
+    }
+    catch {
+        return { status: 'error', reason: 'invalid response body' };
+    }
+    const rows = Array.isArray(data.crossings) ? data.crossings : [];
+    return { status: 'ok', crossing: rows.find(c => c.id === crossingId) ?? null };
+}

package/dist/cli/src/commands/crossing-explain.js

@@ -4,14 +4,16 @@ exports.crossingExplain = crossingExplain;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const bound_task_1 = require("../lib/bound-task");
 /**
  * `lumo crossing explain <id> --note "…"` — append an agent self-explanation
  * ("申辩") to a boundary crossing (LUM-542).
  *
  * This is the AGENT side of the boundary-crossing review loop and the deliberate
  * inverse of dispositioning: it can only ADD an append-only note for the human
- * reviewer to weigh — it never clears the crossing or unblocks Done (a human
- * dispositions that, in the web acceptance panel). The crossing must belong to
+ * reviewer to weigh — it never clears the crossing or unblocks Done (the user
+ * rules on that: `lumo crossing disposition` through the exit-4 confirmation
+ * protocol, or the web acceptance panel). The crossing must belong to
  * the task this session is bound to; the binding is how the target task is
  * resolved, so run it inside a session attached via `lumo session attach`.
  */
@@ -39,24 +41,9 @@ async function crossingExplain(crossingId, options = {}) {
         headers['X-Lumo-Session-Id'] = sessionId;
     // The crossing is addressed by id, but the route is task-scoped — resolve the
     // bound task from the session so the server can verify the crossing is on it.
-    if (!sessionId) {
-        console.error('Error: $CLAUDE_CODE_SESSION_ID is not set — run inside a session bound via `lumo session attach <LUM-N>`.');
-        return 1;
-    }
-    let bound;
-    try {
-        const res = await fetch(`${base}/api/sessions/${encodeURIComponent(sessionId)}`, { headers });
-        bound = res.ok
-            ? (await res.json())
-            : null;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Error: could not reach Lumo API (${msg})`);
-        return 1;
-    }
-    if (!bound?.taskIdentifier) {
-        console.error('Error: this session is not bound to a task. Run `lumo session attach <LUM-N>` first.');
+    const bound = await (0, bound_task_1.resolveBoundTask)({ base, headers, sessionId });
+    if (!bound.ok) {
+        console.error(bound.message);
         return 1;
     }
     const taskId = bound.taskIdentifier;
@@ -88,6 +75,8 @@ async function crossingExplain(crossingId, options = {}) {
     const outcome = (await res.json());
     process.stdout.write(`✓ Recorded an explanation on crossing ${(0, sanitize_1.sanitizeField)(outcome.crossingId)}.\n` +
         '  This is an append-only note for the human reviewer — it does not clear ' +
-        'the crossing or unblock Done.\n');
+        'the crossing or unblock Done. Once the user rules, record it with ' +
+        '`lumo crossing disposition <id> --false-positive | --confirmed` (exit-4 envelope) ' +
+        'or in the web panel.\n');
     return;
 }

package/dist/cli/src/commands/doc-delete.js

@@ -1,18 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeDocDelete = describeDocDelete;
 exports.docDelete = docDelete;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
-const resolve_doc_1 = require("../lib/resolve-doc");
 const resolve_doc_id_1 = require("../lib/resolve-doc-id");
 const sanitize_1 = require("../lib/sanitize");
+const confirmation_1 = require("../lib/confirmation");
+/** The changes[] block for the confirmation envelope. */
+function describeDocDelete(id, title) {
+    const escaped = (0, sanitize_1.sanitizeField)(title).replace(/"/g, '\\"');
+    return [
+        `Will delete document ${id} "${escaped}"`,
+        'Every document nested under it is deleted with it; task bindings and shares are dropped',
+    ];
+}
 async function docDelete(reference, opts) {
     if (!reference) {
-        console.error('Error: missing <doc>. Usage: lumo doc delete <doc> --yes');
-        return 1;
-    }
-    if (!opts.yes) {
-        console.error('Error: Refusing to delete without --yes');
+        console.error('Error: missing <doc>. Usage: lumo doc delete <doc> --confirm');
         return 1;
     }
     const creds = (0, config_1.readCredentials)();
@@ -21,26 +26,33 @@ async function docDelete(reference, opts) {
         return 1;
     }
     const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
-    // For a cuid reference we don't have the title; for a title we look up id+title at once.
-    let id;
-    let title = '';
-    if ((0, resolve_doc_1.isLikelyCuid)(reference)) {
-        id = reference;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    const headers = { Authorization: `Bearer ${creds.token}` };
+    const id = await (0, resolve_doc_id_1.lookupDocId)(apiUrl, creds.token, reference);
+    if (!id) {
+        console.error(`Error: Document not found: ${reference}`);
+        return 1;
+    }
+    // Always fetch the doc first: the envelope needs its real title, and the
+    // same GET confirms it exists before anything destructive happens.
+    const showRes = await fetch(`${base}/api/documents/${id}`, { headers });
+    if (!showRes.ok) {
+        const text = await showRes.text();
+        console.error(`Error: ${showRes.status} ${showRes.statusText}: ${(0, sanitize_1.sanitizeField)(text)}`);
+        return 1;
     }
-    else {
-        const fetched = await (0, resolve_doc_id_1.lookupDocId)(apiUrl, creds.token, reference);
-        if (!fetched) {
-            console.error(`Error: Document not found: ${reference}`);
-            return 1;
-        }
-        id = fetched;
-        // Pick up the title from the lookup payload by repeating the GET — small extra cost.
-        // (Alternative: change lookupDocId to return the full DocLike. For now keep it simple.)
-        title = reference;
+    const { document } = (await showRes.json());
+    const title = document.title ?? '';
+    // LUM-755: no --confirm → envelope, no DELETE.
+    if (!(0, confirmation_1.isConfirmed)(opts)) {
+        return (0, confirmation_1.emitConfirmation)({
+            command: 'doc delete',
+            changes: describeDocDelete(id, title),
+        });
     }
-    const res = await fetch(`${(0, api_1.trimTrailingSlash)(apiUrl)}/api/documents/${id}`, {
+    const res = await fetch(`${base}/api/documents/${id}`, {
         method: 'DELETE',
-        headers: { Authorization: `Bearer ${creds.token}` },
+        headers,
     });
     if (!res.ok) {
         const text = await res.text();

package/dist/cli/src/commands/doc-rebuild-source.js

@@ -5,6 +5,7 @@ const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const resolve_doc_id_1 = require("../lib/resolve-doc-id");
 const sanitize_1 = require("../lib/sanitize");
+const confirmation_1 = require("../lib/confirmation");
 /**
  * `lumo doc rebuild-source <doc>` (LUM-446).
  *
@@ -13,7 +14,9 @@ const sanitize_1 = require("../lib/sanitize");
  * re-enabling `doc show --raw` / `diff` / `patch` / `append`. The rebuilt source
  * is structure-guarded server-side: any table/tr/heading shrink is rejected 422
  * (zero silent flattening — LUM-410 口径) unless --allow-shrink is passed. A doc
- * that already has a source is refused 409 unless --force re-derives it.
+ * that already has a source is refused 409 unless --force re-derives it —
+ * that refusal is surfaced as a confirmation envelope (LUM-755): exit 4 with
+ * the server's reason and a confirmCommand carrying `--force --confirm`.
  */
 async function docRebuildSource(reference, opts) {
     if (!reference) {
@@ -57,11 +60,20 @@ async function docRebuildSource(reference, opts) {
     if (!res.ok) {
         const text = await res.text();
         const message = (0, api_1.extractErrorMessage)(text);
+        if (res.status === 409 && !opts.force) {
+            // The --force gate: nothing was written. Hand back the protocol
+            // envelope so the agent shows the user what --force would replace.
+            return (0, confirmation_1.emitConfirmation)({
+                command: 'doc rebuild-source',
+                changes: [
+                    (0, sanitize_1.sanitizeField)(message),
+                    `Will replace the existing (byte-faithful) markdown source of ${id} with a freshly serialized one — inspect it first with \`lumo doc show ${reference} --raw\``,
+                ],
+                extraFlags: ['--force'],
+            });
+        }
         if (res.status === 409) {
             console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
-            console.error('Hint: the doc already has a markdown source. Inspect it with ' +
-                `\`lumo doc show ${reference} --raw\`; pass --force only if you intend ` +
-                'to replace it with a freshly serialized one.');
             return 1;
         }
         if (res.status === 422) {

package/dist/cli/src/commands/memory-rm.js

@@ -1,15 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeMemoryContent = summarizeMemoryContent;
+exports.describeMemoryRm = describeMemoryRm;
 exports.memoryRm = memoryRm;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+const confirmation_1 = require("../lib/confirmation");
+const SUMMARY_MAX = 120;
+/**
+ * One-line summary of a memory's structured content for the envelope: the
+ * first string field (memory cards lead with their headline field), trimmed.
+ */
+function summarizeMemoryContent(content) {
+    if (typeof content === 'string')
+        return truncate(content);
+    if (content && typeof content === 'object') {
+        for (const value of Object.values(content)) {
+            if (typeof value === 'string' && value.trim())
+                return truncate(value);
+        }
+    }
+    return null;
+}
+function truncate(s) {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    return flat.length > SUMMARY_MAX ? `${flat.slice(0, SUMMARY_MAX - 1)}…` : flat;
+}
+/** The changes[] block for the confirmation envelope. */
+function describeMemoryRm(memory) {
+    const lines = [`Will hard-delete memory ${memory.id} [${memory.category}]`];
+    const summary = summarizeMemoryContent(memory.content);
+    if (summary)
+        lines.push(`Content: ${summary}`);
+    lines.push('The memory is removed for the whole team; there is no undo');
+    return lines.map(l => (0, sanitize_1.sanitizeField)(l));
+}
 async function memoryRm(memoryId, options) {
     if (!memoryId) {
-        console.error('Error: missing <memoryId>. Usage: lumo memory rm <memoryId> --yes');
-        return 1;
-    }
-    if (!options.yes) {
-        console.error('Error: refusing to delete without --yes. Re-run with --yes to confirm.');
+        console.error('Error: missing <memoryId>. Usage: lumo memory rm <memoryId> --confirm');
         return 1;
     }
     const creds = (0, config_1.readCredentials)();
@@ -19,19 +48,48 @@ async function memoryRm(memoryId, options) {
     }
     const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
     const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    const url = `${base}/api/memories/${encodeURIComponent(memoryId)}`;
+    const headers = { Authorization: `Bearer ${creds.token}` };
+    const notFound = `Error: memory ${memoryId} not found — pass the full memory id (cuid) from \`lumo task memory list\` / \`lumo project memory list\`; truncated id prefixes are not resolved`;
+    // LUM-755: without --confirm, fetch the card so the envelope shows what
+    // would be deleted, then stop — no DELETE is sent.
+    if (!(0, confirmation_1.isConfirmed)(options)) {
+        let showRes;
+        try {
+            showRes = await fetch(url, { headers });
+        }
+        catch (err) {
+            console.error(`Error: could not reach Lumo API at ${apiUrl} (${err instanceof Error ? err.message : String(err)})`);
+            return 1;
+        }
+        if (showRes.status === 401) {
+            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+            return 1;
+        }
+        if (showRes.status === 404) {
+            console.error(notFound);
+            return 1;
+        }
+        if (!showRes.ok) {
+            console.error(`Error: memory lookup failed (HTTP ${showRes.status})`);
+            return 1;
+        }
+        const { memory } = (await showRes.json());
+        return (0, confirmation_1.emitConfirmation)({
+            command: 'memory rm',
+            changes: describeMemoryRm(memory),
+        });
+    }
     let res;
     try {
-        res = await fetch(`${base}/api/memories/${encodeURIComponent(memoryId)}`, {
-            method: 'DELETE',
-            headers: { Authorization: `Bearer ${creds.token}` },
-        });
+        res = await fetch(url, { method: 'DELETE', headers });
     }
     catch (err) {
         console.error(`Error: could not reach Lumo API at ${apiUrl} (${err instanceof Error ? err.message : String(err)})`);
         return 1;
     }
     if (res.status === 404) {
-        console.error(`Error: memory ${memoryId} not found — pass the full memory id (cuid) from \`lumo task memory list\` / \`lumo project memory list\`; truncated id prefixes are not resolved`);
+        console.error(notFound);
         return 1;
     }
     if (res.status !== 204) {

package/dist/cli/src/commands/milestone-delete.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDeleteRefusal = formatDeleteRefusal;
+exports.describeMilestoneDelete = describeMilestoneDelete;
 exports.milestoneDelete = milestoneDelete;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const resolve_1 = require("../lib/resolve");
 const sanitize_1 = require("../lib/sanitize");
-function formatDeleteRefusal(name, taskCount) {
-    const head = `Refusing to delete milestone "${(0, sanitize_1.sanitizeField)(name)}" without --yes.`;
-    const tail = `Re-run with --yes to confirm.`;
-    if (taskCount === 0)
-        return `${head}\n${tail}`;
-    return `${head}\n${taskCount} tasks under it will keep their data; only milestoneId is cleared.\n${tail}`;
+const confirmation_1 = require("../lib/confirmation");
+/** The changes[] block for the confirmation envelope (LUM-755). */
+function describeMilestoneDelete(name, taskCount) {
+    const lines = [`Will delete milestone "${(0, sanitize_1.sanitizeField)(name)}"`];
+    if (taskCount > 0)
+        lines.push(`${taskCount} tasks under it keep their data; only milestoneId is cleared`);
+    return lines;
 }
 function totalTasks(counts) {
     return counts.TODO + counts.IN_PROGRESS + counts.IN_REVIEW + counts.DONE;
@@ -59,9 +60,11 @@ async function milestoneDelete(identifier, opts) {
     const { milestone } = (await showRes.json());
     const name = resolvedName || milestone.name;
     const total = totalTasks(milestone.taskCounts);
-    if (!opts.yes) {
-        console.error(formatDeleteRefusal(name, total));
-        return 1;
+    if (!(0, confirmation_1.isConfirmed)(opts)) {
+        return (0, confirmation_1.emitConfirmation)({
+            command: 'milestone delete',
+            changes: describeMilestoneDelete(name, total),
+        });
     }
     let res;
     try {