supipowers 1.5.3 → 2.0.1

package/src/review/output.ts

@@ -1,80 +1,15 @@
-import type { TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import invalidOutputRetryPrompt from "./prompts/invalid-output-retry.md" with { type: "text" };
-import { runStructuredAgentSession } from "../quality/ai-session.js";
-import { stripMarkdownCodeFence } from "../text.js";
-import type { GateExecutionContext, ReviewOutput } from "../types.js";
-import {
-  ReviewOutputSchema,
-  collectReviewValidationErrors,
-  formatReviewValidationErrors,
-} from "./types.js";
-import { renderReviewTemplate } from "./template.js";
-
-export interface StructuredParseResult<T> {
-  output: T | null;
-  error: string | null;
-}
-
-export interface OutputValidationRunOptions<T> {
-  cwd: string;
-  prompt: string;
-  schema: string;
-  parse: (raw: string) => StructuredParseResult<T>;
-  model?: string;
-  thinkingLevel?: string | null;
-  timeoutMs?: number;
-  maxAttempts?: number;
-}
-
-export type OutputValidationRunResult<T> =
-  | {
-      status: "ok";
-      output: T;
-      rawOutput: string;
-      attempts: number;
-    }
-  | {
-      status: "blocked";
-      error: string;
-      rawOutputs: string[];
-      attempts: number;
-    };
-
-function truncateForPrompt(text: string, maxLength = 1200): string {
-  const normalized = text.trim();
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-
-  return `${normalized.slice(0, maxLength - 1)}…`;
-}
-
-export function parseStructuredOutput<T>(raw: string, schema: TSchema): StructuredParseResult<T> {
-  let parsed: unknown;
-
-  try {
-    parsed = JSON.parse(stripMarkdownCodeFence(raw));
-  } catch (error) {
-    return {
-      output: null,
-      error: error instanceof Error ? `Invalid JSON: ${error.message}` : "Invalid JSON.",
-    };
-  }
-
-  if (!Value.Check(schema, parsed)) {
-    const errors = formatReviewValidationErrors(collectReviewValidationErrors(schema, parsed));
-    return {
-      output: null,
-      error: errors.length > 0 ? errors.join("; ") : "Output does not match the required schema.",
-    };
-  }
-
-  return {
-    output: parsed as T,
-    error: null,
-  };
-}
+// src/review/output.ts
+//
+// Review-specific thin wrappers over the shared structured-output foundation.
+// Everything generic (parseStructuredOutput<T>, runWithOutputValidation<T>,
+// StructuredOutputResult<T>, validation-error helpers) lives in
+// src/ai/structured-output.ts. This module exists only so review callers can
+// parse a raw model response into ReviewOutput without rewriting the schema
+// reference at every site.
+
+import { parseStructuredOutput } from "../ai/structured-output.js";
+import type { ReviewOutput } from "../types.js";
+import { ReviewOutputSchema } from "./types.js";
 
 export function parseReviewOutput(raw: string): ReviewOutput | null {
   return parseStructuredOutput<ReviewOutput>(raw, ReviewOutputSchema).output;
@@ -83,65 +18,3 @@ export function parseReviewOutput(raw: string): ReviewOutput | null {
 export function explainReviewOutputFailure(raw: string): string | null {
   return parseStructuredOutput<ReviewOutput>(raw, ReviewOutputSchema).error;
 }
-
-export async function runWithOutputValidation<T>(
-  createAgentSession: GateExecutionContext["createAgentSession"],
-  options: OutputValidationRunOptions<T>,
-): Promise<OutputValidationRunResult<T>> {
-  const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
-  const rawOutputs: string[] = [];
-  let prompt = options.prompt;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    const result = await runStructuredAgentSession(createAgentSession, {
-      cwd: options.cwd,
-      prompt,
-      model: options.model,
-      thinkingLevel: options.thinkingLevel ?? null,
-      timeoutMs: options.timeoutMs,
-    });
-
-    if (result.status !== "ok") {
-      return {
-        status: "blocked",
-        error: result.error,
-        rawOutputs,
-        attempts: attempt,
-      };
-    }
-
-    rawOutputs.push(result.finalText);
-    const parsed = options.parse(result.finalText);
-    if (parsed.output) {
-      return {
-        status: "ok",
-        output: parsed.output,
-        rawOutput: result.finalText,
-        attempts: attempt,
-      };
-    }
-
-    if (attempt === maxAttempts) {
-      return {
-        status: "blocked",
-        error: parsed.error ?? "Agent output was invalid.",
-        rawOutputs,
-        attempts: attempt,
-      };
-    }
-
-    prompt = renderReviewTemplate(invalidOutputRetryPrompt, {
-      prompt: options.prompt,
-      error: parsed.error ?? "Agent output was invalid.",
-      previousOutput: truncateForPrompt(result.finalText),
-      schema: options.schema,
-    });
-  }
-
-  return {
-    status: "blocked",
-    error: "Output validation exhausted without producing a valid result.",
-    rawOutputs,
-    attempts: maxAttempts,
-  };
-}

package/src/review/runner.ts

@@ -1,8 +1,12 @@
-import reviewOutputSchema from "./prompts/review-output-schema.md" with { type: "text" };
 import singleReviewPrompt from "./prompts/single-review.md" with { type: "text" };
 import type { GateExecutionContext, ReviewLevel, ReviewOutput, ReviewScope } from "../types.js";
-import { explainReviewOutputFailure, parseReviewOutput, runWithOutputValidation } from "./output.js";
-import { renderReviewTemplate } from "./template.js";
+import { runWithOutputValidation, type ReliabilityReporter } from "../ai/structured-output.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import { explainReviewOutputFailure, parseReviewOutput } from "./output.js";
+import { renderTemplate } from "../ai/template.js";
+import { ReviewOutputSchema } from "./types.js";
+
+const REVIEW_OUTPUT_SCHEMA_TEXT = renderSchemaText(ReviewOutputSchema);
 
 export type SingleReviewLevel = Extract<ReviewLevel, "quick" | "deep">;
 
@@ -14,6 +18,7 @@ export interface SingleReviewRunnerInput {
   model?: string;
   thinkingLevel?: string | null;
   timeoutMs?: number;
+  reliability?: ReliabilityReporter;
 }
 
 export interface SingleReviewRunResult {
@@ -70,12 +75,12 @@ export function normalizeReviewOutput(output: ReviewOutput): ReviewOutput {
 }
 
 export function buildSingleReviewPrompt(scope: ReviewScope, level: SingleReviewLevel): string {
-  return renderReviewTemplate(singleReviewPrompt, {
+  return renderTemplate(singleReviewPrompt, {
     level,
     scope,
     isQuick: level === "quick",
     isDeep: level === "deep",
-    outputSchema: reviewOutputSchema.trim(),
+    outputSchema: REVIEW_OUTPUT_SCHEMA_TEXT,
   });
 }
 
@@ -83,7 +88,7 @@ export async function runSingleReview(input: SingleReviewRunnerInput): Promise<S
   const result = await runWithOutputValidation(input.createAgentSession, {
     cwd: input.cwd,
     prompt: buildSingleReviewPrompt(input.scope, input.level),
-    schema: reviewOutputSchema.trim(),
+    schema: REVIEW_OUTPUT_SCHEMA_TEXT,
     parse(raw) {
       const output = parseReviewOutput(raw);
       return {
@@ -94,6 +99,7 @@ export async function runSingleReview(input: SingleReviewRunnerInput): Promise<S
     model: input.model,
     thinkingLevel: input.thinkingLevel ?? null,
     timeoutMs: input.timeoutMs ?? 120_000,
+    reliability: input.reliability,
   });
 
   if (result.status === "blocked") {

package/src/review/scope.ts

@@ -1,5 +1,7 @@
 import type { Platform, PlatformContext } from "../platform/types.js";
-import type { ReviewScope, ReviewScopeFile, ReviewScopeStats } from "../types.js";
+import type { ReviewScope, ReviewScopeFile, ReviewScopeStats, WorkspaceTarget } from "../types.js";
+import { filterGitLogOnelineToWorkspaceTarget } from "../workspace/git-scope.js";
+import { findWorkspaceTargetForPath } from "../workspace/path-mapping.js";
 
 interface ExcludedReviewScopeFile {
   path: string;
@@ -14,6 +16,11 @@ export interface ParsedReviewDiff {
   stats: ReviewScopeStats;
 }
 
+export interface ReviewWorkspaceSelection {
+  target: WorkspaceTarget;
+  targets: WorkspaceTarget[];
+}
+
 export const EXCLUDED_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
   { pattern: /\.lock$/, reason: "lock file" },
   { pattern: /-lock\.(json|yaml|yml)$/, reason: "lock file" },
@@ -200,6 +207,51 @@ function ensureReviewableScope(scope: ReviewScope, message: string): ReviewScope
   return scope;
 }
 
+function buildTargetLabel(selection: ReviewWorkspaceSelection): string {
+  return `${selection.target.name} (${selection.target.relativeDir})`;
+}
+
+function appendTargetContext(description: string, selection?: ReviewWorkspaceSelection | null): string {
+  return selection ? `${description} for ${buildTargetLabel(selection)}` : description;
+}
+
+function buildEmptyScopeMessage(baseMessage: string, selection?: ReviewWorkspaceSelection | null): string {
+  return selection
+    ? `${baseMessage} for ${buildTargetLabel(selection)}.`
+    : `${baseMessage}.`;
+}
+
+function ensureTargetScopeHasDiff(
+  diff: string,
+  emptyScopeMessage: string,
+  selection?: ReviewWorkspaceSelection | null,
+): void {
+  if (selection && !diff.trim()) {
+    throw new Error(emptyScopeMessage);
+  }
+}
+
+function filterDiffToWorkspaceTarget(diffOutput: string, selection?: ReviewWorkspaceSelection | null): string {
+  if (!selection || !diffOutput.trim()) {
+    return diffOutput;
+  }
+
+  return diffOutput
+    .split(/^diff --git /m)
+    .filter(Boolean)
+    .map((chunk) => `diff --git ${chunk}`)
+    .filter((chunk) => {
+      const headerMatch = chunk.match(/^diff --git a\/(.+?) b\/(.+)/m);
+      const repoRelativePath = headerMatch?.[2]?.trim();
+      if (!repoRelativePath) {
+        return false;
+      }
+
+      return findWorkspaceTargetForPath(selection.targets, repoRelativePath)?.id === selection.target.id;
+    })
+    .join("\n");
+}
+
 export async function listReviewBaseBranches(platform: Pick<Platform, "exec">, cwd: string): Promise<string[]> {
   const output = await execGit(platform, cwd, ["branch", "--all", "--format=%(refname:short)"]);
   return [...new Set(
@@ -220,9 +272,18 @@ export async function listRecentReviewCommits(
   platform: Pick<Platform, "exec">,
   cwd: string,
   count = 20,
+  selection?: ReviewWorkspaceSelection | null,
 ): Promise<string[]> {
-  const output = await execGit(platform, cwd, ["log", "--oneline", `-${count}`]);
-  return output
+  if (!selection) {
+    const output = await execGit(platform, cwd, ["log", "--oneline", `-${count}`]);
+    return output
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+  }
+
+  const output = await execGit(platform, cwd, ["log", `-${count}`, "--format=%H%x1f%s%x1e", "--name-only"]);
+  return filterGitLogOnelineToWorkspaceTarget(output, selection.targets, selection.target)
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.length > 0);
@@ -233,63 +294,120 @@ export async function loadPullRequestScope(
   cwd: string,
   baseBranch: string,
   currentBranch?: string,
+  selection?: ReviewWorkspaceSelection | null,
 ): Promise<ReviewScope> {
   const branch = currentBranch ?? await getCurrentReviewBranch(platform, cwd);
-  const diff = await execGit(platform, cwd, ["diff", "--no-ext-diff", "--binary", `${baseBranch}...${branch}`]);
+  const rawDiff = await execGit(platform, cwd, ["diff", "--no-ext-diff", "--binary", `${baseBranch}...${branch}`]);
+  const diff = filterDiffToWorkspaceTarget(rawDiff, selection);
+  ensureTargetScopeHasDiff(
+    diff,
+    buildEmptyScopeMessage("No reviewable files remain after filtering PR-style changes", selection),
+    selection,
+  );
   const scope = createScope(
     "pull-request",
-    `Reviewing changes between ${baseBranch} and ${branch}`,
+    appendTargetContext(`Reviewing changes between ${baseBranch} and ${branch}`, selection),
     diff,
     { baseBranch },
   );
-  return ensureReviewableScope(scope, "No reviewable files remain after filtering PR-style changes.");
+  return ensureReviewableScope(
+    scope,
+    buildEmptyScopeMessage("No reviewable files remain after filtering PR-style changes", selection),
+  );
 }
 
-export async function loadUncommittedScope(platform: Pick<Platform, "exec">, cwd: string): Promise<ReviewScope> {
+export async function loadUncommittedScope(
+  platform: Pick<Platform, "exec">,
+  cwd: string,
+  selection?: ReviewWorkspaceSelection | null,
+): Promise<ReviewScope> {
   const [unstaged, staged, untracked] = await Promise.all([
     execGit(platform, cwd, ["diff", "--no-ext-diff", "--binary"]),
     execGit(platform, cwd, ["diff", "--cached", "--no-ext-diff", "--binary"]),
     buildUntrackedDiff(platform, cwd),
   ]);
-  const diff = [unstaged, staged, untracked].filter((chunk) => chunk.trim().length > 0).join("\n");
-  const scope = createScope("uncommitted", "Reviewing uncommitted changes", diff);
-  return ensureReviewableScope(scope, "No reviewable files remain after filtering uncommitted changes.");
+  const rawDiff = [unstaged, staged, untracked].filter((chunk) => chunk.trim().length > 0).join("\n");
+  const diff = filterDiffToWorkspaceTarget(rawDiff, selection);
+  ensureTargetScopeHasDiff(
+    diff,
+    buildEmptyScopeMessage("No reviewable files remain after filtering uncommitted changes", selection),
+    selection,
+  );
+  const scope = createScope(
+    "uncommitted",
+    appendTargetContext("Reviewing uncommitted changes", selection),
+    diff,
+  );
+  return ensureReviewableScope(
+    scope,
+    buildEmptyScopeMessage("No reviewable files remain after filtering uncommitted changes", selection),
+  );
 }
 
 export async function loadCommitScope(
   platform: Pick<Platform, "exec">,
   cwd: string,
   commit: string,
+  selection?: ReviewWorkspaceSelection | null,
 ): Promise<ReviewScope> {
-  const diff = await execGit(platform, cwd, ["show", "--format=", "--no-ext-diff", "--binary", commit]);
-  const scope = createScope("commit", `Reviewing commit ${commit}`, diff, { commit });
-  return ensureReviewableScope(scope, "No reviewable files remain after filtering commit changes.");
+  const rawDiff = await execGit(platform, cwd, ["show", "--format=", "--no-ext-diff", "--binary", commit]);
+  const diff = filterDiffToWorkspaceTarget(rawDiff, selection);
+  ensureTargetScopeHasDiff(
+    diff,
+    buildEmptyScopeMessage("No reviewable files remain after filtering commit changes", selection),
+    selection,
+  );
+  const scope = createScope(
+    "commit",
+    appendTargetContext(`Reviewing commit ${commit}`, selection),
+    diff,
+    { commit },
+  );
+  return ensureReviewableScope(
+    scope,
+    buildEmptyScopeMessage("No reviewable files remain after filtering commit changes", selection),
+  );
 }
 
 export async function loadCustomReviewScope(
   platform: Pick<Platform, "exec">,
   cwd: string,
   instructions: string,
+  selection?: ReviewWorkspaceSelection | null,
 ): Promise<ReviewScope> {
-  let diff = "";
+  let rawDiff = "";
 
   try {
-    diff = await execGit(platform, cwd, ["diff", "--no-ext-diff", "--binary", "HEAD"]);
+    rawDiff = await execGit(platform, cwd, ["diff", "--no-ext-diff", "--binary", "HEAD"]);
   } catch {
-    diff = "";
+    rawDiff = "";
   }
 
-  return createScope(
+  const diff = filterDiffToWorkspaceTarget(rawDiff, selection);
+  ensureTargetScopeHasDiff(
+    diff,
+    buildEmptyScopeMessage("No reviewable files remain after filtering custom review changes", selection),
+    selection,
+  );
+  const scope = createScope(
     "custom",
-    `Custom review: ${instructions.slice(0, 60)}`,
+    appendTargetContext(`Custom review: ${instructions.slice(0, 60)}`, selection),
     diff,
     { customInstructions: instructions },
   );
+
+  return selection
+    ? ensureReviewableScope(
+        scope,
+        buildEmptyScopeMessage("No reviewable files remain after filtering custom review changes", selection),
+      )
+    : scope;
 }
 
 export async function selectReviewScope(
   platform: Pick<Platform, "exec">,
   ctx: Pick<PlatformContext, "cwd" | "ui">,
+  selection?: ReviewWorkspaceSelection | null,
 ): Promise<ReviewScope | null> {
   const choice = await ctx.ui.select(
     "What should /supi:review inspect?",
@@ -317,17 +435,19 @@ export async function selectReviewScope(
     if (!selected) {
       return null;
     }
-    return loadPullRequestScope(platform, ctx.cwd, selected);
+    return loadPullRequestScope(platform, ctx.cwd, selected, undefined, selection);
   }
 
   if (choice.startsWith("Uncommitted changes")) {
-    return loadUncommittedScope(platform, ctx.cwd);
+    return loadUncommittedScope(platform, ctx.cwd, selection);
   }
 
   if (choice.startsWith("Specific commit")) {
-    const commits = await listRecentReviewCommits(platform, ctx.cwd);
+    const commits = await listRecentReviewCommits(platform, ctx.cwd, 20, selection);
     if (commits.length === 0) {
-      throw new Error("No commits found.");
+      throw new Error(selection
+        ? `No commits found for ${buildTargetLabel(selection)}.`
+        : "No commits found.");
     }
     const selected = await ctx.ui.select("Commit to review", commits, {
       helpText: "Select a recent commit · Esc to cancel",
@@ -339,7 +459,7 @@ export async function selectReviewScope(
     if (!commit) {
       throw new Error("Could not determine the selected commit hash.");
     }
-    return loadCommitScope(platform, ctx.cwd, commit);
+    return loadCommitScope(platform, ctx.cwd, commit, selection);
   }
 
   const instructions = await ctx.ui.input("Custom review focus", {
@@ -349,5 +469,5 @@ export async function selectReviewScope(
   if (!instructions?.trim()) {
     return null;
   }
-  return loadCustomReviewScope(platform, ctx.cwd, instructions.trim());
+  return loadCustomReviewScope(platform, ctx.cwd, instructions.trim(), selection);
 }

package/src/review/types.ts

@@ -1,5 +1,4 @@
 import { Type } from "@sinclair/typebox";
-import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import type {
   ConfiguredReviewAgent,
@@ -132,6 +131,7 @@ export const ReviewAgentConfigSchema = Type.Object(
       Type.Literal("xhigh"),
       Type.Null(),
     ])),
+    peerCoordination: Type.Optional(Type.Boolean()),
   },
   { additionalProperties: false },
 );
@@ -222,25 +222,6 @@ export const ReviewSessionSchema = Type.Object(
   { additionalProperties: false },
 );
 
-export interface ReviewValidationError {
-  path: string;
-  message: string;
-}
-
-function normalizeErrorPath(path: string): string {
-  return path.replace(/^\//, "").replace(/\//g, ".") || "(root)";
-}
-
-export function collectReviewValidationErrors(schema: TSchema, data: unknown): ReviewValidationError[] {
-  return [...Value.Errors(schema, data)].map((error) => ({
-    path: normalizeErrorPath(error.path),
-    message: error.message,
-  }));
-}
-
-export function formatReviewValidationErrors(errors: ReviewValidationError[]): string[] {
-  return errors.map((error) => `${error.path}: ${error.message}`);
-}
 
 export function isReviewScopeFile(value: unknown): value is ReviewScopeFile {
   return Value.Check(ReviewScopeFileSchema, value);

package/src/review/validator.ts

@@ -1,8 +1,12 @@
-import reviewOutputSchema from "./prompts/review-output-schema.md" with { type: "text" };
 import validationReviewPrompt from "./prompts/validation-review.md" with { type: "text" };
 import type { GateExecutionContext, ReviewFinding, ReviewOutput, ReviewScope } from "../types.js";
-import { explainReviewOutputFailure, parseReviewOutput, runWithOutputValidation } from "./output.js";
-import { renderReviewTemplate } from "./template.js";
+import { runWithOutputValidation, type ReliabilityReporter } from "../ai/structured-output.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import { explainReviewOutputFailure, parseReviewOutput } from "./output.js";
+import { renderTemplate } from "../ai/template.js";
+import { ReviewOutputSchema } from "./types.js";
+
+const REVIEW_OUTPUT_SCHEMA_TEXT = renderSchemaText(ReviewOutputSchema);
 
 export interface ReviewValidationInput {
   cwd: string;
@@ -14,6 +18,7 @@ export interface ReviewValidationInput {
   timeoutMs?: number;
   validatorName?: string;
   now?: () => Date;
+  reliability?: ReliabilityReporter;
 }
 
 export interface ReviewValidationResult {
@@ -80,12 +85,12 @@ export function buildValidationPrompt(
   validatorName: string,
   validatedAt: string,
 ): string {
-  return renderReviewTemplate(validationReviewPrompt, {
+  return renderTemplate(validationReviewPrompt, {
     scope,
     findingsJson: JSON.stringify(findings, null, 2),
     validatorName,
     validatedAt,
-    outputSchema: reviewOutputSchema.trim(),
+    outputSchema: REVIEW_OUTPUT_SCHEMA_TEXT,
   });
 }
 
@@ -107,7 +112,7 @@ export async function validateReviewFindings(input: ReviewValidationInput): Prom
   const result = await runWithOutputValidation(input.createAgentSession, {
     cwd: input.cwd,
     prompt: buildValidationPrompt(input.scope, input.findings, validatorName, validatedAt),
-    schema: reviewOutputSchema.trim(),
+    schema: REVIEW_OUTPUT_SCHEMA_TEXT,
     parse(raw) {
       const output = parseReviewOutput(raw);
       return {
@@ -118,6 +123,7 @@ export async function validateReviewFindings(input: ReviewValidationInput): Prom
     model: input.model,
     thinkingLevel: input.thinkingLevel ?? null,
     timeoutMs: input.timeoutMs ?? 120_000,
+    reliability: input.reliability,
   });
 
   if (result.status === "blocked") {

package/src/storage/fix-pr-sessions.ts

@@ -2,15 +2,17 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { FixPrSessionLedger } from "../fix-pr/types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { getProjectTargetStatePath } from "../workspace/state-paths.js";
 
 const SESSIONS_DIR = "fix-pr-sessions";
 
-function getBaseDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, SESSIONS_DIR);
+function getBaseDir(paths: PlatformPaths, target: WorkspaceTarget): string {
+  return getProjectTargetStatePath(paths, target, SESSIONS_DIR);
 }
 
-export function getSessionDir(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getBaseDir(paths, cwd), sessionId);
+export function getSessionDir(paths: PlatformPaths, target: WorkspaceTarget, sessionId: string): string {
+  return path.join(getBaseDir(paths, target), sessionId);
 }
 
 export function generateFixPrSessionId(): string {
@@ -21,14 +23,14 @@ export function generateFixPrSessionId(): string {
   return `fpr-${date}-${time}-${rand}`;
 }
 
-export function createFixPrSession(paths: PlatformPaths, cwd: string, ledger: FixPrSessionLedger): void {
-  const sessionDir = getSessionDir(paths, cwd, ledger.id);
+export function createFixPrSession(paths: PlatformPaths, target: WorkspaceTarget, ledger: FixPrSessionLedger): void {
+  const sessionDir = getSessionDir(paths, target, ledger.id);
   fs.mkdirSync(path.join(sessionDir, "snapshots"), { recursive: true });
   fs.writeFileSync(path.join(sessionDir, "ledger.json"), JSON.stringify(ledger, null, 2));
 }
 
-export function loadFixPrSession(paths: PlatformPaths, cwd: string, sessionId: string): FixPrSessionLedger | null {
-  const ledgerPath = path.join(getSessionDir(paths, cwd, sessionId), "ledger.json");
+export function loadFixPrSession(paths: PlatformPaths, target: WorkspaceTarget, sessionId: string): FixPrSessionLedger | null {
+  const ledgerPath = path.join(getSessionDir(paths, target, sessionId), "ledger.json");
   if (!fs.existsSync(ledgerPath)) return null;
   try {
     return JSON.parse(fs.readFileSync(ledgerPath, "utf-8")) as FixPrSessionLedger;
@@ -37,14 +39,19 @@ export function loadFixPrSession(paths: PlatformPaths, cwd: string, sessionId: s
   }
 }
 
-export function updateFixPrSession(paths: PlatformPaths, cwd: string, ledger: FixPrSessionLedger): void {
-  const ledgerPath = path.join(getSessionDir(paths, cwd, ledger.id), "ledger.json");
+export function updateFixPrSession(paths: PlatformPaths, target: WorkspaceTarget, ledger: FixPrSessionLedger): void {
+  const ledgerPath = path.join(getSessionDir(paths, target, ledger.id), "ledger.json");
   ledger.updatedAt = new Date().toISOString();
   fs.writeFileSync(ledgerPath, JSON.stringify(ledger, null, 2));
 }
 
-export function findActiveFixPrSession(paths: PlatformPaths, cwd: string): FixPrSessionLedger | null {
-  const baseDir = getBaseDir(paths, cwd);
+export function findActiveFixPrSession(
+  paths: PlatformPaths,
+  target: WorkspaceTarget,
+  repo: string,
+  prNumber: number,
+): FixPrSessionLedger | null {
+  const baseDir = getBaseDir(paths, target);
   if (!fs.existsSync(baseDir)) return null;
 
   const dirs = fs.readdirSync(baseDir)
@@ -53,8 +60,8 @@ export function findActiveFixPrSession(paths: PlatformPaths, cwd: string): FixPr
     .reverse();
 
   for (const dir of dirs) {
-    const ledger = loadFixPrSession(paths, cwd, dir);
-    if (ledger && ledger.status === "running") return ledger;
+    const ledger = loadFixPrSession(paths, target, dir);
+    if (ledger && ledger.status === "running" && ledger.repo === repo && ledger.prNumber === prNumber) return ledger;
   }
   return null;
 }