@openrig/cli 0.6.9 → 0.6.11

package/daemon/dist/domain/queue-repository.js

@@ -76,6 +76,19 @@ export function isTypedGateBlocker(value) {
     const p = typedGateBlockerPrefix(value);
     return p != null && value.slice(p.length).trim().length > 0;
 }
+/**
+ * #165: a claim is the destination acting on the row, which is stronger evidence than
+ * the wake send could get. While the row is claimed, an unconfirmed wire result
+ * (`delivered-ack-pending` or `indeterminate:*`) is presented as `claimed`. The stored
+ * result is never rewritten, so a re-wake or an unclaim reads the wire result again.
+ */
+export function presentedNudgeResult(wireResult, claimedAt) {
+    if (!claimedAt || wireResult === null)
+        return wireResult;
+    if (wireResult === "delivered-ack-pending" || wireResult.startsWith("indeterminate:"))
+        return "claimed";
+    return wireResult;
+}
 /**
  * 0.5.1-54 DR-1 (classifier fold, PM ruling qitem-20260811163927-74493d76) — classify a create-path
  * nudge FAILURE so the surfaced count becomes ACTIONABLE (constraint iii). Two classes:
@@ -172,6 +185,19 @@ export function deriveCrossHostSuccessorId(sourceQitemId, destinationSession, ho
         .slice(0, 16);
     return `qitem-xh-${digest}`;
 }
+/** The retained next owner must describe this closure, not a handoff before a reopen. */
+export function matchesRecordedHandoffTarget(qitemId, handedOffTo, closureTarget) {
+    if (!handedOffTo || !closureTarget)
+        return false;
+    if (closureTarget === handedOffTo)
+        return true;
+    // Cross-host re-drives preserve the pre-convention member@rig@host target.
+    const legacy = /^(.+)@([A-Za-z0-9][A-Za-z0-9._-]*)$/.exec(closureTarget);
+    if (legacy?.[1] === handedOffTo)
+        return true;
+    const foreign = /^(qitem-[^@]+)@([^@]+)$/.exec(closureTarget);
+    return foreign !== null && foreign[1] === deriveCrossHostSuccessorId(qitemId, handedOffTo, foreign[2]);
+}
 /** PL-007 — defensive column probe. Older test fixtures bypass the
  *  canonical migration list, so target_repo may be absent. Mirrors
  *  the `hasNodeColumn` pattern in rig-repository.ts. */
@@ -201,9 +227,19 @@ function detectTable(db, tableName) {
  * Phase A wires no-op; Phase B can plug in the rig registry to reject
  * phantom-rig destinations. POC compatibility: `qitem_id` shape preserved.
  */
-// Reduced column set for compact list rows (body/summary/evidence_ref omitted →
-// rowToItem backfills them empty). Shared by `list` and `findOverdue` (Slice 15)
-// so the compact projection cannot drift between the two.
+// Reduced column set for compact rows. `list`, `findOverdue` and `findUndelivered` all select it
+// (plus summary, through QueueRepository.compactColumns) and pass each row through compactRow, so
+// the compact projection is one thing: present text is shown, and what isn't selected is left out
+// and named in fieldsElided, never backfilled as empty.
+const COMPACT_ELIDED_FIELDS = [
+    "body", "evidenceRef", "humanDetail", "waiting", "chainOfRecord", "replyTo", "humanQuestions", "humanAnswers",
+];
+function compactRow(item) {
+    const row = { ...item, fieldsElided: [...COMPACT_ELIDED_FIELDS] };
+    for (const field of COMPACT_ELIDED_FIELDS)
+        delete row[field];
+    return row;
+}
 const COMPACT_QUEUE_COLUMNS = "qitem_id, ts_created, ts_updated, source_session, destination_session, state, priority, tier, tags, blocked_on, handed_off_to, handed_off_from, expires_at, closure_reason, closure_target, closure_required_at, claimed_at, last_nudge_attempt, last_nudge_result, last_heartbeat, resolution, target_repo";
 export function stampSelfHostSuffix(session) {
     if (session === undefined)
@@ -860,13 +896,7 @@ export class QueueRepository {
         // address it can never hold). Classified indeterminate for gateway
         // (landed with the owning subsystem; render unconfirmable here) — never
         // verified, never failed.
-        const destClass = classifyDestination(destinationSession, {
-            entities: (() => {
-                const loaded = this.loadHumanRegistryFn();
-                return loaded.ok ? loaded.entities : null;
-            })(),
-            hasTerminalTransport: (dest) => this.hasTerminalTransport(dest),
-        });
+        const destClass = this.classifyDestinationOf(destinationSession);
         if (destClass.class === "gateway-routable") {
             const resolvedNote = destClass.via === "registry-alias" && destClass.resolvedHuman
                 ? ` — the human registry resolves it to registered human '${destClass.resolvedHuman}'`
@@ -2449,8 +2479,11 @@ export class QueueRepository {
             const item = this.getById(input.qitemId);
             if (!item?.humanQuestions?.length)
                 return { status: "not-applicable", reason: "no-questions" };
-            if (item.state !== "pending")
-                return { status: "not-applicable", reason: `state-${item.state}` };
+            if (item.state !== "pending") {
+                // Slack can redeliver the click that closed it. Only to the asked human, say whether this answer is on record.
+                const onRecord = item.destinationSession === input.actorSession && item.humanAnswers?.[input.questionId] === input.optionId;
+                return { status: "not-applicable", reason: `state-${item.state}`, ...(onRecord ? { answerOnRecord: true } : {}) };
+            }
             if (item.destinationSession !== input.actorSession)
                 return { status: "not-applicable", reason: "not-the-asked-human" };
             const question = item.humanQuestions.find((q) => q.id === input.questionId);
@@ -2555,7 +2588,7 @@ export class QueueRepository {
             params.push(opts.targetRepo);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-        const columns = opts?.compact ? COMPACT_QUEUE_COLUMNS + (this.hasHumanIntentColumn ? ", human_intent" : "") : "*";
+        const columns = opts?.compact ? this.compactColumns() : "*";
         const useActiveFirst = !!(opts?.rig || opts?.asSession || opts?.activeOnly);
         const orderBy = useActiveFirst
             ? "CASE WHEN state IN ('pending', 'in-progress', 'blocked') THEN 0 ELSE 1 END, ts_created DESC"
@@ -2573,12 +2606,7 @@ export class QueueRepository {
                 ...(ledger && ledger.outcome !== "posted" ? { deliveryFailureDetail: ledger.detail } : {}),
             };
         });
-        return opts?.compact
-            ? items.map((item) => ({
-                ...item,
-                fieldsElided: ["body", "summary", "evidenceRef", "humanDetail", "waiting"],
-            }))
-            : items;
+        return opts?.compact ? items.map(compactRow) : items;
     }
     /**
      * OPR.0.3.2.20 — durable attention-class query.
@@ -2680,15 +2708,10 @@ export class QueueRepository {
         const rows = this.db.prepare(sql).all(...params);
         return rows.map((r) => this.rowToItem(r));
     }
-    /**
-     * Find qitems whose `closure_required_at` is past now. Used by watchdog;
-     * does NOT itself emit events — callers decide whether to nudge or escalate.
-     *
-     * Slice 15 (finding 2): optionally rig-scoped, limited, and compact — mirroring
-     * `list` — so `rig queue overdue` is bounded and body-free by default instead of
-     * dumping every rig's full qitem bodies to a single caller. No args = the prior
-     * behavior (all overdue, full rows) for the watchdog.
-     */
+    /** The compact listings' columns: the shared set plus the summary, which is short and is what people search for. */
+    compactColumns() {
+        return COMPACT_QUEUE_COLUMNS + (this.hasSummaryColumn ? ", summary" : "") + (this.hasHumanIntentColumn ? ", human_intent" : "");
+    }
     findOverdue(opts) {
         const cutoff = opts?.now ?? new Date().toISOString();
         const conditions = ["state = 'in-progress'", "closure_required_at IS NOT NULL", "closure_required_at <= ?"];
@@ -2698,14 +2721,15 @@ export class QueueRepository {
             conditions.push("(destination_session LIKE ? ESCAPE '\\' OR source_session LIKE ? ESCAPE '\\')");
             params.push(`%@${escaped}`, `%@${escaped}`);
         }
-        const columns = opts?.compact ? COMPACT_QUEUE_COLUMNS + (this.hasHumanIntentColumn ? ", human_intent" : "") : "*";
+        const columns = opts?.compact ? this.compactColumns() : "*";
         let sql = `SELECT ${columns} FROM queue_items WHERE ${conditions.join(" AND ")} ORDER BY closure_required_at ASC`;
         if (opts?.limit !== undefined) {
             sql += " LIMIT ?";
             params.push(opts.limit);
         }
         const rows = this.db.prepare(sql).all(...params);
-        return rows.map((r) => this.rowToItem(r, !opts?.compact));
+        const items = rows.map((r) => this.rowToItem(r, !opts?.compact));
+        return opts?.compact ? items.map(compactRow) : items;
     }
     /**
      * Record that an in-progress queue item has exceeded its closure_required_at
@@ -2759,13 +2783,6 @@ export class QueueRepository {
         this.eventBus.notifySubscribers(persisted);
         return persisted;
     }
-    /**
-     * Surface two evidence-backed undelivered classes: the original pending
-     * create-path nudge failures, and active human-notification episodes whose
-     * gateway ledger says transport-failed or receiptless past the post window.
-     * A generic null nudge is still excluded; only a structured OWNER episode
-     * makes that absence meaningful. READ only — no retry or unwind.
-     */
     findUndelivered(opts) {
         // OPR.0.5.6.14 — delivery truth belongs to the CURRENT human-notification
         // episode, not to the row's whole history. Pull every active row that can
@@ -2794,7 +2811,7 @@ export class QueueRepository {
             conditions.push("(destination_session LIKE ? ESCAPE '\\' OR source_session LIKE ? ESCAPE '\\')");
             params.push(`%@${escaped}`, `%@${escaped}`);
         }
-        const columns = opts?.compact ? COMPACT_QUEUE_COLUMNS + (this.hasHumanIntentColumn ? ", human_intent" : "") : "*";
+        const columns = opts?.compact ? this.compactColumns() : "*";
         const sql = `SELECT ${columns} FROM queue_items WHERE ${conditions.join(" AND ")} ORDER BY ts_created ASC`;
         const rows = this.db.prepare(sql).all(...params);
         const out = [];
@@ -2831,7 +2848,18 @@ export class QueueRepository {
             if (opts?.limit !== undefined && out.length >= opts.limit)
                 break;
         }
-        return out;
+        return opts?.compact ? out.map(compactRow) : out;
+    }
+    /** OPR.0.5.6.14 — the one destination-classification seam, as the wake path consults it.
+     *  Public for the single-row read route; getById itself stays free of topology reads. */
+    classifyDestinationOf(destinationSession) {
+        return classifyDestination(destinationSession, {
+            entities: (() => {
+                const loaded = this.loadHumanRegistryFn();
+                return loaded.ok ? loaded.entities : null;
+            })(),
+            hasTerminalTransport: (dest) => this.hasTerminalTransport(dest),
+        });
     }
     /** OPR.0.5.6.14 — terminal transport is a CAPABILITY, not topology presence.
      *  An exact session or composed canonical seat is pane-bound only when its
@@ -3151,9 +3179,9 @@ export class QueueRepository {
         return view;
     }
     handoffAdvisory(row) {
-        // handoff() creates its local successor in the same transaction. Do not
-        // scan successor history again on every projection of those source rows.
-        if (row.state === "handed-off" || !isTerminalState(row.state)
+        // Generic updates can write handed-off and retain a previous handoff's owner
+        // after reopening. Skip only when that owner still matches this closure.
+        if ((row.state === "handed-off" && matchesRecordedHandoffTarget(row.qitem_id, row.handed_off_to, row.closure_target)) || !isTerminalState(row.state)
             || row.closure_reason !== "handed_off_to" || !row.closure_target)
             return undefined;
         const target = row.closure_target;
@@ -3234,7 +3262,8 @@ export class QueueRepository {
             closureRequiredAt: row.closure_required_at,
             claimedAt: row.claimed_at,
             lastNudgeAttempt: row.last_nudge_attempt,
-            lastNudgeResult: row.last_nudge_result,
+            lastNudgeResult: presentedNudgeResult(row.last_nudge_result, row.claimed_at),
+            lastNudgeWireResult: row.last_nudge_result,
             lastHeartbeat: row.last_heartbeat,
             resolution: row.resolution,
             // PL-007: target_repo present only when migration 038 has applied;