@bli-cockpit/cli 0.2.237 → 0.2.239

package/dist/commands/brief-edit.js

@@ -41,54 +41,20 @@ export async function runBriefEdit(command, io) {
     const log = (line) => writeLine(io.stderr, line);
     const startedAt = Date.now();
     // ── 1. The page, as a document ────────────────────────────────────────────
-    const read = await towerJsonRequest({
-        dashboardUrl,
-        path: `/api/jarvis/brief${briefQuery(command)}`,
-        deviceToken: session.device_token,
-        fetch: io.fetch,
-        method: "GET",
-        label: "brief:edit",
-        timeoutMs: REQUEST_DEADLINE_MS,
-        log,
-    });
-    if (!read.ok)
-        return fail(command, io, read.reason, read.detail);
-    const brief = read.body;
-    const personId = brief.page?.personId;
-    const original = brief.editable?.document;
-    const lines = (brief.editable?.lines ?? []).filter((line) => typeof line.claimId === "string" && typeof line.text === "string");
-    if (!brief.ok || !personId || typeof original !== "string" || lines.length === 0) {
-        return fail(command, io, brief.error ?? "no_page", brief.reply ?? "There is no page to edit.");
-    }
+    const page = await readEditablePage(command, io, session, dashboardUrl, log);
+    if (!page.ok)
+        return fail(command, io, page.reason, page.detail);
     // ── 2. Their editor, or their stdin ───────────────────────────────────────
-    const edited = await collectEditedDocument(io, original, log);
+    const edited = await collectEditedDocument(io, page.original, log);
     if (!edited.ok)
         return fail(command, io, edited.reason, edited.detail);
     // ── 3. The diff, here ─────────────────────────────────────────────────────
-    const diff = diffDocument(lines, edited.text);
-    if (diff.invented.length > 0) {
-        return fail(command, io, "invented_claim", `The page has no line called “${diff.invented[0]}”. Change the words after an id, never the id ` +
-            "itself — nothing has been sent to Tower.");
-    }
-    if (diff.deleted.length > 0) {
-        return fail(command, io, "deleted_claim", `The line [${diff.deleted[0]}] is missing from what you saved. Put it back — a line you delete ` +
-            "reads as no opinion at all, not as a sentence to remove, and Tower cannot tell those apart. " +
-            "Nothing has been sent.");
-    }
-    if (diff.edits.length === 0) {
-        const styled = colorEnabled(io);
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ ok: true, saved: 0, reason: "nothing_changed" }));
-        }
-        else {
-            writeLine(io.stdout, dim("Nothing changed, so nothing was written.", styled));
-        }
-        writeLine(io.stderr, `[brief edit] nothing changed ${JSON.stringify({
-            lines: lines.length,
-            elapsed_ms: Date.now() - startedAt,
-        })}`);
-        return 0;
-    }
+    const diff = diffDocument(page.lines, edited.text);
+    const refusal = refuseBadDiff(diff);
+    if (refusal)
+        return fail(command, io, refusal.reason, refusal.detail);
+    if (diff.edits.length === 0)
+        return reportNothingChanged(command, io, page.lines.length, startedAt);
     // ── 4. The same door the browser's save posts to ──────────────────────────
     const saved = await towerJsonRequest({
         dashboardUrl,
@@ -99,8 +65,8 @@ export async function runBriefEdit(command, io) {
         timeoutMs: REQUEST_DEADLINE_MS,
         log,
         body: {
-            personId,
-            pageId: brief.page?.pageId ?? null,
+            personId: page.personId,
+            pageId: page.pageId,
             edits: diff.edits,
             ...(command.reason ? { reason: command.reason } : {}),
         },
@@ -122,6 +88,65 @@ export async function runBriefEdit(command, io) {
     })}`);
     return 0;
 }
+async function readEditablePage(command, io, session, dashboardUrl, log) {
+    const read = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${briefQuery(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief:edit",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+    });
+    if (!read.ok)
+        return { ok: false, reason: read.reason, detail: read.detail };
+    const brief = read.body;
+    const personId = brief.page?.personId;
+    const original = brief.editable?.document;
+    const lines = (brief.editable?.lines ?? []).filter((line) => typeof line.claimId === "string" && typeof line.text === "string");
+    if (!brief.ok || !personId || typeof original !== "string" || lines.length === 0) {
+        return {
+            ok: false,
+            reason: brief.error ?? "no_page",
+            detail: brief.reply ?? "There is no page to edit.",
+        };
+    }
+    return { ok: true, personId, pageId: brief.page?.pageId ?? null, original, lines };
+}
+/** The refusal for a diff that invented or deleted a claim id, or null when the diff may be sent. */
+function refuseBadDiff(diff) {
+    if (diff.invented.length > 0) {
+        return {
+            reason: "invented_claim",
+            detail: `The page has no line called “${diff.invented[0]}”. Change the words after an id, never the id ` +
+                "itself — nothing has been sent to Tower.",
+        };
+    }
+    if (diff.deleted.length > 0) {
+        return {
+            reason: "deleted_claim",
+            detail: `The line [${diff.deleted[0]}] is missing from what you saved. Put it back — a line you delete ` +
+                "reads as no opinion at all, not as a sentence to remove, and Tower cannot tell those apart. " +
+                "Nothing has been sent.",
+        };
+    }
+    return null;
+}
+function reportNothingChanged(command, io, lineCount, startedAt) {
+    const styled = colorEnabled(io);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, saved: 0, reason: "nothing_changed" }));
+    }
+    else {
+        writeLine(io.stdout, dim("Nothing changed, so nothing was written.", styled));
+    }
+    writeLine(io.stderr, `[brief edit] nothing changed ${JSON.stringify({
+        lines: lineCount,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
 function briefQuery(command) {
     const params = new URLSearchParams({ editable: "1" });
     if (command.subject)

package/dist/commands/cal-detail.js

@@ -0,0 +1,35 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+export async function runCalDetail(command, door) {
+    const query = new URLSearchParams({ tz: command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone });
+    if (command.occurrenceStart)
+        query.set("occurrence_start", command.occurrenceStart);
+    const path = `/api/cal/events/${encodeURIComponent(command.subjectId)}${command.action === "export" ? "/export" : ""}?${query}`;
+    const answer = await askAgentDoor(door, { method: "GET", path, label: `cal ${command.action}`, timeoutMs: 30000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[cal cli]", answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    if (command.action === "export") {
+        writeLine(door.io.stdout, String(answer.body.content));
+        return 0;
+    }
+    const event = answer.body.event;
+    const zone = command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const date = new Date(event.starts_at).toLocaleDateString("en-CA", { timeZone: event.all_day ? "UTC" : zone });
+    const clock = (value) => new Intl.DateTimeFormat("en-GB", { timeZone: zone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).format(new Date(value));
+    writeLine(door.io.stdout, `${event.title} · ${date} · ${event.all_day ? "All day" : `${clock(event.starts_at)}–${clock(event.ends_at)}`} · ${zone} · ${event.calendar_name}`);
+    writeLine(door.io.stdout, event.recurrence_summary);
+    if (event.recurrence_coverage_note)
+        writeLine(door.io.stdout, event.recurrence_coverage_note);
+    writeLine(door.io.stdout, `Organizer: ${event.organizer_detail?.name ?? "Unknown"}`);
+    for (const guest of event.guests)
+        writeLine(door.io.stdout, `${guest.name} · ${guest.rsvp}${guest.optional ? " · Optional" : ""}`);
+    if (event.meeting_url)
+        writeLine(door.io.stdout, `Join: ${event.meeting_url}`);
+    if (event.location)
+        writeLine(door.io.stdout, `Location: ${event.location}`);
+    if (event.capabilities.reason)
+        writeLine(door.io.stdout, event.capabilities.reason);
+    return 0;
+}

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-overlay.js

@@ -1,29 +1,51 @@
 import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
 import { readPipedText, isInteractiveStdin, writeLine } from "./cli-io.js";
+const FAIL_TAG = "[cal cli]";
+const REQUEST_TIMEOUT_MS = 30000;
 export async function runCalOverlay(command, door) {
-    if (command.action === "calendar-change") {
-        let body = command.color ? { color_override: command.color === "provider" ? null : command.color } : {};
-        if (!command.color && !isInteractiveStdin(door.io)) {
-            try {
-                const parsed = JSON.parse(await readPipedText(door.io.stdin, { maxChars: 4000, overflowMessage: "Preferences are too large." }));
-                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-                    throw new Error("invalid_preferences");
-                body = parsed;
-            }
-            catch {
-                return failAgentDoor(door, "[cal cli]", "invalid_body", "Pipe JSON preferences or use --color '#4285f4' (provider resets).");
-            }
+    if (command.action === "calendar-change")
+        return changeCalendarPreferences(command, door);
+    return showConflicts(command, door);
+}
+async function changeCalendarPreferences(command, door) {
+    let body = command.color ? { color_override: command.color === "provider" ? null : command.color } : {};
+    if (!command.color && !isInteractiveStdin(door.io)) {
+        const piped = await readPipedPreferences(door);
+        if (piped === null) {
+            return failAgentDoor(door, FAIL_TAG, "invalid_body", "Pipe JSON preferences or use --color '#4285f4' (provider resets).");
         }
-        if (!Object.keys(body).length)
-            return failAgentDoor(door, "[cal cli]", "invalid_body", "Use --color '#4285f4', --color provider, or pipe JSON with color_override/selected.");
-        const answer = await askAgentDoor(door, { method: "PATCH", path: `/api/cal/calendars/${encodeURIComponent(command.subjectId)}`, body, label: "cal calendar-change", timeoutMs: 30000 });
-        if (!answer.ok)
-            return failAgentDoor(door, "[cal cli]", answer.reason, answer.detail);
-        if (door.json)
-            return emitAgentDoor(door, answer.body);
-        writeLine(door.io.stdout, "Calendar preferences saved. Provider sync preserves your colour override.");
-        return 0;
+        body = piped;
     }
+    if (!Object.keys(body).length) {
+        return failAgentDoor(door, FAIL_TAG, "invalid_body", "Use --color '#4285f4', --color provider, or pipe JSON with color_override/selected.");
+    }
+    const answer = await askAgentDoor(door, {
+        method: "PATCH",
+        path: `/api/cal/calendars/${encodeURIComponent(command.subjectId)}`,
+        body,
+        label: "cal calendar-change",
+        timeoutMs: REQUEST_TIMEOUT_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, FAIL_TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    writeLine(door.io.stdout, "Calendar preferences saved. Provider sync preserves your colour override.");
+    return 0;
+}
+/** Piped JSON preferences, or null when the pipe is unreadable or not a JSON object. */
+async function readPipedPreferences(door) {
+    try {
+        const parsed = JSON.parse(await readPipedText(door.io.stdin, { maxChars: 4000, overflowMessage: "Preferences are too large." }));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function showConflicts(command, door) {
     const query = new URLSearchParams({ tz: command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone });
     if (command.from)
         query.set("from", command.from);
@@ -33,31 +55,52 @@ export async function runCalOverlay(command, door) {
         query.set("offset", String(command.offset));
     if (command.includeDeselected)
         query.set("all", "true");
-    const answer = await askAgentDoor(door, { method: "GET", path: `/api/cal/conflicts?${query}`, label: "cal conflicts", timeoutMs: 30000 });
+    const answer = await askAgentDoor(door, { method: "GET", path: `/api/cal/conflicts?${query}`, label: "cal conflicts", timeoutMs: REQUEST_TIMEOUT_MS });
     if (!answer.ok)
-        return failAgentDoor(door, "[cal cli]", answer.reason, answer.detail);
+        return failAgentDoor(door, FAIL_TAG, answer.reason, answer.detail);
     if (door.json)
         return emitAgentDoor(door, answer.body);
     const result = answer.body;
     const zone = result.window?.time_zone ?? command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    writeConflictGroups(door, result, zone);
+    writeCoverage(door, result);
+    return 0;
+}
+function writeConflictGroups(door, result, zone) {
     writeLine(door.io.stdout, `${result.groups.length} double-bookings · own calendars`);
     for (const group of result.groups) {
         const parts = new Intl.DateTimeFormat("en-GB", { timeZone: zone, weekday: "short", day: "numeric", month: "short", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(new Date(group.from));
         const part = (name) => parts.find(item => item.type === name)?.value;
-        writeLine(door.io.stdout, `${part("weekday")} ${part("day")} ${part("month")} ${part("hour")}:${part("minute")}: ${group.meetings.map(meeting => `${meeting.event.title} · ${meeting.event.calendar_name}`).join(" / ")}`);
+        const meetingTitles = group.meetings.map(meeting => `${meeting.event.title} · ${meeting.event.calendar_name}`).join(" / ");
+        writeLine(door.io.stdout, `${part("weekday")} ${part("day")} ${part("month")} ${part("hour")}:${part("minute")}: ${meetingTitles}`);
     }
-    const checked = result.coverage.calendars.filter(calendar => calendar.checked);
+}
+function describeSyncAge(checked) {
     const oldest = Math.min(...checked.map(calendar => calendar.lastSyncAt ? Date.parse(calendar.lastSyncAt) : NaN));
     const minutes = Math.max(0, Math.floor((Date.now() - oldest) / 60000));
-    const age = !checked.length ? "none checked" : !Number.isFinite(oldest) ? "sync age unknown" : minutes < 1 ? "just now" : minutes < 60 ? `${minutes} min ago` : minutes < 1440 ? `${Math.floor(minutes / 60)} h ago` : `${Math.floor(minutes / 1440)} days ago`;
-    writeLine(door.io.stdout, `Checked ${checked.length} calendar${checked.length === 1 ? "" : "s"} · ${age}`);
+    if (!checked.length)
+        return "none checked";
+    if (!Number.isFinite(oldest))
+        return "sync age unknown";
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    if (minutes < 1440)
+        return `${Math.floor(minutes / 60)} h ago`;
+    return `${Math.floor(minutes / 1440)} days ago`;
+}
+function writeCoverage(door, result) {
+    const checked = result.coverage.calendars.filter(calendar => calendar.checked);
+    writeLine(door.io.stdout, `Checked ${checked.length} calendar${checked.length === 1 ? "" : "s"} · ${describeSyncAge(checked)}`);
     for (const calendar of result.coverage.calendars.filter(calendar => calendar.hidden || !calendar.checked)) {
         writeLine(door.io.stdout, `${calendar.name}: ${calendar.hidden ? "hidden; " : ""}${calendar.checked ? "included by request" : `not checked (${(calendar.excludedReason ?? "unavailable").replaceAll("_", " ")})`}`);
     }
-    for (const account of result.coverage.accounts ?? [])
+    for (const account of result.coverage.accounts ?? []) {
         if (!account.calendars)
             writeLine(door.io.stdout, `${account.label}: no discovered calendars (${account.status.replaceAll("_", " ")})`);
-    if (result.coverage.incomplete || result.coverage.truncated || result.coverage.notes.length)
+    }
+    if (result.coverage.incomplete || result.coverage.truncated || result.coverage.notes.length) {
         writeLine(door.io.stdout, "Incomplete window. This check cannot confirm free time.");
-    return 0;
+    }
 }

package/dist/commands/cal.js

@@ -22,8 +22,10 @@
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { runCalAddIcal, runCalDetach, runCalShare, runCalSync } from "./cal-calendars-write.js";
+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";
@@ -33,6 +35,13 @@ const WRITE_DEADLINE_MS = 60_000;
 export async function runCal(command, io) {
     const door = await openAgentDoor("cal", command, io);
     switch (command.action) {
+        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);
@@ -95,6 +104,19 @@ function windowQuery(command) {
     return query;
 }
 async function window(command, door) {
+    const answer = await askForWindow(command, door);
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...body, ...cacheCoverage(answer) });
+    if (answer.fromCache) {
+        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
+    }
+    writeWindow(body, door);
+    return 0;
+}
+async function askForWindow(command, door) {
     // `--from`/`--to` beat a named window, on any of the three verbs: somebody
     // who named two dates meant them.
     const path = command.from && command.to ? "events" : command.action;
@@ -109,33 +131,27 @@ async function window(command, door) {
         timeoutMs: READ_DEADLINE_MS,
         warmRoute: cached,
     });
-    const answer = cached
-        ? await readThroughCache({
-            io: door.io,
-            homeDir: door.homeDir,
-            deviceToken: door.deviceToken,
-            surface: "cal",
-            label: "cal today",
-            path: apiPath,
-            json: door.json,
-            ask,
-        })
-        : { ...(await ask()), fromCache: false, ageMs: null };
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const body = answer.body;
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, ...body, ...cacheCoverage(answer) });
-    if (answer.fromCache) {
-        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
-    }
+    if (!cached)
+        return { ...(await ask()), fromCache: false, ageMs: null };
+    return readThroughCache({
+        io: door.io,
+        homeDir: door.homeDir,
+        deviceToken: door.deviceToken,
+        surface: "cal",
+        label: "cal today",
+        path: apiPath,
+        json: door.json,
+        ask,
+    });
+}
+function writeWindow(body, door) {
     const zone = body.window?.time_zone ?? localTimeZone();
     const events = body.events ?? [];
     if (events.length === 0) {
         writeLine(door.io.stdout, (body.calendars ?? []).length === 0
             ? "No calendars attached yet. `cockpit cal add-ical` for a personal one, or connect Google in the browser."
             : `Nothing on ${describeWindow(body, zone)}.`);
-        return 0;
+        return;
     }
     writeLine(door.io.stdout, describeWindow(body, zone));
     writeLine(door.io.stdout, "");
@@ -156,7 +172,6 @@ async function window(command, door) {
     for (const note of body.notes ?? []) {
         writeLine(door.io.stdout, `Note: "${note.title}" repeats on a rule Tower does not expand (${note.detail.join(", ")}), so only its first occurrence is shown.`);
     }
-    return 0;
 }
 function describeWindow(body, zone) {
     if (!body.window)
@@ -289,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(),
         },
     });
@@ -297,6 +314,10 @@ async function create(command, door) {
     const event = answer.body.event;
     if (door.json)
         return emitAgentDoor(door, { ok: true, event });
+    writeCreated(command, door, event);
+    return 0;
+}
+function writeCreated(command, door, event) {
     const zone = command.timeZone ?? localTimeZone();
     writeLine(door.io.stdout, `Created "${event?.title ?? command.title}" on ${event ? `${dayLabel(event.starts_at, zone)} ${clock(event.starts_at, zone)}` : "that calendar"}.`);
     if (event?.event_id) {
@@ -317,7 +338,6 @@ async function create(command, door) {
     if (command.attendees.length > 0) {
         writeLine(door.io.stdout, `Invitations went to ${command.attendees.join(", ")} from Google.`);
     }
-    return 0;
 }
 function meetingLinkText(event) {
     const label = { meet: "Meet link", zoom: "Zoom link", teams: "Teams link" }[event.meeting_kind ?? ""] ?? "Meeting link";
@@ -327,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/clean.js

@@ -83,11 +83,14 @@ export async function runClean(command, io) {
         writeLine(io.stdout, cleanJson(footprint, plan, vaults, pruned, reconciled));
         return pruned.status === "fail" ? 1 : 0;
     }
+    writeFreedSummary(io, pruned, removedVaults);
+    return pruned.status === "fail" ? 1 : 0;
+}
+function writeFreedSummary(io, pruned, removedVaults) {
     writeLine(io.stdout, `Freed ${mb(pruned.deleted_bytes)} MB across ${pruned.deleted_files} file(s) and ${pruned.removed_packs} pack(s)${removedVaults > 0 ? `, plus ${removedVaults} evidence vault(s)` : ""}.`);
     if (pruned.cap_blocked_by_uncommitted) {
         writeLine(io.stdout, `Still ${mb(pruned.bytes_after)} MB over a ${mb(pruned.cap_bytes)} MB cap, held by ${pruned.cap_blocked_count} object(s) the upload ledger cannot vouch for. Run \`cockpit sync\` to try delivering them; nothing here will delete them.`);
     }
-    return pruned.status === "fail" ? 1 : 0;
 }
 /** The bucket table a person reads before anything is deleted. */
 export function cleanLines(footprint, plan, vaults, command, logArchives = []) {

package/dist/commands/docs-read.js

@@ -166,8 +166,11 @@ export async function readDoc(command, door) {
         writeDocumentBlock(door.io, result.document);
         return 0;
     }
-    // Several refs: `{ ok, documents: [{ ref, ok, document|error }] }` — one bad
-    // ref never loses the rest of the batch.
+    return reportSeveralDocuments(door, results);
+}
+// Several refs: `{ ok, documents: [{ ref, ok, document|error }] }` — one bad
+// ref never loses the rest of the batch.
+function reportSeveralDocuments(door, results) {
     const failed = results.filter((result) => !result.ok);
     if (door.json) {
         return emitAgentDoor(door, {