@lumoai/cli 1.32.0 → 1.34.0

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatShowOutput = formatShowOutput;
+exports.selectDocShowOutput = selectDocShowOutput;
 exports.docShow = docShow;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
@@ -8,6 +9,7 @@ const markdown_tiptap_1 = require("../lib/markdown-tiptap");
 const markdown_sections_1 = require("../lib/markdown-sections");
 const resolve_doc_id_1 = require("../lib/resolve-doc-id");
 const sanitize_1 = require("../lib/sanitize");
+const output_budget_1 = require("../../../shared/src/output-budget");
 function scopeLabel(s) {
     if (s === 'PRIVATE')
         return 'personal';
@@ -27,43 +29,21 @@ function formatShowOutput(vm) {
         `Mentioned tasks: ${vm.mentionedTasks.length ? vm.mentionedTasks.join(', ') : '-'}`,
     ];
     const header = lines.join('\n');
-    return vm.bodyMarkdown ? `${header}\n\n${(0, sanitize_1.sanitizeField)(vm.bodyMarkdown)}` : header;
+    if (!vm.bodyMarkdown)
+        return header;
+    const full = `${header}\n\n${(0, sanitize_1.sanitizeField)(vm.bodyMarkdown)}`;
+    // The *rendered* view is the only doc-show path with a budget (LUM-428): a
+    // book-length doc would otherwise swallow the agent's context. The pointer
+    // routes to the byte-faithful reads — `--section` for a just-in-time slice,
+    // `--raw` for the whole source — which are NEVER capped (they are edit bases).
+    return (0, output_budget_1.capRenderedOutput)(full, {
+        fetchHint: `read one section with: lumo doc show ${vm.id} --section "<heading>", ` +
+            `or the full markdown source with: lumo doc show ${vm.id} --raw`,
+        unitNoun: 'lines',
+    }).text;
 }
-async function docShow(reference, opts = {}) {
-    if (!reference) {
-        console.error('Error: missing <doc>. Usage: lumo doc show <doc> [--raw | --section <heading>]');
-        return 1;
-    }
-    if (opts.raw && opts.section !== undefined) {
-        console.error('Error: --raw and --section are mutually exclusive (--raw prints the whole source)');
-        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 id = await (0, resolve_doc_id_1.lookupDocId)(apiUrl, creds.token, reference);
-    if (!id) {
-        console.error(`Error: Document not found: ${reference}`);
-        return 1;
-    }
-    const res = await fetch(`${(0, api_1.trimTrailingSlash)(apiUrl)}/api/documents/${id}`, {
-        headers: { Authorization: `Bearer ${creds.token}` },
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        console.error(`Error: ${res.status} ${res.statusText}: ${(0, sanitize_1.sanitizeField)(text)}`);
-        return 1;
-    }
-    // The exact shape of the GET response is not guaranteed; defensively unwrap.
-    const data = (await res.json());
-    const d = data.document;
-    if (!d) {
-        console.error('Error: server returned an empty document response');
-        return 1;
-    }
+function selectDocShowOutput(d, opts) {
+    const revision = typeof d.contentRevision === 'number' ? d.contentRevision : null;
     if (opts.raw) {
         // Byte-identical markdown source of the last markdown upload (LUM-408).
         // Written verbatim (no header, no sanitization, no added newline) so the
@@ -71,30 +51,28 @@ async function docShow(reference, opts = {}) {
         // No silent fallback to the lossy HTML→markdown reverse render — that
         // fallback is exactly what flattened tables in LUM-349.
         if (typeof d.sourceMarkdown !== 'string') {
-            console.error(`Error: ${d.id} has no stored markdown source (last edit was HTML-direct ` +
-                `or predates markdown source storage). --raw refuses to fall back to the ` +
-                `lossy HTML→markdown render. Rebuild a base instead: run \`lumo doc show ${d.id}\`, ` +
-                `reconstruct the markdown faithfully, then \`lumo doc update ${d.id} --file <rebuilt.md>\` ` +
-                `— from then on --raw works.`);
-            return 1;
+            return {
+                kind: 'error',
+                message: `Error: ${d.id} has no stored markdown source (last edit was HTML-direct ` +
+                    `or predates markdown source storage). --raw refuses to fall back to the ` +
+                    `lossy HTML→markdown render. Rebuild a base instead: run \`lumo doc show ${d.id}\`, ` +
+                    `reconstruct the markdown faithfully, then \`lumo doc update ${d.id} --file <rebuilt.md>\` ` +
+                    `— from then on --raw works.`,
+            };
         }
-        process.stdout.write(d.sourceMarkdown);
-        // Revision goes to stderr so stdout stays a byte-pure edit base while
-        // the agent still sees the number to pass back as --if-revision.
-        if (typeof d.contentRevision === 'number') {
-            console.error(`Revision: ${d.contentRevision}`);
-        }
-        return;
+        return { kind: 'bytes', text: d.sourceMarkdown, revision };
     }
     if (opts.section !== undefined) {
         // Section reads slice the stored markdown source — same no-fallback rule
         // as --raw: a rendered-output slice would not be a legal edit base.
         if (typeof d.sourceMarkdown !== 'string') {
-            console.error(`Error: ${d.id} has no stored markdown source (last edit was HTML-direct ` +
-                `or predates markdown source storage), so --section cannot slice it. ` +
-                `Rebuild a base first: run \`lumo doc show ${d.id}\`, reconstruct the markdown ` +
-                `faithfully, then \`lumo doc update ${d.id} --file <rebuilt.md>\`.`);
-            return 1;
+            return {
+                kind: 'error',
+                message: `Error: ${d.id} has no stored markdown source (last edit was HTML-direct ` +
+                    `or predates markdown source storage), so --section cannot slice it. ` +
+                    `Rebuild a base first: run \`lumo doc show ${d.id}\`, reconstruct the markdown ` +
+                    `faithfully, then \`lumo doc update ${d.id} --file <rebuilt.md>\`.`,
+            };
         }
         const match = (0, markdown_sections_1.findSection)(d.sourceMarkdown, opts.section);
         if (match.kind === 'not-found') {
@@ -102,24 +80,27 @@ async function docShow(reference, opts = {}) {
                 .slice(0, 30)
                 .map(s => `  ${'#'.repeat(s.depth)} ${(0, sanitize_1.sanitizeField)(s.heading)}`)
                 .join('\n');
-            console.error(`Error: section not found: "${opts.section}". Available headings:\n${list || '  (none)'}`);
-            return 1;
+            return {
+                kind: 'error',
+                message: `Error: section not found: "${opts.section}". Available headings:\n${list || '  (none)'}`,
+            };
         }
         if (match.kind === 'ambiguous') {
             const list = match.candidates
                 .map(s => `  ${'#'.repeat(s.depth)} ${(0, sanitize_1.sanitizeField)(s.heading)} (line ${s.line + 1})`)
                 .join('\n');
-            console.error(`Error: section "${opts.section}" is ambiguous — ${match.candidates.length} headings match:\n${list}\n` +
-                `Disambiguate by depth, e.g. --section "${'#'.repeat(match.candidates[0].depth)} ${match.candidates[0].heading}"`);
-            return 1;
-        }
-        // Byte-faithful slice, verbatim on stdout (legal patch base); revision on
-        // stderr for the follow-up `doc patch --if-revision`.
-        process.stdout.write((0, markdown_sections_1.extractSection)(d.sourceMarkdown, match.section));
-        if (typeof d.contentRevision === 'number') {
-            console.error(`Revision: ${d.contentRevision}`);
+            return {
+                kind: 'error',
+                message: `Error: section "${opts.section}" is ambiguous — ${match.candidates.length} headings match:\n${list}\n` +
+                    `Disambiguate by depth, e.g. --section "${'#'.repeat(match.candidates[0].depth)} ${match.candidates[0].heading}"`,
+            };
         }
-        return;
+        // Byte-faithful slice, verbatim (legal patch base).
+        return {
+            kind: 'bytes',
+            text: (0, markdown_sections_1.extractSection)(d.sourceMarkdown, match.section),
+            revision,
+        };
     }
     // Server returns `contentMarkdown` derived from the HTML body (LUM-83+).
     // Fall back to parsing the raw content as legacy Tiptap JSON for docs
@@ -149,15 +130,71 @@ async function docShow(reference, opts = {}) {
         return null;
     })
         .filter((x) => x !== null);
-    console.log(formatShowOutput({
-        id: d.id,
-        title: d.title,
-        scope: d.visibility ?? 'PRIVATE',
-        projectName: d.project?.name ?? null,
-        createdAt: d.createdAt ?? '',
-        updatedAt: d.updatedAt ?? '',
-        revision: typeof d.contentRevision === 'number' ? d.contentRevision : null,
-        mentionedTasks,
-        bodyMarkdown: body,
-    }));
+    return {
+        kind: 'rendered',
+        text: formatShowOutput({
+            id: d.id,
+            title: d.title,
+            scope: d.visibility ?? 'PRIVATE',
+            projectName: d.project?.name ?? null,
+            createdAt: d.createdAt ?? '',
+            updatedAt: d.updatedAt ?? '',
+            revision,
+            mentionedTasks,
+            bodyMarkdown: body,
+        }),
+    };
+}
+async function docShow(reference, opts = {}) {
+    if (!reference) {
+        console.error('Error: missing <doc>. Usage: lumo doc show <doc> [--raw | --section <heading>]');
+        return 1;
+    }
+    if (opts.raw && opts.section !== undefined) {
+        console.error('Error: --raw and --section are mutually exclusive (--raw prints the whole source)');
+        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 id = await (0, resolve_doc_id_1.lookupDocId)(apiUrl, creds.token, reference);
+    if (!id) {
+        console.error(`Error: Document not found: ${reference}`);
+        return 1;
+    }
+    const res = await fetch(`${(0, api_1.trimTrailingSlash)(apiUrl)}/api/documents/${id}`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        console.error(`Error: ${res.status} ${res.statusText}: ${(0, sanitize_1.sanitizeField)(text)}`);
+        return 1;
+    }
+    // The exact shape of the GET response is not guaranteed; defensively unwrap.
+    const data = (await res.json());
+    const d = data.document;
+    if (!d) {
+        console.error('Error: server returned an empty document response');
+        return 1;
+    }
+    const sel = selectDocShowOutput(d, opts);
+    if (sel.kind === 'error') {
+        console.error(sel.message);
+        return 1;
+    }
+    if (sel.kind === 'bytes') {
+        // Byte-faithful read (--raw / --section): written verbatim, NEVER routed
+        // through the output cap — it is a legal edit base for `doc patch`
+        // (LUM-408/409/428). Revision goes to stderr so stdout stays byte-pure
+        // while the agent still sees the number to pass back as --if-revision.
+        process.stdout.write(sel.text);
+        if (sel.revision !== null) {
+            console.error(`Revision: ${sel.revision}`);
+        }
+        return;
+    }
+    console.log(sel.text);
 }

package/dist/cli/src/commands/session-attach.js

@@ -4,26 +4,20 @@ exports.sessionAttach = sessionAttach;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
-const line_prompt_1 = require("../lib/line-prompt");
 /**
  * `lumo session attach <identifier>` — bind the currently-running
  * Claude Code session to a task.
  *
  * Required environment: `CLAUDE_CODE_SESSION_ID` (set automatically by
- * Claude Code). Must be invoked from inside a Claude Code session — there
- * is no longer a global "current task" pointer for terminals outside CC.
+ * Claude Code). Must be invoked from inside a Claude Code session.
  *
- * The binding lives entirely on the server (`Session.taskId`); subsequent
- * hooks read it back via the session row. The CLI keeps no local sentinel.
- *
- * Re-binding a session that's already attached to a *different* task no
- * longer silently clobbers `Session.taskId` (LUM-266): the server returns
- * the current binding and we confirm before overwriting —
- *   - `--force` skips the prompt and overwrites directly;
- *   - on a TTY we ask `Already bound to LUM-X. Rebind to LUM-Y? [y/N]`;
- *   - off a TTY (the usual agent case) we refuse and point at `--force`.
+ * The binding is a **lifetime lock** (LUM-459): `Session.taskId` is write-once.
+ * Re-attaching to the *same* task is an idempotent no-op (re-emits context).
+ * Attaching to a *different* task is refused with HTTP 409 — there is no
+ * `--force` and no `session detach`; a different task requires a brand-new
+ * Claude Code session.
  */
-async function sessionAttach(identifier, options = {}) {
+async function sessionAttach(identifier) {
     if (!identifier) {
         console.error('Error: missing <identifier>. Usage: lumo session attach <LUM-42>');
         return 1;
@@ -41,75 +35,63 @@ async function sessionAttach(identifier, options = {}) {
     }
     const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
     const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
-    const bind = async (force) => {
-        let res;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${creds.token}`,
+            },
+            body: JSON.stringify({ taskIdentifier: identifier }),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (res.status === 404) {
+        let message = 'Not found';
         try {
-            res = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${creds.token}`,
-                },
-                body: JSON.stringify({ taskIdentifier: identifier, force }),
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
-            return { ok: false, code: 1 };
+            const data = (await res.json());
+            if (data.error)
+                message = data.error;
         }
-        if (res.status === 401) {
-            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
-            return { ok: false, code: 1 };
+        catch {
+            // fall through
         }
-        if (res.status === 404) {
-            let message = 'Not found';
-            try {
-                const data = (await res.json());
-                if (data.error)
-                    message = data.error;
-            }
-            catch {
-                // fall through
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
+        return 1;
+    }
+    // Lifetime lock (LUM-459): the session is permanently bound to another task.
+    if (res.status === 409) {
+        let current = 'another task';
+        try {
+            const data = (await res.json());
+            if (data.currentTaskIdentifier) {
+                current = data.currentTaskTitle
+                    ? `${data.currentTaskIdentifier} "${(0, sanitize_1.sanitizeField)(data.currentTaskTitle)}"`
+                    : data.currentTaskIdentifier;
             }
-            console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
-            return { ok: false, code: 1 };
         }
-        if (!res.ok) {
-            console.error(`Error: bind-task failed (HTTP ${res.status})`);
-            return { ok: false, code: 1 };
+        catch {
+            // fall through with the generic phrasing
         }
-        return { ok: true, body: (await res.json()) };
-    };
-    // First attempt. `--force` overwrites unconditionally; otherwise the server
-    // may answer `already-bound` so we can confirm before clobbering.
-    const first = await bind(options.force === true);
-    if (!first.ok)
-        return first.code;
-    let body = first.body;
-    if (body.status === 'already-bound') {
-        // Reached only when not forced (force=true would have overwritten).
-        if (!process.stdin.isTTY) {
-            console.error(`Session already bound to ${body.currentTaskIdentifier} "${(0, sanitize_1.sanitizeField)(body.currentTaskTitle)}". ` +
-                `Not overwriting. Re-run with --force to switch to ${identifier} ` +
-                '(or run `lumo session detach` first).');
-            return 0;
-        }
-        const answer = await (0, line_prompt_1.promptLine)(`Already bound to ${body.currentTaskIdentifier}. Rebind to ${identifier}? [y/N] `);
-        if (!/^y(es)?$/i.test(answer)) {
-            console.log(`Cancelled — still bound to ${body.currentTaskIdentifier}.`);
-            return 0;
-        }
-        const second = await bind(true);
-        if (!second.ok)
-            return second.code;
-        body = second.body;
+        console.error(`Error: this session is permanently bound to ${current}. ` +
+            'A session works one task for its lifetime — start a new Claude Code ' +
+            `session to work on ${identifier}.`);
+        return 1;
     }
-    if (body.status === 'already-bound') {
-        // Defensive: a forced bind should never report already-bound.
-        console.error(`Error: bind did not take effect (still bound to ${body.currentTaskIdentifier}).`);
+    if (!res.ok) {
+        console.error(`Error: bind-task failed (HTTP ${res.status})`);
         return 1;
     }
+    const body = (await res.json());
     console.log(`Attached session ${sessionId} to ${body.taskIdentifier} "${(0, sanitize_1.sanitizeField)(body.taskTitle)}"`);
     console.log(`Re-tagged ${body.retaggedEventCount} previously-untagged event${body.retaggedEventCount === 1 ? '' : 's'} in this session.`);
     // Warnings come before contract/memory: matches the hook injection order —

package/dist/cli/src/commands/session-wrap.js

@@ -7,6 +7,7 @@ const progress_comment_section_1 = require("./wrap/progress-comment-section");
 const memory_review_section_1 = require("./wrap/memory-review-section");
 const fragment_usage_section_1 = require("./wrap/fragment-usage-section");
 const blocked_prompt_section_1 = require("./wrap/blocked-prompt-section");
+const crossings_reminder_1 = require("./wrap/crossings-reminder");
 /**
  * `lumo session wrap [--yes] [--dry-run]`
  *
@@ -40,4 +41,11 @@ async function sessionWrap(options) {
         yes: options.yes === true,
         dryRun: options.dryRun === true,
     });
+    // After the panel: a read-only nudge if the bound task has open boundary
+    // crossings still undispositioned (LUM-448). Silent when there are none —
+    // a clean task adds no wrap-up noise. Awareness only; clearing a crossing is
+    // web + human-only (LUM-426/435/422).
+    const reminder = await (0, crossings_reminder_1.openCrossingReminder)(creds);
+    if (reminder)
+        process.stdout.write(reminder);
 }

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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCommentThread = formatCommentThread;
 exports.taskCommentList = taskCommentList;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const output_budget_1 = require("../../../shared/src/output-budget");
 /**
  * Strip TipTap/HTML markup to readable plain text. Comment bodies are stored as
  * HTML; the CLI only needs the visible text. We collapse block tags to newlines
@@ -23,17 +25,42 @@ function htmlToPlainText(html) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
-function printComment(c, indent) {
+/** Render one comment (and its nested replies) as an indented text block. */
+function renderCommentBlock(c, indent) {
+    const lines = [];
     const author = (0, sanitize_1.sanitizeField)(c.authorActorId ?? 'unknown');
-    console.log(`${indent}${author} · ${c.createdAt}`);
+    lines.push(`${indent}${author} · ${c.createdAt}`);
     const text = (0, sanitize_1.sanitizeField)(htmlToPlainText(c.body));
     for (const line of (text || '(empty)').split('\n')) {
-        console.log(`${indent}${line}`);
+        lines.push(`${indent}${line}`);
     }
-    console.log('');
     for (const reply of c.replies ?? []) {
-        printComment(reply, indent + '  ');
+        lines.push('');
+        lines.push(renderCommentBlock(reply, indent + '  '));
     }
+    return lines.join('\n');
+}
+/**
+ * Render the full comment thread as agent-facing text. One block per top-level
+ * comment (replies indented underneath). Capped to the output-token budget by
+ * default (LUM-428) — a long-running task's thread is one of the easiest ways
+ * to blow the agent's context — with a fetch-more pointer to `--full`. Pass
+ * `{ full: true }` to print everything.
+ */
+function formatCommentThread(comments, opts = {}) {
+    if (comments.length === 0)
+        return '(no comments)';
+    const blocks = comments.map(c => renderCommentBlock(c, ''));
+    if (opts.full)
+        return blocks.join('\n\n');
+    const id = opts.identifier ?? '<LUM-N>';
+    return (0, output_budget_1.truncateUnitsToBudget)({
+        units: blocks,
+        maxTokens: opts.maxTokens,
+        unitNoun: 'comments',
+        fetchHint: `read the whole thread with: lumo task comments list ${id} --full`,
+        separator: '\n\n',
+    }).text;
 }
 /**
  * `lumo task comments list <LUM-N>`
@@ -43,7 +70,7 @@ function printComment(c, indent) {
  * thread from `/api/tasks/:id/comments` and prints each top-level comment
  * (replies indented) as `author · time` followed by the plain-text body.
  */
-async function taskCommentList(identifier) {
+async function taskCommentList(identifier, opts = {}) {
     if (!identifier) {
         console.error('Error: usage: lumo task comments list <LUM-42>');
         return 1;
@@ -105,7 +132,8 @@ async function taskCommentList(identifier) {
         console.log('(no comments)');
         return;
     }
-    for (const c of comments) {
-        printComment(c, '');
-    }
+    console.log(formatCommentThread(comments, {
+        full: opts.full,
+        identifier: resolved.identifier,
+    }));
 }

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

@@ -6,6 +6,7 @@ const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
 const format_1 = require("../lib/format");
+const output_budget_1 = require("../../../shared/src/output-budget");
 async function taskContext(identifier) {
     if (!identifier) {
         console.error('Error: missing <identifier>. Usage: lumo task context <LUM-42>');
@@ -144,5 +145,15 @@ function formatTaskContextMarkdown(data, now) {
         lines.push((0, sanitize_1.sanitizeField)(data.lineageSection.trimEnd()));
         lines.push('');
     }
-    return lines.join('\n');
+    // A memory-rich task with a long comment thread and many sessions is the
+    // single most context-hungry agent-facing command (LUM-428). Cap the
+    // assembled handoff to the output budget; the pointer routes the agent to the
+    // precise sub-commands to pull any dropped section just-in-time.
+    const id = data.task.identifier;
+    return (0, output_budget_1.capRenderedOutput)(lines.join('\n'), {
+        fetchHint: `pull the dropped sections individually: lumo task status ${id} · ` +
+            `lumo task comments list ${id} --full · lumo task lineage ${id} · ` +
+            `lumo doc show <doc>`,
+        unitNoun: 'lines',
+    }).text;
 }

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

@@ -20,6 +20,12 @@ function formatCriteriaRows(criteria) {
         if (c.checkpointer) {
             lines.push(`  ↳ check: ${(0, sanitize_1.sanitizeField)(c.checkpointer)}`);
         }
+        if (c.judgeSteps) {
+            const judgeLines = (0, sanitize_1.sanitizeField)(c.judgeSteps).split('\n');
+            lines.push(`  ↳ judge: ${judgeLines[0]}`);
+            for (const jl of judgeLines.slice(1))
+                lines.push(`           ${jl}`);
+        }
     }
     return lines.length > 0 ? lines.join('\n') + '\n' : '';
 }

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

@@ -104,6 +104,31 @@ async function taskCriteriaSet(identifier, options) {
     const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
     if (sessionId)
         headers['X-Lumo-Session-Id'] = sessionId;
+    // LUM-437: when a contract already exists, preserve criterion identity across
+    // an after-start edit by matching submitted items to existing criteria by exact
+    // statement and attaching their ids. Best-effort — fall back to id-less submit.
+    let criteriaItems = parsed.items;
+    if (!options.human) {
+        try {
+            const listRes = await fetch(`${base}/api/tasks/${encodeURIComponent(identifier)}/criteria`, { headers: { Authorization: `Bearer ${creds.token}` } });
+            if (listRes.ok) {
+                const listData = (await listRes.json());
+                const activeByStatement = new Map(listData.criteria.map(c => [c.statement, c.id]));
+                criteriaItems = parsed.items.map(item => {
+                    if (item !== null && typeof item === 'object' && !('id' in item)) {
+                        const stmt = item['statement'];
+                        if (typeof stmt === 'string' && activeByStatement.has(stmt)) {
+                            return { ...item, id: activeByStatement.get(stmt) };
+                        }
+                    }
+                    return item;
+                });
+            }
+        }
+        catch {
+            // leave criteriaItems as-is; the server still records via full diff
+        }
+    }
     let res;
     try {
         res = await fetch(`${base}/api/tasks/${encodeURIComponent(identifier)}/criteria`, {
@@ -111,7 +136,7 @@ async function taskCriteriaSet(identifier, options) {
             headers,
             body: JSON.stringify({
                 source: options.human ? 'HUMAN_EDIT' : 'AGENT_DRAFT',
-                criteria: parsed.items,
+                criteria: criteriaItems,
                 ...(causeTag ? { causeTag } : {}),
             }),
         });
@@ -143,4 +168,7 @@ async function taskCriteriaSet(identifier, options) {
     if (data.warning) {
         process.stdout.write(`⚠ ${(0, sanitize_1.sanitizeField)(data.warning)}\n`);
     }
+    if (data.judgeStepsWarning) {
+        process.stdout.write(`⚠ ${(0, sanitize_1.sanitizeField)(data.judgeStepsWarning)}\n`);
+    }
 }