infraweaver 0.3.7 → 0.3.8

package/src/mcp/reviewComments.ts

@@ -13,6 +13,7 @@ import { getTempDir } from "#app/utils/env";
 import { resolveBodyAssets } from "#app/utils/github/body";
 import { stripExistingFooter } from "#app/utils/github/buildInfraweaverFooter";
 import { log } from "#app/utils/log";
+import { type HunkHeader, parseDiffLines } from "#app/utils/unifiedDiff";
 
 /**
  * A GraphQL review-thread fetch worth retrying: an HTTP 5xx / network blip
@@ -24,7 +25,7 @@ import { log } from "#app/utils/log";
  */
 export function isTransientGraphqlError(error: unknown): boolean {
   if (isTransientServerError(error)) return true;
-  const msg = error instanceof Error ? error.message : String(error);
+  const msg = errorMessage(error);
   return /something went wrong while executing your query/i.test(msg);
 }
 
@@ -100,7 +101,7 @@ query ($owner: String!, $name: String!, $prNumber: Int!, $cursor: String) {
           line
           startLine
           diffSide
-          comments(first: 1) { nodes { databaseId body author { login __typename } } }
+          comments(first: 1) { nodes { databaseId body originalCommit { oid } author { login __typename } } }
         }
       }
     }
@@ -127,6 +128,7 @@ export type OutstandingThreadsResponse = {
                   | ({
                       databaseId?: number | null;
                       body?: string | null;
+                      originalCommit?: { oid: string } | null;
                       author: { login: string; __typename?: string } | null;
                     } | null)[]
                   | null;
@@ -148,6 +150,10 @@ export type OpenInfraweaverThread = {
   rootCommentId?: number;
   /** the marker the root comment carries, when the engine wrote one */
   marker?: CommentMarker;
+  /** the root comment's body */
+  rootBody?: string;
+  /** the commit the root comment was made on */
+  rootCommit?: string;
 };
 
 /**
@@ -202,6 +208,8 @@ export async function listOpenInfraweaverThreads(input: {
       if (typeof root.databaseId === "number") entry.rootCommentId = root.databaseId;
       const marker = parseCommentMarker(root.body);
       if (marker) entry.marker = marker;
+      if (root.body) entry.rootBody = root.body;
+      if (root.originalCommit?.oid) entry.rootCommit = root.originalCommit.oid;
       // a thread with no current `line` has no comparable span — outdated, or a
       // file-level comment. counted, never matched against.
       if (!entry.isOutdated && thread.path && thread.line != null) {
@@ -289,62 +297,26 @@ function extractCommentedLines(
   endLine: number | null,
   side: "LEFT" | "RIGHT",
 ): string {
-  const lines = diffHunk.split("\n");
-  if (lines.length <= 1) return diffHunk;
-
-  const header = lines[0] ?? "";
-  const contentLines = lines.slice(1);
-
-  // parse header: @@ -old_start,old_count +new_start,new_count @@
-  const headerMatch = header.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-  if (!headerMatch) return diffHunk;
-
-  // destructure with defaults instead of `!` — the two `(\d+)` groups are required,
-  // so the defaults never apply; this carries the non-null in the binding, not an assertion.
-  const [, oldStr = "", newStr = ""] = headerMatch;
-  const hunkOldStart = parseInt(oldStr, 10);
-  const hunkNewStart = parseInt(newStr, 10);
+  const [first, ...rest] = parseDiffLines(diffHunk);
+  if (rest.length === 0 || first?.kind !== "hunk") return diffHunk;
+  const header = first.raw;
 
   // LEFT = old file (deletions), RIGHT = new file (additions)
-  const hunkStart = side === "LEFT" ? hunkOldStart : hunkNewStart;
+  const hunkStart = side === "LEFT" ? first.header.oldStart : first.header.newStart;
   const commentStart = startLine ?? endLine ?? hunkStart;
   const commentEnd = endLine ?? commentStart;
 
-  // walk through diff lines, tracking line numbers for both old and new files
+  // number each diff line on the commented side only
   // - lines: old file only (LEFT)
   // + lines: new file only (RIGHT)
   // context lines: both files
-  type DiffLine = { text: string; lineNum: number | null };
-  const diffLines: DiffLine[] = [];
-  let oldLineNum = hunkOldStart;
-  let newLineNum = hunkNewStart;
-
-  for (const line of contentLines) {
-    const prefix = line[0];
-    if (prefix === "-") {
-      // deletion - only has old line number
-      diffLines.push({
-        text: line,
-        lineNum: side === "LEFT" ? oldLineNum : null,
-      });
-      oldLineNum++;
-    } else if (prefix === "+") {
-      // addition - only has new line number
-      diffLines.push({
-        text: line,
-        lineNum: side === "RIGHT" ? newLineNum : null,
-      });
-      newLineNum++;
-    } else {
-      // context - has both line numbers
-      diffLines.push({
-        text: line,
-        lineNum: side === "LEFT" ? oldLineNum : newLineNum,
-      });
-      oldLineNum++;
-      newLineNum++;
-    }
-  }
+  const diffLines = rest.map((line) => {
+    let lineNum: number | null = null;
+    if (line.kind === "remove") lineNum = side === "LEFT" ? line.oldLine : null;
+    else if (line.kind === "add") lineNum = side === "RIGHT" ? line.newLine : null;
+    else if (line.kind === "context") lineNum = side === "LEFT" ? line.oldLine : line.newLine;
+    return { text: line.raw, lineNum };
+  });
 
   // find lines for comment range with context
   const targetStart = commentStart - CONTEXT_PADDING;
@@ -373,44 +345,26 @@ function extractCommentedLines(
 }
 
 // parsed hunk from a unified diff
-export type ParsedHunk = {
+export type ParsedHunk = HunkHeader & {
   header: string;
-  oldStart: number;
-  oldCount: number;
-  newStart: number;
-  newCount: number;
   content: string[];
 };
 
 // parse a full file patch into individual hunks
 export function parseFilePatches(patch: string): ParsedHunk[] {
   const hunks: ParsedHunk[] = [];
-  const lines = patch.split("\n");
-
   let currentHunk: ParsedHunk | null = null;
 
-  for (const line of lines) {
-    // anchor to line start (mirrors commentableLinesForFile's `^@@`): an added,
-    // removed, or context line whose TEXT contains a hunk-header-shaped substring
-    // (e.g. `+  log.info("@@ -1,2 +3,4 @@")`) must not be mistaken for a real hunk
-    // boundary — that would mis-key downstream overlap math and show wrong context.
-    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    if (hunkMatch) {
+  // the hunk-header match is anchored to line start: an added, removed, or context
+  // line whose TEXT contains a hunk-header-shaped substring must not be mistaken for
+  // a real hunk boundary — that would mis-key downstream overlap math and show wrong
+  // context.
+  for (const line of parseDiffLines(patch)) {
+    if (line.kind === "hunk") {
       if (currentHunk) hunks.push(currentHunk);
-      // destructure with defaults — `oldS`/`newS` are required `(\d+)` groups (the
-      // "" default never applies); `oldC`/`newC` are the optional counts, defaulting to
-      // "1" exactly as the prior `?? "1"` did.
-      const [, oldS = "", oldC = "1", newS = "", newC = "1"] = hunkMatch;
-      currentHunk = {
-        header: line,
-        oldStart: parseInt(oldS, 10),
-        oldCount: parseInt(oldC, 10),
-        newStart: parseInt(newS, 10),
-        newCount: parseInt(newC, 10),
-        content: [],
-      };
+      currentHunk = { ...line.header, header: line.raw, content: [] };
     } else if (currentHunk) {
-      currentHunk.content.push(line);
+      currentHunk.content.push(line.raw);
     }
   }
   if (currentHunk) hunks.push(currentHunk);
@@ -1092,13 +1046,12 @@ export function ResolveReviewThreadTool(ctx: GitHubToolContext) {
         };
       } catch (error) {
         // handle common error cases gracefully
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const isResolved =
-          errorMessage.includes("already resolved") || errorMessage.includes("isResolved");
+        const msg = errorMessage(error);
+        const isResolved = msg.includes("already resolved") || msg.includes("isResolved");
 
         const message = isResolved
           ? `thread ${params.thread_id} was already resolved`
-          : `failed to resolve thread ${params.thread_id}: ${errorMessage}`;
+          : `failed to resolve thread ${params.thread_id}: ${msg}`;
         log.info(message);
 
         return {

package/src/mcp/reviewDedup.ts

@@ -75,7 +75,7 @@ export type DuplicateComment = {
 /** how much of a withheld comment the note quotes back */
 const GIST_MAX_CHARS = 120;
 
-function gistOf(body: unknown): string | undefined {
+export function gistOf(body: unknown): string | undefined {
   if (typeof body !== "string") return undefined;
   // The claim is prose. Skip fenced blocks WHOLE — a suggestion's contents are
   // code, and `x = 1` as the summary of a withheld finding tells a reader

package/src/mcp/reviewMarkers.ts

@@ -16,16 +16,22 @@ import { isInfraweaver } from "#app/utils/config/payload";
 
 export type CommentMarker =
   | { kind: "finding"; key: string; proven: boolean }
-  | { kind: "judgement" };
+  | { kind: "judgement" }
+  /** a reply re-proving its thread's suggestion on a later head, at the
+   *  thread's current lines — what lets the apply command take it there */
+  | { kind: "reproof"; head: string; startLine: number; line: number };
 
 const PREFIX = `${PRODUCT_SLUG}:`;
-const MARKER = new RegExp(`<!-- ${PREFIX}(finding|judgement)((?: [a-z]+=[^\\s]*)*) -->`);
+const MARKER = new RegExp(`<!-- ${PREFIX}(finding|judgement|reproof)((?: [a-z]+=[^\\s]*)*) -->`);
 
 // `-` is encoded too: `--` inside an HTML comment is not allowed to appear.
 const enc = (s: string): string => encodeURIComponent(s).replace(/-/g, "%2D");
 
 export function renderCommentMarker(marker: CommentMarker): string {
   if (marker.kind === "judgement") return `<!-- ${PREFIX}judgement -->`;
+  if (marker.kind === "reproof") {
+    return `<!-- ${PREFIX}reproof head=${enc(marker.head)} start=${marker.startLine} line=${marker.line} -->`;
+  }
   return `<!-- ${PREFIX}finding key=${enc(marker.key)}${marker.proven ? " proven=1" : ""} -->`;
 }
 
@@ -43,6 +49,15 @@ export function parseCommentMarker(body: string | null | undefined): CommentMark
         return [pair.slice(0, eq), pair.slice(eq + 1)] as const;
       }),
   );
+  if (m[1] === "reproof") {
+    const head = fields.get("head");
+    const startLine = Number(fields.get("start"));
+    const line = Number(fields.get("line"));
+    const valid = (n: number) => Number.isInteger(n) && n > 0;
+    if (!head || !/^[0-9a-f]{7,64}$/.test(head) || !valid(startLine) || !valid(line)) return null;
+    if (startLine > line) return null;
+    return { kind: "reproof", head, startLine, line };
+  }
   const raw = fields.get("key");
   if (!raw) return null;
   try {
@@ -52,6 +67,14 @@ export function parseCommentMarker(body: string | null | undefined): CommentMark
   }
 }
 
+const SUGGESTION = /```suggestion\r?\n([\s\S]*?)```/;
+
+/** The text of a comment's `suggestion` block, without its closing newline. */
+export function suggestionText(body: string): string | undefined {
+  const m = SUGGESTION.exec(body);
+  return m ? (m[1] ?? "").replace(/\r?\n$/, "") : undefined;
+}
+
 /**
  * A review comment the engine wrote: by the Infraweaver app, or by any Bot
  * account when it carries the marker (the workflow-token path).

package/src/mcp/reviewProvenance.ts

@@ -13,24 +13,24 @@
  * one that is neither is named in the summary as not addressed, so a silently
  * skipped finding is visible to the author rather than absent.
  */
-import { type } from "arktype";
 import { packControlsForConcern } from "#app/mcp/crosswalk";
 import { claimsBlockingSeverity, type WithheldFinding } from "#app/mcp/findingAudit";
 import {
   controlsTouched,
   type DeltaVerdict,
+  failsGate,
+  renderUndeclaredRenames,
   reviewedFindings,
 } from "#app/mcp/terraform/deltaSummary";
-import type { DeltaFinding, GateDelta } from "#app/mcp/terraform/scanDelta";
+import { count } from "#app/mcp/terraform/prose";
+import { type DeltaFinding, type GateDelta, undeclaredRenames } from "#app/mcp/terraform/scanDelta";
 import { neutralizeMarkup } from "#app/mcp/untrustedContent";
 
-export const Dismissal = type({
-  finding_id: type.string.describe("the `finding_id` from review_scan_delta"),
-  reason: type.string.describe(
-    "why this introduced finding needs no comment — e.g. mitigated by a named sibling resource, or a false positive for a stated reason. Shown to the author in the review summary.",
-  ),
-});
-export type Dismissal = typeof Dismissal.infer;
+/** An introduced finding the reviewer decided needs no comment, and why. */
+export interface Dismissal {
+  finding_id: string;
+  reason: string;
+}
 
 interface ProvenanceComment {
   path: string;
@@ -103,15 +103,35 @@ const code = (text: string): string =>
       .trim() || "—"
   }\``;
 
-/** The provenance line closing an inline comment. */
-export function provenanceLine(kind: CommentKind): string {
+/**
+ * The provenance line closing an inline comment.
+ *
+ * A scanner-backed comment carries two severities, and the line says which one
+ * decides what. The marker it opens with (🚨 ⚠️ ℹ️) is the reviewer's reading of
+ * the risk in this configuration; the gate counts the scanner's severity and
+ * the required controls. When the two disagree, the line says so, so an ℹ️ that
+ * still blocks the merge — or a 🚨 that does not — reads as intended.
+ */
+export function provenanceLine(
+  kind: CommentKind,
+  opts: { requiredControls?: string[]; reviewerMarker?: string | null } = {},
+): string {
   if (kind.kind === "judgement") {
     return "<sub>**Review judgement** — the scanners do not flag this; it is the reviewer's own reading.</sub>";
   }
   const c = kind.finding.concern;
   const controls = packControlsForConcern(c);
+  const blocks = failsGate(kind.finding, opts.requiredControls ?? []);
+  const reviewerBlocks = opts.reviewerMarker === "🚨";
+  const disagreement = !opts.reviewerMarker
+    ? ""
+    : blocks && !reviewerBlocks
+      ? " — the reviewer rates the risk here lower, but the gate counts the scanner's severity"
+      : !blocks && reviewerBlocks
+        ? " — the reviewer rates the risk here higher; the gate does not count it"
+        : "";
   return (
-    `<sub>**Scanner:** ${code(c.rule_id)} (${c.severity})` +
+    `<sub>**Scanner:** ${code(c.rule_id)} (${c.severity} · ${blocks ? "fails the gate" : "below the gate"}${disagreement})` +
     (controls.length ? ` · **Controls:** ${controls.map(code).join(", ")}` : "") +
     "</sub>"
   );
@@ -135,8 +155,6 @@ function where(f: DeltaFinding): string {
   return code(c.location.line ? `${c.location.file}:${c.location.line}` : c.location.file);
 }
 
-const plural = (n: number, one: string, many = `${one}s`): string => `${n} ${n === 1 ? one : many}`;
-
 /**
  * The verdict opening a customer-PR review: whether the PR can merge as far as
  * the gate goes, why, and what the author can do next — in plain words, from
@@ -151,24 +169,41 @@ export function renderReviewVerdict(input: {
   proven: number;
   applyCommand: string;
   fixedThreads?: { resolved: number; unresolved: number } | undefined;
+  /** the run's `required_controls`, so findings on renamed resources can be told
+   *  apart among the ones the gate fails on. */
+  requiredControls?: readonly string[];
 }): string {
   const { delta, verdict } = input;
   const introduced = delta.introduced.length;
   const blocking = verdict.gating + verdict.required;
+  const renamedBlocking = delta.introduced.filter(
+    (f) => f.possiblyPreexisting && failsGate(f, [...(input.requiredControls ?? [])]),
+  ).length;
   let lead: string;
-  if (!verdict.pass) {
+  if (!verdict.pass && renamedBlocking > 0 && renamedBlocking === blocking) {
+    // every blocker rides on a rename: one thing to do, not N findings to read
+    lead =
+      `**❌ Blocks merge** — the gate fails on ${count(blocking, "finding")}, all on resources ` +
+      "that look renamed without a `moved` block. Adding the blocks named below should clear " +
+      `${blocking === 1 ? "it" : "them"}.`;
+  } else if (!verdict.pass) {
     lead =
-      `**❌ Blocks merge** — this pull request introduces ${plural(blocking, "finding")} ` +
-      `the gate fails on${introduced > blocking ? `, and ${introduced - blocking} lesser` : ""}.`;
+      `**❌ Blocks merge** — this pull request introduces ${count(blocking, "finding")} ` +
+      `the gate fails on${introduced > blocking ? `, and ${introduced - blocking} lesser` : ""}` +
+      `${renamedBlocking > 0 ? `; ${renamedBlocking} of the blocking ones ${renamedBlocking === 1 ? "sits" : "sit"} on resources that look renamed without a \`moved\` block` : ""}.`;
   } else if (introduced > 0) {
-    lead = `**✅ Passes the gate** — ${plural(introduced, "new finding")}, none the gate fails on.`;
+    lead = `**✅ Passes the gate** — ${count(introduced, "new finding")}, none the gate fails on.`;
   } else {
     lead = "**✅ Passes the gate** — this pull request introduces no scanner findings.";
   }
   const lines = [lead];
+  // named whether or not the gate fails: a rename without `moved` is a destroy
+  // and re-create at apply, which no severity threshold speaks to.
+  const renames = renderUndeclaredRenames(undeclaredRenames(delta.introduced), code);
+  if (renames) lines.push(renames);
   if (input.concerns > 0) {
     lines.push(
-      `The review also raises ${plural(input.concerns, "concern")} the scanners cannot see — the gate does not count ${input.concerns === 1 ? "it" : "them"}, so read before merging.`,
+      `The review also raises ${count(input.concerns, "concern")} the scanners cannot see — the gate does not count ${input.concerns === 1 ? "it" : "them"}, so read before merging.`,
     );
   }
   if (input.proven > 0) {
@@ -179,12 +214,12 @@ export function renderReviewVerdict(input: {
   const fixed = input.fixedThreads;
   if (fixed?.resolved) {
     lines.push(
-      `Resolved ${plural(fixed.resolved, "earlier thread")} whose finding this push fixed.`,
+      `Resolved ${count(fixed.resolved, "earlier thread")} whose finding this push fixed.`,
     );
   }
   if (fixed?.unresolved) {
     lines.push(
-      `${plural(fixed.unresolved, "earlier thread")} ${fixed.unresolved === 1 ? "is" : "are"} fixed but still open — this workflow's token may not resolve threads (\`contents: write\`).`,
+      `${count(fixed.unresolved, "earlier thread")} ${fixed.unresolved === 1 ? "is" : "are"} fixed but still open — this workflow's token may not resolve threads (\`contents: write\`).`,
     );
   }
   return `${lines.join("\n\n")}\n\n`;

package/src/mcp/roots.ts

@@ -4,6 +4,7 @@ import { type } from "arktype";
 import type { LocalToolContext } from "#app/mcp/localContext";
 import { parseModuleBlocks, walkTfFiles } from "#app/mcp/modules";
 import { execute, tool } from "#app/mcp/shared";
+import { BLOCK_LABEL } from "#app/mcp/terraform/hcl";
 import type { SourceFile } from "#app/mcp/terraform/tree";
 import { log } from "#app/utils/cli";
 import { pushInto } from "#app/utils/collect";
@@ -33,7 +34,7 @@ export interface TerraformRoot {
 // a provider CONFIGURATION block — `provider "aws" {`. Distinct from a
 // `required_providers` block (which child modules also have). The negative
 // lookbehind avoids matching `required_providers`.
-const PROVIDER_CONFIG = /(?:^|\n)\s*provider\s+"[^"]+"\s*\{/;
+const PROVIDER_CONFIG = new RegExp(String.raw`(?:^|\n)\s*provider\s+${BLOCK_LABEL}\s*\{`);
 const BACKEND_BLOCK = /(?:^|\n)\s*backend\s+"[^"]+"\s*\{/;
 
 /** detect whether some concatenated HCL marks a root module. */
@@ -112,7 +113,7 @@ export interface RootClassification {
 /** a dir that declares infrastructure — resources or module calls. Used only by
  *  the fallback, where the question is "is this a place someone runs terraform",
  *  not "what kind of module is it". */
-const DECLARES_INFRA = /(?:^|\n)\s*(?:resource|module)\s+"/;
+const DECLARES_INFRA = /(?:^|\n)\s*(?:resource|module)\s+(?:"|[A-Za-z_])/;
 
 /** normalize a POSIX path, resolving `.`/`..` segments. */
 function normalizeRel(path: string): string {

package/src/mcp/server.ts

@@ -47,7 +47,7 @@ import { PolicyCheckTool } from "#app/mcp/policy";
 import { CreatePullRequestTool, UpdatePullRequestBodyTool } from "#app/mcp/pr";
 import { PullRequestInfoTool } from "#app/mcp/prInfo";
 import { TerraformProviderSchemaTool } from "#app/mcp/providerSchema";
-import { CreatePullRequestReviewTool } from "#app/mcp/review";
+import { CreatePullRequestReviewTool, StageReviewTool } from "#app/mcp/review";
 import {
   GetReviewCommentsTool,
   ListPullRequestReviewsTool,
@@ -186,6 +186,7 @@ function buildCommonTools(ctx: ToolContext, outputSchema?: JsonSchema): Infrawea
     GetIssueCommentsTool(ctx),
     GetIssueEventsTool(ctx),
     CreatePullRequestReviewTool(ctx),
+    StageReviewTool(ctx),
     PullRequestInfoTool(ctx),
     CommitInfoTool(ctx),
     CheckoutPrTool(ctx),

package/src/mcp/shared.ts

@@ -246,10 +246,49 @@ function instrument(tool: InfraweaverTool): InfraweaverTool {
   } as InfraweaverTool;
 }
 
+/**
+ * How often a running tool tells the client it is still working. Claude Code
+ * aborts a call that sends neither a response nor a progress notification for
+ * five minutes, and a scan that downloads external modules, or a plan, can run
+ * longer than that while working normally.
+ */
+export const PROGRESS_HEARTBEAT_MS = 30_000;
+
+/**
+ * Send a progress notification every {@link PROGRESS_HEARTBEAT_MS} while the
+ * tool runs, carrying the seconds elapsed (the spec requires `progress` to
+ * increase). It only reaches the client while the event loop is free, so a tool
+ * that blocks on a synchronous subprocess still looks idle — which is why the
+ * Terraform and scanner paths spawn asynchronously.
+ */
+export function withProgressHeartbeat(tool: InfraweaverTool): InfraweaverTool {
+  if (typeof tool.execute !== "function") return tool;
+  const inner = tool.execute.bind(tool);
+  return {
+    ...tool,
+    execute: async (...args: Parameters<typeof inner>) => {
+      const [, context] = args;
+      const started = Date.now();
+      const timer = setInterval(() => {
+        const seconds = Math.round((Date.now() - started) / 1000);
+        void context.reportProgress({ progress: seconds, message: `${tool.name}: ${seconds}s` });
+      }, PROGRESS_HEARTBEAT_MS);
+      timer.unref?.();
+      try {
+        return await inner(...args);
+      } finally {
+        clearInterval(timer);
+      }
+    },
+  } as InfraweaverTool;
+}
+
 export const addTools = (ctx: ToolContext, server: FastMCP<any>, tools: InfraweaverTool[]) => {
   const shouldSanitize = isGeminiRouted(ctx);
   for (const tool of tools) {
-    server.addTool(instrument(shouldSanitize ? sanitizeToolForGemini(tool) : tool));
+    server.addTool(
+      withProgressHeartbeat(instrument(shouldSanitize ? sanitizeToolForGemini(tool) : tool)),
+    );
   }
   return server;
 };

package/src/mcp/shell.ts

@@ -185,16 +185,15 @@ const SOCKET_CLEANUP = [
 // let the agent bypass the .git/* binds. resolveRepoRoot pins the actual
 // repo root once at startup via $GITHUB_WORKSPACE or `git rev-parse`.
 function buildFsMounts(repoDir: string): string {
-  // shell-escape via single-quote wrap; bash interprets \' as the escape
-  // for a single quote inside a single-quoted string by closing-and-reopening.
-  // repoDir paths in practice are GHA workspace paths (no quotes), but the
-  // escape keeps us correct against arbitrary user-configured workspaces.
-  const escaped = repoDir.replace(/'/g, "'\\''");
+  // shell-escape via single-quote wrap. repoDir paths in practice are GHA
+  // workspace paths (no quotes), but the escape keeps us correct against
+  // arbitrary user-configured workspaces.
+  const gitDir = shSingleQuote(`${repoDir}/.git`);
   return [
     `mkdir -p /var/lib/infraweaver 2>/dev/null;`,
     `mount -t tmpfs tmpfs /var/lib/infraweaver 2>/dev/null;`,
     `[ -n "$RUNNER_TEMP" ] && [ -d "$RUNNER_TEMP/_runner_file_commands" ] && mount -t tmpfs tmpfs "$RUNNER_TEMP/_runner_file_commands" 2>/dev/null;`,
-    `[ -e '${escaped}/.git' ] && mount --bind '${escaped}/.git' '${escaped}/.git' 2>/dev/null && mount -o remount,bind,ro '${escaped}/.git' 2>/dev/null;`,
+    `[ -e ${gitDir} ] && mount --bind ${gitDir} ${gitDir} 2>/dev/null && mount -o remount,bind,ro ${gitDir} 2>/dev/null;`,
     // the corepack shim dir sits FIRST on PATH (utils/setup/packageManager.ts)
     // and PATH survives filterEnv, so a writable pm-bin lets sandboxed code
     // plant a `git`/`pnpm` that a later UNSANDBOXED spawn resolves with the
@@ -215,8 +214,8 @@ function buildFsMounts(repoDir: string): string {
 function shimMount(): string {
   const tempDir = readTempDir();
   if (!tempDir) return "";
-  const dir = packageManagerBinDir(tempDir).replace(/'/g, "'\\''");
-  return `[ -d '${dir}' ] && mount --bind '${dir}' '${dir}' 2>/dev/null && mount -o remount,bind,ro '${dir}' 2>/dev/null;`;
+  const dir = shSingleQuote(packageManagerBinDir(tempDir));
+  return `[ -d ${dir} ] && mount --bind ${dir} ${dir} 2>/dev/null && mount -o remount,bind,ro ${dir} 2>/dev/null;`;
 }
 
 /** locate the repo root once at action startup. process.cwd() is unreliable
@@ -313,7 +312,6 @@ function spawnShell(params: SpawnParams): ChildProcess {
       params.timeoutMs && params.timeoutMs > 0
         ? `timeout --kill-after=5 --signal=TERM ${Math.ceil(params.timeoutMs / 1000)}s bash -c ${shSingleQuote(params.command)}`
         : params.command;
-    const escaped = (pathRestore + userCommand).replace(/'/g, "'\\''");
     envArgs.push(`SANDBOX_PATH=${params.env.PATH ?? ""}`);
     return spawn(
       "sudo",
@@ -326,7 +324,7 @@ function spawnShell(params: SpawnParams): ChildProcess {
         "--mount-proc",
         "bash",
         "-c",
-        `${PROC_CLEANUP} ${SOCKET_CLEANUP} ${fsMounts} exec su -p -s /bin/bash ${username} -c '${escaped}'`,
+        `${PROC_CLEANUP} ${SOCKET_CLEANUP} ${fsMounts} exec su -p -s /bin/bash ${username} -c ${shSingleQuote(pathRestore + userCommand)}`,
       ],
       { ...spawnOpts, env: {} },
     );
@@ -352,13 +350,20 @@ function sudoKillGroup(pid: number, signal: "SIGTERM" | "SIGKILL"): void {
   }
 }
 
+/** SIGTERM a process group, give it 200ms to exit cleanly, then SIGKILL it.
+ * `signal` delivers one signal to the group; a throw from it propagates. */
+async function termThenKill(signal: (sig: "SIGTERM" | "SIGKILL") => void): Promise<void> {
+  signal("SIGTERM");
+  await sleep(200);
+  signal("SIGKILL");
+}
+
 /** kill process and its entire process group */
 async function killProcessGroup(proc: ChildProcess): Promise<void> {
-  if (!proc.pid) return;
+  const pid = proc.pid;
+  if (!pid) return;
   try {
-    process.kill(-proc.pid, "SIGTERM");
-    await new Promise((r) => setTimeout(r, 200));
-    process.kill(-proc.pid, "SIGKILL");
+    await termThenKill((sig) => process.kill(-pid, sig));
   } catch {
     try {
       proc.kill("SIGKILL");
@@ -652,21 +657,15 @@ export function KillBackgroundTool(ctx: ToolContext) {
       // under sudo-unshare the group is root-owned — process.kill(-pid) EPERMs,
       // so escalate straight through sudo. otherwise the unprivileged kill works.
       if (getSandboxMethod() === "sudo-unshare") {
-        sudoKillGroup(proc.pid, "SIGTERM");
-        await sleep(200);
-        sudoKillGroup(proc.pid, "SIGKILL");
+        await termThenKill((sig) => sudoKillGroup(proc.pid, sig));
       } else {
-        try {
-          process.kill(-proc.pid, "SIGTERM");
-        } catch {
-          // already dead
-        }
-        await sleep(200);
-        try {
-          process.kill(-proc.pid, "SIGKILL");
-        } catch {
-          // already dead
-        }
+        await termThenKill((sig) => {
+          try {
+            process.kill(-proc.pid, sig);
+          } catch {
+            // already dead
+          }
+        });
       }
 
       ctx.toolState.backgroundProcesses.delete(params.handle);

package/src/mcp/suggestionProver.ts

@@ -50,8 +50,9 @@ export interface SuggestionProof {
 const MAX_SINGLE_PROOFS = 4;
 
 export interface ProverDeps {
-  /** a gate-configured scan of the tree at `cwd`, ACTIVE concerns only */
-  scan: (cwd: string) => Promise<Concern[]>;
+  /** a gate-configured scan of the tree at `cwd`, ACTIVE concerns only, covering
+   *  at least the root modules that `files` (relative to `cwd`) reach */
+  scan: (cwd: string, files: string[]) => Promise<Concern[]>;
 }
 
 /**
@@ -87,14 +88,17 @@ export async function proveSuggestions(
     return input.candidates.map((c) => out.get(c.index) as SuggestionProof);
   }
   const scanCwd = prefix ? join(worktree, prefix) : worktree;
+  // a suggestion can change findings only in the roots its file reaches, so
+  // both sides of each comparison scan those
+  const files = [...new Set(ready.map((c) => c.path.slice(prefix.length)))];
   try {
-    const before = await deps.scan(scanCwd);
+    const before = await deps.scan(scanCwd, files);
     // review paths are repo-relative; concern paths are relative to the scan dir
     const pristine = snapshot(worktree, prefix, ready);
     const judge = async (subset: SuggestionCandidate[]) => {
       restore(worktree, prefix, pristine);
       for (const [path, group] of groupByPath(subset)) apply(worktree, path, group);
-      const after = await deps.scan(scanCwd);
+      const after = await deps.scan(scanCwd, files);
       return {
         after,
         delta: computeScanDelta({