specrails-desktop 2.29.0 → 2.29.2

package/server/dist/interactive-job-session.js

@@ -31,12 +31,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InteractiveJobSession = exports.UNKNOWN_COMMAND_RE = void 0;
 exports.isModelWorkEvent = isModelWorkEvent;
 exports.isZeroWorkSettle = isZeroWorkSettle;
+const node_crypto_1 = require("node:crypto");
 const node_readline_1 = require("node:readline");
 const cli_prompt_1 = require("./util/cli-prompt");
+const win_spawn_1 = require("./util/win-spawn");
 const explore_stdin_session_1 = require("./explore-stdin-session");
 const result_event_1 = require("./result-event");
 const db_1 = require("./db");
 const stream_display_1 = require("./util/stream-display");
+/** Claude's stream-json result frames do not carry a turn id. Hash a canonical
+ * representation of the real frame instead: an exact/semantic retransmission
+ * remains identifiable even after the next stdin turn has been armed, while a
+ * genuine later result differs through its cumulative/session/result fields. */
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(',')}}`;
+}
+function resultFrameSignature(frame) {
+    return (0, node_crypto_1.createHash)('sha256').update(canonicalJson(frame)).digest('hex');
+}
 /** The claude CLI's synthetic no-op marker: the result text of a frame emitted
  *  for a command the CLI could not resolve (nothing was sent to the model). */
 exports.UNKNOWN_COMMAND_RE = /^Unknown command:/;
@@ -100,18 +120,22 @@ class InteractiveJobSession {
     _settleMode;
     _zombieTimeoutMs;
     _nextEventSeq;
+    _persistTurnUsage;
+    _persistTurnActivity;
     _spawn;
+    _killTree;
     _child = null;
     _stdoutReader = null;
     _stderrReader = null;
     _eventSeq = 0;
+    _lastPersistedEventSeq = -1;
     _streaming = false;
     /** True between writing a turn to stdin and receiving its `result` event.
      *  Guards _onTurnResult against double-counting a duplicate `result` frame. */
     _awaitingResult = false;
-    /** Monotonic id assigned to each turn written to stdin. A `result` frame is only
-     *  counted when its turn-id matches the in-flight turn — so a stray/late/duplicate
-     *  result for a finished turn can never be folded into the NEXT turn's totals. */
+    /** Monotonic id assigned to each delivered turn. It gates one accepted result
+     * per active turn; canonical result signatures provide the cross-turn replay
+     * barrier because Claude's protocol does not expose a turn id. */
     _turnSeq = 0;
     /** The turn-id currently awaiting a `result` (== _turnSeq while streaming). */
     _activeTurnId = 0;
@@ -120,6 +144,10 @@ class InteractiveJobSession {
     _lastSettledTurnId = 0;
     _pending = [];
     _turnEvents = [];
+    /** Accepted result-frame signatures for this resident child. The protocol has
+     * no turn id, so this is the durable-in-process correlation barrier that keeps
+     * a retransmitted prior result out of a newly-armed turn. */
+    _acceptedResultSignatures = new Set();
     _accum = zeroUsage();
     _model = null;
     _sessionId = null;
@@ -148,6 +176,12 @@ class InteractiveJobSession {
     _finalizing = false;
     _settled = false;
     _disposed = false;
+    /** `ChildProcess.killed` only means a signal was sent. This tracks the real
+     *  lifecycle event used to decide whether SIGKILL escalation is still needed. */
+    _childClosed = false;
+    _stdinFailed = false;
+    _terminationStarted = false;
+    _terminationReason = null;
     _killTimer = null;
     /** Auto-mode wedge detector (see InteractiveJobSessionDeps.zombieTimeoutMs). */
     _zombieTimer = null;
@@ -161,7 +195,10 @@ class InteractiveJobSession {
         this._settleMode = deps.settleMode ?? 'finalize';
         this._zombieTimeoutMs = deps.zombieTimeoutMs ?? 0;
         this._nextEventSeq = deps.nextEventSeq ?? null;
+        this._persistTurnUsage = deps.persistTurnUsage ?? null;
+        this._persistTurnActivity = deps.persistTurnActivity ?? null;
         this._spawn = deps.spawn ?? cli_prompt_1.spawnAiCli;
+        this._killTree = deps.killTree ?? win_spawn_1.treeKillSafe;
     }
     /** Spawn the resident child and run the first turn (the freestyle prompt). */
     start(spec, firstPrompt) {
@@ -172,6 +209,10 @@ class InteractiveJobSession {
             cwd: spec.cwd,
         });
         this._child = child;
+        this._childClosed = false;
+        this._stdinFailed = false;
+        this._terminationStarted = false;
+        this._terminationReason = null;
         // Absorb spawn 'error' (e.g. ENOENT) so it does not crash the process; the
         // 'close' that follows settles the job as crashed through _handleClose.
         child.on('error', (err) => {
@@ -185,7 +226,22 @@ class InteractiveJobSession {
             this._stderrReader = (0, node_readline_1.createInterface)({ input: child.stderr, crlfDelay: Infinity });
             this._stderrReader.on('line', (line) => this._handleStderrLine(line));
         }
-        child.on('close', (code) => this._handleClose(code));
+        child.on('close', (code) => {
+            this._childClosed = true;
+            this._clearKillTimer();
+            this._handleClose(code);
+        });
+        // A buffered write can fail asynchronously (typically EPIPE after the child
+        // exits). `try/catch` around write() cannot observe that event, and an
+        // unhandled Writable 'error' terminates Node. Install this BEFORE the first
+        // `send()` below so even the initial frame is protected.
+        child.stdin?.on('error', (err) => {
+            this._stdinFailed = true;
+            console.error(`[interactive-job] stdin failed for ${this._jobId}: ${err.message}`);
+            if (this._disposed || this._settled)
+                return;
+            this._terminateChildTree(this._finalizing ? 'finalized' : 'crashed');
+        });
         // Auto-mode wedge detector: reset on ANY raw output ('data' — synchronous
         // under fake timers, mirroring the one-shot path's zombie timer) and fire
         // when the child stays silent for the whole budget. Finalize mode never
@@ -222,7 +278,7 @@ class InteractiveJobSession {
             const note = `⚠️ Could not deliver your message — the agent's input channel is closed.`;
             this._persistLog('stderr', note);
             this._emitLog('stderr', note);
-            this._settle('crashed');
+            this._terminateChildTree('crashed');
             return false;
         }
         // Surface the user turn in the transcript via the existing `log` channel so
@@ -262,27 +318,7 @@ class InteractiveJobSession {
             return;
         this._finalizing = true;
         this._clearZombieTimer();
-        const child = this._child;
-        if (!child || child.killed || !child.pid) {
-            this._settle('finalized');
-            return;
-        }
-        try {
-            child.kill('SIGTERM');
-        }
-        catch { /* already gone */ }
-        this._killTimer = setTimeout(() => {
-            try {
-                if (this._child && !this._child.killed)
-                    this._child.kill('SIGKILL');
-            }
-            catch { /* gone */ }
-            // Hard-deadline fallback: if the child never emits 'close' (D-state /
-            // uninterruptible / signal-swallowing), _handleClose never runs and the slot
-            // would leak forever. Force the settle here so the queue always drains. If
-            // 'close' does fire, _settle is idempotent so this is a no-op.
-            this._settle('finalized');
-        }, FINALIZE_KILL_GRACE_MS);
+        this._terminateChildTree('finalized');
     }
     /** Programmatic teardown that SETTLES 'crashed' after folding any in-flight
      *  turn (loop step timeout / run cancel). Unlike dispose(), the onSettle
@@ -298,39 +334,16 @@ class InteractiveJobSession {
             this._persistLog('stderr', note);
             this._emitLog('stderr', note);
         }
-        const child = this._child;
-        try {
-            if (child && !child.killed)
-                child.kill('SIGTERM');
-        }
-        catch { /* gone */ }
-        // Escalate to SIGKILL after the grace window if the child survives SIGTERM.
-        // NOT stored in _killTimer — _settle below clears that slot, and this
-        // escalation must outlive the settle. unref'd so it never holds the process.
-        const escalate = setTimeout(() => {
-            try {
-                if (this._child && !this._child.killed)
-                    this._child.kill('SIGKILL');
-            }
-            catch { /* gone */ }
-        }, FINALIZE_KILL_GRACE_MS);
-        if (typeof escalate.unref === 'function')
-            escalate.unref();
-        this._settle('crashed');
+        this._terminateChildTree('crashed');
     }
     /** Teardown without settling (project removal / shutdown). */
     dispose() {
         if (this._disposed)
             return;
         this._disposed = true;
-        this._clearKillTimer();
         this._clearZombieTimer();
         this._closeReaders();
-        try {
-            if (this._child && !this._child.killed)
-                this._child.kill('SIGTERM');
-        }
-        catch { /* gone */ }
+        this._terminateChildTree(null);
         this._child = null;
     }
     // ─── internals ─────────────────────────────────────────────────────────────
@@ -339,8 +352,20 @@ class InteractiveJobSession {
      *  caller must NOT treat an unconfirmed turn as accepted. */
     _writeTurn(text) {
         const child = this._child;
-        if (!child || !child.stdin || child.stdin.destroyed)
+        if (!child || !child.stdin || child.stdin.destroyed || this._stdinFailed)
             return false;
+        const turnStartedAtMs = Date.now();
+        if (this._persistTurnActivity) {
+            try {
+                // Commit the start BEFORE stdin delivery. If this fails, the provider
+                // never receives work that startup recovery cannot time/account.
+                this._persistTurnActivity(turnStartedAtMs, turnStartedAtMs);
+            }
+            catch (err) {
+                this._failStopPersistence('turn-start checkpoint', err);
+                return false;
+            }
+        }
         try {
             child.stdin.write((0, explore_stdin_session_1.frameStreamJsonUserMessage)(text));
         }
@@ -348,16 +373,15 @@ class InteractiveJobSession {
             console.error('[interactive-job] stdin write failed:', err);
             return false;
         }
-        // Tag this turn so only its OWN `result` is counted (BUG-INTJOB-03): a late or
-        // duplicate result for a prior turn won't match _activeTurnId once a new turn
-        // has begun, so it can never inflate the next turn's totals.
+        // Arm exactly one result for this delivered turn. Cross-turn retransmissions
+        // are rejected by the canonical-signature barrier in _handleStdoutLine.
         this._turnSeq += 1;
         this._activeTurnId = this._turnSeq;
         this._streaming = true;
         this._awaitingResult = true;
         this._turnEvents = [];
         // Start the active-duration segment for this turn (LOW-15).
-        this._turnStartMs = Date.now();
+        this._turnStartMs = turnStartedAtMs;
         return true;
     }
     _handleStdoutLine(line) {
@@ -366,6 +390,19 @@ class InteractiveJobSession {
             parsed = JSON.parse(line);
         }
         catch { /* plain text */ }
+        // A late retransmission can arrive after the next queued prompt has already
+        // been written. Drop it BEFORE adapter parsing and event persistence: adding
+        // it to the next turn's event buffer corrupts live totals, while persisting
+        // it beyond the prior checkpoint would make crash recovery count it again.
+        if (parsed?.type === 'result') {
+            // A terminal frame with no active turn is causally unassignable. Drop it
+            // before adapter parsing/persistence so raw recovery cannot count it.
+            if (!this._awaitingResult)
+                return;
+            const signature = resultFrameSignature(parsed);
+            if (this._acceptedResultSignatures.has(signature))
+                return;
+        }
         const adapterEv = this._adapter.parseStreamLine(line);
         if (adapterEv) {
             this._turnEvents.push(adapterEv);
@@ -374,7 +411,11 @@ class InteractiveJobSession {
         }
         if (parsed) {
             const eventType = parsed.type ?? 'unknown';
-            const seq = this._persistEvent(eventType, line);
+            const { seq, persisted } = this._persistEvent(eventType, line);
+            if (!persisted)
+                return;
+            if (eventType !== 'result' && !this._checkpointRawActivity())
+                return;
             this._broadcast({
                 type: 'event',
                 jobId: this._jobId,
@@ -385,7 +426,7 @@ class InteractiveJobSession {
                 seq,
             });
             if (eventType === 'result') {
-                this._onTurnResult(parsed);
+                this._onTurnResult(parsed, seq, resultFrameSignature(parsed));
             }
             const displayText = (0, stream_display_1.extractDisplayText)(parsed);
             if (displayText !== null) {
@@ -405,20 +446,47 @@ class InteractiveJobSession {
     }
     _handleStderrLine(line) {
         this._persistLog('stderr', line);
+        if (!this._checkpointRawActivity())
+            return;
         this._emitLog('stderr', line);
     }
-    _onTurnResult(parsed) {
+    /** Update the active wall segment on raw activity. Failure is terminal: the
+     * raw event/log is already durable while the completed-event frontier remains
+     * unchanged, so startup can replay the turn exactly once. */
+    _checkpointRawActivity() {
+        if (!this._persistTurnActivity || this._turnStartMs === null)
+            return true;
+        try {
+            this._persistTurnActivity(this._turnStartMs, Date.now());
+            return true;
+        }
+        catch (err) {
+            this._failStopPersistence('raw-activity checkpoint', err);
+            return false;
+        }
+    }
+    _failStopPersistence(context, err) {
+        console.error(`[interactive-job] ${context} failed; stopping session:`, err);
+        if (this._disposed || this._settled)
+            return;
+        // Block send()/auto-settle immediately while the child termination is in
+        // flight. `_terminationReason` remains crashed even though `_finalizing`
+        // also serves as the admission gate.
+        this._finalizing = true;
+        this._terminateChildTree('crashed');
+    }
+    _onTurnResult(parsed, resultEventSeq, resultSignature) {
         // Count a result only for the in-flight turn, exactly once (BUG-INTJOB-03).
         // `_awaitingResult` alone is insufficient: after a turn settles, the next
         // queued prompt re-arms `_awaitingResult`, so a stray/duplicate result for the
-        // PRIOR turn would be folded into the new turn's (reset) events. Tagging each
-        // turn with a monotonic id and recording the last settled id closes that gap —
-        // a result is rejected unless a turn is genuinely awaiting AND its id hasn't
-        // already been settled.
+        // PRIOR turn would be folded into the new turn's (reset) events. The active
+        // sequence gates one result per delivery; _handleStdoutLine rejects any
+        // previously accepted canonical frame before it reaches this method.
         if (!this._awaitingResult)
             return;
         if (this._activeTurnId <= this._lastSettledTurnId)
             return;
+        this._acceptedResultSignatures.add(resultSignature);
         this._lastSettledTurnId = this._activeTurnId;
         this._awaitingResult = false;
         this._streaming = false;
@@ -462,20 +530,39 @@ class InteractiveJobSession {
         if (normalised.session_id)
             this._sessionId = normalised.session_id;
         if (this._db) {
-            try {
-                (0, db_1.accumulateInteractiveTurn)(this._db, this._jobId, {
-                    tokens_in: normalised.tokens_in ?? 0,
-                    tokens_out: normalised.tokens_out ?? 0,
-                    tokens_cache_read: normalised.tokens_cache_read ?? 0,
-                    tokens_cache_create: normalised.tokens_cache_create ?? 0,
-                    total_cost_usd: costDelta,
-                    num_turns: turnsDelta,
-                    model: normalised.model,
-                    session_id: normalised.session_id,
-                });
+            const usage = {
+                tokens_in: normalised.tokens_in ?? 0,
+                tokens_out: normalised.tokens_out ?? 0,
+                tokens_cache_read: normalised.tokens_cache_read ?? 0,
+                tokens_cache_create: normalised.tokens_cache_create ?? 0,
+                total_cost_usd: costDelta,
+                num_turns: turnsDelta,
+                model: normalised.model,
+                session_id: normalised.session_id,
+            };
+            if (this._persistTurnUsage) {
+                try {
+                    this._persistTurnUsage(usage, resultEventSeq, {
+                        cost: this._baselineCost,
+                        turns: this._baselineTurns,
+                        activeDurationMs: this._activeDurationMs,
+                    });
+                }
+                catch (err) {
+                    // The result row is already durable, but its frontier did not commit.
+                    // Stop before turn_done/next-prompt/auto-finalize; onSettle or startup
+                    // recovery consumes the retained turn exactly once.
+                    this._failStopPersistence('turn usage checkpoint', err);
+                    return;
+                }
             }
-            catch (err) {
-                console.error('[interactive-job] accumulate turn failed:', err);
+            else {
+                try {
+                    (0, db_1.accumulateInteractiveTurn)(this._db, this._jobId, usage);
+                }
+                catch (err) {
+                    console.error('[interactive-job] accumulate turn failed:', err);
+                }
             }
         }
         this._broadcast({
@@ -500,7 +587,7 @@ class InteractiveJobSession {
                     const note = `⚠️ Could not deliver a queued message — the agent's input channel is closed.`;
                     this._persistLog('stderr', note);
                     this._emitLog('stderr', note);
-                    this._settle('crashed');
+                    this._terminateChildTree('crashed');
                 }
             });
         }
@@ -530,18 +617,24 @@ class InteractiveJobSession {
     _persistEvent(eventType, payload) {
         const seq = this._takeSeq();
         if (!this._db)
-            return seq;
+            return { seq, persisted: true };
         try {
             (0, db_1.appendEvent)(this._db, this._jobId, seq, {
                 event_type: eventType,
                 source: 'stdout',
                 payload,
             });
+            this._lastPersistedEventSeq = Math.max(this._lastPersistedEventSeq, seq);
+            return { seq, persisted: true };
         }
         catch (err) {
             console.error('[interactive-job] persist event failed:', err);
+            // Every DB-backed session now relies on raw rows for crash recovery.
+            // Continuing would let a later result/frontier certify provider work that
+            // cannot be reconstructed after process death.
+            this._failStopPersistence('raw event persistence', err);
+            return { seq, persisted: false };
         }
-        return seq;
     }
     _persistLog(source, line) {
         const seq = this._takeSeq();
@@ -604,7 +697,7 @@ class InteractiveJobSession {
             this._sessionId = partial.session_id;
         if (this._db) {
             try {
-                (0, db_1.accumulateInteractiveTurn)(this._db, this._jobId, {
+                const usage = {
                     tokens_in: partial.tokens_in ?? 0,
                     tokens_out: partial.tokens_out ?? 0,
                     tokens_cache_read: partial.tokens_cache_read ?? 0,
@@ -616,7 +709,14 @@ class InteractiveJobSession {
                     // Mark the jobs row estimated when this folded turn was priced from the
                     // rate card (no terminal `result` frame) — keeps Job Detail honest.
                     estimated: partialCost > 0 && estimated,
-                });
+                };
+                if (this._persistTurnUsage) {
+                    this._persistTurnUsage(usage, this._lastPersistedEventSeq, {
+                        activeDurationMs: this._activeDurationMs,
+                    });
+                }
+                else
+                    (0, db_1.accumulateInteractiveTurn)(this._db, this._jobId, usage);
             }
             catch (err) {
                 console.error('[interactive-job] fold in-flight turn failed:', err);
@@ -642,7 +742,7 @@ class InteractiveJobSession {
     _handleClose(_code) {
         if (this._disposed || this._settled)
             return;
-        this._settle(this._finalizing ? 'finalized' : 'crashed');
+        this._settle(this._terminationReason ?? (this._finalizing ? 'finalized' : 'crashed'));
     }
     // ─── Auto-mode wedge detector ────────────────────────────────────────────────
     _resetZombieTimer() {
@@ -727,6 +827,61 @@ class InteractiveJobSession {
             zeroWork,
         });
     }
+    /**
+     * Shared teardown for finalize / abort / dispose. Signal the WHOLE process
+     * tree, then escalate only when the child has not emitted a real `close`.
+     * `ChildProcess.killed` is deliberately ignored: Node flips it as soon as a
+     * signal is sent, even when the process survives that signal.
+     *
+     * Finalize/abort settle on close. A child that never closes is force-settled
+     * only after SIGKILL has actually been requested, preserving queue liveness
+     * without releasing the slot after a mere SIGTERM attempt. Dispose never
+     * settles because its owner already flushed/reconciles the job separately.
+     */
+    _terminateChildTree(reason) {
+        if (reason !== null && this._terminationReason === null)
+            this._terminationReason = reason;
+        const child = this._child;
+        if (!child || this._childClosed || !child.pid) {
+            if (reason !== null && !this._disposed)
+                this._settle(reason);
+            return;
+        }
+        if (this._terminationStarted)
+            return;
+        this._terminationStarted = true;
+        const pid = child.pid;
+        // Arm before SIGTERM: an injected/synchronous terminator may cause `close`
+        // immediately, and that close must be able to cancel the escalation.
+        this._killTimer = setTimeout(() => {
+            this._killTimer = null;
+            if (this._childClosed)
+                return;
+            try {
+                this._killTree(pid, 'SIGKILL', (err) => {
+                    if (err)
+                        console.error(`[interactive-job] SIGKILL failed for ${this._jobId}: ${err.message}`);
+                });
+            }
+            catch (err) {
+                console.error(`[interactive-job] SIGKILL failed for ${this._jobId}: ${err.message}`);
+            }
+            // Hard deadline: the OS may never deliver `close` for an uninterruptible
+            // child. The tree has now received SIGKILL, so release an awaiting owner.
+            if (reason !== null && !this._disposed)
+                this._settle(reason);
+        }, FINALIZE_KILL_GRACE_MS);
+        this._killTimer.unref?.();
+        try {
+            this._killTree(pid, 'SIGTERM', (err) => {
+                if (err)
+                    console.error(`[interactive-job] SIGTERM failed for ${this._jobId}: ${err.message}`);
+            });
+        }
+        catch (err) {
+            console.error(`[interactive-job] SIGTERM failed for ${this._jobId}: ${err.message}`);
+        }
+    }
     _clearKillTimer() {
         if (this._killTimer !== null) {
             clearTimeout(this._killTimer);

package/server/dist/jira/jira-adf.js

@@ -12,6 +12,8 @@ exports.bodyForDeployment = bodyForDeployment;
 exports.commentMarker = commentMarker;
 exports.discardCommentMarker = discardCommentMarker;
 exports.prMergedCommentMarker = prMergedCommentMarker;
+exports.railCompletedCommentMarker = railCompletedCommentMarker;
+exports.railRefinedCommentMarker = railRefinedCommentMarker;
 exports.railReviewCommentMarker = railReviewCommentMarker;
 exports.bodyContainsMarker = bodyContainsMarker;
 exports.commentHasMarker = commentHasMarker;
@@ -243,6 +245,14 @@ function discardCommentMarker(ticketId, nonce) {
 function prMergedCommentMarker(refId, ticketId) {
     return `[specrails:pr-merged=${refId}:ticket=${ticketId}]`;
 }
+/** Idempotency marker for accepting a fresh no-change delivery as complete. */
+function railCompletedCommentMarker(refId, ticketId) {
+    return `[specrails:rail-completed=${refId}:ticket=${ticketId}]`;
+}
+/** Idempotency marker for returning a fresh no-change delivery to refinement. */
+function railRefinedCommentMarker(refId, ticketId) {
+    return `[specrails:rail-refined=${refId}:ticket=${ticketId}]`;
+}
 /**
  * Idempotency marker for the "ready for review" comment posted when an isolated
  * rail parks a Jira-linked ticket on_review awaiting the PR decision.

package/server/dist/jira/jira-db.js

@@ -281,9 +281,21 @@ function enqueueMany(db, ops) {
 function claimDrainable(db, limit, nowIso = new Date().toISOString()) {
     const tx = db.transaction((max) => {
         const rows = db
-            .prepare(`SELECT * FROM jira_outbox
-          WHERE state = 'pending' AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
-          ORDER BY id ASC`)
+            .prepare(`SELECT candidate.* FROM jira_outbox AS candidate
+          WHERE candidate.state = 'pending'
+            AND (candidate.next_attempt_at IS NULL OR candidate.next_attempt_at <= ?)
+            AND NOT EXISTS (
+              SELECT 1 FROM jira_outbox AS prior
+               WHERE prior.jira_issue_id = candidate.jira_issue_id
+                 AND prior.id < candidate.id
+                 AND prior.state IN ('pending', 'inflight')
+            )
+            AND NOT EXISTS (
+              SELECT 1 FROM jira_outbox AS active
+               WHERE active.jira_issue_id = candidate.jira_issue_id
+                 AND active.state = 'inflight'
+            )
+          ORDER BY candidate.id ASC`)
             .all(nowIso);
         const claimed = [];
         const seenIssues = new Set();