@openrig/cli 0.5.11 → 0.5.13

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

@@ -1,9 +1,11 @@
+import { readWakeLadderBackstop } from "./queue-wake-ladder.js";
 import { createHash } from "node:crypto";
 import { loadHumanRegistry, resolveRegisteredHumanAddress } from "./gateway/human-registry.js";
 import { resolveExternal } from "./gateway/external-admission.js";
 import { QueueTransitionLog } from "./queue-transition-log.js";
 import { WAKE_INTENT_PREFIX } from "./outbox-handler.js";
 import { derivePickup } from "./queue-pickup.js";
+import { lastMeaningfulTransition, readWaitingView } from "./queue-waiting.js";
 import { wrapPaneEnvelope } from "../lib/pane-envelope.js";
 import { getSelfHostId } from "./hosts/fanout-contract.js";
 import { parseSessionName } from "./session-name.js";
@@ -12,7 +14,7 @@ import { computeClosureRequiredAt, validateClosure, } from "./hot-potato-enforce
 import { isHumanSeatSession, validateHumanPark, validateHumanRoute } from "./human-route-enforcer.js";
 import { QueueWakeRepository, USAGE_LIMIT_BLOCKER_TAG, } from "./queue-wake-repository.js";
 import { WatchdogJobsRepository } from "./watchdog-jobs-repository.js";
-import { armQueueWait, backOffQueueWait, refreshQueueWaits } from "./queue-wait-backoff.js";
+import { armQueueWait, backOffQueueWait, refreshQueueWaits, evaluateQueueWait, retargetQueueWait } from "./queue-wait-backoff.js";
 export const QUEUE_STATES = [
     "pending",
     "in-progress",
@@ -362,8 +364,8 @@ export class QueueRepository {
     }
     /** Startup wires this after queue/watchdog composition. Tests may also call
      * it after reconstruction; it only reconciles queue-owned repeating timers. */
-    reconcileWaitReminders(changedQitem) {
-        refreshQueueWaits(this.db, this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db), changedQitem);
+    reconcileWaitReminders(changedQitem, proofChanged = false) {
+        refreshQueueWaits(this.db, this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db), changedQitem, proofChanged);
     }
     startWaitReminders() {
         this.reconcileWaitReminders();
@@ -371,6 +373,9 @@ export class QueueRepository {
             if (event.type.startsWith("queue.") && "qitemId" in event && typeof event.qitemId === "string") {
                 this.reconcileWaitReminders(event.qitemId);
             }
+            else if (event.type === "proof.judged" || event.type === "proof.sources_changed") {
+                this.reconcileWaitReminders(undefined, true);
+            }
         });
     }
     /**
@@ -450,6 +455,8 @@ export class QueueRepository {
             toSession,
             identityProvenance,
             bareBody: `Queue handoff: ${successorQitemId} - check your queue.`,
+            tags: this.getById(successorQitemId)?.handedOffFrom
+                ? [`queue:return:${this.getByIdOrThrow(successorQitemId).handedOffFrom}`] : undefined,
         });
     }
     recordWakeIntent(input) {
@@ -479,7 +486,7 @@ export class QueueRepository {
             toSession: input.destinationSession,
             identityProvenance: input.identityProvenance,
             bareBody: `Blocker ${input.blockerQitemId} resolved; parked qitem ${input.qitemId} is pending. Resume the recorded continuation and update the row.`,
-            tags: [AUTO_UNPARK_WAKE_TAG, `${AUTO_UNPARK_BLOCKER_TAG_PREFIX}${input.blockerQitemId}`],
+            tags: [AUTO_UNPARK_WAKE_TAG, `${AUTO_UNPARK_BLOCKER_TAG_PREFIX}${input.blockerQitemId}`, `queue:return:${input.blockerQitemId}`],
         });
     }
     deliverWakeIntentAfterCommit(outboxId) {
@@ -543,11 +550,55 @@ export class QueueRepository {
         // cannot both send. A losing claim — the row is no longer `pending` (already
         // resolved, in-flight under another drainer, or claimed) — simply skips: no
         // send, no tally. This makes the external effect once, not merely the state.
-        if (!this.outbox.claimForDelivery(outboxId))
-            return "skipped";
-        const intent = this.outbox.getById(outboxId);
+        // Claim the exact return's arrival + dependent resumes atomically. Each
+        // original frozen intent and audit pointer survives; only transport coalesces.
+        let superseded = false;
+        const actionable = (entry) => {
+            const row = entry.auditPointer ? this.db.prepare("SELECT state FROM queue_items WHERE qitem_id = ?").get(entry.auditPointer) : undefined;
+            let current = row?.state === "pending";
+            const resumePrefix = `${WAKE_INTENT_PREFIX}blocker-`;
+            if (current && entry.outboxId.startsWith(resumePrefix)) {
+                const expected = Number(entry.outboxId.slice(resumePrefix.length));
+                const latest = this.db.prepare(`SELECT transition_id FROM (
+          SELECT transition_id, state, LAG(state) OVER (ORDER BY transition_id) AS previous_state
+          FROM queue_transitions WHERE qitem_id = ?)
+          WHERE state = 'pending' AND previous_state IS NOT 'pending' ORDER BY transition_id DESC LIMIT 1`)
+                    .get(entry.auditPointer);
+                current = expected === latest?.transition_id;
+            }
+            if (!current) {
+                // Existing failed state means the requested old delivery was refused;
+                // the explicit tag distinguishes supersession from a transport attempt.
+                // Do not stamp last_nudge_result or delivered_at: neither happened.
+                const changed = this.db.prepare("UPDATE outbox_entries SET delivery_state = 'failed', tags = ? WHERE outbox_id = ? AND delivery_state = 'pending'")
+                    .run(JSON.stringify([...(entry.tags ?? []), "queue:wake-superseded"]), entry.outboxId);
+                superseded ||= changed.changes > 0;
+            }
+            return current;
+        };
+        const group = this.db.transaction(() => {
+            const candidate = this.outbox.getById(outboxId);
+            if (!candidate || candidate.deliveryState !== "pending" || !actionable(candidate))
+                return [];
+            if (!this.outbox.claimForDelivery(outboxId))
+                return [];
+            const first = this.outbox.getById(outboxId);
+            const intents = [first];
+            const correlation = first.tags?.find(tag => tag.startsWith("queue:return:"));
+            if (correlation) {
+                const peers = this.db.prepare(`SELECT outbox_id FROM outbox_entries
+          WHERE delivery_state = 'pending' AND destination_session = ? AND substr(outbox_id, 1, ?) = ?
+          AND EXISTS (SELECT 1 FROM json_each(outbox_entries.tags) WHERE value = ?)
+          ORDER BY outbox_id`).all(first.destinationSession, WAKE_INTENT_PREFIX.length, WAKE_INTENT_PREFIX, correlation);
+                for (const peer of peers)
+                    if (actionable(this.outbox.getById(peer.outbox_id)) && this.outbox.claimForDelivery(peer.outbox_id))
+                        intents.push(this.outbox.getById(peer.outbox_id));
+            }
+            return intents;
+        })();
+        const intent = group[0];
         if (!intent)
-            return "skipped"; // unreachable post-claim; defensive
+            return superseded ? "failed" : "skipped";
         // Only deliver a wake for a qitem that actually exists. A wake intent whose
         // target qitem is missing — a caller-recorded id under this prefix (the route
         // no longer refuses those), or a successor already swept — is finalized
@@ -558,46 +609,50 @@ export class QueueRepository {
         }
         const qitemId = intent.auditPointer ?? outboxId;
         // MF4: send the FROZEN envelope stored on the intent verbatim (no re-resolution).
-        const outcome = await this.performWakeSend(qitemId, intent.destinationSession, intent.senderSession, undefined, intent.body);
+        const outcome = await this.performWakeSend(qitemId, intent.destinationSession, intent.senderSession, undefined, group.map(entry => entry.body).join("\n"));
         const finalState = outcome.classified === "verified" ? "delivered" : outcome.classified;
-        const blockerRef = intent.tags?.includes(AUTO_UNPARK_WAKE_TAG)
-            ? intent.tags
-                .find((tag) => tag.startsWith(AUTO_UNPARK_BLOCKER_TAG_PREFIX))
-                ?.slice(AUTO_UNPARK_BLOCKER_TAG_PREFIX.length)
-            : undefined;
-        const wakeEvent = this.db.transaction(() => {
-            this.recordNudgeAttempt(qitemId, outcome.nudgeResult);
-            this.outbox.finalizeDelivery(outboxId, finalState);
-            if (!blockerRef)
-                return null;
-            const item = this.getByIdOrThrow(qitemId);
-            const transition = this.transitionLog.append({
-                qitemId,
-                state: item.state,
-                actorSession: "queue@system",
-                transitionNote: `blocker ${blockerRef} wake attempted; delivery=${outcome.nudgeResult}`,
-            });
-            this.wakeRepo.record({
-                transitionId: transition.transitionId,
-                qitemId,
-                phase: "fired",
-                kind: "blocker",
-                ref: blockerRef,
-                deliveryStatus: outcome.nudgeResult,
-            });
-            return this.eventBus.persistWithinTransaction({
-                type: "queue.updated",
-                qitemId,
-                fromState: item.state,
-                toState: item.state,
-                closureReason: null,
-                closureTarget: null,
-                actorSession: "queue@system",
-                summary: item.summary ?? null,
-            });
-        })();
-        if (wakeEvent)
-            this.eventBus.notifySubscribers(wakeEvent);
+        for (const member of group) {
+            const intent = member;
+            const qitemId = intent.auditPointer;
+            const blockerRef = intent.tags?.includes(AUTO_UNPARK_WAKE_TAG)
+                ? intent.tags
+                    .find((tag) => tag.startsWith(AUTO_UNPARK_BLOCKER_TAG_PREFIX))
+                    ?.slice(AUTO_UNPARK_BLOCKER_TAG_PREFIX.length)
+                : undefined;
+            const wakeEvent = this.db.transaction(() => {
+                this.recordNudgeAttempt(qitemId, outcome.nudgeResult);
+                this.outbox.finalizeDelivery(intent.outboxId, finalState);
+                if (!blockerRef)
+                    return null;
+                const item = this.getByIdOrThrow(qitemId);
+                const transition = this.transitionLog.append({
+                    qitemId,
+                    state: item.state,
+                    actorSession: "queue@system",
+                    transitionNote: `blocker ${blockerRef} wake attempted; delivery=${outcome.nudgeResult}`,
+                });
+                this.wakeRepo.record({
+                    transitionId: transition.transitionId,
+                    qitemId,
+                    phase: "fired",
+                    kind: "blocker",
+                    ref: blockerRef,
+                    deliveryStatus: outcome.nudgeResult,
+                });
+                return this.eventBus.persistWithinTransaction({
+                    type: "queue.updated",
+                    qitemId,
+                    fromState: item.state,
+                    toState: item.state,
+                    closureReason: null,
+                    closureTarget: null,
+                    actorSession: "queue@system",
+                    summary: item.summary ?? null,
+                });
+            })();
+            if (wakeEvent)
+                this.eventBus.notifySubscribers(wakeEvent);
+        }
         return finalState;
     }
     /**
@@ -1994,6 +2049,31 @@ export class QueueRepository {
             .prepare("SELECT qitem_id, destination_session FROM queue_items WHERE blocked_on = ? AND state = 'blocked'")
             .all(input.qitemId);
         for (const r of blockedRows) {
+            const closed = this.getById(input.qitemId);
+            const successors = input.terminalState === "handed-off" ? this.db.prepare("SELECT qitem_id FROM queue_items WHERE handed_off_from = ? AND destination_session = ?").all(input.qitemId, closed?.handedOffTo ?? "") : [];
+            const successor = successors.length === 1 ? this.getById(successors[0].qitem_id) : null;
+            if (successor && isBlockerLive(successor.state) && successor.destinationSession !== r.destination_session) {
+                // Onward custody is a changed blocker. Returning to the waiting owner
+                // below is the result arrival that actually resumes its continuation.
+                const oldWake = this.wakeRepo.getStatus(r.qitem_id);
+                this.db.prepare("UPDATE queue_items SET blocked_on = ?, ts_updated = ? WHERE qitem_id = ?")
+                    .run(successor.qitemId, input.ts, r.qitem_id);
+                const rebound = this.transitionLog.append({ qitemId: r.qitem_id, state: "blocked", actorSession: input.actorSession,
+                    transitionNote: `blocker custody moved from ${input.qitemId} to ${successor.qitemId}`,
+                    identityProvenance: input.identityProvenance });
+                const jobs = this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db);
+                const retainedTimer = oldWake?.kind === "timer" && retargetQueueWait(this.db, jobs, oldWake.ref, successor.qitemId);
+                if (!retainedTimer)
+                    this.retireParkGeneratedTimer(r.qitem_id, "blocker_custody_moved");
+                this.wakeRepo.record({ transitionId: rebound.transitionId, qitemId: r.qitem_id, phase: "armed",
+                    kind: retainedTimer ? "timer" : "blocker", ref: retainedTimer ? oldWake.ref : successor.qitemId, deliveryStatus: null });
+                const event = this.eventBus.persistWithinTransaction({ type: "queue.updated", qitemId: r.qitem_id,
+                    fromState: "blocked", toState: "blocked", closureReason: null, closureTarget: null,
+                    actorSession: input.actorSession, summary: this.getById(r.qitem_id)?.summary ?? null });
+                this.eventBus.registerPersistedWithinActiveEnvelope(event);
+                dependentEvents.push(event);
+                continue;
+            }
             this.db
                 .prepare("UPDATE queue_items SET state = 'pending', blocked_on = NULL, ts_updated = ? WHERE qitem_id = ?")
                 .run(input.ts, r.qitem_id);
@@ -2114,7 +2194,7 @@ export class QueueRepository {
         const events = this.db.transaction(() => {
             const firedEvents = targets.map(recordFired);
             if (usageLimitBlockers.length === 0) {
-                if (parkGeneratedTimer && !backOffQueueWait(this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db), jobId)) {
+                if (parkGeneratedTimer && !backOffQueueWait(this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db), jobId, deliveryStatus)) {
                     (this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db)).markTerminal(jobId, "park_timer_fired_once");
                 }
                 return firedEvents;
@@ -2197,7 +2277,7 @@ export class QueueRepository {
             .prepare(`SELECT ${columns} FROM queue_items ${where} ORDER BY ${orderBy} LIMIT ?`)
             .all(...params);
         const items = rows.map((r) => {
-            const item = this.rowToItem(r);
+            const item = this.rowToItem(r, !opts?.compact);
             const ledger = this.deliveryOutcomeFor(item.qitemId);
             return {
                 ...item,
@@ -2208,7 +2288,7 @@ export class QueueRepository {
         return opts?.compact
             ? items.map((item) => ({
                 ...item,
-                fieldsElided: ["body", "summary", "evidenceRef"],
+                fieldsElided: ["body", "summary", "evidenceRef", "waiting"],
             }))
             : items;
     }
@@ -2319,7 +2399,7 @@ export class QueueRepository {
             params.push(opts.limit);
         }
         const rows = this.db.prepare(sql).all(...params);
-        return rows.map((r) => this.rowToItem(r));
+        return rows.map((r) => this.rowToItem(r, !opts?.compact));
     }
     /**
      * Surface two evidence-backed undelivered classes: the original pending
@@ -2361,7 +2441,7 @@ export class QueueRepository {
         const rows = this.db.prepare(sql).all(...params);
         const out = [];
         for (const r of rows) {
-            const item = this.rowToItem(r);
+            const item = this.rowToItem(r, !opts?.compact);
             const ledger = this.deliveryOutcomeFor(item.qitemId);
             if (ledger?.outcome === "posted")
                 continue; // the receipt wins, always
@@ -2610,31 +2690,65 @@ export class QueueRepository {
         txn();
         return rows.length;
     }
-    /** S04 — substantive post-claim motion: transitions strictly after the claim, excluding the
-     *  claim's own 'claimed' transition. Lazily prepared; indexed on qitem_id. */
-    postClaimMotionStmt;
-    postClaimMotionCount(qitemId, claimedAt) {
-        this.postClaimMotionStmt ??= this.db.prepare("SELECT COUNT(*) AS n FROM queue_transitions WHERE qitem_id = ? AND ts > ? AND transition_note IS NOT 'claimed'");
+    activityReader;
+    attachActivityReader(reader) { this.activityReader = reader; }
+    workflowGuidance;
+    attachWorkflowGuidance(reader) { this.workflowGuidance = reader; }
+    evaluateWaitReminder(input) {
+        if (this.wakeRepo.findQitemsByAttachedWatchdog(input.jobId).length > 0
+            && this.wakeRepo.findQitemsByGeneratedTimer(input.jobId).every(row => row.state !== "blocked"))
+            return null;
+        const binding = this.wakeRepo.findBlockedQitemsByWatchdog(input.jobId).find(row => row.kind === "timer");
+        const result = evaluateQueueWait(this.watchdogJobsRepo ?? new WatchdogJobsRepository(this.db), input.jobId, binding ? this.waitingView(binding.qitemId) : null);
+        // Only an already-admitted send reads prose: healthy silence, receipts and
+        // failed-delivery retries remain owned by the existing wait evaluator.
+        if (result?.action === "send" && binding && this.workflowGuidance) {
+            try {
+                result.message += "\n" + this.workflowGuidance(binding.qitemId).join("\n");
+            }
+            catch (error) {
+                result.message += "\nWorkflow method: UNKNOWN: current guidance unavailable: " + String(error);
+            }
+        }
+        return result;
+    }
+    ownerActivity(session) {
         try {
-            return this.postClaimMotionStmt.get(qitemId, claimedAt).n;
+            return this.activityReader?.(session) ?? null;
         }
         catch {
-            return 0; // minimal fixture DBs without the transitions table: degrade, never throw
+            return null;
+        }
+    }
+    waitingView(qitemId) {
+        const view = readWaitingView(this.db, qitemId, this.activityReader);
+        if (view && ["pending", "in-progress"].includes(view.state)) {
+            const recovery = readWakeLadderBackstop(this.db, qitemId);
+            if (recovery) {
+                view.laterBackstop = { ...view.nextBackstop, note: "Conditional safety net; current delivery/recovery ownership is evaluated first." };
+                view.nextBackstop = recovery;
+            }
         }
+        return view;
     }
-    rowToItem(row) {
+    rowToItem(row, includeWaiting = true) {
         // S04 — derive the pickup receipt at the ONE shared projection point (list/show/overdue
         // all flow through here), so the park-vs-strand question is answered by the row face.
+        const meaningful = lastMeaningfulTransition(this.db, row.qitem_id);
+        const waiting = includeWaiting ? this.waitingView(row.qitem_id) : null;
+        const activity = this.ownerActivity(row.destination_session);
         const pickup = derivePickup({
             state: row.state,
+            lastMeaningfulAt: meaningful?.at,
+            activity: activity?.activity,
+            needsInput: activity?.needsInput.count,
             claimedAt: row.claimed_at,
             lastHeartbeat: row.last_heartbeat,
-            postClaimMotionCount: row.claimed_at && row.state !== "blocked"
-                ? this.postClaimMotionCount(row.qitem_id, row.claimed_at)
-                : 0,
+            postClaimMotionCount: 0, // this reader supplies the current meaningful timestamp
         });
         return {
             pickup,
+            ...(waiting ? { waiting } : {}),
             qitemId: row.qitem_id,
             tsCreated: row.ts_created,
             tsUpdated: row.ts_updated,