@in-the-loop-labs/pair-review 3.5.2 → 3.7.0

package/src/ai/background-queue.js

@@ -0,0 +1,290 @@
+// Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
+
+const { broadcastReviewEvent } = require('../events/review-events');
+const logger = require('../utils/logger');
+const { makeAbortError } = require('./abort-signal-wiring');
+
+const BACKGROUND_QUEUE_CONCURRENCY = 2;
+
+const defaults = {
+  broadcast: broadcastReviewEvent,
+};
+
+/**
+ * Bounded-concurrency in-process queue with per-key dedup.
+ *
+ * Jobs are keyed by `${reviewId}:${jobType}`; concurrent enqueues
+ * for the same key share a single execution and a single promise.
+ *
+ * Cancellation: each enqueued job is associated with an `AbortController`.
+ * The worker thunk is invoked as `fn(signal)` so it can plumb the signal
+ * into downstream provider calls / `fetch` / `child_process.spawn`.
+ * Callers cancel via `cancel(reviewId, jobKey)`, which aborts the
+ * signal and removes the controller; the worker is expected to react
+ * to the abort and settle (typically by rejecting with an AbortError).
+ */
+class BackgroundQueue {
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.concurrency] - Max concurrent jobs.
+   * @param {Object} [options._deps] - Override dependencies (testing).
+   * @param {Function} [options._deps.broadcast] - Broadcast hook.
+   */
+  constructor(options = {}) {
+    const { concurrency = BACKGROUND_QUEUE_CONCURRENCY, _deps = {} } = options;
+    this.concurrency = concurrency;
+    this.active = 0;
+    this.queue = [];
+    this.inFlight = new Map();
+    // Per-key AbortController covers both queued and running jobs so a
+    // single lookup can resolve cancellation against either state.
+    this.controllers = new Map();
+    this._deps = { ...defaults, ..._deps };
+  }
+
+  /**
+   * Enqueue a job for execution.
+   *
+   * Dedup contract: if a job for the same `(reviewId, jobType)` key is
+   * already queued or running, this returns the existing promise without
+   * invoking `fn`. The duplicate `fn` is silently dropped.
+   *
+   * The thunk is called as `fn(signal)` where `signal` is the `AbortSignal`
+   * for this job. Workers that touch the network, spawn processes, or
+   * otherwise burn upstream resources should thread the signal through so
+   * cancellation actually frees those resources.
+   *
+   * @param {string|number} reviewId - Review identifier.
+   * @param {string} jobType - Job category (e.g. 'summaries', 'tour').
+   * @param {Function} fn - Thunk `(signal) => value|Promise<value>`.
+   * @returns {Promise} Resolves/rejects with the job result.
+   */
+  enqueue(reviewId, jobType, fn) {
+    const key = `${reviewId}:${jobType}`;
+    if (this.inFlight.has(key)) {
+      return this.inFlight.get(key);
+    }
+    let resolve;
+    let reject;
+    const p = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.inFlight.set(key, p);
+    const controller = new AbortController();
+    this.controllers.set(key, controller);
+    this.queue.push({
+      key,
+      run: fn,
+      resolve,
+      reject,
+      reviewId,
+      jobType,
+      controller,
+      promise: p,
+    });
+    this._drain();
+    return p;
+  }
+
+  /**
+   * Cancel an in-flight or queued job. Aborts its `AbortSignal` so the
+   * worker can tear down upstream resources, then drops the controller.
+   *
+   * Matching is exact on `(reviewId, jobKey)`. For composite jobTypes
+   * like `summaries:${digest}`, callers may also pass a bare prefix
+   * (`summaries`) — this cancels ALL matching `summaries:*` jobs for the
+   * review. This is what the toolbar "Cancel Summaries" button needs:
+   * users don't know about digests, they just want the pulse to stop.
+   *
+   * @param {string|number} reviewId
+   * @param {string} jobKey - bare `jobType` (e.g. `tour`) or full key
+   *   suffix (e.g. `summaries:abc123`).
+   * @returns {{cancelled: number}} number of jobs aborted.
+   */
+  cancel(reviewId, jobKey) {
+    if (jobKey === undefined || jobKey === null || jobKey === '') {
+      return { cancelled: 0 };
+    }
+    const exact = `${reviewId}:${jobKey}`;
+    const prefix = `${exact}:`;
+    let cancelled = 0;
+    // Snapshot keys before aborting — settling a worker mid-iteration would
+    // mutate this.controllers (via _settle).
+    const keys = Array.from(this.controllers.keys());
+    for (const key of keys) {
+      if (key !== exact && !key.startsWith(prefix)) continue;
+      const controller = this.controllers.get(key);
+      if (!controller) continue;
+      try {
+        controller.abort();
+      } catch (err) {
+        logger.warn(`BackgroundQueue controller.abort() failed for ${key}: ${err.message}`);
+      }
+      // Eagerly evict the cancelled key from the dedup/controller maps and
+      // splice any not-yet-started descriptors out of the queue. Without
+      // this, a follow-up enqueue() for the same key would hit the dedup
+      // guard and inherit the about-to-reject promise, and _drain() could
+      // hand the worker an already-aborted signal. _settle()'s deletes are
+      // identity-guarded, so when the cancelled worker eventually rejects
+      // it won't clobber a replacement job installed under the same key.
+      this._evictKey(key);
+      cancelled++;
+    }
+    return { cancelled };
+  }
+
+  /**
+   * Remove a key from the dedup/controller maps and reject any queued (not
+   * yet started) descriptor with an AbortError. Safe to call when the key
+   * has already been cleaned up — Map.delete and Array.splice both no-op.
+   *
+   * @param {string} key - Composite `${reviewId}:${jobType}` key.
+   * @private
+   */
+  _evictKey(key) {
+    // Splice queued descriptors and reject their promises so the dedup'd
+    // caller (if any) sees a clean cancellation rather than a hung promise.
+    for (let i = this.queue.length - 1; i >= 0; i--) {
+      if (this.queue[i].key !== key) continue;
+      const [descriptor] = this.queue.splice(i, 1);
+      try {
+        descriptor.reject(makeAbortError('Job cancelled before start'));
+      } catch (rejectErr) {
+        logger.warn(
+          `BackgroundQueue descriptor.reject failed for ${key}: ${rejectErr.message}`
+        );
+      }
+    }
+    this.inFlight.delete(key);
+    this.controllers.delete(key);
+  }
+
+  /** Start as many queued jobs as concurrency allows. */
+  _drain() {
+    while (this.active < this.concurrency && this.queue.length > 0) {
+      const descriptor = this.queue.shift();
+      this.active++;
+      Promise.resolve()
+        .then(() => descriptor.run(descriptor.controller.signal))
+        .then(
+          (result) => this._settle(descriptor, null, result),
+          (error) => this._settle(descriptor, error, undefined)
+        );
+    }
+  }
+
+  /** Finalize a job: free its key, broadcast, settle, and drain. */
+  _settle(descriptor, error, result) {
+    // Identity-guarded cleanup: if cancel() evicted this descriptor and a
+    // replacement was enqueued under the same key, the maps now point at
+    // the new descriptor's controller/promise — unconditional deletes would
+    // wipe the replacement's bookkeeping (invisible to hasActiveForReview,
+    // immune to cancel, vulnerable to duplicate enqueue).
+    if (this.controllers.get(descriptor.key) === descriptor.controller) {
+      this.controllers.delete(descriptor.key);
+    }
+    if (this.inFlight.get(descriptor.key) === descriptor.promise) {
+      this.inFlight.delete(descriptor.key);
+    }
+    this.active--;
+    this._onComplete(descriptor.reviewId, descriptor.jobType, error);
+    if (error === null) {
+      descriptor.resolve(result);
+    } else {
+      descriptor.reject(error);
+    }
+    this._drain();
+  }
+
+  /**
+   * Is there an in-flight or queued job for this review whose jobType
+   * starts with the given prefix? Useful for surfacing a "generating"
+   * indicator on the frontend (`hasActiveForReview(id, 'summaries')`).
+   *
+   * Job keys are stored as `${reviewId}:${jobType}`; `summaries` jobs use
+   * the form `summaries:${digest}`, so a prefix match on
+   * `${reviewId}:summaries` catches every digest variant.
+   *
+   * @param {string|number} reviewId
+   * @param {string} jobTypePrefix
+   * @returns {boolean}
+   */
+  hasActiveForReview(reviewId, jobTypePrefix) {
+    if (!jobTypePrefix) return false;
+    const prefix = `${reviewId}:${jobTypePrefix}`;
+    for (const key of this.inFlight.keys()) {
+      if (key === prefix || key.startsWith(prefix + ':')) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Like `hasActiveForReview` but returns the in-flight/queued jobType string
+   * (without the `${reviewId}:` prefix), or null. Useful when callers track a
+   * versioned key like `summaries:${digest}` and need to know the *exact* key
+   * to cancel before re-enqueueing under a new digest.
+   *
+   * @param {string|number} reviewId
+   * @param {string} jobTypePrefix
+   * @returns {string|null}
+   */
+  findActiveJobType(reviewId, jobTypePrefix) {
+    if (!jobTypePrefix) return null;
+    const prefix = `${reviewId}:${jobTypePrefix}`;
+    for (const key of this.inFlight.keys()) {
+      if (key === prefix || key.startsWith(prefix + ':')) {
+        return key.slice(String(reviewId).length + 1);
+      }
+    }
+    return null;
+  }
+
+  /** Broadcast job completion; broadcast failures are logged, not thrown. */
+  _onComplete(reviewId, jobType, error) {
+    try {
+      // Include whether more jobs of the same type-prefix remain queued or
+      // in-flight so listeners (e.g. the summaries toolbar pulse) don't
+      // clear their "generating" state when a sibling job is still running.
+      // For composite types like `summaries:${digest}`, we strip the suffix
+      // so the prefix match catches every digest variant.
+      const colonIdx = jobType.indexOf(':');
+      const prefix = colonIdx >= 0 ? jobType.slice(0, colonIdx) : jobType;
+      const hasActiveForType = this.hasActiveForReview(reviewId, prefix);
+      this._deps.broadcast(reviewId, {
+        type: 'review:background_job_finished',
+        jobType,
+        ok: error === null,
+        hasActiveForType,
+        cancelled: isAbortError(error),
+      });
+    } catch (broadcastError) {
+      logger.warn(
+        `BackgroundQueue broadcast failed for ${reviewId}:${jobType}: ${broadcastError.message}`
+      );
+    }
+  }
+}
+
+/**
+ * Recognize errors that originated from `AbortController.abort()`.
+ * Node sets `name === 'AbortError'` on the DOMException for AbortSignal,
+ * but providers that wrap the abort in a custom Error may instead set
+ * `code === 'ABORT_ERR'` or surface `signal.aborted` themselves. Check
+ * the common shapes so the broadcast payload is honest about cancels.
+ *
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+function isAbortError(err) {
+  if (!err) return false;
+  if (typeof err !== 'object') return false;
+  if (err.name === 'AbortError') return true;
+  if (err.code === 'ABORT_ERR') return true;
+  if (err.isCancellation === true) return true;
+  return false;
+}
+
+const backgroundQueue = new BackgroundQueue();
+
+module.exports = { BackgroundQueue, backgroundQueue, BACKGROUND_QUEUE_CONCURRENCY, isAbortError };

package/src/ai/claude-cli.js

@@ -100,7 +100,7 @@ class ClaudeCLI {
         }
 
         // Extract JSON from the text response using robust extraction strategies
-        const extracted = extractJSON(stdout, level);
+        const extracted = extractJSON(stdout, level, levelPrefix);
         if (extracted.success) {
           logger.success(`${levelPrefix} Successfully parsed JSON response`);
           resolve(extracted.data);

package/src/ai/claude-provider.js

@@ -12,6 +12,7 @@ const logger = require('../utils/logger');
 const { extractJSON } = require('../utils/json-extractor');
 const { CancellationError, isAnalysisCancelled } = require('../routes/shared');
 const { StreamParser, parseClaudeLine } = require('./stream-parser');
+const { wireAbortToChild, makeAbortError } = require('./abort-signal-wiring');
 
 // Directory containing bin scripts (git-diff-lines, etc.)
 const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
@@ -286,7 +287,7 @@ class ClaudeProvider extends AIProvider {
    */
   async execute(prompt, options = {}) {
     return new Promise((resolve, reject) => {
-      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, onStreamEvent, logPrefix } = options;
+      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, onStreamEvent, logPrefix, abortSignal } = options;
 
       const levelPrefix = logPrefix || `[Level ${level}]`;
       logger.info(`${levelPrefix} Executing Claude CLI...`);
@@ -300,7 +301,12 @@ class ClaudeProvider extends AIProvider {
           ...this.extraEnv,
           PATH: `${BIN_DIR}:${process.env.PATH}`
         },
-        shell: this.useShell
+        shell: this.useShell,
+        // In shell mode the immediate child is `/bin/sh -c '...claude...'`.
+        // Detaching makes the shell its own process-group leader so
+        // wireAbortToChild can `process.kill(-pid, SIGTERM)` and reap the
+        // CLI grandchild along with the shell. No effect when shell:false.
+        detached: this.useShell
       });
 
       const pid = claude.pid;
@@ -314,6 +320,13 @@ class ClaudeProvider extends AIProvider {
         logger.info(`${levelPrefix} Registered process ${pid} for analysis ${analysisId}`);
       }
 
+      // Wire AbortSignal -> SIGTERM. Tour/summary jobs run through the
+      // BackgroundQueue which threads its per-job signal here so a user
+      // "Cancel" click stops burning tokens on the upstream CLI call.
+      // Pass shell: this.useShell so the helper signals the whole process
+      // group (group-kill) instead of just the shell wrapper.
+      const abortWiring = wireAbortToChild(claude, abortSignal, { logPrefix: levelPrefix, shell: this.useShell });
+
       let stdout = '';
       let stderr = '';
       let timeoutId = null;
@@ -321,10 +334,16 @@ class ClaudeProvider extends AIProvider {
       let lineBuffer = '';  // Buffer for incomplete JSONL lines
       let lineCount = 0;    // Count of JSONL events for progress tracking
 
+      // Centralize abort-listener cleanup in `settle` so it ALWAYS runs
+      // when this execute() returns — including when the timeout path
+      // settles before the child exits. Otherwise the abort listener
+      // outlives the call and leaks across the loop tour/summary
+      // generators run with a shared per-job signal.
       const settle = (fn, value) => {
         if (settled) return;
         settled = true;
         if (timeoutId) clearTimeout(timeoutId);
+        abortWiring.detach();
         fn(value);
       };
 
@@ -375,11 +394,24 @@ class ClaudeProvider extends AIProvider {
       claude.on('close', (code) => {
         if (settled) return;  // Already settled by timeout or error
 
+        // Note: abort listener detach is centralized in `settle` so it
+        // runs even when the timeout path settled first.
+
         // Flush any remaining stream parser buffer
         if (streamParser) {
           streamParser.flush();
         }
 
+        // BackgroundQueue-driven cancellation: the user clicked "Cancel
+        // Tour"/"Cancel Summaries", which aborted our signal and we sent
+        // SIGTERM via wireAbortToChild. Surface it as an AbortError so
+        // upstream callers can distinguish "user cancel" from real failure.
+        if (abortWiring.cancelled()) {
+          logger.info(`${levelPrefix} Claude CLI terminated by user cancel (exit code ${code})`);
+          settle(reject, makeAbortError(`${levelPrefix} Cancelled by user`));
+          return;
+        }
+
         // Check for cancellation signals (SIGTERM=143, SIGKILL=137)
         const isCancellationCode = code === 143 || code === 137;
         if (isCancellationCode && analysisId && isAnalysisCancelled(analysisId)) {
@@ -410,13 +442,23 @@ class ClaudeProvider extends AIProvider {
         const parsed = this.parseClaudeResponse(stdout, level, levelPrefix);
         if (parsed.success) {
           logger.success(`${levelPrefix} Successfully parsed JSON response`);
-          // Dump the parsed data for debugging
-          const dataPreview = JSON.stringify(parsed.data, null, 2);
-          logger.debug(`${levelPrefix} [parsed_data] ${dataPreview.substring(0, 3000)}${dataPreview.length > 3000 ? '...' : ''}`);
+          // Dump the parsed data for debugging.
+          // Skip for summary calls — they run per-file and the dump is per-call
+          // noise. The `[response]` line below already gives a useful one-liner.
+          const isSummaryCall = typeof levelPrefix === 'string' && levelPrefix.startsWith('[Summary');
+          if (!isSummaryCall) {
+            const dataPreview = JSON.stringify(parsed.data, null, 2);
+            logger.debug(`${levelPrefix} [parsed_data] ${dataPreview.substring(0, 3000)}${dataPreview.length > 3000 ? '...' : ''}`);
+          }
           // Log suggestion count if present
           if (parsed.data?.suggestions) {
             const count = Array.isArray(parsed.data.suggestions) ? parsed.data.suggestions.length : 0;
             logger.info(`${levelPrefix} [response] ${count} suggestions in parsed response`);
+          } else if (isSummaryCall && Array.isArray(parsed.data?.summaries)) {
+            const total = parsed.data.summaries.length;
+            const withText = parsed.data.summaries.filter((s) => s && typeof s.summary === 'string' && s.summary.length > 0).length;
+            const skipped = parsed.data.summaries.filter((s) => s && s.summary === null).length;
+            logger.info(`${levelPrefix} [response] ${total} summaries (${withText} with text, ${skipped} null)`);
           }
           settle(resolve, parsed.data);
         } else {
@@ -451,6 +493,7 @@ class ClaudeProvider extends AIProvider {
 
       // Handle errors
       claude.on('error', (error) => {
+        // Detach happens inside `settle` below.
         if (error.code === 'ENOENT') {
           logger.error(`${levelPrefix} Claude CLI not found. Please ensure Claude CLI is installed.`);
           settle(reject, new Error(`${levelPrefix} Claude CLI not found. ${ClaudeProvider.getInstallInstructions()}`));
@@ -756,7 +799,7 @@ class ClaudeProvider extends AIProvider {
       if (textContent) {
         logger.debug(`${levelPrefix} Extracted ${textContent.length} chars of text content from JSONL`);
         // Try to extract JSON from the accumulated text content
-        const extracted = extractJSON(textContent, level);
+        const extracted = extractJSON(textContent, level, levelPrefix);
         if (extracted.success) {
           return extracted;
         }
@@ -774,7 +817,7 @@ class ClaudeProvider extends AIProvider {
 
     } catch (parseError) {
       // stdout might not be valid JSONL at all, try extracting JSON from it
-      const extracted = extractJSON(stdout, level);
+      const extracted = extractJSON(stdout, level, levelPrefix);
       if (extracted.success) {
         return extracted;
       }

package/src/ai/codex-provider.js

@@ -13,6 +13,7 @@ const logger = require('../utils/logger');
 const { extractJSON } = require('../utils/json-extractor');
 const { CancellationError, isAnalysisCancelled } = require('../routes/shared');
 const { StreamParser, parseCodexLine } = require('./stream-parser');
+const { wireAbortToChild, makeAbortError } = require('./abort-signal-wiring');
 
 // Directory containing bin scripts (git-diff-lines, etc.)
 const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
@@ -242,7 +243,7 @@ class CodexProvider extends AIProvider {
    */
   async execute(prompt, options = {}) {
     return new Promise((resolve, reject) => {
-      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, onStreamEvent, logPrefix } = options;
+      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, onStreamEvent, logPrefix, abortSignal } = options;
 
       const levelPrefix = logPrefix || `[Level ${level}]`;
       logger.info(`${levelPrefix} Executing Codex CLI...`);
@@ -255,7 +256,10 @@ class CodexProvider extends AIProvider {
           ...this.extraEnv,
           PATH: `${BIN_DIR}:${process.env.PATH}`
         },
-        shell: this.useShell
+        shell: this.useShell,
+        // Detach in shell mode so wireAbortToChild can group-kill via
+        // process.kill(-pid). See claude-provider for the rationale.
+        detached: this.useShell
       });
 
       const pid = codex.pid;
@@ -267,6 +271,10 @@ class CodexProvider extends AIProvider {
         logger.info(`${levelPrefix} Registered process ${pid} for analysis ${analysisId}`);
       }
 
+      // Wire AbortSignal -> SIGTERM for tour/summary cancellation.
+      // shell flag triggers group-kill so the CLI grandchild dies with the shell.
+      const abortWiring = wireAbortToChild(codex, abortSignal, { logPrefix: levelPrefix, shell: this.useShell });
+
       let stdout = '';
       let stderr = '';
       let timeoutId = null;
@@ -274,10 +282,15 @@ class CodexProvider extends AIProvider {
       let lineBuffer = '';  // Buffer for incomplete JSONL lines
       let lineCount = 0;    // Count of JSONL events for progress tracking
 
+      // Centralize detach in `settle` so the abort listener is removed
+      // regardless of which exit path (close/timeout/error) wins. Avoids
+      // leaking a listener on the per-job AbortSignal that tour/summary
+      // generators reuse across many provider.execute() calls.
       const settle = (fn, value) => {
         if (settled) return;
         settled = true;
         if (timeoutId) clearTimeout(timeoutId);
+        abortWiring.detach();
         fn(value);
       };
 
@@ -328,11 +341,20 @@ class CodexProvider extends AIProvider {
       codex.on('close', (code) => {
         if (settled) return;  // Already settled by timeout or error
 
+        // Detach is centralized in `settle`.
+
         // Flush any remaining stream parser buffer
         if (streamParser) {
           streamParser.flush();
         }
 
+        // BackgroundQueue-driven cancellation — mirror of claude-provider.
+        if (abortWiring.cancelled()) {
+          logger.info(`${levelPrefix} Codex CLI terminated by user cancel (exit code ${code})`);
+          settle(reject, makeAbortError(`${levelPrefix} Cancelled by user`));
+          return;
+        }
+
         // Check for cancellation signals (SIGTERM=143, SIGKILL=137)
         const isCancellationCode = code === 143 || code === 137;
         if (isCancellationCode && analysisId && isAnalysisCancelled(analysisId)) {
@@ -407,6 +429,7 @@ class CodexProvider extends AIProvider {
 
       // Handle errors
       codex.on('error', (error) => {
+        // Detach happens inside `settle`.
         if (error.code === 'ENOENT') {
           logger.error(`${levelPrefix} Codex CLI not found. Please ensure Codex CLI is installed.`);
           settle(reject, new Error(`${levelPrefix} Codex CLI not found. ${CodexProvider.getInstallInstructions()}`));
@@ -510,7 +533,7 @@ class CodexProvider extends AIProvider {
         // The accumulated agent_message text contains the AI's response
         // Try to extract JSON from it (the AI was asked to output JSON)
         logger.debug(`${levelPrefix} Extracted ${agentMessageText.length} chars of agent message text from JSONL`);
-        const extracted = extractJSON(agentMessageText, level);
+        const extracted = extractJSON(agentMessageText, level, levelPrefix);
         if (extracted.success) {
           return extracted;
         }
@@ -522,12 +545,12 @@ class CodexProvider extends AIProvider {
       }
 
       // No agent message found, try extracting JSON directly from stdout
-      const extracted = extractJSON(stdout, level);
+      const extracted = extractJSON(stdout, level, levelPrefix);
       return extracted;
 
     } catch (parseError) {
       // stdout might not be valid JSONL at all, try extracting JSON from it
-      const extracted = extractJSON(stdout, level);
+      const extracted = extractJSON(stdout, level, levelPrefix);
       if (extracted.success) {
         return extracted;
       }

package/src/ai/copilot-provider.js

@@ -12,6 +12,7 @@ const { AIProvider, registerProvider, quoteShellArgs } = require('./provider');
 const logger = require('../utils/logger');
 const { extractJSON } = require('../utils/json-extractor');
 const { CancellationError, isAnalysisCancelled } = require('../routes/shared');
+const { wireAbortToChild, makeAbortError } = require('./abort-signal-wiring');
 
 // Directory containing bin scripts (git-diff-lines, etc.)
 const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
@@ -220,7 +221,7 @@ class CopilotProvider extends AIProvider {
     return new Promise((resolve, reject) => {
       // Note: Copilot does not support streaming — output is plain text returned on process exit, not JSONL.
       // onStreamEvent is therefore not destructured here (no StreamParser integration).
-      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, logPrefix } = options;
+      const { cwd = process.cwd(), timeout = 300000, level = 'unknown', analysisId, registerProcess, logPrefix, abortSignal } = options;
 
       const levelPrefix = logPrefix || `[Level ${level}]`;
       logger.info(`${levelPrefix} Executing Copilot CLI...`);
@@ -249,7 +250,9 @@ class CopilotProvider extends AIProvider {
           ...this.extraEnv,
           PATH: `${BIN_DIR}:${process.env.PATH}`
         },
-        shell: this.useShell
+        shell: this.useShell,
+        // Detach in shell mode so group-kill can reap the CLI grandchild.
+        detached: this.useShell
       });
 
       const pid = copilot.pid;
@@ -261,15 +264,21 @@ class CopilotProvider extends AIProvider {
         logger.info(`${levelPrefix} Registered process ${pid} for analysis ${analysisId}`);
       }
 
+      // Wire AbortSignal -> SIGTERM for tour/summary cancellation.
+      const abortWiring = wireAbortToChild(copilot, abortSignal, { logPrefix: levelPrefix, shell: this.useShell });
+
       let stdout = '';
       let stderr = '';
       let timeoutId = null;
       let settled = false;  // Guard against multiple resolve/reject calls
 
+      // Detach centralized in settle so timeout-then-close cannot leak
+      // an abort listener on the per-job AbortSignal.
       const settle = (fn, value) => {
         if (settled) return;
         settled = true;
         if (timeoutId) clearTimeout(timeoutId);
+        abortWiring.detach();
         fn(value);
       };
 
@@ -296,6 +305,15 @@ class CopilotProvider extends AIProvider {
       copilot.on('close', (code) => {
         if (settled) return;  // Already settled by timeout or error
 
+        // Detach is centralized in `settle`.
+
+        // BackgroundQueue-driven cancellation — mirror of claude-provider.
+        if (abortWiring.cancelled()) {
+          logger.info(`${levelPrefix} Copilot CLI terminated by user cancel (exit code ${code})`);
+          settle(reject, makeAbortError(`${levelPrefix} Cancelled by user`));
+          return;
+        }
+
         // Check for cancellation signals (SIGTERM=143, SIGKILL=137)
         const isCancellationCode = code === 143 || code === 137;
         if (isCancellationCode && analysisId && isAnalysisCancelled(analysisId)) {
@@ -320,7 +338,7 @@ class CopilotProvider extends AIProvider {
         }
 
         // Extract JSON from the response
-        const extracted = extractJSON(stdout, level);
+        const extracted = extractJSON(stdout, level, levelPrefix);
         if (extracted.success) {
           logger.success(`${levelPrefix} Successfully parsed JSON response`);
           settle(resolve, extracted.data);
@@ -352,6 +370,7 @@ class CopilotProvider extends AIProvider {
 
       // Handle errors
       copilot.on('error', (error) => {
+        // Detach happens inside `settle`.
         if (error.code === 'ENOENT') {
           logger.error(`${levelPrefix} Copilot CLI not found. Please ensure Copilot CLI is installed.`);
           settle(reject, new Error(`${levelPrefix} Copilot CLI not found. ${CopilotProvider.getInstallInstructions()}`));