@lumoai/cli 1.59.0 → 1.61.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/milestone-changelog.js

@@ -83,7 +83,7 @@ function formatEntry(entry) {
 }
 function formatMilestoneChangelog(cl) {
     const lines = [
-        `# Changelog — ${(0, sanitize_1.sanitizeField)(cl.milestone.name)} (${cl.milestone.status})`,
+        `# Changelog — ${(0, sanitize_1.sanitizeField)(cl.milestone.name)} (${cl.milestone.state})`,
     ];
     const window = formatWindow(cl.milestone.startDate, cl.milestone.targetDate);
     if (window)

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

@@ -19,23 +19,30 @@ function formatDate(iso) {
         return '-';
     return iso.slice(0, 10);
 }
+/** LUM-714: the milestone's state, folded from its two timestamps. */
+function rowState(r) {
+    if (r.archivedAt)
+        return 'ARCHIVED';
+    return r.completedAt ? 'COMPLETED' : 'ACTIVE';
+}
 /**
  * Render milestones as fixed-width rows:
- *   <STATUS>  <HEALTH>  <target-date or ->  <name>
+ *   <STATE>  <HEALTH>  <target-date or ->  <name>
  *
+ * STATE is ACTIVE / COMPLETED / ARCHIVED (LUM-714) — derived, never stored.
  * HEALTH is the target-date risk light (ON-TRACK / AT-RISK / OVERDUE), or `-`
- * when no light applies (terminal status or no target date).
+ * when no light applies (completed, archived, or no target date).
  *
  * Sorted server-side by targetDate asc nulls last, createdAt asc.
  */
 function formatMilestoneList(rows) {
     if (rows.length === 0)
         return 'No milestones.';
-    const statusW = Math.max(...rows.map(r => r.status.length));
+    const stateW = Math.max(...rows.map(r => rowState(r).length));
     const healthW = Math.max(...rows.map(r => formatHealth(r.health).length));
     const dateW = Math.max(...rows.map(r => formatDate(r.targetDate).length));
     return rows
-        .map(r => `${r.status.padEnd(statusW)}  ${formatHealth(r.health).padEnd(healthW)}  ${formatDate(r.targetDate).padEnd(dateW)}  ${r.archivedAt ? `${(0, sanitize_1.sanitizeField)(r.name)} (archived)` : (0, sanitize_1.sanitizeField)(r.name)}`)
+        .map(r => `${rowState(r).padEnd(stateW)}  ${formatHealth(r.health).padEnd(healthW)}  ${formatDate(r.targetDate).padEnd(dateW)}  ${(0, sanitize_1.sanitizeField)(r.name)}`)
         .join('\n');
 }
 async function milestoneList(options) {

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

@@ -65,15 +65,25 @@ function formatMilestoneShow(m, tasks) {
         m.taskCounts.IN_PROGRESS +
         m.taskCounts.IN_REVIEW +
         m.taskCounts.DONE;
-    const statusLine = m.staleness?.statusDrift
-        ? `Status:       ${m.status}  (stale — task progress indicates ${(0, sanitize_1.sanitizeField)(m.staleness.statusDrift)}; auto-updating)`
-        : `Status:       ${m.status}`;
+    // LUM-714: state is derived, so the line reports what the two timestamps
+    // say — and, when the tasks disagree with the stored stamp, what the rollup
+    // is about to do about it.
+    const state = m.archivedAt
+        ? 'archived'
+        : m.completedAt
+            ? 'completed'
+            : 'active';
+    const drift = m.staleness?.completionDrift;
+    const stateLine = drift
+        ? `State:        ${state}  (stale — task progress indicates ${drift === 'complete' ? 'completed' : 'active'}; auto-updating)`
+        : `State:        ${state}`;
     const targetLine = m.staleness?.datesMissing
         ? `Target:       ${fmtDate(m.targetDate)}  (no target date — schedule health unavailable)`
         : `Target:       ${fmtDate(m.targetDate)}`;
     const lines = [
         `Milestone:    ${(0, sanitize_1.sanitizeField)(m.name)}`,
-        statusLine,
+        stateLine,
+        `Completed:    ${m.completedAt ? m.completedAt.slice(0, 10) : 'no'}`,
         `Archived:     ${m.archivedAt ? m.archivedAt.slice(0, 10) : 'no'}`,
         `Health:       ${fmtHealth(m.health)}`,
         `Start:        ${fmtDate(m.startDate)}`,
@@ -156,7 +166,7 @@ async function milestoneShow(identifier, opts) {
     process.stdout.write(formatMilestoneShow({
         id: milestone.id,
         name: milestone.name,
-        status: milestone.status,
+        completedAt: milestone.completedAt,
         startDate: milestone.startDate,
         targetDate: milestone.targetDate,
         archivedAt: milestone.archivedAt,

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeMilestoneStatus = normalizeMilestoneStatus;
 exports.normalizeTokenBudget = normalizeTokenBudget;
 exports.buildMilestoneUpdatePayload = buildMilestoneUpdatePayload;
 exports.formatMilestoneUpdateSummary = formatMilestoneUpdateSummary;
@@ -9,20 +8,6 @@ const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const resolve_1 = require("../lib/resolve");
 const sanitize_1 = require("../lib/sanitize");
-const ALLOWED_STATUSES = [
-    'PLANNED',
-    'ACTIVE',
-    'COMPLETED',
-    'CANCELLED',
-];
-function normalizeMilestoneStatus(value) {
-    if (!value)
-        return null;
-    const upper = value.toUpperCase().replace(/-/g, '_');
-    return ALLOWED_STATUSES.includes(upper)
-        ? upper
-        : null;
-}
 /**
  * LUM-644: '' clears the budget (→ null, the nullable-flag convention);
  * otherwise the value must be a positive integer within Postgres INT range.
@@ -49,10 +34,6 @@ function buildMilestoneUpdatePayload(opts) {
         payload.description = opts.description === '' ? null : opts.description;
         flagsGiven.push('--description');
     }
-    if (opts.status !== undefined) {
-        payload.status = opts.status;
-        flagsGiven.push('--status');
-    }
     if (opts.start !== undefined) {
         payload.startDate = opts.start === '' ? null : opts.start;
         flagsGiven.push('--start');
@@ -85,9 +66,6 @@ function formatMilestoneUpdateSummary(before, after) {
     if (after.description !== undefined) {
         changes.push(after.description === null ? 'description → ∅' : 'description updated');
     }
-    if (after.status !== undefined && after.status !== before.status) {
-        changes.push(`status ${before.status} → ${after.status}`);
-    }
     if (after.startDate !== undefined) {
         changes.push(`start → ${fmtDate(after.startDate)}`);
     }
@@ -102,28 +80,15 @@ function formatMilestoneUpdateSummary(before, after) {
     return `Updated milestone "${beforeName}": ${changes.join(', ')}`;
 }
 async function milestoneUpdate(identifier, opts) {
-    // Validate status flag eagerly.
-    let normalizedStatus;
-    if (opts.status !== undefined) {
-        const n = normalizeMilestoneStatus(opts.status);
-        if (!n) {
-            console.error(`Error: invalid status "${opts.status}". Allowed: planned, active, completed, cancelled`);
-            return 1;
-        }
-        normalizedStatus = n;
-    }
     // Validate token budget eagerly (LUM-644): positive integer, or '' to clear.
     if (opts.tokenBudget !== undefined &&
         normalizeTokenBudget(opts.tokenBudget) === undefined) {
         console.error(`Error: invalid token budget "${opts.tokenBudget}". Provide a positive integer (e.g. 5000000), or "" to clear.`);
         return 1;
     }
-    const { payload, flagsGiven } = buildMilestoneUpdatePayload({
-        ...opts,
-        ...(normalizedStatus !== undefined && { status: normalizedStatus }),
-    });
+    const { payload, flagsGiven } = buildMilestoneUpdatePayload(opts);
     if (flagsGiven.length === 0) {
-        console.error('Error: provide at least one field to update (--name, --description, --status, --start, --target, --token-budget)');
+        console.error('Error: provide at least one field to update (--name, --description, --start, --target, --token-budget)');
         return 1;
     }
     const creds = (0, config_1.readCredentials)();

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

@@ -64,7 +64,7 @@ function formatTaskContextMarkdown(data, now) {
         const target = data.task.milestone.targetDate
             ? `, target ${data.task.milestone.targetDate.slice(0, 10)}`
             : '';
-        lines.push(`**Milestone**: ${(0, sanitize_1.sanitizeField)(data.task.milestone.name)} (${data.task.milestone.status}${target})`);
+        lines.push(`**Milestone**: ${(0, sanitize_1.sanitizeField)(data.task.milestone.name)} (${data.task.milestone.state}${target})`);
         const milestoneGoal = data.task.milestone.description;
         if (milestoneGoal && milestoneGoal.trim().length > 0) {
             lines.push(`**Milestone goal**: ${(0, sanitize_1.sanitizeField)(milestoneGoal)}`);