@openrig/cli 0.6.6 → 0.6.8

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

@@ -7,6 +7,7 @@ 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 { renderQueueHandoffNudge } from "./queue-nudge-text.js";
 import { getSelfHostId } from "./hosts/fanout-contract.js";
 import { parseSessionName, isHumanSeatSessionRef } from "./session-name.js";
 import { parseReplyToChoice, formatReplyToChoice, describeReplyToFallback, REPLY_TO_CHOICE_ACTOR } from "./reply-to-choice.js";
@@ -475,15 +476,17 @@ export class QueueRepository {
         // defect only when a wake WAS intended.
         if (nudge === false)
             return;
+        // The successor row is already written in this txn, so its stored summary is
+        // read here rather than threaded through every staging caller.
+        const successor = this.getById(successorQitemId);
         this.recordWakeIntent({
             outboxId: `${WAKE_INTENT_PREFIX}${successorQitemId}`,
             auditPointer: successorQitemId,
             fromSession,
             toSession,
             identityProvenance,
-            bareBody: `Queue handoff: ${successorQitemId} - check your queue.`,
-            tags: this.getById(successorQitemId)?.handedOffFrom
-                ? [`queue:return:${this.getByIdOrThrow(successorQitemId).handedOffFrom}`] : undefined,
+            bareBody: renderQueueHandoffNudge(successorQitemId, successor?.summary),
+            tags: successor?.handedOffFrom ? [`queue:return:${successor.handedOffFrom}`] : undefined,
         });
     }
     recordWakeIntent(input) {
@@ -887,7 +890,7 @@ export class QueueRepository {
         else {
             // OPR.0.4.4.19 FR-7: bodyOverride lets the resolve verb carry the
             // decision text to the parked owner; default stays the handoff nudge.
-            const bareBody = bodyOverride ?? `Queue handoff: ${qitemId} - check your queue.`;
+            const bareBody = bodyOverride ?? renderQueueHandoffNudge(qitemId, null);
             // GHOST-STAGE (h): the single HG-5 baseline change deferred from g — the handoff nudge now carries
             // a Sent: stamp (so it renders byte-parically with a rig send) plus the SOURCE seat's occupant
             // generation (g's already-wired render, resolved here; absent=UNKNOWN=omit, never forged). The
@@ -1139,8 +1142,10 @@ export class QueueRepository {
             this.db.prepare("UPDATE queue_items SET human_intent = ?, human_detail = ? WHERE qitem_id = ?")
                 .run(input.humanIntent ?? null, input.humanDetail ?? null, id);
         }
-        if (input.replyTo != null) {
-            this.db.prepare("UPDATE queue_items SET reply_to = ? WHERE qitem_id = ?").run(input.replyTo, id);
+        const replyTo = input.replyTo
+            ?? (input.inboundReplyTo != null && this.hasReplyToColumn && this.getById(input.inboundReplyTo) ? input.inboundReplyTo : null);
+        if (replyTo != null) {
+            this.db.prepare("UPDATE queue_items SET reply_to = ? WHERE qitem_id = ?").run(replyTo, id);
         }
         if (humanQuestions) {
             this.db.prepare("UPDATE queue_items SET human_questions = ? WHERE qitem_id = ?").run(JSON.stringify(humanQuestions), id);
@@ -1646,14 +1651,14 @@ export class QueueRepository {
                 this.db
                     .prepare(`UPDATE queue_items
                SET state = 'in-progress', ts_updated = ?, claimed_at = ?, closure_required_at = ?,
-                   claimed_by_generation_uuid = ?
+                   claimed_by_generation_uuid = ?, blocked_on = NULL
              WHERE qitem_id = ?`)
                     .run(ts, ts, closureRequiredAt, claimedByGeneration, input.qitemId);
             }
             else {
                 this.db
                     .prepare(`UPDATE queue_items
-               SET state = 'in-progress', ts_updated = ?, claimed_at = ?, closure_required_at = ?
+               SET state = 'in-progress', ts_updated = ?, claimed_at = ?, closure_required_at = ?, blocked_on = NULL
              WHERE qitem_id = ?`)
                     .run(ts, ts, closureRequiredAt, input.qitemId);
             }
@@ -1662,6 +1667,9 @@ export class QueueRepository {
                 state: "in-progress",
                 actorSession: input.destinationSession,
                 transitionNote: "claimed",
+                // Preserve the former gate as an audit pointer without marking a closure
+                // or changing the note execution-view uses to exclude claim activity.
+                closureTarget: qitem.state === "blocked" ? qitem.blockedOn ?? undefined : undefined,
                 identityProvenance: input.identityProvenance ?? null, // P21 §4 era-stamp
             });
             // OPR.0.5.8.1 S1b — CLAIM-RESUME. A blocked row is claimable ("only
@@ -1768,6 +1776,15 @@ export class QueueRepository {
         const result = this.updateInTransactionalContext(input);
         return { qitemId: input.qitemId, ...result };
     }
+    /** Internal read-only audit pointer for non-state receipts. Never search past a state write. */
+    retainedClaimBlocker(qitemId) {
+        const latest = this.transitionLog.listForQitem(qitemId).at(-1);
+        // Explicit state writes do not carry this non-closure audit pointer. Do not
+        // search past one, even if an older claim still records a gate in history.
+        return latest?.state === "in-progress" && latest.closureReason === null
+            ? latest.closureTarget ?? undefined
+            : undefined;
+    }
     /**
      * Internal: closure validation + UPDATE + transition log + emit
      * queue.updated event. Caller is responsible for transaction wrapping
@@ -1806,6 +1823,9 @@ export class QueueRepository {
                 state: qitem.state,
                 actorSession: input.actorSession,
                 transitionNote: input.transitionNote,
+                // A note-only append does not clear the claim's retained park gate.
+                // Carry its audit pointer so a later state write can end this chain.
+                closureTarget: qitem.state === "in-progress" ? this.retainedClaimBlocker(input.qitemId) : undefined,
                 identityProvenance: input.identityProvenance ?? null,
             });
             const persistedEvent = this.eventBus.persistWithinTransaction({
@@ -1888,7 +1908,13 @@ export class QueueRepository {
         // enforcement is here at the write path — the `rig queue block` verb and
         // raw `update --state blocked` hit the same validator (no verb-only
         // enforcement). Blocking on another qitem requires nothing new (BR-1).
-        const effectiveBlockedOn = input.blockedOn ?? qitem.blockedOn;
+        // A claimed item has no current gate, but re-parking without --blocked-on
+        // retains the previous park's gate, as it did before claim cleared the row.
+        const previousClaimBlocker = input.state === "blocked" && qitem.state === "in-progress"
+            && input.blockedOn == null && qitem.blockedOn == null
+            ? this.retainedClaimBlocker(input.qitemId)
+            : null;
+        const effectiveBlockedOn = input.blockedOn ?? qitem.blockedOn ?? previousClaimBlocker ?? null;
         if (input.state === "blocked" && effectiveBlockedOn && this.getById(effectiveBlockedOn)?.humanIntent === "update") {
             throw new QueueRepositoryError("invalid_human_notification", "An informational update is not an approval dependency. Create a separate decision request if a human decision is needed.");
         }
@@ -2026,16 +2052,12 @@ export class QueueRepository {
             // OPR.0.5.8.1 S1 — start the interval at registration for EVERY explicit
             // `--wake-after` timer, not only provider-limit ones.
             //
-            // `isDue` treats a job with no `last_evaluation_at` as due immediately, so
-            // an unseeded timer fires on the scheduler's very first pass regardless of
-            // its interval: measured at 0.69s for a requested 20m and 0.77s for a
-            // requested 2h. The duration was never lost — `interval_seconds` held 1200
-            // and 7200 correctly — it simply was not the thing being measured against.
-            //
-            // S16 introduced this seeding for provider-limit parks only and recorded
-            // the narrow scope as deliberate. Widening it is the whole repair: the
-            // mechanism is unchanged and already proven by the provider-limit path, so
-            // this adds no scheduler and no per-wake bookkeeping.
+            // When this was written, `isDue` treated any job with no `last_evaluation_at`
+            // as due immediately, so an unseeded timer fired on the scheduler's first
+            // pass: measured at 0.69s for a requested 20m and 0.77s for a requested 2h.
+            // Since #801/#860 a never-evaluated periodic reminder measures its first
+            // interval from registration on its own, so this seed now sets the same
+            // start explicitly; it also gives the row's wake a real "last check" time.
             jobsRepo.recordEvaluation(job.jobId, job.registeredAt, false);
             parkWake = { kind: "timer", ref: job.jobId };
         }
@@ -2436,7 +2458,13 @@ export class QueueRepository {
             return false;
         // Same trust rule as replyToChoiceFor: a pre-provenance schema reads every row as null.
         const provenance = this.hasTransitionProvenanceColumn ? " AND identity_provenance IS NULL" : "";
-        return this.db.prepare(`SELECT 1 FROM queue_transitions WHERE transition_note = ? AND actor_session = ?${provenance} LIMIT 1`).get(formatReplyToChoice({ kind: "thread", threadTs }), REPLY_TO_CHOICE_ACTOR) !== undefined;
+        // #192: with a channel map the note carries a ` channel=<id>` suffix. Match the exact note, or
+        // the exact note followed by that suffix; a prefix compare, not LIKE (the note itself contains
+        // `_`), and the trailing space keeps thread 1.1 from matching 1.10.
+        const note = formatReplyToChoice({ kind: "thread", threadTs });
+        const withChannel = `${note} channel=`;
+        return this.db.prepare(`SELECT 1 FROM queue_transitions
+        WHERE (transition_note = ? OR substr(transition_note, 1, ?) = ?) AND actor_session = ?${provenance} LIMIT 1`).get(note, withChannel.length, withChannel, REPLY_TO_CHOICE_ACTOR) !== undefined;
     }
     replyToFallbackFor(qitemId) {
         const choice = this.replyToChoiceFor(qitemId);
@@ -2670,6 +2698,7 @@ export class QueueRepository {
                     state: qitem.state,
                     actorSession: "daemon@system",
                     transitionNote: "closure-overdue",
+                    closureTarget: this.retainedClaimBlocker(qitemId),
                 });
             }
             return this.eventBus.persistWithinTransaction({
@@ -2943,6 +2972,7 @@ export class QueueRepository {
                 state: qitem.state,
                 actorSession: "system:queue-fallback",
                 transitionNote: `fallback-routed: ${originalDestination} → ${fallbackDestination} (${reason})`,
+                closureTarget: qitem.state === "in-progress" ? this.retainedClaimBlocker(qitemId) : undefined,
             });
             return this.eventBus.persistWithinTransaction({
                 type: "qitem.fallback_routed",