supipowers 1.5.2 → 2.0.0

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,
@@ -17,6 +16,7 @@ import type {
   ReviewScopeStats,
   ReviewSession,
   ReviewSessionArtifacts,
+  ThinkingLevel,
 } from "../types.js";
 export type {
   ConfiguredReviewAgent,
@@ -122,6 +122,16 @@ export const ReviewAgentConfigSchema = Type.Object(
     enabled: Type.Boolean(),
     data: Type.String({ minLength: 1 }),
     model: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+    thinkingLevel: Type.Optional(Type.Union([
+      Type.Literal("off"),
+      Type.Literal("minimal"),
+      Type.Literal("low"),
+      Type.Literal("medium"),
+      Type.Literal("high"),
+      Type.Literal("xhigh"),
+      Type.Null(),
+    ])),
+    peerCoordination: Type.Optional(Type.Boolean()),
   },
   { additionalProperties: false },
 );
@@ -212,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;
 }

package/src/storage/plans.ts

@@ -1,16 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { normalizeLineEndings } from "../text.js";
-import type { Plan, PlanTask, TaskComplexity } from "../types.js";
+import type { Plan, PlanTask, TaskComplexity, WorkspaceTarget } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
 
 function getPlansDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "plans");
+  return getProjectStatePath(paths, cwd, "plans");
 }
 
-/** List all saved plans */
-export function listPlans(paths: PlatformPaths, cwd: string): string[] {
-  const dir = getPlansDir(paths, cwd);
+function listPlanFiles(dir: string): string[] {
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir)
@@ -19,6 +18,16 @@ export function listPlans(paths: PlatformPaths, cwd: string): string[] {
     .reverse();
 }
 
+/** List all saved plans */
+export function listPlans(paths: PlatformPaths, cwd: string): string[] {
+  return listPlanFiles(getPlansDir(paths, cwd));
+}
+
+/** List all saved plans for a specific workspace target. */
+export function listTargetPlans(paths: PlatformPaths, target: WorkspaceTarget): string[] {
+  return listPlanFiles(getProjectTargetStatePath(paths, target, "plans"));
+}
+
 /** Read a plan file by name */
 export function readPlanFile(paths: PlatformPaths, cwd: string, name: string): string | null {
   const filePath = path.join(getPlansDir(paths, cwd), name);

package/src/storage/qa-sessions.ts

@@ -1,14 +1,20 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { E2eSessionLedger } from "../qa/types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
+import type { E2eSessionLedger } from "../qa/types.js";
+
+function getSessionsDir(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string {
+  if (target) {
+    return getProjectTargetStatePath(paths, target, "qa-sessions");
+  }
 
-function getSessionsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "qa-sessions");
+  return getProjectStatePath(paths, cwd, "qa-sessions");
 }
 
-export function getSessionDir(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getSessionsDir(paths, cwd), sessionId);
+export function getSessionDir(paths: PlatformPaths, cwd: string, sessionId: string, target?: WorkspaceTarget): string {
+  return path.join(getSessionsDir(paths, cwd, target), sessionId);
 }
 
 /** Generate a unique QA session ID */
@@ -21,8 +27,8 @@ export function generateSessionId(): string {
 }
 
 /** Create a new QA session */
-export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger): void {
-  const sessionDir = getSessionDir(paths, cwd, ledger.id);
+export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger, target?: WorkspaceTarget): void {
+  const sessionDir = getSessionDir(paths, cwd, ledger.id, target);
   fs.mkdirSync(sessionDir, { recursive: true });
   fs.writeFileSync(
     path.join(sessionDir, "ledger.json"),
@@ -31,8 +37,8 @@ export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSess
 }
 
 /** Load a QA session ledger */
-export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string): E2eSessionLedger | null {
-  const filePath = path.join(getSessionDir(paths, cwd, sessionId), "ledger.json");
+export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  const filePath = path.join(getSessionDir(paths, cwd, sessionId, target), "ledger.json");
   if (!fs.existsSync(filePath)) return null;
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -42,14 +48,14 @@ export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string
 }
 
 /** Update a QA session ledger */
-export function updateSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger): void {
-  const filePath = path.join(getSessionDir(paths, cwd, ledger.id), "ledger.json");
+export function updateSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger, target?: WorkspaceTarget): void {
+  const filePath = path.join(getSessionDir(paths, cwd, ledger.id, target), "ledger.json");
   fs.writeFileSync(filePath, JSON.stringify(ledger, null, 2) + "\n");
 }
 
 /** List all QA sessions, newest first */
-export function listSessions(paths: PlatformPaths, cwd: string): string[] {
-  const dir = getSessionsDir(paths, cwd);
+export function listSessions(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string[] {
+  const dir = getSessionsDir(paths, cwd, target);
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir)
@@ -59,9 +65,9 @@ export function listSessions(paths: PlatformPaths, cwd: string): string[] {
 }
 
 /** Find the latest session with incomplete phases */
-export function findActiveSession(paths: PlatformPaths, cwd: string): E2eSessionLedger | null {
-  for (const sessionId of listSessions(paths, cwd)) {
-    const ledger = loadSession(paths, cwd, sessionId);
+export function findActiveSession(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  for (const sessionId of listSessions(paths, cwd, target)) {
+    const ledger = loadSession(paths, cwd, sessionId, target);
     if (!ledger) continue;
     const allCompleted = Object.values(ledger.phases).every(
       (p) => p.status === "completed",
@@ -72,9 +78,9 @@ export function findActiveSession(paths: PlatformPaths, cwd: string): E2eSession
 }
 
 /** Find the latest session with failed test results */
-export function findSessionWithFailures(paths: PlatformPaths, cwd: string): E2eSessionLedger | null {
-  for (const sessionId of listSessions(paths, cwd)) {
-    const ledger = loadSession(paths, cwd, sessionId);
+export function findSessionWithFailures(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  for (const sessionId of listSessions(paths, cwd, target)) {
+    const ledger = loadSession(paths, cwd, sessionId, target);
     if (!ledger) continue;
     if (ledger.results.some((r) => r.status === "fail")) return ledger;
   }

package/src/storage/reliability-metrics.ts

@@ -0,0 +1,180 @@
+// src/storage/reliability-metrics.ts
+//
+// Local-first reliability metrics. Each AI-heavy command appends one
+// ReliabilityRecord per attempt to .omp/supipowers/reliability/events.jsonl.
+// /supi:status and /supi:doctor read these records to surface concrete
+// numbers (parse-success rate, blocked rate, retries-per-run, fallback
+// counts) instead of vibes.
+//
+// Storage format: append-only JSONL. One record per line. Robust to partial
+// writes — readers skip malformed lines rather than aborting.
+//
+// Non-goals:
+//   - Hosted telemetry (records never leave the project)
+//   - Streaming queries (everything is in-memory after read)
+//   - Cross-cwd aggregation in a single read (callers pass the cwd they want)
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { PlatformPaths } from "../platform/types.js";
+import { getProjectStatePath } from "../workspace/state-paths.js";
+import type { ReliabilityOutcome, ReliabilityRecord, ReliabilitySummary } from "../types.js";
+
+const EVENTS_FILE = "events.jsonl";
+const RELIABILITY_DIR = "reliability";
+
+function getReliabilityDir(paths: PlatformPaths, cwd: string): string {
+  return getProjectStatePath(paths, cwd, RELIABILITY_DIR);
+}
+
+function getEventsPath(paths: PlatformPaths, cwd: string): string {
+  return path.join(getReliabilityDir(paths, cwd), EVENTS_FILE);
+}
+
+/**
+ * Append a single reliability record. Best-effort: failures are swallowed
+ * because metrics must never crash the workflow they observe.
+ */
+export function appendReliabilityRecord(
+  paths: PlatformPaths,
+  cwd: string,
+  record: ReliabilityRecord,
+): void {
+  try {
+    fs.mkdirSync(getReliabilityDir(paths, cwd), { recursive: true });
+    fs.appendFileSync(getEventsPath(paths, cwd), JSON.stringify(record) + "\n");
+  } catch {
+    // Swallow — metrics observability must not break the workflow.
+  }
+}
+
+/**
+ * Read all reliability records for the given cwd. Malformed lines are
+ * skipped silently (best-effort recovery). Returns an empty array when the
+ * file does not exist yet.
+ */
+export function readReliabilityRecords(paths: PlatformPaths, cwd: string): ReliabilityRecord[] {
+  const file = getEventsPath(paths, cwd);
+  if (!fs.existsSync(file)) return [];
+  const records: ReliabilityRecord[] = [];
+  let raw: string;
+  try {
+    raw = fs.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line) as ReliabilityRecord;
+      // Minimal shape check — drop records missing the required fields.
+      if (
+        typeof parsed?.ts === "string" &&
+        typeof parsed.command === "string" &&
+        typeof parsed.outcome === "string" &&
+        typeof parsed.attempts === "number"
+      ) {
+        records.push(parsed);
+      }
+    } catch {
+      // Skip malformed line.
+    }
+  }
+  return records;
+}
+
+const ZERO_OUTCOME_COUNTS: Record<ReliabilityOutcome, number> = {
+  ok: 0,
+  blocked: 0,
+  "retry-exhausted": 0,
+  fallback: 0,
+  "agent-error": 0,
+};
+
+/**
+ * Aggregate records into per-command summaries. Returns one summary per
+ * distinct `command` that appears in `records`, sorted by command name.
+ */
+export function summarizeReliabilityRecords(records: ReliabilityRecord[]): ReliabilitySummary[] {
+  const buckets = new Map<string, ReliabilityRecord[]>();
+  for (const record of records) {
+    const list = buckets.get(record.command) ?? [];
+    list.push(record);
+    buckets.set(record.command, list);
+  }
+
+  const summaries: ReliabilitySummary[] = [];
+  for (const [command, list] of buckets) {
+    const byOutcome = { ...ZERO_OUTCOME_COUNTS };
+    let attemptsTotal = 0;
+    let lastRecordedAt: string | null = null;
+    for (const r of list) {
+      byOutcome[r.outcome] = (byOutcome[r.outcome] ?? 0) + 1;
+      attemptsTotal += r.attempts;
+      if (!lastRecordedAt || r.ts > lastRecordedAt) lastRecordedAt = r.ts;
+    }
+    summaries.push({
+      command,
+      total: list.length,
+      byOutcome,
+      avgAttempts: list.length > 0 ? attemptsTotal / list.length : 0,
+      lastRecordedAt,
+    });
+  }
+
+  summaries.sort((a, b) => a.command.localeCompare(b.command));
+  return summaries;
+}
+
+/**
+ * Convenience: load + summarize in one call.
+ */
+export function loadReliabilitySummaries(
+  paths: PlatformPaths,
+  cwd: string,
+): ReliabilitySummary[] {
+  return summarizeReliabilityRecords(readReliabilityRecords(paths, cwd));
+}
+
+const RELIABILITY_OUTCOMES: ReliabilityOutcome[] = [
+  "ok",
+  "blocked",
+  "retry-exhausted",
+  "fallback",
+  "agent-error",
+];
+
+/**
+ * Render a concise, aligned reliability section suitable for TUI output.
+ * When no records exist yet, returns a single non-alarming empty-state line.
+ */
+export function formatReliabilitySection(summaries: ReliabilitySummary[]): string[] {
+  if (summaries.length === 0) {
+    return ["Reliability: no records yet (metrics appear after AI-heavy commands run)."];
+  }
+
+  const total = summaries.reduce((n, s) => n + s.total, 0);
+  const nameWidth = Math.max(...summaries.map((s) => s.command.length));
+  const colWidths: Record<ReliabilityOutcome, number> = { ...ZERO_OUTCOME_COUNTS };
+  for (const s of summaries) {
+    for (const outcome of RELIABILITY_OUTCOMES) {
+      const w = String(s.byOutcome[outcome] ?? 0).length;
+      if (w > colWidths[outcome]) colWidths[outcome] = w;
+    }
+  }
+  for (const outcome of RELIABILITY_OUTCOMES) {
+    if (colWidths[outcome] < 1) colWidths[outcome] = 1;
+  }
+
+  const lines: string[] = [`Reliability (last ${total} record${total === 1 ? "" : "s"})`];
+  for (const s of summaries) {
+    const name = s.command.padEnd(nameWidth);
+    const counts = RELIABILITY_OUTCOMES
+      .map((o) => `${o} ${String(s.byOutcome[o] ?? 0).padStart(colWidths[o])}`)
+      .join(" ");
+    const avg = s.avgAttempts.toFixed(1);
+    const last = s.lastRecordedAt ? s.lastRecordedAt.slice(0, 10) : "\u2014";
+    lines.push(`${name}  ${counts}   avg-attempts ${avg}   last ${last}`);
+  }
+  return lines;
+}

package/src/storage/reports.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { GateResult, GateStatus, ReviewReport } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { GateResult, GateStatus, ReviewReport, WorkspaceTarget } from "../types.js";
+import { getProjectTargetStatePath } from "../workspace/state-paths.js";
 
-function getReportsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "reports");
+function getReportsDir(paths: PlatformPaths, target: WorkspaceTarget): string {
+  return getProjectTargetStatePath(paths, target, "reports");
 }
 
 function isGateStatus(value: unknown): value is GateStatus {
@@ -43,8 +44,8 @@ function isReviewReport(value: unknown): value is ReviewReport {
 }
 
 /** Save a review report */
-export function saveReviewReport(paths: PlatformPaths, cwd: string, report: ReviewReport): string {
-  const dir = getReportsDir(paths, cwd);
+export function saveReviewReport(paths: PlatformPaths, target: WorkspaceTarget, report: ReviewReport): string {
+  const dir = getReportsDir(paths, target);
   fs.mkdirSync(dir, { recursive: true });
   const filename = `review-${report.timestamp.slice(0, 10)}.json`;
   const filePath = path.join(dir, filename);
@@ -53,8 +54,8 @@ export function saveReviewReport(paths: PlatformPaths, cwd: string, report: Revi
 }
 
 /** Load the latest review report */
-export function loadLatestReport(paths: PlatformPaths, cwd: string): ReviewReport | null {
-  const dir = getReportsDir(paths, cwd);
+export function loadLatestReport(paths: PlatformPaths, target: WorkspaceTarget): ReviewReport | null {
+  const dir = getReportsDir(paths, target);
   if (!fs.existsSync(dir)) return null;
 
   const files = fs

package/src/storage/review-sessions.ts

@@ -1,15 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { PlatformPaths } from "../platform/types.js";
-import type { ReviewSession } from "../types.js";
 import { isReviewSession } from "../review/types.js";
+import type { ReviewSession, WorkspaceTarget } from "../types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
 
 const SESSIONS_DIR = "reviews";
 const ITERATIONS_DIR = "iterations";
 const AGENTS_DIR = "agents";
 
-function getSessionsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, SESSIONS_DIR);
+function getSessionsDir(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget | null): string {
+  return target
+    ? getProjectTargetStatePath(paths, target, SESSIONS_DIR)
+    : getProjectStatePath(paths, cwd, SESSIONS_DIR);
 }
 
 function ensureLayout(sessionDir: string): void {
@@ -17,8 +20,13 @@ function ensureLayout(sessionDir: string): void {
   fs.mkdirSync(path.join(sessionDir, AGENTS_DIR), { recursive: true });
 }
 
-function getLedgerPath(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getReviewSessionDir(paths, cwd, sessionId), "session.json");
+function getLedgerPath(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): string {
+  return path.join(getReviewSessionDir(paths, cwd, sessionId, target), "session.json");
 }
 
 function resolveArtifactPath(sessionDir: string, relativePath: string): string {
@@ -35,8 +43,13 @@ function resolveArtifactPath(sessionDir: string, relativePath: string): string {
   return resolved;
 }
 
-export function getReviewSessionDir(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getSessionsDir(paths, cwd), sessionId);
+export function getReviewSessionDir(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): string {
+  return path.join(getSessionsDir(paths, cwd, target), sessionId);
 }
 
 export function generateReviewSessionId(now = new Date()): string {
@@ -47,14 +60,24 @@ export function generateReviewSessionId(now = new Date()): string {
   return `review-${date}-${time}-${suffix}`;
 }
 
-export function createReviewSession(paths: PlatformPaths, cwd: string, session: ReviewSession): void {
-  const sessionDir = getReviewSessionDir(paths, cwd, session.id);
+export function createReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  session: ReviewSession,
+  target?: WorkspaceTarget | null,
+): void {
+  const sessionDir = getReviewSessionDir(paths, cwd, session.id, target);
   ensureLayout(sessionDir);
-  fs.writeFileSync(getLedgerPath(paths, cwd, session.id), `${JSON.stringify(session, null, 2)}\n`);
+  fs.writeFileSync(getLedgerPath(paths, cwd, session.id, target), `${JSON.stringify(session, null, 2)}\n`);
 }
 
-export function loadReviewSession(paths: PlatformPaths, cwd: string, sessionId: string): ReviewSession | null {
-  const ledgerPath = getLedgerPath(paths, cwd, sessionId);
+export function loadReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): ReviewSession | null {
+  const ledgerPath = getLedgerPath(paths, cwd, sessionId, target);
   if (!fs.existsSync(ledgerPath)) {
     return null;
   }
@@ -67,15 +90,20 @@ export function loadReviewSession(paths: PlatformPaths, cwd: string, sessionId:
   }
 }
 
-export function updateReviewSession(paths: PlatformPaths, cwd: string, session: ReviewSession): void {
+export function updateReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  session: ReviewSession,
+  target?: WorkspaceTarget | null,
+): void {
   session.updatedAt = new Date().toISOString();
-  const sessionDir = getReviewSessionDir(paths, cwd, session.id);
+  const sessionDir = getReviewSessionDir(paths, cwd, session.id, target);
   ensureLayout(sessionDir);
-  fs.writeFileSync(getLedgerPath(paths, cwd, session.id), `${JSON.stringify(session, null, 2)}\n`);
+  fs.writeFileSync(getLedgerPath(paths, cwd, session.id, target), `${JSON.stringify(session, null, 2)}\n`);
 }
 
-export function listReviewSessions(paths: PlatformPaths, cwd: string): string[] {
-  const sessionsDir = getSessionsDir(paths, cwd);
+export function listReviewSessions(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget | null): string[] {
+  const sessionsDir = getSessionsDir(paths, cwd, target);
   if (!fs.existsSync(sessionsDir)) {
     return [];
   }
@@ -93,8 +121,9 @@ export function writeReviewArtifact(
   sessionId: string,
   relativePath: string,
   payload: unknown,
+  target?: WorkspaceTarget | null,
 ): string {
-  const sessionDir = getReviewSessionDir(paths, cwd, sessionId);
+  const sessionDir = getReviewSessionDir(paths, cwd, sessionId, target);
   ensureLayout(sessionDir);
   const artifactPath = resolveArtifactPath(sessionDir, relativePath);
   fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
@@ -106,8 +135,14 @@ export function writeReviewArtifact(
   return artifactPath;
 }
 
-export function readReviewArtifact(paths: PlatformPaths, cwd: string, sessionId: string, relativePath: string): string | null {
-  const sessionDir = getReviewSessionDir(paths, cwd, sessionId);
+export function readReviewArtifact(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  relativePath: string,
+  target?: WorkspaceTarget | null,
+): string | null {
+  const sessionDir = getReviewSessionDir(paths, cwd, sessionId, target);
   const artifactPath = resolveArtifactPath(sessionDir, relativePath);
   if (!fs.existsSync(artifactPath)) {
     return null;