@openrig/cli 0.6.9 → 0.6.11

package/dist/commands/queue.js

@@ -10,58 +10,183 @@ import { enumArg, positiveIntArg } from "../cli-error.js";
 import { resolveContextRef } from "../context-resolve.js";
 import { shellQuote } from "../cross-host-executor.js";
 import { omittedReadField, readView } from "../read-view.js";
-export async function waitForDeliveryOutcome(client, qitemId, deps = {}) {
+import { buildWriteReceipt, compactOutputEnabled } from "../queue-receipt.js";
+function stringField(row, key) {
+    return typeof row[key] === "string" ? row[key] : null;
+}
+/** The row's own signals decide who owns delivery: the recorded wake result, then the daemon's
+ *  destination class (present before any wake, e.g. --no-nudge), then a gateway receipt. The
+ *  address pattern is only the fallback for a daemon that reports none of these. A gateway
+ *  receipt beside a terminal signal adds a gateway side (gatewayAlsoPosts); it doesn't replace it. */
+function receiptSourceOf(destination, row) {
+    const wakeResult = stringField(row, "lastNudgeResult");
+    if (wakeResult !== null)
+        return wakeResult.startsWith("gateway-owned:") ? "gateway" : "terminal";
+    const destinationClass = stringField(row, "destinationClass");
+    if (destinationClass !== null)
+        return destinationClass === "gateway-routable" ? "gateway" : "terminal";
+    if (stringField(row, "deliveryOutcome") !== null)
+        return "gateway";
+    return destination !== null && isHumanSeatSessionRef(destination) ? "gateway" : "terminal";
+}
+/** A terminal destination the gateway may also post to (a registered person who is also a seat
+ *  with a pane): the row carries the owner notification level the Slack selector keys on, or a
+ *  gateway receipt already exists. */
+function gatewayAlsoPosts(row) {
+    return stringField(row, "ownerNotificationLevel") !== null || stringField(row, "deliveryOutcome") !== null;
+}
+/** A terminal destination is a person when the gateway also posts to it or its address is a human seat's. */
+function terminalDestinationKind(destination, gatewaySide) {
+    return gatewaySide || (destination !== null && isHumanSeatSessionRef(destination)) ? "human" : "agent";
+}
+function gatewayReceiptOf(row) {
+    const outcome = stringField(row, "deliveryOutcome");
+    if (outcome === "posted")
+        return { outcome, connectorAccepted: true };
+    if (outcome === "transport-failed" || outcome === "never-posted") {
+        const detail = stringField(row, "deliveryFailureDetail");
+        return { outcome, connectorAccepted: false, ...(detail ? { detail } : {}) };
+    }
+    return { outcome: "still-pending", connectorAccepted: null };
+}
+function terminalWakeOutcome(wakeResult) {
+    if (wakeResult === null)
+        return "still-pending";
+    if (wakeResult === "verified" || wakeResult === "delivered-ack-pending" || wakeResult === "claimed")
+        return wakeResult;
+    if (wakeResult.startsWith("failed:") || wakeResult.startsWith("unroutable:"))
+        return "failed";
+    if (wakeResult.startsWith("retained:"))
+        return "retained";
+    return "indeterminate";
+}
+/** Only these known states mean "not delivered yet, nothing went wrong". An unknown value never gets that label. */
+function isKnownUnconfirmed(wakeResult, outcome) {
+    if (outcome === "not-requested" || wakeResult === null || wakeResult === "delivered-ack-pending")
+        return true;
+    return wakeResult.startsWith("indeterminate:") || wakeResult.startsWith("retained:");
+}
+function terminalDeliveryResult(qitemId, destination, row, outcome, waitedMs) {
+    const wakeResult = stringField(row, "lastNudgeResult");
+    const claimedAt = stringField(row, "claimedAt");
+    const pickupState = typeof row.pickup === "object" && row.pickup !== null ? stringField(row.pickup, "state") : null;
+    const claim = { observed: claimedAt !== null, claimedAt, pickup: pickupState };
+    const seat = destination ?? "<destination>";
+    const receipt = {
+        "verified": "Terminal receipt confirmed: the wake rendered in the destination pane.",
+        "delivered-ack-pending": "Terminal receipt unconfirmed (delivered-ack-pending): the wake was sent, but its render could not be confirmed.",
+        "claimed": "Terminal receipt unconfirmed, but the seat has claimed the item (claimed).",
+        "retained": `The wake is held (${wakeResult}): nothing was typed into the pane. A held create wake is not retried automatically; inspect it with rig seat held-messages ${seat}.`,
+        "failed": `The wake failed (${wakeResult}).`,
+        "indeterminate": `Terminal receipt unconfirmed (${wakeResult}).`,
+        "still-pending": waitedMs === null ? "No terminal receipt was recorded before the claim." : `No terminal receipt was recorded within ${waitedMs}ms.`,
+        "not-requested": "No terminal wake was requested (--no-nudge).",
+    };
+    const claimText = claim.observed
+        ? `Claimed at ${claimedAt}${pickupState ? ` (pickup ${pickupState})` : ""}. A claim shows the seat took the item; it does not prove the body was read.`
+        : waitedMs === null ? "No claim observed yet." : `No claim observed within ${waitedMs}ms.`;
+    const gatewaySide = gatewayAlsoPosts(row);
+    const gateway = gatewaySide ? gatewayReceiptOf(row) : null;
+    const slackText = gateway === null ? ""
+        : gateway.outcome === "posted" ? " Slack receipt: posted."
+            : gateway.outcome === "still-pending" ? (waitedMs === null ? " No Slack receipt yet." : ` No Slack receipt within ${waitedMs}ms.`)
+                : ` Slack delivery ${gateway.outcome}${gateway.detail ? `: ${gateway.detail}` : ""}.`;
+    const gatewayFailed = gateway !== null && gateway.connectorAccepted === false;
+    const notFailed = !claim.observed && !gatewayFailed && isKnownUnconfirmed(wakeResult, outcome) ? " This is not a failed handoff." : "";
+    const destinationKind = terminalDestinationKind(destination, gatewaySide);
+    const settled = claim.observed && (gateway === null || gateway.outcome === "posted");
+    return {
+        receiptSource: "terminal",
+        destinationKind,
+        ...(destinationKind === "human" ? { humanReadership: "unknown" } : {}),
+        outcome,
+        wakeResult,
+        claim,
+        ...(gateway ? { gateway } : {}),
+        detail: `The qitem is saved. ${receipt[outcome]}${slackText} ${claimText}${notFailed}`,
+        nextAction: settled ? null : outcome === "retained" ? `rig seat held-messages ${seat}` : `rig queue show ${qitemId} --json`,
+    };
+}
+/** The receipt could not be read or correlated: say which part is unknown, nothing more. */
+export function unreadableDeliveryResult(qitemId, destination, row, reason) {
+    const nextAction = qitemId ? `rig queue show ${qitemId} --json` : null;
+    if (receiptSourceOf(destination, row) === "gateway") {
+        return {
+            receiptSource: "gateway",
+            destinationKind: "human",
+            humanReadership: "unknown",
+            outcome: "indeterminate",
+            connectorAccepted: null,
+            detail: reason,
+            nextAction,
+        };
+    }
+    return { ...terminalDeliveryResult(qitemId ?? "", destination, row, "indeterminate", null), detail: reason, nextAction };
+}
+export async function waitForDeliveryOutcome(client, qitemId, deps = {}, target = {}) {
     const timeoutMs = deps.timeoutMs ?? 30_000;
     const intervalMs = deps.intervalMs ?? 500;
     const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const now = deps.now ?? (() => Date.now());
     const started = now();
+    let row = {};
     for (;;) {
         try {
             const response = await client.get(`/api/queue/${encodeURIComponent(qitemId)}`);
             if (response.status !== 200)
                 throw new Error(`receipt lookup returned HTTP ${response.status}`);
-            const outcome = response.data.deliveryOutcome;
+            row = response.data ?? {};
+        }
+        catch (error) {
+            return unreadableDeliveryResult(qitemId, target.destinationSession ?? stringField(row, "destinationSession"), row, `delivery receipt could not be read: ${error.message}`);
+        }
+        const destination = target.destinationSession ?? stringField(row, "destinationSession");
+        const timedOut = now() - started >= timeoutMs;
+        if (receiptSourceOf(destination, row) === "gateway") {
+            const outcome = row.deliveryOutcome;
+            const gateway = { receiptSource: "gateway", destinationKind: "human", humanReadership: "unknown" };
             if (outcome === "posted") {
                 // #96: a --reply-to update reports whether it joined the earlier item's thread.
-                const replyTo = typeof response.data.replyTo === "string" ? response.data.replyTo : null;
-                const fallback = typeof response.data.replyToFallback === "string" ? response.data.replyToFallback : null;
+                const replyTo = stringField(row, "replyTo");
+                const fallback = stringField(row, "replyToFallback");
                 return {
+                    ...gateway,
                     outcome,
                     connectorAccepted: true,
-                    humanReadership: "unknown",
                     ...(replyTo ? { threaded: fallback === null } : {}),
                     ...(replyTo && fallback ? { detail: `posted as a new top-level message, not in ${replyTo}'s thread: ${fallback}` } : {}),
                     nextAction: null,
                 };
             }
             if (outcome === "transport-failed" || outcome === "never-posted") {
+                const { detail } = gatewayReceiptOf(row);
+                return { ...gateway, outcome, connectorAccepted: false, ...(detail ? { detail } : {}), nextAction: `rig queue show ${qitemId} --json` };
+            }
+            if (timedOut) {
                 return {
-                    outcome,
-                    connectorAccepted: false,
-                    humanReadership: "unknown",
-                    detail: typeof response.data.deliveryFailureDetail === "string" ? response.data.deliveryFailureDetail : undefined,
+                    ...gateway,
+                    outcome: "still-pending",
+                    connectorAccepted: null,
+                    detail: `no terminal connector receipt within ${timeoutMs}ms; the durable qitem remains intact`,
                     nextAction: `rig queue show ${qitemId} --json`,
                 };
             }
         }
-        catch (error) {
-            return {
-                outcome: "indeterminate",
-                connectorAccepted: null,
-                humanReadership: "unknown",
-                detail: `delivery receipt could not be read: ${error.message}`,
-                nextAction: `rig queue show ${qitemId} --json`,
-            };
-        }
-        if (now() - started >= timeoutMs) {
-            return {
-                outcome: "still-pending",
-                connectorAccepted: null,
-                humanReadership: "unknown",
-                detail: `no terminal connector receipt within ${timeoutMs}ms; the durable qitem remains intact`,
-                nextAction: `rig queue show ${qitemId} --json`,
-            };
+        else {
+            // --no-nudge requested no wake: there is no terminal receipt to wait for.
+            const wakeResult = stringField(row, "lastNudgeResult");
+            const outcome = target.nudge === false ? "not-requested" : terminalWakeOutcome(wakeResult);
+            // Any recorded wake result (or an existing claim) settles the terminal side: a later pickup
+            // is `rig queue show`'s to report. When the gateway may also post the row, its receipt is
+            // awaited too. Only a missing receipt waits, up to the bound. Nothing here re-sends anything.
+            const gatewaySide = gatewayAlsoPosts(row);
+            const terminalSettled = outcome === "not-requested" || wakeResult !== null || stringField(row, "claimedAt") !== null;
+            const gatewaySettled = !gatewaySide || stringField(row, "deliveryOutcome") !== null;
+            if (terminalSettled && gatewaySettled) {
+                return terminalDeliveryResult(qitemId, destination, row, outcome, null);
+            }
+            if (timedOut)
+                return terminalDeliveryResult(qitemId, destination, row, outcome, timeoutMs);
         }
         await sleep(intervalMs);
     }
@@ -121,8 +246,45 @@ function printResult(json, body, status) {
     if (status >= 400)
         process.exitCode = status >= 500 ? 2 : 1;
 }
+/** Slice 15: the receipt context when a write should print its receipt — the
+ *  `output.compact` switch is on and `--full` was not given — else null (today's
+ *  output). Error responses always print whole, whatever this returns. */
+function writeReceipt(full, ctx) {
+    return !full && compactOutputEnabled() ? ctx : null;
+}
+/** A `--host` id that may name another daemon. Empty and `local` never do; one that
+ *  equals the selected daemon's own host id is settled by {@link settleReceiptHost}. */
+function remoteHostOf(hostId) {
+    return hostId && hostId !== "local" ? hostId : undefined;
+}
+/** The daemon's own rule (`resolvesToLocalHost`): a `--host` naming the selected
+ *  daemon's selfHostId took the local path, so its receipt must not call the row
+ *  remote. Read only for a receipt; an unreadable id leaves the host unconfirmed. */
+async function settleReceiptHost(client, receipt) {
+    if (!receipt.remoteHost)
+        return receipt;
+    let selfHostId;
+    try {
+        const health = await client.get("/healthz", { timeoutMs: 1_000 });
+        if (health.status === 200 && typeof health.data?.selfHostId === "string" && health.data.selfHostId.trim())
+            selfHostId = health.data.selfHostId;
+    }
+    catch { /* An unreadable id must not change or fail the write's output. */ }
+    if (selfHostId === receipt.remoteHost)
+        return { ...receipt, remoteHost: undefined };
+    return selfHostId === undefined ? { ...receipt, remoteHostUnconfirmed: true } : receipt;
+}
+async function printWriteResult(client, json, body, status, receipt) {
+    const settled = receipt && status < 400 ? await settleReceiptHost(client, receipt) : null;
+    const projected = settled ? buildWriteReceipt(body, settled) : null;
+    if (!projected) {
+        printResult(json, body, status);
+        return;
+    }
+    console.log(json ? JSON.stringify(projected.json) : projected.text);
+}
 // Recovery belongs to the selected daemon's reply; never infer a host from an ID.
-async function printQueueItemResult(client, qitemId, json, body, status) {
+async function printQueueItemResult(client, qitemId, json, body, status, receipt = null) {
     if (status >= 400 && body && typeof body === "object"
         && body.error === "qitem_not_found") {
         let selfHostId;
@@ -140,7 +302,7 @@ async function printQueueItemResult(client, qitemId, json, body, status) {
                 + `If it came from another host, run rig host list; replace <daemon-url> with its registered daemon URL and run: OPENRIG_URL='<daemon-url>' rig queue show ${shellQuote(qitemId)} --full --json`,
         };
     }
-    printResult(json, body, status);
+    await printWriteResult(client, json, body, status, receipt);
 }
 // OPR.0.4.3.03 — `rig queue show` body preview.
 //
@@ -347,7 +509,8 @@ export function queueCommand(depsOverride) {
         .option("--evidence-ref <path>", "OPR.0.4.4.19 FR-5: pointer to the durable artifact a human judges (e.g. a PROOF.md path). Required by the daemon when the item is human-routed; optional otherwise.")
         .option("--host <id>", QUEUE_HOST_OPTION_HELP)
         .option("--no-nudge", "Suppress the default destination nudge (cold-queue)")
-        .option("--verify", "Boundedly wait for the existing gateway delivery receipt after persistence; never retries the create and never claims human readership")
+        .option("--verify", "Boundedly wait after persistence for the existing receipts: the gateway receipt for a person, or the wake result and any claim already present for a seat, plus the gateway receipt when the gateway may also post to that seat (a registered person with a pane; eligible to post, not guaranteed). Never retries the create or the wake, and never claims the message was read")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (opts) => {
         // OPR.0.4.6.MH3 D-3 (C3): resolve the host qualifier at the CLI edge —
@@ -479,6 +642,9 @@ export function queueCommand(depsOverride) {
             // stderr survives an interrupted wait without adding a second JSON
             // document to stdout. This is a request identity, NOT a commit receipt.
             console.error(`Queue create request ID: ${qitemId} (not proof of persistence). ${recovery}`);
+            const receipt = writeReceipt(opts.full, {
+                verb: "create", nudgeSuppressed: opts.nudge === false, idGiven: opts.id !== undefined, remoteHost: remoteHostOf(hostResolved.hostId),
+            });
             const res = await client.post("/api/queue/create", {
                 ...(managedSource === undefined ? { sourceSession: source } : {}),
                 qitemId,
@@ -525,24 +691,19 @@ export function queueCommand(depsOverride) {
                 const created = res.data;
                 const qitemId = typeof created.qitemId === "string" ? created.qitemId : null;
                 const delivery = qitemId
-                    ? await waitForDeliveryOutcome(client, qitemId, deps.deliveryVerify)
-                    : {
-                        outcome: "indeterminate",
-                        connectorAccepted: null,
-                        humanReadership: "unknown",
-                        detail: "create response did not include a qitem id; delivery cannot be correlated",
-                        nextAction: null,
-                    };
-                printResult(opts.json ?? false, { ...created, qitemId, persisted: true, delivery }, res.status);
+                    ? await waitForDeliveryOutcome(client, qitemId, deps.deliveryVerify, { destinationSession: hostResolved.destination, nudge: opts.nudge })
+                    : unreadableDeliveryResult(null, hostResolved.destination, {}, "create response did not include a qitem id; delivery cannot be correlated");
+                await printWriteResult(client, opts.json ?? false, { ...created, qitemId, persisted: true, delivery }, res.status, receipt);
                 return;
             }
-            printResult(opts.json ?? false, res.data, res.status);
+            await printWriteResult(client, opts.json ?? false, res.data, res.status, receipt);
         }, hostResolved.hostId !== undefined, hostResolved.hostId);
     });
     cmd
         .command("claim <qitemId>")
         .description("Claim a qitem (pending → in-progress); computes closure_required_at from tier")
         .option("--destination <session>", "(deprecated, ignored) the claimant is derived from the seat env (X-OpenRig-Session); P21 I3 made the claim route derive it from the transport header")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (qitemId, opts) => {
         // P21 I3 reconcile: the claimant is DERIVED from the seat env — --destination deprecated + ignored,
@@ -552,7 +713,7 @@ export function queueCommand(depsOverride) {
         const deps = getDeps();
         await withClient(deps, async (client) => {
             const res = await client.post(`/api/queue/${encodeURIComponent(qitemId)}/claim`, {});
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, { verb: "claim" }));
         });
     });
     cmd
@@ -560,6 +721,7 @@ export function queueCommand(depsOverride) {
         .description("Release a claimed qitem (in-progress → pending)")
         .option("--destination <session>", "(deprecated, ignored) the releaser is derived from the seat env (X-OpenRig-Session); the unclaim route derives it from the transport header")
         .option("--reason <text>", "Reason for unclaim", "manual")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (qitemId, opts) => {
         // P21 I3 reconcile: the releaser is DERIVED from the seat env — --destination deprecated + ignored,
@@ -571,7 +733,7 @@ export function queueCommand(depsOverride) {
             const res = await client.post(`/api/queue/${encodeURIComponent(qitemId)}/unclaim`, {
                 reason: opts.reason,
             });
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, { verb: "unclaim" }));
         });
     });
     cmd
@@ -588,6 +750,7 @@ export function queueCommand(depsOverride) {
         .option("--summary <text>", "OPR.0.4.4.19 FR-6: park-time summary persisted onto the item (human-seat parks only)")
         .option("--evidence-ref <path>", "OPR.0.4.4.19 FR-6: park-time durable-artifact pointer persisted onto the item (human-seat parks only)")
         .option("--note <text>", "Transition note for the audit log")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (qitemId, opts) => {
         // P21 I3 reconcile: the actor is DERIVED from the seat env (X-OpenRig-Session, stamped by
@@ -609,7 +772,7 @@ export function queueCommand(depsOverride) {
                 evidenceRef: opts.evidenceRef,
                 transitionNote: opts.note,
             });
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, { verb: "update" }));
         });
     });
     // OPR.0.4.4.19 FR-6 — the first-class park affordance (C5 leg 1). One verb,
@@ -630,6 +793,7 @@ export function queueCommand(depsOverride) {
         .option("--continuation <text>", "What resumes. Workspace deferred/not-imminent work belongs in a mission/slice")
         .option("--wake-watchdog <jobId>", "Attach an existing live watchdog id targeting the parked owner")
         .option("--wake-after <duration>", "Atomically arm a timer with the park (for example 90s, 15m, 2h)", wakeDurationSeconds)
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .addHelpText("after", `
 --on <blocker> is always required; a wake option does not replace it.
@@ -657,7 +821,7 @@ workspace home that is deferred/not-imminent belongs in its mission/slice.`)
                 wakeAfterSeconds: opts.wakeAfter,
                 transitionNote: opts.continuation ? `continuation: ${opts.continuation}` : (opts.note ?? `parked on ${opts.on}`),
             });
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, { verb: "block" }));
         });
     });
     // OPR.0.4.4.19 FR-7 — the resolve verb's CLI wrapper: a THIN client of the
@@ -710,6 +874,7 @@ workspace home that is deferred/not-imminent belongs in its mission/slice.`)
         .option("--evidence-ref <path>", "OPR.0.4.4.19 FR-5: durable-artifact pointer for the new qitem. Required by the daemon when the new qitem is human-routed; optional otherwise.")
         .option("--host <id>", QUEUE_HOST_OPTION_HELP)
         .option("--no-nudge", "Suppress the default nudge to the new destination")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (qitemId, opts) => {
         // P21 I3 reconcile: the handing-off seat is DERIVED from the seat env (X-OpenRig-Session) —
@@ -767,7 +932,9 @@ workspace home that is deferred/not-imminent belongs in its mission/slice.`)
                 nudge: opts.nudge,
                 ...(hostResolved.hostId !== undefined ? { hostId: hostResolved.hostId } : {}),
             });
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, {
+                verb: "handoff", nudgeSuppressed: opts.nudge === false, remoteHost: remoteHostOf(hostResolved.hostId),
+            }));
         });
     });
     cmd
@@ -787,6 +954,7 @@ workspace home that is deferred/not-imminent belongs in its mission/slice.`)
         .option("--evidence-ref <path>", "OPR.0.4.4.19 FR-5: durable-artifact pointer for the new qitem. Required by the daemon when the new qitem is human-routed; optional otherwise.")
         .option("--host <id>", QUEUE_HOST_OPTION_HELP)
         .option("--no-nudge", "Suppress the default nudge to the new destination")
+        .option("--full", "Print the whole response row(s) as today, even when output.compact is on (the receipt's waiting keeps only blocker and nextBackstop)")
         .option("--json", "JSON output for agents")
         .action(async (qitemId, opts) => {
         // P21 I3 reconcile: the handing-off seat is DERIVED from the seat env (X-OpenRig-Session) —
@@ -842,7 +1010,9 @@ workspace home that is deferred/not-imminent belongs in its mission/slice.`)
                 nudge: opts.nudge,
                 ...(hostResolved.hostId !== undefined ? { hostId: hostResolved.hostId } : {}),
             });
-            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status);
+            await printQueueItemResult(client, qitemId, opts.json ?? false, res.data, res.status, writeReceipt(opts.full, {
+                verb: "handoff-and-complete", nudgeSuppressed: opts.nudge === false, remoteHost: remoteHostOf(hostResolved.hostId),
+            }));
         });
     });
     cmd