@bli-cockpit/cli 0.2.243 → 0.2.245

package/dist/adapters/raw-evidence-budget-admission.js

@@ -0,0 +1,63 @@
+import { terminalDeliveryReason } from "../raw-evidence-staging.js";
+import { admitToStaging } from "../staging-gate.js";
+/**
+ * The one door a file passes before its bytes may be copied: the per-sync
+ * budget below, then the disk (BLI-12832). A refusal from the disk hands the
+ * budget back, because nothing was staged and the next tick re-reads the source.
+ * A copy already staged costs the disk nothing and is never refused by it.
+ */
+export function admitEvidence(collection, byteLength, file) {
+    // Ticket 21952: a copy staged on an earlier tick is queued, not new bytes; re-charging it let a backlog use up the
+    // byte budget every tick. It still costs one object, and its upload resumes from the chunks the server holds.
+    const alreadyStaged = collection.staging.staged[file.contentHash] !== undefined;
+    const charged = alreadyStaged ? 0 : byteLength;
+    const budgetReason = admitToBudget(collection.budget, charged);
+    if (budgetReason)
+        return budgetReason;
+    const allowance = collection.budget.staging;
+    if (!allowance)
+        return null;
+    // BLI-12832: bytes the server refused for good are reclaimed by the prune
+    // (the refusal stays as a receipt), so copying them again would be churn.
+    if (!alreadyStaged &&
+        terminalDeliveryReason(collection.staging.delivery_attempts[file.contentHash]?.last_reason)) {
+        refundBudget(collection.budget, charged);
+        console.error("[staging-gate] not copying bytes the server refused for good", JSON.stringify({ reason: "delivery_terminal_refused", kind: file.kind, file_bytes: byteLength }));
+        return "delivery_terminal_refused";
+    }
+    const diskReason = admitToStaging(allowance, byteLength, {
+        alreadyStaged,
+        kind: file.kind,
+    });
+    if (!diskReason)
+        return null;
+    refundBudget(collection.budget, charged);
+    return `staging_deferred:${diskReason}`;
+}
+/** Hands back one admission that a later gate refused, so nothing was staged and nothing counts as sent. */
+function refundBudget(budget, byteLength) {
+    budget.remainingObjects += 1;
+    budget.remainingBytes += byteLength;
+    budget.admittedBytes = Math.max(0, (budget.admittedBytes ?? 0) - byteLength);
+    budget.admittedObjects = Math.max(0, (budget.admittedObjects ?? 0) - 1);
+}
+/**
+ * Decrements the per-sync budget when a file fits, or returns a deferred-skip
+ * reason when it does not. The object budget bounds request count; the byte
+ * budget bounds buffered bytes.
+ */
+export function admitToBudget(budget, byteLength) {
+    const single = budget.singleFileByteAllowance;
+    const firstLargeFile = single && budget.remainingBytes === single.normalBytes &&
+        byteLength <= single.maxFileBytes;
+    const reason = budget.remainingObjects <= 0 ? "deferred_object_budget" :
+        byteLength > 0 && byteLength > budget.remainingBytes && !firstLargeFile ? "deferred_byte_budget" : null;
+    if (reason) {
+        [budget.deferredObjects, budget.deferredBytes] = [(budget.deferredObjects ?? 0) + 1, (budget.deferredBytes ?? 0) + byteLength];
+        return reason;
+    }
+    budget.remainingObjects -= 1;
+    budget.remainingBytes -= byteLength;
+    [budget.admittedBytes, budget.admittedObjects] = [(budget.admittedBytes ?? 0) + byteLength, (budget.admittedObjects ?? 0) + 1];
+    return null;
+}

package/dist/adapters/raw-evidence-collection-state.js

@@ -7,13 +7,14 @@
  * contract, so `raw-evidence-completeness.ts` can read and write them without
  * knowing about packs, budgets or disks.
  *
- * Two mechanics live here rather than in any one reader, because the Codex
+ * Two mechanics are exposed here rather than in any one reader, because the Codex
  * reader, the Claude reader, the image reader and the git-diff reader all spend
  * them:
  *
  * - **`admitToBudget`** — the per-sync byte and object budget (D7b),
  *   decremented in place so one `cockpit sync` across many worktrees honours
- *   one cap.
+ *   one cap. Admission and disk-refusal refunds live together in
+ *   `raw-evidence-budget-admission.ts`; the exports here keep reader APIs stable.
  * - **`stageEvidenceBytes`** — bytes go on disk exactly once; content an
  *   earlier sync already staged is adopted rather than copied again.
  *
@@ -26,8 +27,8 @@ import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core"
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { DELIVERY_BACKOFF_BYPASS_REASON, deliveryBackoffApplies, heldSourceKeys, readRawEvidenceStagingState, resolveStagedObject, terminalDeliveryReason, } from "../raw-evidence-staging.js";
-import { admitToStaging, openStagingAllowance, } from "../staging-gate.js";
+import { DELIVERY_BACKOFF_BYPASS_REASON, deliveryBackoffApplies, heldSourceKeys, readRawEvidenceStagingState, resolveStagedObject, } from "../raw-evidence-staging.js";
+import { openStagingAllowance, } from "../staging-gate.js";
 import { chmodPrivate } from "./raw-evidence-pack-store.js";
 import { GIT_DIFF_TIMEOUT_MS, MAX_GIT_DIFF_BYTES, } from "./raw-evidence-git-diff.js";
 export const DEFAULT_SINCE_MINUTES = 24 * 60;
@@ -201,60 +202,4 @@ export async function stageEvidenceBytes(collection, options) {
     collection.stagedNewCount += 1;
     return { local_path: destination, staged_in_pack: true };
 }
-/**
- * The one door a file passes before its bytes may be copied: the per-sync
- * budget below, then the disk (BLI-12832). A refusal from the disk hands the
- * budget back, because nothing was staged and the next tick re-reads the source.
- * A copy already staged costs the disk nothing and is never refused by it.
- */
-export function admitEvidence(collection, byteLength, file) {
-    // Ticket 21952: a copy staged on an earlier tick is queued, not new bytes; re-charging it let a backlog use up the
-    // byte budget every tick. It still costs one object, and its upload resumes from the chunks the server holds.
-    const alreadyStaged = collection.staging.staged[file.contentHash] !== undefined;
-    const charged = alreadyStaged ? 0 : byteLength;
-    const budgetReason = admitToBudget(collection.budget, charged);
-    if (budgetReason)
-        return budgetReason;
-    const allowance = collection.budget.staging;
-    if (!allowance)
-        return null;
-    // BLI-12832: bytes the server refused for good are reclaimed by the prune
-    // (the refusal stays as a receipt), so copying them again would be churn.
-    if (!alreadyStaged &&
-        terminalDeliveryReason(collection.staging.delivery_attempts[file.contentHash]?.last_reason)) {
-        refundBudget(collection.budget, charged);
-        console.error("[staging-gate] not copying bytes the server refused for good", JSON.stringify({ reason: "delivery_terminal_refused", kind: file.kind, file_bytes: byteLength }));
-        return "delivery_terminal_refused";
-    }
-    const diskReason = admitToStaging(allowance, byteLength, {
-        alreadyStaged,
-        kind: file.kind,
-    });
-    if (!diskReason)
-        return null;
-    refundBudget(collection.budget, charged);
-    return `staging_deferred:${diskReason}`;
-}
-/** Hands back one admission that a later gate refused, so nothing was staged and nothing counts as sent. */
-function refundBudget(budget, byteLength) {
-    budget.remainingObjects += 1;
-    budget.remainingBytes += byteLength;
-    budget.admittedBytes = Math.max(0, (budget.admittedBytes ?? 0) - byteLength);
-    budget.admittedObjects = Math.max(0, (budget.admittedObjects ?? 0) - 1);
-}
-/**
- * Decrements the per-sync budget when a file fits, or returns a deferred-skip
- * reason when it does not. The object budget bounds request count; the byte
- * budget bounds buffered bytes.
- */
-export function admitToBudget(budget, byteLength) {
-    const reason = budget.remainingObjects <= 0 ? "deferred_object_budget" : byteLength > budget.remainingBytes ? "deferred_byte_budget" : null;
-    if (reason) {
-        [budget.deferredObjects, budget.deferredBytes] = [(budget.deferredObjects ?? 0) + 1, (budget.deferredBytes ?? 0) + byteLength];
-        return reason;
-    }
-    budget.remainingObjects -= 1;
-    budget.remainingBytes -= byteLength;
-    [budget.admittedBytes, budget.admittedObjects] = [(budget.admittedBytes ?? 0) + byteLength, (budget.admittedObjects ?? 0) + 1];
-    return null;
-}
+export { admitEvidence, admitToBudget } from "./raw-evidence-budget-admission.js";

package/dist/commands/issue-contracts.js

@@ -119,11 +119,18 @@ export async function readBody(command, io) {
         return { ok: false, reason: "description_too_long", detail: error instanceof Error ? error.message : String(error) };
     }
 }
-/** The project/parent halves both `create` and `update` need, resolved once. */
+/**
+ * The project/parent halves both `create` and `update` need, resolved once. Three answers per field: `undefined`
+ * (not asked to change), `null` (`none`: clear it, update only; the parser refuses it elsewhere, BLI-22367), or a
+ * uuid. A project or ticket literally named "none" is reached by its uuid.
+ */
 export async function resolveRefs(command, door) {
     let projectId;
     let parentId;
-    if (command.project) {
+    if (command.project && command.project.toLowerCase() === "none") {
+        projectId = null;
+    }
+    else if (command.project) {
         const resolved = await resolveProjectId(door, command.project);
         if (resolved.status === "list_failed")
             return { ok: false, reason: resolved.reason, detail: resolved.detail };
@@ -136,11 +143,65 @@ export async function resolveRefs(command, door) {
         }
         projectId = resolved.id;
     }
-    if (command.parentRef) {
+    if (command.parentRef && command.parentRef.toLowerCase() === "none") {
+        parentId = null;
+    }
+    else if (command.parentRef) {
         const resolved = await resolveIssueUuid(door, command.parentRef);
         if (resolved.status === "failed")
             return { ok: false, reason: resolved.reason, detail: resolved.detail };
         parentId = resolved.id;
     }
-    return { ok: true, ...(projectId ? { projectId } : {}), ...(parentId ? { parentId } : {}) };
+    return { ok: true, ...(projectId !== undefined ? { projectId } : {}), ...(parentId !== undefined ? { parentId } : {}) };
+}
+/**
+ * The receipt for a write the door REFUSED. The door's own receipt wins. Without one, a 4xx answer that names its
+ * reason is a known refusal before anything was written: `not_committed`, never "check again" (BLI-22367; the
+ * self-parent and unknown-label refusals used to say `unknown_check_again` forever). Only a lost answer, a
+ * `mutation_unknown`, a 5xx, or a status with no reason label stays `unknown_check_again`.
+ */
+export function receiptAfterRefusal(answer, requestId) {
+    const sent = answer.body?.mutation;
+    if (sent && typeof sent === "object" && sent.outcome)
+        return sent;
+    const status = answer.httpStatus;
+    const known = typeof status === "number" && status >= 400 && status < 500
+        && answer.reason !== "mutation_unknown" && !/^http_\d+$/.test(answer.reason);
+    return known
+        ? { request_id: requestId, outcome: "not_committed", reason: answer.reason }
+        : { request_id: requestId, outcome: "unknown_check_again" };
+}
+const DELIVERY_WORDS = {
+    pending: "queued, not delivered yet",
+    delivered: "delivered",
+    failed: "failed; the Tower save stands",
+    not_mirrored: "not mirrored",
+    tower_only: "not mirrored (Tower-only)",
+    unknown_check_again: "status unknown; check cockpit ticket mutation-status",
+};
+/**
+ * One sentence a person reads after a committed write: the Tower save first, the Linear copy second, so a pending
+ * or failed delivery never reads as a failed save (contract C1).
+ */
+export function savedLine(receipt) {
+    if (!receipt || receipt.outcome !== "committed")
+        return null;
+    const revision = receipt.revision === undefined ? "" : ` (revision ${receipt.revision})`;
+    if (receipt.reason === "unchanged")
+        return `Saved in Tower${revision}: nothing needed to change.`;
+    const status = receipt.delivery?.status;
+    if (!status)
+        return `Saved in Tower${revision}.`;
+    const words = DELIVERY_WORDS[status] ?? status;
+    const why = receipt.delivery?.reason ? ` (${receipt.delivery.reason})` : "";
+    return `Saved in Tower${revision}. Linear copy: ${words}${why}.`;
+}
+/**
+ * The canonical ticket link (contract C3): the door's own `canonical_url` when it sent one, else
+ * `<configured dashboard url>/tickets/<IDENTIFIER>`. Never a Linear link.
+ */
+export function canonicalTicketUrl(dashboardUrl, identifier, sent) {
+    if (typeof sent === "string" && /^https?:\/\//.test(sent))
+        return sent;
+    return `${dashboardUrl.replace(/\/+$/, "")}/tickets/${encodeURIComponent(identifier)}`;
 }

package/dist/commands/issue-list-page.js

@@ -10,8 +10,23 @@
  */
 import { askAgentDoor } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
-import { READ_DEADLINE_MS, TAG, withSizeLabel } from "./issue-contracts.js";
+import { TAG, withSizeLabel } from "./issue-contracts.js";
 const ALL_PAGE_SIZE = 500;
+/**
+ * `--all` page deadline and bounded retry (BLI-22367). A live export timed out on page 5 of 16 (`turn_timed_out`
+ * at the 30 s read deadline) while the database answered every `work_issue_page` call in at most 288 ms
+ * (pg_stat_statements, 2026-10-19): the stall was transport or the serverless function, not the query. A 500-row
+ * page gets a longer deadline than a 100-row read, and a page that times out, cannot reach Tower or gets a 5xx is
+ * asked again FROM THE SAME CURSOR, at most twice, before the walk stops honestly with `failed_partial` and the
+ * resume cursor. A 4xx (an invalid cursor or filter) is never retried. Every retry is counted on the coverage line.
+ */
+export const ALL_PAGE_DEADLINE_MS = 60_000;
+export const allWalkRetry = { delaysMs: [1_000, 3_000] };
+function retryablePageFailure(answer) {
+    if (answer.httpStatus !== undefined)
+        return answer.httpStatus >= 500;
+    return answer.reason === "turn_timed_out" || answer.reason === "gateway_unreachable";
+}
 /** The additive page fields as `--json` output, only the ones the door sent. */
 export function pageFieldsOf(body) {
     const fields = {};
@@ -61,20 +76,33 @@ export async function streamAllIssues(command, door, base) {
     let pages = 0;
     let expected = null;
     let cursor = null;
+    let retries = 0;
     for (;;) {
         if (cursor)
             query.set("cursor", cursor);
-        const answer = await askAgentDoor(door, {
+        let answer = await askAgentDoor(door, {
             path: `/api/work/issues?${query.toString()}`,
             method: "GET",
             label: "issue list",
-            timeoutMs: READ_DEADLINE_MS,
+            timeoutMs: ALL_PAGE_DEADLINE_MS,
         });
+        for (let attempt = 0; !answer.ok && retryablePageFailure(answer) && attempt < allWalkRetry.delaysMs.length; attempt += 1) {
+            retries += 1;
+            console.error(`${TAG} page retry`, JSON.stringify({ page: pages + 1, attempt: attempt + 2, reason: answer.reason, http_status: answer.httpStatus ?? null }));
+            await new Promise((resolve) => setTimeout(resolve, allWalkRetry.delaysMs[attempt]));
+            answer = await askAgentDoor(door, {
+                path: `/api/work/issues?${query.toString()}`,
+                method: "GET",
+                label: "issue list",
+                timeoutMs: ALL_PAGE_DEADLINE_MS,
+            });
+        }
         if (!answer.ok) {
-            console.error(`${TAG} walk interrupted`, JSON.stringify({ reason: answer.reason, pages, returned }));
+            console.error(`${TAG} walk interrupted`, JSON.stringify({ reason: answer.reason, pages, returned, retries }));
             writeLine(door.io.stdout, JSON.stringify({
                 type: "coverage", coverage: "failed_partial", reason: answer.reason, detail: answer.detail,
-                pages, returned, unique: seen.size, expected, next_cursor: cursor,
+                pages, requested: expected, returned, unique: seen.size, expected, retries, next_cursor: cursor,
+                resume: cursor ? `cockpit ticket list --cursor ${cursor} --limit ${query.get("limit")} --json (same filters), then continue page by page` : "start again; the first page failed",
             }));
             return 1;
         }
@@ -94,7 +122,7 @@ export async function streamAllIssues(command, door, base) {
     }
     const exact = expected === null || expected === returned;
     writeLine(door.io.stdout, JSON.stringify({
-        type: "coverage", coverage: "complete", pages, returned, unique: seen.size, expected,
+        type: "coverage", coverage: "complete", pages, requested: expected, returned, unique: seen.size, expected, retries,
         ...(returned === seen.size && exact ? {} : { note: "returned, unique and expected do not all agree; rows changed during the walk" }),
     }));
     return 0;

package/dist/commands/issue-page-args.js

@@ -0,0 +1,64 @@
+/**
+ * `cockpit ticket list` page and filter flags (BLI-21315) and `--archived` (BLI-22367), split out of
+ * `local-args-tower-work.ts` so that parser stays within its size band. Pure argument checks: no I/O.
+ */
+import { optionalNonEmpty } from "./local-arg-values.js";
+/**
+ * `list --archived` (BLI-22367): archived tickets only, most recently archived first. The archived page takes
+ * --q, --project, --limit, --cursor and --all; any other filter is refused here rather than silently ignored.
+ */
+export function readArchivedFlag(action, values) {
+    if (!values.booleans.has("--archived"))
+        return false;
+    if (action !== "list")
+        throw new Error("--archived belongs to `cockpit ticket list` (archived tickets only).");
+    const unsupported = ["--state", "--assignee", "--label", "--created-after", "--created-before", "--updated-after", "--updated-before", "--sort", "--dir"]
+        .filter((flag) => values.flags.has(flag));
+    if (unsupported.length > 0)
+        throw new Error(`list --archived takes --q, --project, --limit, --cursor and --all; not ${unsupported.join(", ")}.`);
+    return true;
+}
+const INSTANT = /^\d{4}-\d\d-\d\d(?:T\d\d:\d\d:\d\d(?:\.\d{1,6})?(?:Z|[+-]\d\d:\d\d))?$/;
+/** BLI-21315: the cursor contract's flags. Filters and sort belong to `list`; `--cursor` also to `history`. */
+export function readIssuePage(action, values) {
+    const named = ["--q", "--created-after", "--created-before", "--updated-after", "--updated-before", "--sort", "--dir"];
+    for (const flag of named) {
+        if (values.flags.has(flag) && action !== "list")
+            throw new Error(`${flag} belongs to \`cockpit ticket list\`.`);
+    }
+    if (values.booleans.has("--all") && action !== "list")
+        throw new Error("--all belongs to `cockpit ticket list`.");
+    if (values.flags.has("--cursor") && action !== "list" && action !== "history") {
+        throw new Error("--cursor belongs to `cockpit ticket list` and `cockpit ticket history`.");
+    }
+    const instants = {};
+    for (const flag of ["--created-after", "--created-before", "--updated-after", "--updated-before"]) {
+        const value = optionalNonEmpty(values.flags.get(flag));
+        if (value !== undefined && (!INSTANT.test(value) || !Number.isFinite(Date.parse(value)))) {
+            throw new Error(`${flag} must be a UTC instant like 2026-10-01T00:00:00Z or a date like 2026-10-01.`);
+        }
+        instants[flag] = value;
+    }
+    const sort = optionalNonEmpty(values.flags.get("--sort"));
+    if (sort !== undefined && sort !== "updated_at" && sort !== "created_at")
+        throw new Error("--sort must be updated_at or created_at.");
+    const dir = optionalNonEmpty(values.flags.get("--dir"));
+    if (dir !== undefined && dir !== "asc" && dir !== "desc")
+        throw new Error("--dir must be asc or desc.");
+    const all = values.booleans.has("--all");
+    const cursor = optionalNonEmpty(values.flags.get("--cursor"));
+    if (all && cursor)
+        throw new Error("--all walks from the start; drop --cursor, or pass --cursor without --all to read one page.");
+    const q = optionalNonEmpty(values.flags.get("--q"));
+    return {
+        ...(cursor ? { cursor } : {}),
+        ...(q ? { q } : {}),
+        ...(instants["--created-after"] ? { createdAfter: instants["--created-after"] } : {}),
+        ...(instants["--created-before"] ? { createdBefore: instants["--created-before"] } : {}),
+        ...(instants["--updated-after"] ? { updatedAfter: instants["--updated-after"] } : {}),
+        ...(instants["--updated-before"] ? { updatedBefore: instants["--updated-before"] } : {}),
+        ...(sort ? { sort } : {}),
+        ...(dir ? { dir } : {}),
+        ...(all ? { all } : {}),
+    };
+}

package/dist/commands/issue-relations.js

@@ -9,7 +9,7 @@ import { randomUUID } from "node:crypto";
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
-import { askTicketWrite, refuseWrite } from "./issue-write.js";
+import { askTicketWrite, printSaved, refuseWrite, reportCommit } from "./issue-write.js";
 import { READ_DEADLINE_MS, TAG, WRITE_DEADLINE_MS } from "./issue-contracts.js";
 export const RELATION_VALUE_FLAGS = ["--blocks", "--blocked-by", "--related", "--duplicate-of", "--relation"];
 const KIND_FLAGS = [
@@ -120,10 +120,11 @@ export async function unrelateIssue(command, door) {
 }
 function finishWrite(door, body, requestId, sentence, tag) {
     writeLine(door.io.stderr, `${TAG} ${tag} ${JSON.stringify({ relation_id: body.relation_id ?? null })}`);
-    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
+    reportCommit(door, body.mutation, requestId);
     if (door.json)
         return emitAgentDoor(door, { ok: true, issue: body.issue, relation_id: body.relation_id, mutation: body.mutation });
     writeLine(door.io.stdout, sentence);
+    printSaved(door, body.mutation);
     return 0;
 }
 /** `unrelate <id> --blocks B`: the edge id, found through the same read `relations` prints. */

package/dist/commands/issue-show.js

@@ -15,7 +15,7 @@ import { mirroredTicketIdInTitle } from "@bli-cockpit/telemetry-core";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
 import { assigneeLabel, resolveAssigneeDirectory, withAssigneeIdentity } from "./issue-directory.js";
-import { READ_DEADLINE_MS, TAG, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
+import { READ_DEADLINE_MS, TAG, canonicalTicketUrl, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
 async function fetchOneIssue(door, ref) {
     const answer = await askAgentDoor(door, {
         path: `/api/work/issues/${encodeURIComponent(ref)}`,
@@ -25,7 +25,8 @@ async function fetchOneIssue(door, ref) {
     });
     if (!answer.ok)
         return { ref, ok: false, reason: answer.reason, detail: answer.detail };
-    const issue = answer.body.issue;
+    const detailBody = answer.body;
+    const issue = detailBody.issue;
     if (!issue) {
         return {
             ref,
@@ -54,6 +55,8 @@ async function fetchOneIssue(door, ref) {
         ok: true,
         issue,
         comments,
+        canonicalUrl: canonicalTicketUrl(door.dashboardUrl, issue.identifier, detailBody.canonical_url),
+        ...(detailBody.resolved_from ? { resolvedFrom: detailBody.resolved_from } : {}),
         ...(linearTicketId ? { linearTicketId } : {}),
         ...(commentsAnswer.ok ? {} : { commentsUnreadReason: commentsAnswer.reason }),
     };
@@ -64,6 +67,12 @@ function renderOneIssue(door, result, directory) {
     const size = sizeForEstimate(issue.estimate ?? null);
     writeLine(door.io.stdout, `${issue.state}  ·  priority ${issue.priority ?? 0}${size ? `  ·  size ${size}` : ""}  ·  assignee ${assigneeLabel(issue.assignee_id, directory)}  ·  updated ${issue.updated_at}`);
     writeLine(door.io.stdout, `id ${issue.id}${issue.parent_id ? `  ·  parent ${issue.parent_id}` : ""}`);
+    const archivedAt = issue.archived_at;
+    if (archivedAt)
+        writeLine(door.io.stdout, `ARCHIVED ${archivedAt} — hidden from lists and the board; \`cockpit ticket unarchive ${issue.identifier}\` brings it back.`);
+    writeLine(door.io.stdout, `Link: ${result.canonicalUrl}`);
+    if (result.resolvedFrom)
+        writeLine(door.io.stdout, `(found through the old Linear id ${result.resolvedFrom.ref})`);
     if (linearTicketId)
         writeLine(door.io.stdout, `Linear: ${linearTicketId}`);
     writeLine(door.io.stdout, "");
@@ -100,6 +109,8 @@ function readIssueJson(result, directory) {
     return {
         issue: withSizeLabel(withAssigneeIdentity(result.issue, directory)),
         comments: result.comments,
+        canonical_url: result.canonicalUrl,
+        ...(result.resolvedFrom ? { resolved_from: result.resolvedFrom } : {}),
         ...(result.linearTicketId ? { linear_ticket_id: result.linearTicketId } : {}),
         ...(result.commentsUnreadReason ? { comments_unread_reason: result.commentsUnreadReason } : {}),
     };

package/dist/commands/issue-versions.js

@@ -12,6 +12,7 @@ import { randomUUID } from "node:crypto";
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
+import { printSaved, refuseWrite, reportCommit } from "./issue-write.js";
 import { READ_DEADLINE_MS, TAG, WRITE_DEADLINE_MS } from "./issue-contracts.js";
 export async function listIssueVersions(command, door) {
     const ref = command.issueRef ?? "";
@@ -75,19 +76,15 @@ export async function restoreIssueVersion(command, door) {
         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);
-    }
+    if (!answer.ok)
+        return refuseWrite(door, answer, requestId);
     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 })}`);
+    reportCommit(door, body.mutation, 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 ?? "?"}.`);
+    printSaved(door, body.mutation);
     return 0;
 }