supipowers 1.5.2 → 2.0.0

package/src/quality/gates/ai-review.ts

@@ -1,5 +1,6 @@
-import { stripMarkdownCodeFence } from "../../text.js";
-import { runStructuredAgentSession } from "../ai-session.js";
+import { parseStructuredOutput, runWithOutputValidation, type ReliabilityReporter } from "../../ai/structured-output.js";
+import { renderSchemaText } from "../../ai/schema-text.js";
+import { AiReviewOutputSchema, type AiReviewOutput } from "../contracts.js";
 import type {
   GateExecutionContext,
   GateIssue,
@@ -15,11 +16,7 @@ export interface AiReviewResult {
   metadata?: Record<string, unknown>;
 }
 
-interface AiReviewPayload {
-  summary: string;
-  issues: GateIssue[];
-  recommendedStatus: AiReviewResult["status"];
-}
+const AI_REVIEW_SCHEMA_TEXT = renderSchemaText(AiReviewOutputSchema);
 
 export function buildAiReviewPrompt(
   scopeFiles: string[],
@@ -42,8 +39,8 @@ export function buildAiReviewPrompt(
     "Files in scope:",
     files,
     "",
-    "Return JSON only with this exact shape:",
-    '{"summary":"string","issues":[{"severity":"error|warning|info","message":"string","file":"optional string","line":"optional number","detail":"optional string"}],"recommendedStatus":"passed|failed|blocked"}',
+    "Return JSON only matching this schema:",
+    AI_REVIEW_SCHEMA_TEXT,
     "",
     "Rules:",
     "- recommendedStatus must be 'failed' when you found actionable issues.",
@@ -52,42 +49,6 @@ export function buildAiReviewPrompt(
   ].join("\n");
 }
 
-function isGateIssue(value: unknown): value is GateIssue {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    (value as GateIssue).severity !== undefined &&
-    ["error", "warning", "info"].includes((value as GateIssue).severity) &&
-    typeof (value as GateIssue).message === "string" &&
-    ((value as GateIssue).file === undefined || typeof (value as GateIssue).file === "string") &&
-    ((value as GateIssue).line === undefined || typeof (value as GateIssue).line === "number") &&
-    ((value as GateIssue).detail === undefined || typeof (value as GateIssue).detail === "string")
-  );
-}
-
-function parseAiReviewPayload(raw: string): AiReviewPayload | null {
-  try {
-    const parsed = JSON.parse(stripMarkdownCodeFence(raw)) as Record<string, unknown>;
-
-    if (
-      typeof parsed.summary !== "string" ||
-      !Array.isArray(parsed.issues) ||
-      !parsed.issues.every(isGateIssue) ||
-      !["passed", "failed", "blocked"].includes(String(parsed.recommendedStatus))
-    ) {
-      return null;
-    }
-
-    return {
-      summary: parsed.summary,
-      issues: parsed.issues,
-      recommendedStatus: parsed.recommendedStatus as AiReviewPayload["recommendedStatus"],
-    };
-  } catch {
-    return null;
-  }
-}
-
 function buildBlockedResult(summary: string, metadata?: Record<string, unknown>): AiReviewResult {
   return {
     status: "blocked",
@@ -100,30 +61,31 @@ function buildBlockedResult(summary: string, metadata?: Record<string, unknown>)
 export async function runAiReview(
   context: Pick<GateExecutionContext, "cwd" | "scopeFiles" | "fileScope" | "createAgentSession" | "reviewModel">,
   depth: AiReviewDepth,
+  reliability?: ReliabilityReporter,
 ): Promise<AiReviewResult> {
-  const sessionResult = await runStructuredAgentSession(context.createAgentSession, {
+  const result = await runWithOutputValidation<AiReviewOutput>(context.createAgentSession, {
     cwd: context.cwd,
     prompt: buildAiReviewPrompt(context.scopeFiles, context.fileScope, depth),
+    schema: AI_REVIEW_SCHEMA_TEXT,
+    parse: (raw) => parseStructuredOutput<AiReviewOutput>(raw, AiReviewOutputSchema),
     model: context.reviewModel?.model,
     thinkingLevel: context.reviewModel?.thinkingLevel ?? null,
     timeoutMs: 120_000,
+    reliability,
   });
 
-  if (sessionResult.status !== "ok") {
-    return buildBlockedResult(sessionResult.error);
-  }
-
-  const parsed = parseAiReviewPayload(sessionResult.finalText);
-  if (!parsed) {
-    return buildBlockedResult("AI review returned invalid JSON.", {
-      rawOutput: sessionResult.finalText,
+  if (result.status === "blocked") {
+    return buildBlockedResult(result.error, {
+      depth,
+      attempts: result.attempts,
+      ...(result.rawOutputs.length > 0 ? { rawOutputs: result.rawOutputs } : {}),
     });
   }
 
   return {
-    status: parsed.recommendedStatus,
-    summary: parsed.summary,
-    issues: parsed.issues,
-    metadata: { depth },
+    status: result.output.recommendedStatus,
+    summary: result.output.summary,
+    issues: result.output.issues as GateIssue[],
+    metadata: { depth, attempts: result.attempts },
   };
 }

package/src/quality/gates/command.ts

@@ -1,15 +1,38 @@
 import type {
   CommandGateConfig,
   CommandGateId,
+  CommandGateRun,
   GateDefinition,
   GateIssue,
   ProjectFacts,
+  ProjectFactsTarget,
+  WorkspaceTarget,
 } from "../../types.js";
 import { GATE_CONFIG_SCHEMAS } from "../registry.js";
 
-interface DetectedCommand {
+const ARTIFACT_REF_RE = /artifact:\/\/[a-zA-Z0-9_-]+/g;
+
+function extractArtifactRefs(...streams: string[]): string[] {
+  const seen = new Set<string>();
+  for (const stream of streams) {
+    if (!stream) continue;
+    const matches = stream.match(ARTIFACT_REF_RE);
+    if (!matches) continue;
+    for (const ref of matches) seen.add(ref);
+  }
+  return [...seen];
+}
+
+interface TargetDetectedCommand {
+  target: ProjectFactsTarget;
   command: string;
   confidence: "high" | "medium";
+  source: string;
+}
+
+interface DetectedCommandPlan {
+  runs: CommandGateRun[];
+  confidence: "high" | "medium";
   reason: string;
 }
 
@@ -26,64 +49,198 @@ function normalizeCommand(command: string | undefined): string | null {
   return trimmed ? trimmed : null;
 }
 
-function detectScriptByName(
-  projectFacts: ProjectFacts,
+function formatTargetLocation(target: Pick<ProjectFactsTarget, "kind" | "relativeDir">): string {
+  return target.kind === "root" ? "root" : target.relativeDir;
+}
+
+function describeRunSelector(target: CommandGateRun["target"]): string {
+  switch (target.scope) {
+    case "all-targets":
+      return "all targets";
+    case "root":
+      return "root target";
+    case "all-workspaces":
+      return "all workspace targets";
+    case "workspace":
+      return `workspace ${target.relativeDir}`;
+  }
+}
+
+function detectCommandInTarget(
+  target: ProjectFactsTarget,
   options: CommandGateOptions<CommandGateId>,
-): DetectedCommand | null {
+): TargetDetectedCommand | null {
   for (const scriptName of options.scriptNames) {
-    const command = normalizeCommand(projectFacts.packageScripts[scriptName]);
+    const command = normalizeCommand(target.packageScripts[scriptName]);
     if (!command) {
       continue;
     }
 
-    // When a safety filter is defined, apply it even for exact name matches.
-    // A repo with `"lint": "eslint . --fix"` must not be auto-configured.
     if (options.matchScript && !options.matchScript(scriptName, command)) {
       continue;
     }
 
     return {
+      target,
       command,
       confidence: "high",
-      reason: `Detected package.json ${scriptName} script.`,
+      source: `package.json ${scriptName} script`,
     };
   }
 
-  return null;
-}
-
-function detectScriptByHeuristic(
-  projectFacts: ProjectFacts,
-  options: CommandGateOptions<CommandGateId>,
-): DetectedCommand | null {
   if (!options.matchScript) {
     return null;
   }
 
-  for (const [scriptName, rawCommand] of Object.entries(projectFacts.packageScripts)) {
+  for (const [scriptName, rawCommand] of Object.entries(target.packageScripts)) {
     const command = normalizeCommand(rawCommand);
     if (!command || !options.matchScript(scriptName, command)) {
       continue;
     }
 
     return {
+      target,
       command,
       confidence: "medium",
-      reason: `Detected package.json ${scriptName} script by command heuristic.`,
+      source: `package.json ${scriptName} script by command heuristic`,
     };
   }
 
   return null;
 }
 
+function detectCommands(projectFacts: ProjectFacts, options: CommandGateOptions<CommandGateId>): TargetDetectedCommand[] {
+  return projectFacts.targets
+    .map((target) => detectCommandInTarget(target, options))
+    .filter((match): match is TargetDetectedCommand => match !== null);
+}
+
+function buildDetectedRuns(matches: TargetDetectedCommand[]): CommandGateRun[] {
+  const uniqueCommands = [...new Set(matches.map((match) => match.command))];
+  if (uniqueCommands.length === 1) {
+    return [{ command: uniqueCommands[0]!, target: { scope: "all-targets" } }];
+  }
+
+  const rootMatch = matches.find((match) => match.target.kind === "root");
+  const workspaceMatches = matches.filter((match) => match.target.kind === "workspace");
+  const runs: CommandGateRun[] = [];
+
+  if (rootMatch) {
+    runs.push({ command: rootMatch.command, target: { scope: "root" } });
+  }
+
+  if (workspaceMatches.length > 0) {
+    const workspaceCommands = [...new Set(workspaceMatches.map((match) => match.command))];
+    if (workspaceCommands.length === 1) {
+      runs.push({ command: workspaceCommands[0]!, target: { scope: "all-workspaces" } });
+    } else {
+      runs.push(
+        ...workspaceMatches.map((match) => ({
+          command: match.command,
+          target: { scope: "workspace", relativeDir: match.target.relativeDir } as const,
+        })),
+      );
+    }
+  }
+
+  return runs;
+}
+
+function describeDetectedPlan(
+  projectFacts: ProjectFacts,
+  options: CommandGateOptions<CommandGateId>,
+  matches: TargetDetectedCommand[],
+  runs: CommandGateRun[],
+): string {
+  if (projectFacts.targets.length === 1) {
+    return `Detected ${matches[0]!.source}.`;
+  }
+
+  if (runs.length === 1 && runs[0]?.target.scope === "all-targets") {
+    return `Detected ${options.label.toLowerCase()} command shared across all targets via per-target scripts.`;
+  }
+
+  if (
+    runs.length === 2
+    && runs.some((run) => run.target.scope === "root")
+    && runs.some((run) => run.target.scope === "all-workspaces")
+  ) {
+    return `Detected ${options.label.toLowerCase()} commands covering the root target and all workspace targets via per-target scripts.`;
+  }
+
+  if (runs.length === 1 && runs[0]?.target.scope === "all-workspaces") {
+    return `Detected ${options.label.toLowerCase()} command shared across all workspace targets via per-target scripts.`;
+  }
+
+  return `Detected ${options.label.toLowerCase()} commands covering every target via per-target scripts.`;
+}
+
+function detectCompleteCommandPlan(
+  projectFacts: ProjectFacts,
+  options: CommandGateOptions<CommandGateId>,
+): DetectedCommandPlan | null {
+  const matches = detectCommands(projectFacts, options);
+  if (matches.length !== projectFacts.targets.length) {
+    return null;
+  }
+
+  const runs = buildDetectedRuns(matches);
+  return {
+    runs,
+    confidence: matches.every((match) => match.confidence === "high") ? "high" : "medium",
+    reason: describeDetectedPlan(projectFacts, options, matches, runs),
+  };
+}
+
+function describeIncompleteCoverage(
+  projectFacts: ProjectFacts,
+  options: CommandGateOptions<CommandGateId>,
+): string | null {
+  if (projectFacts.targets.length <= 1) {
+    return null;
+  }
+
+  const matches = detectCommands(projectFacts, options);
+  if (matches.length === 0 || matches.length === projectFacts.targets.length) {
+    return null;
+  }
+
+  const targetLocations = matches.map((match) => formatTargetLocation(match.target));
+  const rootMatched = matches.some((match) => match.target.kind === "root");
+
+  if (!rootMatched && matches.every((match) => match.target.kind === "workspace")) {
+    return `Detected ${options.label.toLowerCase()} commands in workspace targets only (${targetLocations.join(", ")}), not in the root target. /supi:checks All also runs the root target, so this gate was not auto-configured.`;
+  }
+
+  return `Detected ${options.label.toLowerCase()} commands only in some targets (${targetLocations.join(", ")}). /supi:checks All runs every target, so this gate was not auto-configured.`;
+}
+
+function runMatchesTarget(run: CommandGateRun, target: WorkspaceTarget): boolean {
+  switch (run.target.scope) {
+    case "all-targets":
+      return true;
+    case "root":
+      return target.kind === "root";
+    case "all-workspaces":
+      return target.kind === "workspace";
+    case "workspace":
+      return target.kind === "workspace" && target.relativeDir === run.target.relativeDir;
+  }
+}
+
 function createFailureDetail(label: string, exitCode: number, stdout: string, stderr: string): string {
   return stderr.trim() || stdout.trim() || `${label} command exited with code ${exitCode}.`;
 }
 
-function createFailureIssue(label: string, detail: string): GateIssue {
+function createFailureIssue(
+  label: string,
+  detail: string,
+  target: WorkspaceTarget,
+  run: CommandGateRun,
+): GateIssue {
   return {
     severity: "error",
-    message: `${label} command failed.`,
+    message: `${label} command failed for ${formatTargetLocation(target)} (${describeRunSelector(run.target)}).`,
     detail,
   };
 }
@@ -96,53 +253,99 @@ export function createCommandGate<TGateId extends CommandGateId>(
     description: options.description,
     configSchema: GATE_CONFIG_SCHEMAS[options.id],
     detect(projectFacts) {
-      const detected =
-        detectScriptByName(projectFacts, options) ?? detectScriptByHeuristic(projectFacts, options);
-      if (!detected) {
+      const detectedPlan = detectCompleteCommandPlan(projectFacts, options);
+      if (detectedPlan) {
+        return {
+          suggestedConfig: {
+            enabled: true,
+            runs: detectedPlan.runs,
+          },
+          confidence: detectedPlan.confidence,
+          reason: detectedPlan.reason,
+        };
+      }
+
+      const incompleteCoverage = describeIncompleteCoverage(projectFacts, options);
+      if (!incompleteCoverage) {
         return null;
       }
 
       return {
-        suggestedConfig: {
-          enabled: true,
-          command: detected.command,
-        },
-        confidence: detected.confidence,
-        reason: detected.reason,
+        suggestedConfig: null,
+        confidence: "medium",
+        reason: incompleteCoverage,
       };
     },
     async run(context, config) {
-      if (config.enabled !== true || typeof config.command !== "string") {
-        throw new Error(`${options.id} gate requires an enabled config with a command.`);
+      if (config.enabled !== true || !Array.isArray(config.runs)) {
+        throw new Error(`${options.id} gate requires an enabled config with runs.`);
       }
 
-      const result = await context.execShell(config.command, {
-        cwd: context.cwd,
-        timeout: 120_000,
-      });
-
-      if (result.code === 0) {
+      const matchingRuns = config.runs.filter((run) => runMatchesTarget(run, context.target));
+      if (matchingRuns.length === 0) {
         return {
           gate: options.id,
-          status: "passed",
-          summary: `${options.label} passed.`,
+          status: "skipped",
+          summary: `${options.label} skipped for ${formatTargetLocation(context.target)} — no configured run matches this target.`,
           issues: [],
           metadata: {
-            command: config.command,
-            exitCode: result.code,
+            target: context.target.relativeDir,
+            reason: "no-matching-runs",
           },
         };
       }
 
-      const detail = createFailureDetail(options.label, result.code, result.stdout, result.stderr);
+      const executedRuns: Array<{
+        command: string;
+        target: CommandGateRun["target"];
+        exitCode: number;
+        artifactRefs?: string[];
+      }> = [];
+      for (const run of matchingRuns) {
+        const result = await context.execShell(run.command, {
+          cwd: context.cwd,
+          timeout: 120_000,
+        });
+        const artifactRefs = extractArtifactRefs(result.stdout, result.stderr);
+        executedRuns.push({
+          command: run.command,
+          target: run.target,
+          exitCode: result.code,
+          ...(artifactRefs.length > 0 ? { artifactRefs } : {}),
+        });
+
+        if (result.code !== 0) {
+          const detail = createFailureDetail(options.label, result.code, result.stdout, result.stderr);
+          const failedRefs = extractArtifactRefs(
+            ...executedRuns.flatMap((r) => r.artifactRefs ?? []),
+          );
+          return {
+            gate: options.id,
+            status: "failed",
+            summary: `${options.label} failed for ${formatTargetLocation(context.target)}.`,
+            issues: [createFailureIssue(options.label, detail, context.target, run)],
+            metadata: {
+              target: context.target.relativeDir,
+              runs: executedRuns,
+              failedCommand: run.command,
+              ...(failedRefs.length > 0 ? { artifactRefs: failedRefs } : {}),
+            },
+          };
+        }
+      }
+
+      const passedRefs = extractArtifactRefs(
+        ...executedRuns.flatMap((r) => r.artifactRefs ?? []),
+      );
       return {
         gate: options.id,
-        status: "failed",
-        summary: `${options.label} failed.`,
-        issues: [createFailureIssue(options.label, detail)],
+        status: "passed",
+        summary: `${options.label} passed.`,
+        issues: [],
         metadata: {
-          command: config.command,
-          exitCode: result.code,
+          target: context.target.relativeDir,
+          runs: executedRuns,
+          ...(passedRefs.length > 0 ? { artifactRefs: passedRefs } : {}),
         },
       };
     },

package/src/quality/review-gates.ts

@@ -1,5 +1,5 @@
-import type { QualityGatesConfig, ProjectFacts } from "../types.js";
-import { CANONICAL_GATE_ORDER, type GateRegistry } from "./registry.js";
+import type { ProjectFacts, QualityGatesConfig } from "../types.js";
+import { CANONICAL_GATE_ORDER, GATE_DISPLAY_NAMES, type GateRegistry } from "./registry.js";
 import { lspDiagnosticsGate } from "./gates/lsp-diagnostics.js";
 import { lintGate } from "./gates/lint.js";
 import { typecheckGate } from "./gates/typecheck.js";
@@ -31,3 +31,19 @@ export function detectReviewGates(projectFacts: ProjectFacts): QualityGatesConfi
 
   return gates;
 }
+
+export function collectReviewGateNotes(projectFacts: ProjectFacts): string[] {
+  const notes: string[] = [];
+
+  for (const gateId of CANONICAL_GATE_ORDER) {
+    const definition = REVIEW_GATE_REGISTRY[gateId];
+    const detection = definition?.detect(projectFacts);
+    if (!detection?.reason || !detection.reason.includes("target")) {
+      continue;
+    }
+
+    notes.push(`${GATE_DISPLAY_NAMES[gateId]}: ${detection.reason}`);
+  }
+
+  return notes;
+}

package/src/quality/runner.ts

@@ -1,4 +1,5 @@
 // src/quality/runner.ts
+import path from "node:path";
 import type { ExecOptions, ExecResult, Platform } from "../platform/types.js";
 import type {
   GateDefinition,
@@ -10,9 +11,12 @@ import type {
   QualityGatesConfig,
   ResolvedModel,
   ReviewReport,
+  WorkspaceTarget,
 } from "../types.js";
-import { CANONICAL_GATE_ORDER, type GateRegistry } from "./registry.js";
 import { collectLspDiagnostics } from "../lsp/bridge.js";
+import { filterPathsForWorkspaceTarget, normalizeRepoPath } from "../workspace/path-mapping.js";
+import { createExecShell } from "../utils/shell.js";
+import { CANONICAL_GATE_ORDER, type GateRegistry } from "./registry.js";
 
 interface ReviewScope {
   changedFiles: string[];
@@ -39,6 +43,8 @@ export type ReviewRunEvent =
 export interface RunQualityGatesInput {
   platform: Pick<Platform, "exec" | "getActiveTools" | "createAgentSession">;
   cwd: string;
+  target: WorkspaceTarget;
+  workspaceTargets: WorkspaceTarget[];
   gates: QualityGatesConfig;
   filters: GateFilters;
   reviewModel: ResolvedModel;
@@ -61,11 +67,11 @@ function normalizeFileList(...chunks: string[]): string[] {
 
   for (const chunk of chunks) {
     for (const line of chunk.split("\n")) {
-      const file = line.trim();
-      if (file.length === 0) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
         continue;
       }
-      seen.add(file);
+      seen.add(normalizeRepoPath(trimmed));
     }
   }
 
@@ -89,14 +95,48 @@ async function safeExec(
   }
 }
 
+export async function discoverChangedRepoFiles(
+  exec: Platform["exec"],
+  repoRoot: string,
+): Promise<string[]> {
+  const head = await safeExec(exec, "git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot });
+  const cached = await safeExec(exec, "git", ["diff", "--name-only", "--cached"], { cwd: repoRoot });
+  const untracked = await safeExec(exec, "git", ["ls-files", "--others", "--exclude-standard"], {
+    cwd: repoRoot,
+  });
+
+  return normalizeFileList(head.stdout, cached.stdout, untracked.stdout);
+}
+
+async function discoverTrackedRepoFiles(
+  exec: Platform["exec"],
+  repoRoot: string,
+): Promise<string[]> {
+  const tracked = await safeExec(exec, "git", ["ls-files"], { cwd: repoRoot });
+  return normalizeFileList(tracked.stdout);
+}
+
+function mapRepoPathsToTargetPaths(
+  workspaceTargets: WorkspaceTarget[],
+  target: WorkspaceTarget,
+  repoRelativePaths: string[],
+): string[] {
+  return filterPathsForWorkspaceTarget(workspaceTargets, target, repoRelativePaths).map((repoRelativePath) =>
+    normalizeRepoPath(path.relative(target.packageDir, path.join(target.repoRoot, repoRelativePath))),
+  );
+}
+
 export async function discoverReviewScope(
   exec: Platform["exec"],
-  cwd: string,
+  repoRoot: string,
+  workspaceTargets: WorkspaceTarget[],
+  target: WorkspaceTarget,
 ): Promise<ReviewScope> {
-  const head = await safeExec(exec, "git", ["diff", "--name-only", "HEAD"], { cwd });
-  const cached = await safeExec(exec, "git", ["diff", "--name-only", "--cached"], { cwd });
-  const untracked = await safeExec(exec, "git", ["ls-files", "--others", "--exclude-standard"], { cwd });
-  const changedFiles = normalizeFileList(head.stdout, cached.stdout, untracked.stdout);
+  const changedFiles = mapRepoPathsToTargetPaths(
+    workspaceTargets,
+    target,
+    await discoverChangedRepoFiles(exec, repoRoot),
+  );
 
   if (changedFiles.length > 0) {
     return {
@@ -106,8 +146,11 @@ export async function discoverReviewScope(
     };
   }
 
-  const tracked = await safeExec(exec, "git", ["ls-files"], { cwd });
-  const scopeFiles = normalizeFileList(tracked.stdout);
+  const scopeFiles = mapRepoPathsToTargetPaths(
+    workspaceTargets,
+    target,
+    await discoverTrackedRepoFiles(exec, repoRoot),
+  );
 
   return {
     changedFiles: [],
@@ -129,21 +172,13 @@ function selectConfiguredGates(gates: QualityGatesConfig, filters: GateFilters):
   return enabledGates;
 }
 
-function createExecShell(exec: Platform["exec"]): GateExecutionContext["execShell"] {
-  return async (command: string, opts?: ExecOptions): Promise<ExecResult> => {
-    if (process.platform === "win32") {
-      return exec("cmd", ["/d", "/s", "/c", command], opts);
-    }
-
-    return exec("sh", ["-lc", command], opts);
-  };
-}
 
 function createGateExecutionContext(
   input: RunQualityGatesInput,
   scope: ReviewScope,
 ): GateExecutionContext {
-  const exec = input.platform.exec.bind(input.platform);
+  const exec: GateExecutionContext["exec"] = (cmd, args, opts) =>
+    input.platform.exec(cmd, args, { cwd: input.cwd, ...opts });
   const createAgentSession = input.platform.createAgentSession.bind(input.platform);
   const activeTools = input.platform.getActiveTools();
   const reviewModel = {
@@ -156,6 +191,7 @@ function createGateExecutionContext(
     changedFiles: scope.changedFiles,
     scopeFiles: scope.scopeFiles,
     fileScope: scope.fileScope,
+    target: input.target,
     exec,
     execShell: createExecShell(exec),
     getLspDiagnostics:
@@ -224,7 +260,12 @@ export function computeOverallStatus(summary: GateSummary): ReviewReport["overal
 
 export async function runQualityGates(input: RunQualityGatesInput): Promise<ReviewReport> {
   const selectedGates = selectConfiguredGates(input.gates, input.filters);
-  const scope = await discoverReviewScope(input.platform.exec.bind(input.platform), input.cwd);
+  const scope = await discoverReviewScope(
+    input.platform.exec.bind(input.platform),
+    input.target.repoRoot,
+    input.workspaceTargets,
+    input.target,
+  );
   input.onEvent?.({
     type: "scope-discovered",
     changedFiles: scope.changedFiles.length,