@openrig/cli 0.6.5 → 0.6.7

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

@@ -524,7 +524,7 @@ export class QueueRepository {
     deliverWakeIntentAfterCommit(outboxId) {
         queueMicrotask(() => {
             void this.deliverWakeIntent(outboxId).catch((err) => {
-                console.error(`Auto-unpark wake delivery failed for ${outboxId}:`, err);
+                console.error(`Queue wake delivery failed for ${outboxId}:`, err);
             });
         });
     }
@@ -948,7 +948,22 @@ export class QueueRepository {
         if (!this.validateRig(input.destinationSession)) {
             throw destinationValidationError("destination_session", input.destinationSession, this.loadHumanRegistryFn);
         }
-        const txn = this.db.transaction(() => this.createInTransactionalContext(input));
+        let wakeStaged = false;
+        const txn = this.db.transaction(() => {
+            const created = this.createInTransactionalContext(input);
+            if (this.outbox && input.nudge !== false) {
+                try {
+                    // A savepoint removes any partial intent when staging fails, while
+                    // preserving ordinary create's existing acceptance of the task.
+                    this.db.transaction(() => this.stageWakeIntent(created.qitemId, input.sourceSession, input.destinationSession, input.identityProvenance ?? null, input.nudge))();
+                    wakeStaged = true;
+                }
+                catch (err) {
+                    this.recordNudgeAttempt(created.qitemId, `failed:wake not retained: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            return created;
+        });
         let id;
         let persistedEvent;
         try {
@@ -992,7 +1007,17 @@ export class QueueRepository {
             throw err;
         }
         this.eventBus.notifySubscribers(persistedEvent);
-        await this.maybeNudge(id, input.destinationSession, input.nudge, input.sourceSession);
+        // The receipt acknowledges persistence, not terminal delivery. The intent
+        // survives a crash before the scheduled wake if staging succeeded. A staging
+        // failure is recorded on the row; callers without an outbox retain their
+        // existing best-effort path without claiming durability.
+        if (this.outbox) {
+            if (wakeStaged)
+                this.deliverWakeIntentAfterCommit(`${WAKE_INTENT_PREFIX}${id}`);
+        }
+        else {
+            await this.maybeNudge(id, input.destinationSession, input.nudge, input.sourceSession);
+        }
         return this.getByIdOrThrow(id);
     }
     /**
@@ -1296,9 +1321,10 @@ export class QueueRepository {
         for (const e of events) {
             this.eventBus.notifySubscribers(e.payload);
         }
-        // W1-b: deliver the just-committed wake intent (marking it), or the pre-W1
-        // best-effort nudge when no intent store is attached. Post-commit only.
-        await this.deliverWakeForSuccessor(newId, input.toSession, input.nudge, input.fromSession);
+        // Closure and successor are persisted. Delivery is separate and recoverable
+        // from the committed intent; a slow terminal must not hold the receipt.
+        if (input.nudge !== false)
+            this.deliverWakeIntentAfterCommit(`${WAKE_INTENT_PREFIX}${newId}`);
         return {
             closed: this.getByIdOrThrow(source.qitemId),
             created: this.getByIdOrThrow(newId),
@@ -1439,9 +1465,9 @@ export class QueueRepository {
         for (const e of events) {
             this.eventBus.notifySubscribers(e.payload);
         }
-        // W1-b: deliver the just-committed wake intent (marking it), or the pre-W1
-        // best-effort nudge when no intent store is attached. Post-commit only.
-        await this.deliverWakeForSuccessor(newId, input.toSession, input.nudge, input.fromSession);
+        // Return the persisted closure and successor without awaiting terminal delivery.
+        if (input.nudge !== false)
+            this.deliverWakeIntentAfterCommit(`${WAKE_INTENT_PREFIX}${newId}`);
         return {
             closed: this.getByIdOrThrow(source.qitemId),
             created: this.getByIdOrThrow(newId),
@@ -1620,14 +1646,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);
             }
@@ -1636,6 +1662,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
@@ -1742,6 +1771,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
@@ -1780,6 +1818,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({
@@ -1862,7 +1903,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.");
         }
@@ -1922,7 +1969,7 @@ export class QueueRepository {
             if (effectiveBlockedOn.startsWith("qitem-")) {
                 const blocker = this.getById(effectiveBlockedOn);
                 if (!blocker) {
-                    throw new QueueRepositoryError("blocker_not_found", `blocked_on names a qitem that does not exist: ${effectiveBlockedOn}. A park must name a real, live blocker — a nonexistent blocker can never complete, so the row could never unpark.`, 
+                    throw new QueueRepositoryError("blocker_not_found", `blocked_on names a qitem that does not exist on this daemon: ${effectiveBlockedOn}. A qitem absent from this daemon cannot be a live blocker here. If it is stored on another host, use a typed gate such as external:<host>/<id> with --wake-watchdog or --wake-after.`, 
                     // F1 (error-honesty): the rejected value is named rejectedBlocker — an error payload
                     // never carries the success-shaped blockedOn field (the field-filtered-misread class).
                     { rejectedBlocker: effectiveBlockedOn });
@@ -2000,16 +2047,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 };
         }
@@ -2410,7 +2453,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);
@@ -2644,6 +2693,7 @@ export class QueueRepository {
                     state: qitem.state,
                     actorSession: "daemon@system",
                     transitionNote: "closure-overdue",
+                    closureTarget: this.retainedClaimBlocker(qitemId),
                 });
             }
             return this.eventBus.persistWithinTransaction({
@@ -2917,6 +2967,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",