@bli-cockpit/cli 0.2.238 → 0.2.239

package/dist/commands/cal-direct.js

@@ -0,0 +1,119 @@
+/**
+ * `cockpit cal duplicate | batch | undo` (BLI-21296, calendar slice 4): the
+ * terminal in front of the same doors the browser's grid uses. `batch` reads
+ * its changes as JSON on stdin; every verb takes `--idempotency-key` so a retry
+ * writes once, and `--json` prints the door's answer untouched.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+const TAG = "[cal cli]";
+const WRITE_DEADLINE_MS = 300_000;
+export async function runCalDirect(command, door) {
+    if (command.action === "duplicate")
+        return duplicate(command, door);
+    if (command.action === "batch")
+        return batch(command, door);
+    return undo(command, door);
+}
+function keyed(command) {
+    return {
+        ...(command.idempotencyKey ? { idempotency_key: command.idempotencyKey } : {}),
+        ...(command.reason ? { reason: command.reason } : {}),
+    };
+}
+function writeReceiptLines(door, receipt) {
+    if (receipt.event?.account_name)
+        writeLine(door.io.stdout, `Account: ${receipt.event.account_name}.`);
+    if (receipt.event?.event_id)
+        writeLine(door.io.stdout, `Tower event: ${receipt.event.event_id}`);
+    if (receipt.change_id)
+        writeLine(door.io.stdout, `Change: ${receipt.change_id} (undo with: cockpit cal undo ${receipt.change_id})`);
+    else
+        writeLine(door.io.stdout, "Google took the change but Tower could not record it in the ledger, so there is no change id to undo.");
+    if (receipt.event?.version)
+        writeLine(door.io.stdout, `Version: ${receipt.event.version}`);
+    if (receipt.replayed)
+        writeLine(door.io.stdout, "This key was used before: nothing new was written; this is the first receipt.");
+}
+async function duplicate(command, door) {
+    const answer = await askAgentDoor(door, {
+        method: "POST",
+        path: `/api/cal/events/${encodeURIComponent(command.subjectId ?? "")}/duplicate`,
+        label: "cal duplicate",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            ...(command.startsAt ? { starts_at: command.startsAt } : {}),
+            ...(command.endsAt ? { ends_at: command.endsAt } : {}),
+            ...(command.calendarId ? { calendar_id: command.calendarId } : {}),
+            ...(command.accountName ? { account: command.accountName } : {}),
+            ...(command.keepInvitees ? { keep_invitees: true } : {}),
+            ...keyed(command),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    const receipt = answer.body;
+    writeLine(door.io.stdout, `Duplicated "${receipt.event?.title ?? "the event"}". ${receipt.invitees === "kept" ? "The same guests were invited (Google emailed them)." : "No guests were invited."}`);
+    writeReceiptLines(door, receipt);
+    return 0;
+}
+async function readBatchBody(door) {
+    if (isInteractiveStdin(door.io))
+        return null;
+    try {
+        const parsed = JSON.parse(await readPipedText(door.io.stdin, { maxChars: 200_000, overflowMessage: "The batch is too large." }));
+        if (Array.isArray(parsed))
+            return { changes: parsed };
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function batch(command, door) {
+    const body = await readBatchBody(door);
+    if (!body || !Array.isArray(body.changes)) {
+        return failAgentDoor(door, TAG, "invalid_body", 'Pipe JSON: {"changes":[{"event_id":"…","starts_at":"…","ends_at":"…","expected_version":"…"}]} (or a bare array). Up to 25 changes, each event once.');
+    }
+    const answer = await askAgentDoor(door, {
+        method: "POST",
+        path: "/api/cal/events/batch",
+        label: "cal batch",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { ...body, ...keyed(command) },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const result = answer.body;
+    // A script must be able to tell "all of it" from "some of it" without parsing: exit 1 unless every item was written.
+    const code = result.outcome === "all_committed" ? 0 : 1;
+    if (door.json)
+        return emitAgentDoor(door, { ok: code === 0, ...result }, code);
+    for (const item of result.items) {
+        writeLine(door.io.stdout, `#${item.index + 1} ${item.event_id}: ${item.outcome}${item.reason ? ` (${item.reason})` : ""}${item.change_id ? ` change ${item.change_id}` : ""}`);
+    }
+    writeLine(door.io.stdout, `${result.committed} of ${result.items.length} changed (${result.outcome.replaceAll("_", " ")}).`);
+    if (result.unchanged.length > 0) {
+        writeLine(door.io.stdout, `Left as they were: ${result.unchanged.map((item) => `#${item.index + 1} ${item.event_id}`).join(", ")}.`);
+    }
+    return code;
+}
+async function undo(command, door) {
+    const answer = await askAgentDoor(door, {
+        method: "POST",
+        path: "/api/cal/undo",
+        label: "cal undo",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { ...(command.subjectId ? { change_id: command.subjectId } : {}), ...keyed(command) },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    const receipt = answer.body;
+    writeLine(door.io.stdout, `Undid change ${receipt.undoes_change_id}. The earlier values are back (or the created event is gone); guests, if any, were told by Google.`);
+    writeReceiptLines(door, receipt);
+    return 0;
+}

package/dist/commands/cal.js

@@ -25,6 +25,7 @@ import { runCalAddIcal, runCalDetach, runCalShare, runCalSync } from "./cal-cale
 import { runCalDetail } from "./cal-detail.js";
 import { runCalOverlay } from "./cal-overlay.js";
 import { runCalDelete } from "./cal-delete.js";
+import { runCalDirect } from "./cal-direct.js";
 import { runCalSyncStatus } from "./cal-sync-status.js";
 import { writeLine } from "./cli-io.js";
 import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
@@ -37,6 +38,10 @@ export async function runCal(command, io) {
         case "event":
         case "export":
             return runCalDetail(command, door);
+        case "duplicate":
+        case "batch":
+        case "undo":
+            return runCalDirect(command, door);
         case "conflicts":
         case "calendar-change":
             return runCalOverlay(command, door);
@@ -299,6 +304,8 @@ async function create(command, door) {
             ...(command.allDay ? { all_day: true } : {}),
             ...(command.attendees.length > 0 ? { attendees: command.attendees } : {}),
             ...(command.meet ? { meet: true } : {}),
+            ...(command.idempotencyKey ? { idempotency_key: command.idempotencyKey } : {}),
+            ...(command.reason ? { reason: command.reason } : {}),
             time_zone: command.timeZone ?? localTimeZone(),
         },
     });
@@ -340,11 +347,28 @@ function meetingLinkText(event) {
 }
 async function changeEvent(command, door) {
     const answer = await askAgentDoor(door, { path: `/api/cal/events/${encodeURIComponent(command.subjectId)}`, method: "PATCH", label: "cal change", timeoutMs: WRITE_DEADLINE_MS,
-        body: { ...(command.accountName ? { account: command.accountName } : {}), ...(command.title ? { title: command.title } : {}), ...(command.startsAt ? { starts_at: command.startsAt } : {}), ...(command.endsAt ? { ends_at: command.endsAt } : {}), ...(command.location ? { location: command.location } : {}) } });
+        body: {
+            ...(command.accountName ? { account: command.accountName } : {}),
+            ...(command.title ? { title: command.title } : {}),
+            ...(command.startsAt ? { starts_at: command.startsAt } : {}),
+            ...(command.endsAt ? { ends_at: command.endsAt } : {}),
+            ...(command.location ? { location: command.location } : {}),
+            // BLI-21296: all-day conversion either way, and the write controls.
+            ...(command.allDay ? { all_day: true } : command.timed ? { all_day: false } : {}),
+            ...(command.timeZone && (command.allDay || command.timed) ? { time_zone: command.timeZone } : {}),
+            ...(command.expectedVersion ? { expected_version: command.expectedVersion } : {}),
+            ...(command.idempotencyKey ? { idempotency_key: command.idempotencyKey } : {}),
+            ...(command.reason ? { reason: command.reason } : {}),
+        } });
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     if (door.json)
         return emitAgentDoor(door, { ok: true, ...answer.body });
-    writeLine(door.io.stdout, `Changed event in ${answer.body.event?.account_name ?? "its account"}.`);
+    const changed = answer.body;
+    writeLine(door.io.stdout, `Changed event in ${changed.event?.account_name ?? "its account"}.`);
+    if (changed.change_id)
+        writeLine(door.io.stdout, `Change: ${changed.change_id} (undo with: cockpit cal undo ${changed.change_id})`);
+    if (changed.version)
+        writeLine(door.io.stdout, `Version: ${changed.version}`);
     return 0;
 }

package/dist/commands/docs.js

@@ -27,6 +27,7 @@
  * `document_not_writable`, `title_too_long`, `content_too_long`,
  * `circular_parent`, and so on — never rephrased here.
  */
+import { randomUUID } from "node:crypto";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { readDoc } from "./docs-read.js";
@@ -59,6 +60,8 @@ export async function runDocs(command, io) {
             return syncStatusDocs(command, door);
         case "export":
             return exportDoc(command, door);
+        case "mutation-status":
+            return mutationStatusDocs(command, door);
     }
 }
 /** `--parent`, `--query`, `--word`, `--limit`, `--bodies` (BLI-10450) as the door's own query parameters (BLI-3737). */
@@ -248,14 +251,41 @@ async function updateDoc(command, door) {
         && !command.clearParent) {
         return failAgentDoor(door, TAG, "invalid_body", "docs update needs at least one of --title, --visibility, --parent/--clear-parent, or a body on --body-stdin/--file.");
     }
-    const answer = await updateDocument(command, door, resolved.id, bodyMarkdown);
+    // BLI-21298: every save carries a request id, so a lost response can be checked and a retry applies once.
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision })}`);
+    const answer = await updateDocument(command, door, resolved.id, bodyMarkdown, requestId);
+    if (!answer.ok)
+        return refuseDocsWrite(door, answer, requestId);
+    const { document = {}, mutation } = answer.body;
+    writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ document_id: document["id"] ?? resolved.id, request_id: requestId, revision: mutation?.["revision"] ?? document["revision"] })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, document, mutation });
+    writeLine(door.io.stdout, `Updated ${String(document["title"] ?? "")} (${String(document["id"] ?? resolved.id)}), revision ${String(mutation?.["revision"] ?? document["revision"] ?? "?")}.`);
+    return 0;
+}
+/** Says where the save stands, then fails with the door's own reason (a conflict names the current revision). */
+function refuseDocsWrite(door, answer, requestId) {
+    const mutation = answer.body?.mutation;
+    writeLine(door.io.stderr, `${TAG} check the save with cockpit docs mutation-status ${requestId}; retry unchanged input with --request-id ${requestId}.`);
+    if (mutation?.current) {
+        writeLine(door.io.stderr, `${TAG} conflict ${JSON.stringify({ request_id: requestId, current_revision: mutation.current.revision ?? mutation.revision })}`);
+    }
+    return failAgentDoor(door, TAG, answer.reason, answer.detail, mutation ? { mutation } : {});
+}
+/** BLI-21298: reads only your own save receipt. A missing receipt is unknown_check_again, never "nothing changed". */
+async function mutationStatusDocs(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/docs/mutations/${encodeURIComponent(command.docRef ?? "")}`,
+        method: "GET",
+        label: "docs mutation status",
+        timeoutMs: READ_DEADLINE_MS,
+    });
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const document = answer.body.document ?? {};
-    writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ document_id: document["id"] ?? resolved.id })}`);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, document });
-    writeLine(door.io.stdout, `Updated ${String(document["title"] ?? "")} (${String(document["id"] ?? resolved.id)}).`);
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    writeLine(door.io.stdout, JSON.stringify(answer.body));
     return 0;
 }
 /**
@@ -327,13 +357,15 @@ async function deleteOneDocument(door, ref, id) {
         return { ref, ok: false, reason: answer.reason, detail: answer.detail };
     return { ref, ok: true, id };
 }
-async function updateDocument(command, door, documentId, bodyMarkdown) {
+async function updateDocument(command, door, documentId, bodyMarkdown, requestId) {
     return askAgentDoor(door, {
         path: `/api/docs/documents/${encodeURIComponent(documentId)}`,
         method: "PATCH",
         label: "docs update",
         timeoutMs: WRITE_DEADLINE_MS,
         body: {
+            request_id: requestId,
+            ...(command.expectedRevision !== undefined ? { expected_revision: command.expectedRevision } : {}),
             ...(command.title !== undefined ? { title: command.title } : {}),
             ...(bodyMarkdown !== undefined ? { body_markdown: bodyMarkdown } : {}),
             ...(command.visibility !== undefined ? { visibility: command.visibility } : {}),

package/dist/commands/issue-versions.js

@@ -0,0 +1,93 @@
+import { randomUUID } from "node:crypto";
+/**
+ * `cockpit ticket versions <id>` and `cockpit ticket restore <id> --version <n>`
+ * (BLI-21300): the saved descriptions of one ticket, and the write that puts an
+ * older one back as a NEW version. Same doors the browser uses
+ * (`GET .../versions`, `POST .../versions/restore`).
+ *
+ * `restore` takes the version NUMBER the person read in `versions`, looks up
+ * that version's id in the same list, and sends the id: the door never guesses
+ * "the previous one". A number the list does not carry is refused here with
+ * the numbers that do exist, before anything is written.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { READ_DEADLINE_MS, TAG, WRITE_DEADLINE_MS } from "./issue-contracts.js";
+export async function listIssueVersions(command, door) {
+    const ref = command.issueRef ?? "";
+    const query = command.limit === undefined ? "" : `?limit=${command.limit}`;
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/versions${query}`,
+        method: "GET",
+        label: "issue versions",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const versions = answer.body.versions ?? [];
+    console.error(`${TAG} versions ${JSON.stringify({ count: versions.length })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, versions });
+    if (versions.length === 0) {
+        writeLine(door.io.stdout, `No saved description versions for ${ref}.`);
+        return 0;
+    }
+    for (const row of versions) {
+        const from = row.restored_from_version ? ` (restored from ${row.restored_from_version})` : "";
+        writeLine(door.io.stdout, `v${row.version}  ${row.id}  ${row.created_at}  ${row.source}${from}  ${row.markdown.length} chars`);
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${versions.length} version(s), newest first. Restore one with: cockpit ticket restore ${ref} --version <n>`);
+    return 0;
+}
+export async function restoreIssueVersion(command, door) {
+    const ref = command.issueRef ?? "";
+    const wanted = command.versionNumber;
+    const listed = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/versions?limit=500`,
+        method: "GET",
+        label: "issue versions",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!listed.ok)
+        return failAgentDoor(door, TAG, listed.reason, listed.detail);
+    const versions = listed.body.versions ?? [];
+    const chosen = versions.find(row => row.version === wanted);
+    if (!chosen) {
+        const have = versions.map(row => row.version).join(", ") || "none";
+        console.error(`${TAG} restore refused ${JSON.stringify({ reason: "version_not_found", requested: wanted ?? null, available: versions.length })}`);
+        return failAgentDoor(door, TAG, "version_not_found", `${ref} has no version ${wanted}. Versions: ${have}.`);
+    }
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision, version: chosen.version })}`);
+    let answer;
+    try {
+        answer = await askAgentDoor(door, {
+            path: `/api/work/issues/${encodeURIComponent(ref)}/versions/restore`,
+            method: "POST",
+            label: "issue restore",
+            timeoutMs: WRITE_DEADLINE_MS,
+            body: { request_id: requestId, expected_revision: command.expectedRevision, version_id: chosen.id },
+        });
+    }
+    catch {
+        console.error(`${TAG} response lost`, JSON.stringify({ reason: "mutation_unknown" }));
+        writeLine(door.io.stderr, `${TAG} check local commit with cockpit ticket mutation-status ${requestId}; retry unchanged input with --request-id ${requestId}.`);
+        return failAgentDoor(door, TAG, "mutation_unknown", "Result unknown. Check this request ID before retrying with identical input.");
+    }
+    if (!answer.ok) {
+        writeLine(door.io.stderr, `${TAG} check local commit with cockpit ticket mutation-status ${requestId}; retry unchanged input with --request-id ${requestId}.`);
+        const mutation = answer.body?.mutation ?? { request_id: requestId, outcome: "unknown_check_again" };
+        if (door.json)
+            return emitAgentDoor(door, { ok: false, error: answer.reason, detail: answer.detail, mutation }, 1);
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    }
+    const body = answer.body;
+    const newVersion = body.mutation?.description_version;
+    writeLine(door.io.stderr, `${TAG} restored ${JSON.stringify({ restored_version: chosen.version, new_version: newVersion ?? null })}`);
+    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issue: body.issue, mutation: body.mutation });
+    writeLine(door.io.stdout, `Restored version ${chosen.version} of ${ref} as new version ${newVersion ?? "?"}.`);
+    return 0;
+}

package/dist/commands/issue.js

@@ -33,6 +33,7 @@ import { readTicketBoard } from "./tickets-board.js";
 import { showIssue } from "./issue-show.js";
 import { READ_DEADLINE_MS, TAG, resolveProjectId, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
 import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
+import { listIssueVersions, restoreIssueVersion } from "./issue-versions.js";
 export async function runIssue(command, io) {
     const door = await openAgentDoor("issue", command, io);
     switch (command.action) {
@@ -62,6 +63,10 @@ export async function runIssue(command, io) {
             return commentIssue(command, door);
         case "history":
             return issueHistory(command, door);
+        case "versions":
+            return listIssueVersions(command, door);
+        case "restore":
+            return restoreIssueVersion(command, door);
     }
 }
 function issueLine(issue, directory) {

package/dist/commands/local-args-tower-cal.js

@@ -20,7 +20,7 @@
  */
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
 const CAL_ACTIONS = new Set([
-    "event", "export", "conflicts", "calendar-change",
+    "event", "export", "duplicate", "batch", "undo", "conflicts", "calendar-change",
     "today",
     "week",
     "next",
@@ -36,9 +36,9 @@ const CAL_ACTIONS = new Set([
     "delete",
 ]);
 /** Every verb that names ONE thing first — a calendar id, or (delete) an event id. */
-const CAL_ACTIONS_NEEDING_A_SUBJECT = new Set(["event", "export", "calendar-change", "sync", "detach", "share", "delete", "change", "cancel"]);
+const CAL_ACTIONS_NEEDING_A_SUBJECT = new Set(["event", "export", "duplicate", "calendar-change", "sync", "detach", "share", "delete", "change", "cancel"]);
 /** `sync-status [<calendar id>]` — every calendar, or one's. Ticket 10730. */
-const CAL_ACTIONS_WITH_OPTIONAL_SUBJECT = new Set(["sync-status"]);
+const CAL_ACTIONS_WITH_OPTIONAL_SUBJECT = new Set(["sync-status", "undo"]);
 const CAL_ALLOWED_FLAGS = [
     "--home",
     "--dashboard-url",
@@ -60,12 +60,17 @@ const CAL_ALLOWED_FLAGS = [
     "--location",
     "--attendee",
     "--all-day",
+    "--timed",
+    "--keep-invitees",
     "--meet",
     "--org-visible",
     "--private",
     "--full",
     "--yes",
     "--json",
+    "--idempotency-key",
+    "--expected-version",
+    "--reason",
 ];
 const CAL_VALUE_FLAGS = [
     "--home",
@@ -86,6 +91,9 @@ const CAL_VALUE_FLAGS = [
     "--until",
     "--location",
     "--attendee",
+    "--idempotency-key",
+    "--expected-version",
+    "--reason",
 ];
 export function parseCalArgs(args) {
     const values = parseNamedArgs(args, { allowedFlags: CAL_ALLOWED_FLAGS, valueFlags: CAL_VALUE_FLAGS });
@@ -104,7 +112,7 @@ function readCalAction(values) {
     const first = values.positionals[0];
     const action = (first === undefined ? "today" : first);
     if (!CAL_ACTIONS.has(action)) {
-        throw new Error(`Unknown cal command: ${first}. Try today, week, conflicts, calendar-change, next, find, calendars, add-ical, create, share, detach, sync, sync-status, or delete.`);
+        throw new Error(`Unknown cal command: ${first}. Try today, week, conflicts, calendar-change, next, find, calendars, add-ical, create, duplicate, batch, undo, share, detach, sync, sync-status, or delete.`);
     }
     return { action, rest: values.positionals.slice(first === undefined ? 0 : 1) };
 }
@@ -114,8 +122,8 @@ function readCalSubjectOrQuery(action, rest) {
     if (CAL_ACTIONS_NEEDING_A_SUBJECT.has(action)) {
         subject = optionalNonEmpty(rest[0]);
         if (!subject) {
-            throw new Error(action === "delete"
-                ? "cal delete needs an event id — take one from a window verb's output (today/week/next/find)."
+            throw new Error(action === "delete" || action === "duplicate"
+                ? `cal ${action} needs an event id — take one from a window verb's output (today/week/next/find).`
                 : `cal ${action} needs a calendar id — take one from \`cockpit cal calendars\`.`);
         }
         if (rest.length > 1)
@@ -201,6 +209,11 @@ function buildCalCommand(values, action, subject, query, title, startsAt, endsAt
         location: optionalNonEmpty(values.flags.get("--location")),
         attendees: splitAddresses(values.flags.get("--attendee")),
         allDay: values.booleans.has("--all-day"),
+        timed: values.booleans.has("--timed"),
+        keepInvitees: values.booleans.has("--keep-invitees"),
+        idempotencyKey: optionalNonEmpty(values.flags.get("--idempotency-key")),
+        expectedVersion: optionalNonEmpty(values.flags.get("--expected-version")),
+        reason: optionalNonEmpty(values.flags.get("--reason")),
         meet: values.booleans.has("--meet"),
         orgVisible: values.booleans.has("--org-visible"),
         makePrivate: values.booleans.has("--private"),

package/dist/commands/local-args-tower-docs-msg.js

@@ -8,13 +8,14 @@
  */
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
 import { parseDocsExportFlags } from "./local-args-docs-export.js";
-const DOCS_ACTIONS = new Set(["list", "tree", "read", "create", "update", "delete", "link", "sync-status", "export"]);
+const DOCS_ACTIONS = new Set(["list", "tree", "read", "create", "update", "delete", "link", "sync-status", "export", "mutation-status"]);
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 // BLI-10450: `read` moved to its own branch in `parseDocsDocumentReference` —
 // it takes SEVERAL references now, so it no longer shares the "exactly one"
 // rule `update`/`link` still enforce. BLI‑10555: `delete` takes several too
 // (the same door, called once per ref), so it joined `read`'s branch rather
 // than this set.
-const DOCS_ACTIONS_NEEDING_A_DOC = new Set(["update", "link", "export"]);
+const DOCS_ACTIONS_NEEDING_A_DOC = new Set(["update", "link", "export", "mutation-status"]);
 const DOCS_ALLOWED_FLAGS = [
     "--home",
     "--dashboard-url",
@@ -22,6 +23,8 @@ const DOCS_ALLOWED_FLAGS = [
     "--parent",
     "--clear-parent",
     "--allow-empty",
+    "--expected-revision",
+    "--request-id",
     "--visibility",
     "--file",
     "--body-stdin",
@@ -41,6 +44,8 @@ const DOCS_VALUE_FLAGS = [
     "--dashboard-url",
     "--title",
     "--parent",
+    "--expected-revision",
+    "--request-id",
     "--visibility",
     "--file",
     "--query",
@@ -55,15 +60,18 @@ export function parseDocsArgs(args) {
     const { action, rest } = parseDocsAction(values.positionals);
     const link = parseDocsLink(action, rest, values.booleans.has("--clear"));
     const { docRef, docRefs } = parseDocsDocumentReference(action, link.rest);
-    const { visibility, clearParent, parentId, allowEmpty, title, query, wholeWord, limit, bodies, section, offset } = parseDocsFlags(action, values);
+    const { visibility, clearParent, parentId, allowEmpty, title, requestId, expectedRevision, query, wholeWord, limit, bodies, section, offset } = parseDocsFlags(action, values);
     if (action === "read")
         validateDocsReadTargets(docRefs, parentId, bodies);
+    if (action === "mutation-status" && !UUID_PATTERN.test(docRef ?? "")) {
+        throw new Error("docs mutation-status needs a request UUID (the --request-id you sent, or the one `docs update` printed).");
+    }
     // BLI‑10555: `delete` needs no `--parent`/`--bodies` shape, only at least
     // one reference — `read`'s emptier validation does not apply.
     if (action === "delete" && (!docRefs || docRefs.length === 0)) {
         throw new Error("docs delete needs one or more document ids/slugs.");
     }
-    return buildDocsCommand(values, action, docRef, docRefs, visibility, clearParent, parentId, allowEmpty, title, query, wholeWord, limit, bodies, section, offset, link);
+    return buildDocsCommand(values, action, docRef, docRefs, visibility, clearParent, parentId, allowEmpty, title, query, wholeWord, limit, bodies, section, offset, link, { requestId, expectedRevision });
 }
 /**
  * BLI-10450: `read` takes either several document references OR
@@ -115,7 +123,7 @@ function parseDocsAction(positionals) {
     const first = positionals[0];
     const action = (first === undefined ? "list" : first);
     if (!DOCS_ACTIONS.has(action)) {
-        throw new Error(`Unknown docs command: ${first}. Try list, tree, read, create, update, delete, link, sync-status, or export.`);
+        throw new Error(`Unknown docs command: ${first}. Try list, tree, read, create, update, delete, link, sync-status, export, or mutation-status.`);
     }
     return { action, rest: positionals.slice(first === undefined ? 0 : 1) };
 }
@@ -173,11 +181,19 @@ function parseDocsWriteFlags(action, values) {
     if (allowEmpty && action !== "update") {
         throw new Error("--allow-empty belongs to `cockpit docs update`.");
     }
+    // BLI-21298: the write-safety pair belongs to `update`, like the other save-shaping flags.
+    if ((values.flags.has("--request-id") || values.flags.has("--expected-revision")) && action !== "update") {
+        throw new Error("--request-id and --expected-revision belong to `cockpit docs update`.");
+    }
+    const requestId = optionalNonEmpty(values.flags.get("--request-id"));
+    if (requestId && !UUID_PATTERN.test(requestId))
+        throw new Error("--request-id must be a UUID.");
+    const expectedRevision = optionalPositiveInteger(values.flags.get("--expected-revision"), "--expected-revision");
     const title = optionalNonEmpty(values.flags.get("--title"));
     if (action === "create" && !title) {
         throw new Error("docs create needs --title.");
     }
-    return { visibility, clearParent, parentId, allowEmpty, title };
+    return { visibility, clearParent, parentId, allowEmpty, title, requestId, expectedRevision };
 }
 /** The flags that narrow or slice what a list or read returns. */
 function parseDocsReadFlags(action, values) {
@@ -226,7 +242,7 @@ function parseDocsOffset(raw) {
         throw new Error("--offset must be a whole number 0 or greater.");
     return offset;
 }
-function buildDocsCommand(values, action, docRef, docRefs, visibility, clearParent, parentId, allowEmpty, title, query, wholeWord, limit, bodies, section, offset, link) {
+function buildDocsCommand(values, action, docRef, docRefs, visibility, clearParent, parentId, allowEmpty, title, query, wholeWord, limit, bodies, section, offset, link, safety) {
     return {
         kind: "docs",
         action,
@@ -238,6 +254,8 @@ function buildDocsCommand(values, action, docRef, docRefs, visibility, clearPare
         ...(parentId ? { parentId } : {}),
         clearParent,
         ...(allowEmpty ? { allowEmpty } : {}),
+        ...(safety.requestId ? { requestId: safety.requestId } : {}),
+        ...(safety.expectedRevision === undefined ? {} : { expectedRevision: safety.expectedRevision }),
         visibility: visibility,
         filePath: optionalNonEmpty(values.flags.get("--file")),
         bodyStdin: values.booleans.has("--body-stdin"),

package/dist/commands/local-args-tower-msg.js

@@ -1,6 +1,6 @@
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
-const MSG_ACTIONS = new Set(["channels", "read", "send", "thread", "create", "dm", "show"]);
-const MSG_ACTIONS_NEEDING_A_CHANNEL = new Set(["read", "send"]);
+const MSG_ACTIONS = new Set(["channels", "read", "send", "thread", "create", "dm", "show", "unread"]);
+const MSG_ACTIONS_NEEDING_A_CHANNEL = new Set(["read", "send", "unread"]);
 /**
  * `--members a@x.test,b@y.test` — addresses only, split on commas, never
  * fuzzy (BLI-3749). The door resolves each one exactly, so a typo comes back
@@ -35,24 +35,40 @@ export function parseMsgArgs(args) {
             "--private",
             "--members",
             "--description",
+            "--from",
+            "--mark-read",
             "--json",
         ],
-        valueFlags: ["--home", "--dashboard-url", "--channel", "--thread", "--limit", "--members", "--description", "--before"],
+        valueFlags: ["--home", "--dashboard-url", "--channel", "--thread", "--limit", "--members", "--description", "--before", "--from"],
     });
     const { action, rest } = parseMsgAction(values.positionals);
     if (values.flags.has("--before") && action !== "read" && action !== "thread") {
         throw new Error("--before belongs to msg read or msg thread.");
     }
+    const { markRead, unreadFrom } = parseMsgReadLineFlags(action, values);
     const { channelName, dmEmail } = parseMsgCreateTarget(action, rest);
     const { isPrivate, memberEmails, description } = parseMsgCreateFlags(action, values);
     const { channelRef, threadId, limit } = parseMsgReadTarget(action, rest, values);
-    return buildMsgCommand(values, action, channelRef, channelName, dmEmail, memberEmails, description, isPrivate, threadId, limit);
+    return buildMsgCommand(values, action, channelRef, channelName, dmEmail, memberEmails, description, isPrivate, threadId, limit, markRead, unreadFrom);
+}
+/** `read --mark-read` and `unread --from <message-id>` (BLI-21299): the read line, moved on purpose. */
+function parseMsgReadLineFlags(action, values) {
+    const markRead = values.booleans.has("--mark-read");
+    if (markRead && action !== "read")
+        throw new Error("--mark-read belongs to `cockpit msg read`.");
+    const unreadFrom = optionalNonEmpty(values.flags.get("--from"));
+    if (action === "unread" && !unreadFrom) {
+        throw new Error("msg unread needs --from <message-id>, e.g. `cockpit msg unread general --from <message-id>`.");
+    }
+    if (unreadFrom && action !== "unread")
+        throw new Error("--from belongs to `cockpit msg unread`.");
+    return { markRead, unreadFrom };
 }
 function parseMsgAction(positionals) {
     const first = positionals[0];
     const action = (first === undefined ? "channels" : first);
     if (!MSG_ACTIONS.has(action)) {
-        throw new Error(`Unknown msg command: ${first}. Try channels, read, send, thread, create, dm, or show.`);
+        throw new Error(`Unknown msg command: ${first}. Try channels, read, unread, send, thread, create, dm, or show.`);
     }
     return { action, rest: positionals.slice(first === undefined ? 0 : 1) };
 }
@@ -129,7 +145,7 @@ function parseMsgReadTarget(action, rest, values) {
     }
     return { channelRef, threadId, limit };
 }
-function buildMsgCommand(values, action, channelRef, channelName, dmEmail, memberEmails, description, isPrivate, threadId, limit) {
+function buildMsgCommand(values, action, channelRef, channelName, dmEmail, memberEmails, description, isPrivate, threadId, limit, markRead, unreadFrom) {
     return {
         kind: "msg",
         action,
@@ -144,6 +160,8 @@ function buildMsgCommand(values, action, channelRef, channelName, dmEmail, membe
         isPrivate,
         ...(threadId ? { threadId } : {}),
         ...(limit === undefined ? {} : { limit }),
+        ...(markRead ? { markRead } : {}),
+        ...(unreadFrom ? { unreadFrom } : {}),
         json: values.booleans.has("--json"),
     };
 }

package/dist/commands/local-args-tower-setup.js

@@ -1,13 +1,20 @@
 import { optionalNonEmpty, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
 export function parseSetupArgs(args) {
-    const values = parseNamedArgs(args, { allowedFlags: ["--person", "--compare", "--since", "--details", "--json", "--home", "--dashboard-url"], valueFlags: ["--since", "--person", "--compare", "--home", "--dashboard-url"] });
+    const values = parseNamedArgs(args, { allowedFlags: ["--until", "--machines", "--person", "--compare", "--since", "--details", "--json", "--home", "--dashboard-url"], valueFlags: ["--until", "--since", "--person", "--compare", "--home", "--dashboard-url"] });
     if (values.positionals.length)
         throw new Error("setup takes --person or --compare, not a subcommand.");
     const compare = optionalNonEmpty(values.flags.get("--compare"));
     if (compare && (compare.split(",").length !== 2 || compare.split(",").some(value => !value.trim())))
         throw new Error("--compare takes two people (first names or emails) separated by a comma.");
     const since = optionalNonEmpty(values.flags.get("--since"));
-    if (since && since !== "7d" && since !== "30d" && (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z)?$/.test(since) || !Number.isFinite(Date.parse(since)) || new Date(since).toISOString().slice(0, 10) !== since.slice(0, 10) || Date.parse(since) >= Date.now()))
-        throw new Error("--since takes 7d, 30d, or an ISO date before now.");
-    return { kind: "setup", since, details: values.booleans.has("--details"), person: optionalNonEmpty(values.flags.get("--person")), compare, json: values.booleans.has("--json"), homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")) };
+    const until = optionalNonEmpty(values.flags.get("--until"));
+    const validDate = (value) => /^\d{4}-\d{2}-\d{2}(?:T.*)?$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) === value.slice(0, 10);
+    const end = until ? Date.parse(until) : Date.now();
+    const duration = since ? /^([1-9]\d*)([dh])$/.exec(since) : null;
+    const start = duration ? end - Number(duration[1]) * (duration[2] === "d" ? 86400000 : 3600000) : since ? Date.parse(since) : end - 30 * 86400000;
+    if (!Number.isFinite(end) || !Number.isFinite(start) || start >= end || (until && !validDate(until)) ||
+        (duration && Number(duration[1]) > (duration[2] === "d" ? 365 : 8760)) ||
+        (since && !duration && !validDate(since)))
+        throw new Error("--since takes a duration (1d, 7d, 30d, 90d) or an absolute start; --until takes an absolute end after the start.");
+    return { kind: "setup", since, until, machines: values.booleans.has("--machines"), details: values.booleans.has("--details"), person: optionalNonEmpty(values.flags.get("--person")), compare, json: values.booleans.has("--json"), homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")) };
 }

package/dist/commands/local-args-tower-work.js

@@ -27,6 +27,8 @@ const ISSUE_ACTIONS = new Set([
     "move",
     "comment",
     "history",
+    "versions",
+    "restore",
 ]);
 /** Every verb except `list` and `create` names ONE issue first. */
 const ISSUE_ACTIONS_NEEDING_AN_ISSUE = new Set([
@@ -36,6 +38,8 @@ const ISSUE_ACTIONS_NEEDING_AN_ISSUE = new Set([
     "move",
     "comment",
     "history",
+    "versions",
+    "restore",
 ]);
 /**
  * The closed state vocabulary, copied verbatim from
@@ -63,6 +67,7 @@ const ISSUE_ALLOWED_FLAGS = [
     "--size",
     "--parent",
     "--file",
+    "--version",
     "--body-stdin",
     "--json",
 ];
@@ -82,6 +87,7 @@ const ISSUE_VALUE_FLAGS = [
     "--size",
     "--parent",
     "--file",
+    "--version",
 ];
 export function parseIssueArgs(args) {
     const values = parseNamedArgs(args, {
@@ -96,8 +102,8 @@ export function parseIssueArgs(args) {
         throw new Error("--request-id must be a UUID.");
     if (action === "mutation-status" && !UUID_PATTERN.test(issueRef ?? ""))
         throw new Error("mutation-status needs a request UUID.");
-    if ((requestId || expectedRevision !== undefined) && !["create", "update", "move", "comment"].includes(action)) {
-        throw new Error("Write-safety flags belong to create, update, move or comment.");
+    if ((requestId || expectedRevision !== undefined) && !["create", "update", "move", "comment", "restore"].includes(action)) {
+        throw new Error("Write-safety flags belong to create, update, move, comment or restore.");
     }
     validateIssueState(moveState, "issue move state must be one of: ");
     const stateFilter = readIssueStateFilter(action, values);
@@ -112,13 +118,14 @@ export function parseIssueArgs(args) {
     const estimate = readIssueSize(values);
     const assignee = readIssueAssignee(action, values);
     const limit = readIssueLimit(action, values);
-    return buildIssueCommand(values, action, issueRef, issueRefs, moveState, stateFilter, title, priority, estimate, assignee, limit);
+    const versionNumber = readIssueVersion(action, values);
+    return buildIssueCommand(values, action, issueRef, issueRefs, moveState, stateFilter, title, priority, estimate, assignee, limit, versionNumber);
 }
 function readIssueAction(values) {
     const first = values.positionals[0];
     const action = (first === undefined ? "list" : first);
     if (!ISSUE_ACTIONS.has(action)) {
-        throw new Error(`Unknown issue command: ${first}. Try board, list, show, create, update, move, comment, history, or mutation-status.`);
+        throw new Error(`Unknown issue command: ${first}. Try board, list, show, create, update, move, comment, history, versions, restore, or mutation-status.`);
     }
     return { action, rest: values.positionals.slice(first === undefined ? 0 : 1) };
 }
@@ -206,14 +213,24 @@ function readIssueAssignee(action, values) {
     }
     return assignee;
 }
+/** `restore` names the version it wants; there is no "restore the previous one" (BLI-21300). */
+function readIssueVersion(action, values) {
+    const version = optionalPositiveInteger(values.flags.get("--version"), "--version");
+    if (action === "restore" && version === undefined) {
+        throw new Error("issue restore needs --version <n>; list them with `cockpit ticket versions <id>`.");
+    }
+    if (version !== undefined && action !== "restore")
+        throw new Error("--version belongs to `cockpit ticket restore`.");
+    return version;
+}
 function readIssueLimit(action, values) {
     const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
-    if (limit !== undefined && action !== "list" && action !== "history") {
-        throw new Error("--limit belongs to `cockpit issue list` or `cockpit issue history`.");
+    if (limit !== undefined && action !== "list" && action !== "history" && action !== "versions") {
+        throw new Error("--limit belongs to `cockpit issue list`, `history` or `versions`.");
     }
     return limit;
 }
-function buildIssueCommand(values, action, issueRef, issueRefs, moveState, stateFilter, title, priority, estimate, assignee, limit) {
+function buildIssueCommand(values, action, issueRef, issueRefs, moveState, stateFilter, title, priority, estimate, assignee, limit, versionNumber) {
     return {
         kind: "issue",
         requestId: optionalNonEmpty(values.flags.get("--request-id")),
@@ -230,6 +247,7 @@ function buildIssueCommand(values, action, issueRef, issueRefs, moveState, state
         rows: optionalNonEmpty(values.flags.get("--rows")),
         project: optionalNonEmpty(values.flags.get("--project")),
         ...(limit === undefined ? {} : { limit }),
+        ...(versionNumber === undefined ? {} : { versionNumber }),
         title,
         ...(priority === undefined ? {} : { priority }),
         ...(estimate === undefined ? {} : { estimate }),

package/dist/commands/local-help-commands-tower.js

@@ -47,7 +47,7 @@ export const TOWER_COMMAND_HELP = [
     [
         "docs",
         [
-            "Usage: cockpit docs [list|tree|read <id|slug> [<id|slug>...]|read --parent <id> --bodies|create|update <id>|delete <id|slug> [<id|slug>...]|link <id|slug> <notion-page>|sync-status [<id|slug>]|export <id|slug> [--format md|pdf|docx|txt] [--out <path>]] [flags]",
+            "Usage: cockpit docs [list|tree|read <id|slug> [<id|slug>...]|read --parent <id> --bodies|create|update <id>|delete <id|slug> [<id|slug>...]|link <id|slug> <notion-page>|sync-status [<id|slug>]|export <id|slug> [--format md|pdf|docx|txt] [--out <path>]|mutation-status <request-uuid>] [flags]",
             "",
             "The Tower document library, typed. Bare `cockpit docs` lists every document you may read.",
             "list [--parent <id>|root] [--query <text> [--word]] [--limit <n>] — every document you may see: id, visibility, body size, slug, title. Metadata only — a list never carries a body, so it stays cheap enough for an agent to call (--json was 604 KB for 155 documents before BLI-3737, and is now a few tens of KB). --json shape: { documents: [{ id, slug, title, visibility, parent_id, source, updated_at, body_chars }] }.",
@@ -62,7 +62,10 @@ export const TOWER_COMMAND_HELP = [
             "  --json shape: one ref answers { document }, unchanged from before BLI-10450. Several refs answer { documents: [{ ref, ok, document } | { ref, ok: false, error, detail }] }.",
             "read --parent <id>|root --bodies [--limit <n>] — every document filed directly under that parent, bodies included, in ONE call (GET /api/docs/documents?parent_id=...&bodies=true). --limit here caps the DOCUMENT COUNT (1-50), not characters. --json shape: { documents: [{ id, ..., body_markdown }] }.",
             "create --title \"<title>\" [--parent <id>] [--visibility org|private] [--file <path>|--body-stdin] — the body comes from --file, or stdin (`cat body.md | cockpit docs create --title \"...\"`); neither means an empty body, matching the browser's own default. --json shape: { document }.",
-            "update <id|slug> [--title \"<t>\"] [--visibility org|private] [--parent <id>|--clear-parent] [--file <path>|--body-stdin] [--allow-empty] — only the fields you pass change; a `--parent` change IS a move, there is no separate move verb. --json shape: { document }.",
+            "update <id|slug> [--title \"<t>\"] [--visibility org|private] [--parent <id>|--clear-parent] [--file <path>|--body-stdin] [--allow-empty] [--expected-revision <n>] [--request-id <uuid>] — only the fields you pass change; a `--parent` change IS a move, there is no separate move verb. --json shape: { document, mutation }.",
+            "  --expected-revision <n> is the page revision you read (`docs read --json` shows document.revision). The save is one atomic step: if someone saved since, nothing is written and you get revision_conflict with the current page (--json: mutation.current). Omit it for an unconditional save. Every save advances the revision.",
+            "  --request-id <uuid> makes a retry apply once (minted and printed when absent). Reusing it with different input is request_id_reused. If the response is lost, run `cockpit docs mutation-status <uuid>`, then retry the SAME input with the SAME id.",
+            "mutation-status <request-uuid> — your own save receipt: committed (with the stored revision), not_committed (with the reason) or unknown_check_again (no receipt yet; it never proves nothing changed). --json shape: { mutation }.",
             "  --allow-empty clears the page on purpose. A body that would empty a document that holds text is refused (refused_empty_body) unless you say so, because far more often it is a surface that lost the content than a person who meant it.",
             "delete <id|slug> [<id|slug>...] — soft-deletes one or more documents (BLI-10555): the browser's own delete, sets deleted_at, never a real SQL DELETE. Recoverable — only a super_admin clearing deleted_at brings it back, there is no self-service undo. Deleting a parent does NOT delete its children; they keep their own parent_id and stay exactly where they were. Several refs resolve against ONE shared list call, then one DELETE each — one bad ref never loses the rest. --json shape: one ref answers { ok, document_id }; several answer { documents: [{ ref, ok, document_id } | { ref, ok: false, error, detail }] }.",
             "link <id|slug> <notion-url|page-id> — ties the document to a Notion page so the two-way sync moves it both ways. The page is the truth from then on: the next sync pulls it over this copy and keeps the copy as a version. `link <id|slug> --clear` unties it. Refusals: invalid_notion_page, notion_page_already_linked, document_not_writable.",
@@ -77,13 +80,14 @@ export const TOWER_COMMAND_HELP = [
     [
         "msg",
         [
-            "Usage: cockpit msg [channels|create <name>|dm <email>|read <channel>|send <channel>|thread <id> --channel <channel>|show <message-id>] [flags]",
+            "Usage: cockpit msg [channels|create <name>|dm <email>|read <channel>|unread <channel> --from <message-id>|send <channel>|thread <id> --channel <channel>|show <message-id>] [flags]",
             "",
             "Channels and messages, typed. <channel> is a channel id, or its name with or without a leading #.",
             "channels — every channel you are a member of (or, as a super_admin, every channel).",
             "create <name> [--private] [--members a@x.test,b@y.test] [--description \"<text>\"] — makes a channel and prints its id. A leading # is fine; --private means membership decides who may read it, and --members names who joins at birth BY EMAIL. An address Tower does not carry refuses the whole create — no half-built channel.",
             "dm <email> — opens (or re-opens) the direct message with one person. Idempotent: the same address always resolves to the same channel, and you never have to name yourself.",
-            "read <channel> [--limit <n>] [--thread <id>] — the channel's most recent top-level messages, oldest first; --thread <id> reads one thread's replies instead.",
+            "read <channel> [--limit <n>] [--thread <id>] [--mark-read] — the channel's most recent top-level messages, oldest first; --thread <id> reads one thread's replies instead. The first page also says where the messages come from (for an imported Slack channel: how long ago the archive was checked, or that it is unknown) and where YOUR read line stands. Reading never moves the read line; --mark-read moves it to the newest message shown, and says plainly if that failed.",
+            "unread <channel> --from <message-id> — marks that message and everything after it unread, so the web sidebar badge and the NEW MESSAGES line start there. Opening or reading a channel never clears unseen history.",
             "send <channel> [--thread <id>] — posts a message. The content is never accepted on the command line: pipe it in, e.g. `echo \"hello\" | cockpit msg send general`.",
             "thread <id> --channel <channel> [--before <cursor>] [--limit <n>] — one thread's replies by the parent message's id.",
             "show <message-id> — exact message, thread root and bounded neighbors. read/thread --before takes the preceding nextCursor; repeat until hasMore is false.",
@@ -95,7 +99,7 @@ export const TOWER_COMMAND_HELP = [
     [
         "issue",
         [
-            "Usage: cockpit issue [board|list|show <id> [<id>...]|create|update <id>|move <id> <state>|comment <id>|history <id>|mutation-status <request-uuid>] [flags]",
+            "Usage: cockpit issue [board|list|show <id> [<id>...]|create|update <id>|move <id> <state>|comment <id>|history <id>|versions <id>|restore <id> --version <n>|mutation-status <request-uuid>] [flags]",
             "",
             "Tower's issue tracker. <id> is a BLI-#### identifier (BLI-3654) or an issue's uuid — both work everywhere an issue is named.",
             "list [--state <s>] [--assignee me|unassigned|<uuid>] [--project <name|id>] [--limit <n>] — the issues you may see, most recently updated first. Each row carries assignee_name/assignee_email alongside the bare assignee_id (BLI-10450, one extra `cockpit team members` call for the whole page, never per row), and a `size` label (S/M/L) alongside the raw `estimate` when it matches Tower's own scale (BLI-10575). --json shape: { issues: [{ id, identifier, title, state, priority, estimate, size, assignee_id, assignee_name, assignee_email, project_id, parent_id, updated_at }] }.",
@@ -109,6 +113,8 @@ export const TOWER_COMMAND_HELP = [
             "Writes accept --request-id <uuid> and --expected-revision <n>. Keep the UUID and identical fields across retries; JSON includes mutation receipt and mirror delivery separately.",
             "mutation-status <request-uuid> — check your own local commit and mirror delivery after a lost response; no receipt means unknown_check_again.",
             "history <id> [--limit <n>] — every recorded state move and reassignment, oldest first.",
+            "versions <id> [--limit <n>] — every saved description, newest first, each with its number, id, author, source and time (BLI-21300). --json shape: { versions: [{ id, version, markdown, author_id, source, restored_from_version, created_at }] }.",
+            "restore <id> --version <n> [--request-id <uuid>] [--expected-revision <n>] — writes version <n>'s text back as a NEW version; nothing is rewritten, so the restore can itself be undone. A stale revision conflicts and changes nothing. --json shape: { issue, mutation }.",
             "A project may be named instead of id'd; the name is matched exactly (case-insensitively) against `cockpit project list`.",
             "--json writes one machine-readable object to stdout; every reason and receipt line stays on stderr.",
             "A refusal keeps Tower's own reason label — needs_rls_client, issue_not_found_or_unreadable, issue_not_writable, invalid_state, comment_too_long, and so on.",
@@ -145,7 +151,7 @@ export const TOWER_COMMAND_HELP = [
     [
         "cal",
         [
-            'Usage: cockpit cal [event <id>|export <id>|today|week|conflicts|calendar-change <id> --color <hex-or-provider>|next|find "<words>"|calendars|add-ical|create|share <id>|sync <id>|sync-status [<id>]|detach <id>|delete <event id> --yes] [flags]',
+            'Usage: cockpit cal [event <id>|export <id>|today|week|conflicts|calendar-change <id> --color <hex-or-provider>|next|find "<words>"|calendars|add-ical|create|duplicate <event id>|batch|undo [<change id>]|share <id>|sync <id>|sync-status [<id>]|detach <id>|delete <event id> --yes] [flags]',
             "",
             "Every calendar you attached, in one place — plus any calendar a colleague marked shared.",
             "today [--offset 1] [--tz <zone>] — what is on today, in YOUR zone (this machine's, unless --tz says otherwise). --offset 1 is tomorrow, -1 yesterday.",
@@ -168,7 +174,10 @@ export const TOWER_COMMAND_HELP = [
             "sync <id> [--full] — reads that calendar now instead of waiting for the cron. --full ignores the sync token / ETag and re-reads everything.",
             "sync-status [<id>] — every calendar's health, or one's: last successful sync, the last pass's own reason, how many events it carried, failures in the last 24h, and the lag between an event's own provider clock and when Tower stored it (ticket 10730).",
             "detach <id> — removes the calendar and its stored events from Tower. The calendar itself is untouched at Google.",
-            "change <event id> [--account <name>] [--title <title>] [--at <iso> --until <iso>] [--location <place>] — changes an event on its own account.",
+            "change <event id> [--account <name>] [--title <title>] [--at <iso> --until <iso>] [--location <place>] [--all-day|--timed] [--tz <zone>] [--expected-version <v>] [--idempotency-key <k>] [--reason <why>] — changes an event on its own account and prints the change id (undo it with `undo`). --all-day converts to an all-day event (--at/--until are dates, --until the day AFTER the last day); --timed converts back. --expected-version refuses (version_conflict) instead of overwriting an event that changed since you read it. Recurring events are refused until scoped edits ship.",
+            "duplicate <event id> [--at <iso> --until <iso>] [--calendar <id>|--account <name>] [--keep-invitees] [--idempotency-key <k>] — copies ONE non-recurring event. The copy has NO guests unless you pass --keep-invitees (Google then emails each one) and no Meet room. Same times unless --at/--until are given; --calendar/--account puts the copy on another of your calendars on purpose. The same --idempotency-key twice makes one copy.",
+            'batch [--idempotency-key <k>] [--reason <why>] — up to 25 changes from JSON on stdin: {"changes":[{"event_id":"…","starts_at":"…","ends_at":"…","expected_version":"…"}]} (or a bare array; fields as `change`: title, location, all_day, time_zone). Each is its own write: the output lists every item and the ones left unchanged, and the exit code is 1 unless all were written.',
+            "undo [<change id>] — a NEW write that puts the recorded earlier values back (or removes the event a create or duplicate made), never a deletion of history. No id means your latest change. Refuses when the event changed again since (undo_stale), when that change was already undone, and for guest changes, cancellations and calendar moves.",
             "cancel <event id> --yes [--account <name>] — same door as delete; a named account must own the event.",
             "delete <event id> --yes — removes ONE event, AT GOOGLE first, then here. Refuses without --yes: a delete can email everybody on it, exactly like create's invitations do. Google already having it gone (404/410) is answered as success, not a refusal.",
             "--json writes one machine-readable object to stdout; every reason and receipt line stays on stderr.",

package/dist/commands/local-help-commands.js

@@ -28,7 +28,7 @@ const COMMAND_HELP = new Map([
     // BLI-3709: the Tower nouns live next door, split along the same seam the
     // argument parsers already use — see `local-help-commands-tower.ts`.
     ...TOWER_COMMAND_HELP,
-    ["setup", ["Usage: cockpit setup [--since <7d|30d|date>] [--details] [--person <name|email>] [--compare <name,name>] [--json]", "Read agent setups beside windowed outcomes (default 30 days), or compare two people by first name or email."]],
+    ["setup", ["Usage: cockpit setup [--since <duration|date>] [--until <date>] [--machines] [--details] [--person <name|email>] [--compare <name,name>] [--json]", "Read agent setups beside windowed outcomes (default 30 days), or compare two people by first name or email."]],
     [
         "onboard",
         [

package/dist/commands/local-help.js

@@ -144,7 +144,7 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit msg [channels|create <name>|dm <email>|read <channel>|send <channel>|thread <id> --channel <channel>|show <message-id>] [--private] [--members a@x,b@y] [--description <text>] [--thread <id>] [--limit <n>] [--before <cursor>] [--dashboard-url <url>] [--json]",
     "  cockpit issue [list|show <BLI-id>|create --title <t>|update <BLI-id>|move <BLI-id> <state>|comment <BLI-id>|history <BLI-id>] [--state <s>] [--assignee me|unassigned|<uuid>] [--project <name|id>] [--limit <n>] [--priority 0-4] [--size S|M|L] [--parent <BLI-id>] [--file <path>|--body-stdin] [--dashboard-url <url>] [--json]",
     "  cockpit mail [accounts|add-imap --address <a>|inbox|read <thread>|search \"<words>\"|send --account <id> --to <a> --subject <s>|draft --account <id> --to <a> --subject <s> [--reply-to <message id>]|attachment <id> --out <path>|sync <account>|detach <account>] [--account <id>] [--limit <n>] [--unread] [--label <l>] [--file <path>] [--attach <path>]... [--dashboard-url <url>] [--json]",
-    "  cockpit cal [event <id> [--occurrence-start <iso>]|export <id> [--occurrence-start <iso>]|today|week|conflicts|calendar-change <id> --color <hex-or-provider>|next|find \"<words>\"|calendars|add-ical|create --calendar <id> --title <t> --at <iso> --until <iso>|share <id> --org-visible|--private|sync <id> [--full]|detach <id>] [--tz <zone>] [--offset <n>] [--hours <n>] [--from <d> --to <d>] [--calendar <id>] [--limit <n>] [--all] [--dashboard-url <url>] [--json]",
+    "  cockpit cal [event <id> [--occurrence-start <iso>]|export <id> [--occurrence-start <iso>]|today|week|conflicts|calendar-change <id> --color <hex-or-provider>|next|find \"<words>\"|calendars|add-ical|create --calendar <id> --title <t> --at <iso> --until <iso>|duplicate <event id> [--keep-invitees]|batch|undo [<change id>]|share <id> --org-visible|--private|sync <id> [--full]|detach <id>] [--tz <zone>] [--offset <n>] [--hours <n>] [--from <d> --to <d>] [--calendar <id>] [--limit <n>] [--all] [--dashboard-url <url>] [--json]",
     "  cockpit project [list] [--archived] [--dashboard-url <url>] [--json]",
     "  cockpit github <pr|merge|retitle|rerun> <owner/repo> <n> [--claim <state>] [--method squash|merge|rebase] [--title \"<text>\"] [--run <id>] [--confirm <code>] [--dashboard-url <url>] [--json]",
     `  cockpit search "<words>" [--kind <category,...>] [--limit <n>] [--dashboard-url <url>] [--json]`,
@@ -168,7 +168,7 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit drills [list|start|answer --confidence <1-5> [--text <words>] [--attempt <id>]|theme|theme set <theme> [--play <t>] [--watch <t>] [--train <t>]|review] [--dashboard-url <url>] [--json]",
     "  cockpit manager <clients|client <client>|run <run-id>|list <client>|queue <client>|show <id>|add <client> --title <t>|edit <id> --version <v>|done|reopen|link|approve|dismiss|proposal|archive|unarchive> [--timeline] [--dashboard-url <url>] [--json]",
     "  cockpit image <describe <file> [--session <id>]|show <sha256-or-prefix>> [--dashboard-url <url>] [--json]",
-    "  cockpit setup [--since <7d|30d|date>] [--details] [--person <name|email>] [--compare <name,name>] [--json]",
+    "  cockpit setup [--since <duration|date>] [--until <date>] [--machines] [--details] [--person <name|email>] [--compare <name,name>] [--json]",
     "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
     "  cockpit usage session <id> [--from-window <n>] [--json]",
     "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",

package/dist/commands/msg-read-line.js

@@ -0,0 +1,32 @@
+/**
+ * The read line, from a terminal (BLI-21299), split out of `msg.ts` to keep it
+ * under the file-size ratchet: the two fields every channel read now carries
+ * (`provenance`, `readBoundary`) and the `read --mark-read` step. The web page,
+ * MCP `msg_read` `mark_read` and this all call `POST /api/msg/channels/[id]/read`.
+ */
+import { askAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const WRITE_DEADLINE_MS = 30_000;
+/** POST the read line to the newest top-level message of a page just read (newest first). */
+export async function markReadThrough(door, channelId, messages) {
+    const newest = messages.find((message) => !message.thread_parent_id);
+    if (!newest) {
+        writeLine(door.io.stderr, `${TAG} mark-read skipped ${JSON.stringify({ channel_id: channelId, reason: "nothing_to_mark" })}`);
+        return { ok: false, reason: "nothing_to_mark", detail: "There was no top-level message on this page to mark read." };
+    }
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(channelId)}/read`,
+        method: "POST",
+        label: "msg mark-read",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { message_id: newest.id },
+    });
+    if (!answer.ok) {
+        writeLine(door.io.stderr, `${TAG} mark-read failed ${JSON.stringify({ channel_id: channelId, reason: answer.reason })}`);
+        return { ok: false, reason: answer.reason, detail: answer.detail };
+    }
+    const changed = answer.body.move?.changed === true;
+    writeLine(door.io.stderr, `${TAG} mark-read ${JSON.stringify({ channel_id: channelId, message_id: newest.id, changed })}`);
+    return { ok: true, messageId: newest.id, changed };
+}

package/dist/commands/msg.js

@@ -1,7 +1,7 @@
 /**
  * `cockpit msg` — channels and messages, typed (BLI-3706, BLI-3749).
  *
- * Six verbs over `/api/msg/**` (BLI-3654 Wave 1a), which already accepts the
+ * Eight verbs over `/api/msg/**` (BLI-3654 Wave 1a), which already accepts the
  * collector device token through `resolveCaller({ allowDeviceToken: true })`
  * on every route — no server-side door change was needed for this terminal.
  *
@@ -18,6 +18,7 @@
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
+import { markReadThrough } from "./msg-read-line.js";
 const TAG = "[msg cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 30_000;
@@ -31,6 +32,8 @@ export async function runMsg(command, io) {
             return listChannels(door);
         case "read":
             return readChannel(command, door);
+        case "unread":
+            return markUnread(command, door);
         case "send":
             return sendMessage(command, door);
         case "thread":
@@ -151,11 +154,20 @@ async function readChannel(command, door) {
     // BLI-10449: whether this channel is Tower's own or a Slack snapshot, and
     // how fresh — the door's own sentence, printed as sent.
     const provenance = body.provenance ?? null;
+    const readBoundary = body.readBoundary ?? null;
     const limitApplied = body.limitApplied ?? null;
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, ...body, channelId: resolved.id, provenance, limitApplied, messages, nextCursor: body.nextCursor, hasMore: body.hasMore, coverage: body.coverage });
+    // `--mark-read` (BLI-21299): the person has just been shown these messages, so
+    // the read line moves to the newest top-level one - the only way a terminal
+    // moves it. Never implied by reading alone.
+    const readMove = command.markRead ? await markReadThrough(door, resolved.id, messages) : null;
+    const exitCode = readMove && !readMove.ok ? 1 : 0;
+    if (door.json) {
+        return emitAgentDoor(door, { ok: true, ...body, channelId: resolved.id, provenance, readBoundary, limitApplied, messages, nextCursor: body.nextCursor, hasMore: body.hasMore, coverage: body.coverage, ...(readMove ? { readMove } : {}) }, exitCode);
+    }
     if (provenance?.sentence)
         writeLine(door.io.stdout, provenance.sentence);
+    if (readBoundary?.sentence)
+        writeLine(door.io.stdout, readBoundary.sentence);
     if (limitApplied !== null) {
         writeLine(door.io.stdout, `Showing the newest ${limitApplied}: one read returns at most ${limitApplied} messages.`);
     }
@@ -170,6 +182,36 @@ async function readChannel(command, door) {
         const who = message.agent_label ?? message.user_id ?? message.slack_author_label ?? "someone";
         writeLine(door.io.stdout, `${message.id}  ${message.created_at}  ${who}  ${message.content ?? ""}`);
     }
+    if (readMove) {
+        writeLine(readMove.ok ? door.io.stdout : door.io.stderr, readMove.ok
+            ? `Read line moved to ${readMove.messageId} (${readMove.changed ? "advanced" : "already at or past it"}).`
+            : `Read line NOT moved (${readMove.reason}): ${readMove.detail} Run the same command again to retry.`);
+    }
+    return exitCode;
+}
+/** `cockpit msg unread <channel> --from <message-id>` — this message and everything after it counts as unread. */
+async function markUnread(command, door) {
+    const ref = command.channelRef ?? "";
+    const messageId = command.unreadFrom ?? "";
+    const resolved = await resolveChannelId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, ref);
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/read`,
+        method: "POST",
+        label: "msg unread",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { message_id: messageId, action: "unread" },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const move = answer.body.move ?? {};
+    writeLine(door.io.stderr, `${TAG} unread ${JSON.stringify({ channel_id: resolved.id, message_id: messageId })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channelId: resolved.id, messageId, move });
+    writeLine(door.io.stdout, `Marked ${messageId} and everything after it unread in ${ref}. Read line now at ${move.lastReadAt ?? "the start"}.`);
     return 0;
 }
 async function readThread(command, door) {

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.238");
+    writeLine(io?.stdout ?? process.stdout, "0.2.239");
     return 0;
   }
 

package/dist/commands/setup.js

@@ -3,6 +3,10 @@ import { writeLine } from "./cli-io.js";
 export async function runSetup(command, io) {
     const door = await openAgentDoor("setup", command, io);
     const query = new URLSearchParams();
+    if (command.until)
+        query.set("until", command.until);
+    if (command.machines)
+        query.set("machines", "1");
     if (command.since)
         query.set("since", command.since);
     if (command.person)
@@ -18,6 +22,10 @@ export async function runSetup(command, io) {
     const number = (value) => value === null ? "n/a" : value.toLocaleString(undefined, { maximumFractionDigits: 1 });
     // BLI-13066: the server writes what each number rests on (the share of sessions counted, the sessions judged), so the CLI, the web page and JARVIS say the same words. An older server sends none.
     const coverage = (words) => words ? ` (${words})` : "";
+    if (body.window)
+        writeLine(io.stdout, `Requested window: ${body.window.since} to ${body.window.until}. ${body.automation_basis ?? "Includes automated work"}`);
+    if (body.freshness)
+        writeLine(io.stdout, body.freshness.words);
     for (const person of body.people ?? []) {
         writeLine(io.stdout, `${person.rank ? `#${person.rank} ` : "Unranked · "}${person.display_name ?? person.email ?? "Unknown person"}: ${number(person.prs_per_week)} merged PRs/week · ${number(person.tokens_per_pr)} tokens/merged PR${coverage(person.coverage_words?.tokens)} · ${person.yield === null ? "no session judged yet" : `${number(person.yield * 100)}% session yield`}${coverage(person.coverage_words?.yield)}`);
         if (person.tokens_basis)
@@ -28,6 +36,11 @@ export async function runSetup(command, io) {
         if (!person.machines.length)
             writeLine(io.stdout, "  No setup received.");
         for (const machine of person.machines) {
+            if (machine.health) {
+                writeLine(io.stdout, `  Machine reading: ${machine.health.words ?? machine.health.reason}. ${machine.health.next_action?.words ?? ""}`);
+                for (const piece of machine.health.pieces ?? [])
+                    writeLine(io.stdout, `    ${piece.key}: ${piece.status}${piece.reason ? ` (${piece.reason})` : ""}. ${piece.next_action?.words ?? ""}`);
+            }
             if (!machine.setup) {
                 writeLine(io.stdout, "  No readable setup from this machine yet.");
                 continue;

package/dist/commands/usage.js

@@ -5,6 +5,8 @@ import { writeLine } from "./cli-io.js";
 export async function runUsage(command, io) {
     const door = await openAgentDoor("usage", command, io);
     const query = new URLSearchParams({ since: command.since });
+    if (command.person)
+        query.set("person", command.person);
     addUsageGroupingFilters(command, query);
     if (command.action === "sessions")
         return runUsageSessions(command, io, door, query);
@@ -19,7 +21,7 @@ export async function runUsage(command, io) {
         writeLine(io.stdout, String(answer.body.text ?? ""));
         return 0;
     }
-    if (command.person) {
+    if (command.person && !body.person_filter && !(body.people ?? []).some(person => person.identity)) {
         const email = command.person === "me" ? (await loadPairedSession("usage", command.homeDir)).email : command.person;
         if (!email)
             return failAgentDoor(door, "[usage]", "caller_email_unavailable", "The paired session has no email. Sign in again or pass --person <email>.");

package/dist/spool/local-spool-parse.js

@@ -65,24 +65,25 @@ function parseSourceRetryEntry(value, fieldPath) {
 function parsePendingSessionReport(value, fieldPath) {
     const record = requireRecord(value, fieldPath);
     const sessions = parseMetadataOnlySessionReportRows(record["sessions"], `${fieldPath}.sessions`);
+    const text = (key) => requireString(record[key], `${fieldPath}.${key}`);
     return {
-        report_id: requireString(record["report_id"], `${fieldPath}.report_id`),
-        created_at: requireString(record["created_at"], `${fieldPath}.created_at`),
-        last_attempt_at: requireString(record["last_attempt_at"], `${fieldPath}.last_attempt_at`),
-        dashboard_url: requireString(record["dashboard_url"], `${fieldPath}.dashboard_url`),
-        generated_at: requireString(record["generated_at"], `${fieldPath}.generated_at`),
-        work_context_id: requireString(record["work_context_id"], `${fieldPath}.work_context_id`),
-        repo_label: requireString(record["repo_label"], `${fieldPath}.repo_label`),
-        branch: requireString(record["branch"], `${fieldPath}.branch`),
-        repo_fingerprint: requireString(record["repo_fingerprint"], `${fieldPath}.repo_fingerprint`),
+        report_id: text("report_id"),
+        created_at: text("created_at"),
+        last_attempt_at: text("last_attempt_at"),
+        dashboard_url: text("dashboard_url"),
+        generated_at: text("generated_at"),
+        work_context_id: text("work_context_id"),
+        repo_label: text("repo_label"),
+        branch: text("branch"),
+        repo_fingerprint: text("repo_fingerprint"),
         repo_origin_url: record["repo_origin_url"] === undefined
             ? null
             : requireNullableString(record["repo_origin_url"], `${fieldPath}.repo_origin_url`),
-        worktree_label: requireString(record["worktree_label"], `${fieldPath}.worktree_label`),
-        worktree_fingerprint: requireString(record["worktree_fingerprint"], `${fieldPath}.worktree_fingerprint`),
+        worktree_label: text("worktree_label"),
+        worktree_fingerprint: text("worktree_fingerprint"),
         worktree_is_primary: requireBoolean(record["worktree_is_primary"], `${fieldPath}.worktree_is_primary`),
         sessions,
-        failure_reason: requireString(record["failure_reason"], `${fieldPath}.failure_reason`),
+        failure_reason: text("failure_reason"),
     };
 }
 export function parseMetadataOnlySessionReportRows(value, fieldPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.238",
+  "version": "0.2.239",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.69",
-    "@bli-cockpit/mcp": "0.1.143",
-    "@bli-cockpit/telemetry-core": "0.1.76"
+    "@bli-cockpit/memory-mcp": "0.1.70",
+    "@bli-cockpit/mcp": "0.1.144",
+    "@bli-cockpit/telemetry-core": "0.1.77"
   },
   "repository": {
     "type": "git",