sentinelayer-cli 0.46.5 → 0.48.0

package/src/review/omargate-cache.js

@@ -1,7 +1,7 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 
-import { resolveOutputRoot } from "../config/service.js";
+import { resolveOutputRoot, resolveOutputContext } from "../config/service.js";
 
 const CACHE_SCHEMA_VERSION = "1.0.0";
 const CACHE_KIND = "omargate-deterministic-cache";
@@ -178,7 +178,7 @@ export async function writeOmarGateDeterministicCache({
   reportPath = "",
 } = {}) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
-  const outputRoot = await resolveOutputRoot({
+  const { outputRoot, outputFs } = await resolveOutputContext({
     cwd: normalizedTargetPath,
     outputDirOverride: outputDir,
     env: process.env,
@@ -191,7 +191,7 @@ export async function writeOmarGateDeterministicCache({
   const runDirectory = path.join(outputRoot, "runs", normalizedRunId);
   const artifactPath = path.join(runDirectory, "deterministic.json");
   const latestPath = path.join(outputRoot, "runs", LATEST_INDEX_NAME);
-  await fsp.mkdir(runDirectory, { recursive: true });
+  await outputFs.mkdir(runDirectory, { recursive: true });
 
   const cache = {
     schemaVersion: CACHE_SCHEMA_VERSION,
@@ -212,8 +212,8 @@ export async function writeOmarGateDeterministicCache({
       reportPath: normalizeString(reportPath),
     },
   };
-  await fsp.writeFile(artifactPath, `${JSON.stringify(cache, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(
+  await outputFs.writeFile(artifactPath, `${JSON.stringify(cache, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(
     latestPath,
     `${JSON.stringify(
       {

package/src/review/omargate-orchestrator.js

@@ -9,6 +9,7 @@ import { randomUUID } from "node:crypto";
 import path from "node:path";
 
 import { runAiReviewLayer } from "./ai-review.js";
+import { summarizeSeverityEvaluations, normalizeSeverityClassifier, parseSeverityEvaluationMaxCost } from "./typesafe-severity.js";
 import { buildPersonaReviewPrompt, PERSONA_IDS } from "./persona-prompts.js";
 import { resolveFilteredPersonas, resolveScanMode } from "./scan-modes.js";
 import { reconcileReviewFindings } from "./report.js";
@@ -388,6 +389,13 @@ function resolveAiResultCostUsd(result = {}) {
   );
 }
 
+function incompleteReviewReason(result = {}) {
+  if (result.reviewValidity?.valid === false || result.parser === "fallback_text" || !Array.isArray(result.findings)) {
+    return "invalid_review_response";
+  }
+  return result.budget?.blocking === true ? "budget_blocked" : null;
+}
+
 function buildAiCallEvidence(result = {}, { dryRun = false } = {}) {
   if (dryRun) {
     return {
@@ -462,11 +470,15 @@ function buildPersonaHealthFindings(personaHealth = {}) {
   const aiCallEvidence = personaHealth.aiCallEvidence || {};
   const okCount = Number(personaHealth.ok || 0);
   const unverifiedOkCount = Number(personaHealth.unverifiedOk || 0);
+  const skippedCount = Number(personaHealth.skipped || 0);
+  const incompleteCount = Number(personaHealth.incomplete || 0);
   const allPersonasFailed = total > 0 && errorCount === total;
   const severity = allPersonasFailed ? "P0" : "P1";
   let message = `Omar AI coverage degraded: ${errorCount}/${total} dispatched personas errored (${Math.round(errorRatio * 100)}%).`;
   if (allPersonasFailed) {
     message = `Omar AI coverage failed closed: all ${total} dispatched personas errored before producing findings.`;
+  } else if (skippedCount > 0 || incompleteCount > 0) {
+    message = `Omar AI coverage incomplete: ${skippedCount}/${total} requested personas were skipped and ${incompleteCount}/${total} returned incomplete partition, budget, or structured-response coverage.`;
   } else if (errorCount === 0 && unverifiedOkCount > 0) {
     message = `Omar AI coverage failed closed: ${unverifiedOkCount}/${okCount} successful personas lacked token-bearing usage, billing-ledger, or priced-call evidence.`;
   }
@@ -484,12 +496,13 @@ function buildPersonaHealthFindings(personaHealth = {}) {
       confidenceFloor: 0,
       sources: ["orchestrator"],
       remediation:
-        "Fix SentinelLayer managed LLM proxy/provider credentials or run with --no-ai when deterministic-only coverage is intentional.",
+        "Resolve the reported provider, budget, or usage-evidence failure and rerun every requested persona and partition. Partial coverage cannot satisfy a full AI review gate.",
       evidence: warnings,
       personaHealth: {
         ok: Number(personaHealth.ok || 0),
         error: errorCount,
-        skipped: Number(personaHealth.skipped || 0),
+        skipped: skippedCount,
+        incomplete: incompleteCount,
         total,
         errorRatio,
         totalCostUsd,
@@ -562,6 +575,7 @@ async function runOmarPersonaSwarm({
   outputDir,
   provider,
   model,
+  severityClassifier = "off",
   perPersonaCost,
   dryRun,
   onEvent,
@@ -670,6 +684,7 @@ async function runOmarPersonaSwarm({
           outputDir,
           provider: provider || undefined,
           model: model || undefined,
+          ...(severityClassifier === "typesafe" ? { severityClassifier } : {}),
           sessionId: usageSessionId || `${subagentRunId}-ai`,
           maxCostUsd: budget.maxCostUsd,
           systemPrompt,
@@ -717,6 +732,7 @@ async function runOmarPersonaSwarm({
         });
         const costUsd = resolveAiResultCostUsd(result);
         const aiCallEvidence = buildAiCallEvidence(result, { dryRun });
+        const incompleteReason = incompleteReviewReason(result);
 
         if (onEvent) {
           for (const finding of findings) {
@@ -739,6 +755,7 @@ async function runOmarPersonaSwarm({
               partitionCount: partitions.length,
               fileCount: scopedFiles.length,
               findings: findings.length,
+              status: incompleteReason ? "incomplete" : "ok",
               summary: result?.summary || summarizeFindings(findings),
               costUsd,
               durationMs: Date.now() - subagentStart,
@@ -753,7 +770,7 @@ async function runOmarPersonaSwarm({
         }
 
         return {
-          status: "ok",
+          status: incompleteReason ? "incomplete" : "ok",
           subagentIndex,
           agentId: subagentIdentity.id,
           files: scopedFiles,
@@ -761,8 +778,11 @@ async function runOmarPersonaSwarm({
           summary: result?.summary || summarizeFindings(findings),
           costUsd,
           aiCallEvidence,
+          reason: incompleteReason,
+          reviewValidity: result.reviewValidity || null,
           model: result?.model || model || null,
           billing: result?.billing || null,
+          ...(severityClassifier === "typesafe" ? { severityClassification: result?.severityClassification || null } : {}),
           artifacts: result?.artifacts || null,
           durationMs: Date.now() - subagentStart,
         };
@@ -827,6 +847,14 @@ async function runOmarPersonaSwarm({
   const summary = summarizeFindings(findings);
   const okCount = settledSubagents.filter((result) => result.status === "ok").length;
   const errorCount = settledSubagents.filter((result) => result.status === "error").length;
+  const completedCount = settledSubagents.filter((result) =>
+    result.status === "ok" && (dryRun || Number(result.aiCallEvidence?.confirmedCalls || 0) > 0)
+  ).length;
+  const coverage = {
+    requested: partitions.length,
+    completed: completedCount,
+    incomplete: partitions.length - completedCount,
+  };
   const usageLedgerErrors = settledSubagents.filter((result) =>
     result.status === "error" && isUsageLedgerFailure(result.error)
   );
@@ -875,6 +903,7 @@ async function runOmarPersonaSwarm({
         subagentCount: settledSubagents.length,
         ok: okCount,
         error: errorCount,
+        coverage,
         findings: findings.length,
         summary,
         totalCostUsd,
@@ -892,20 +921,22 @@ async function runOmarPersonaSwarm({
 
   return {
     personaId,
-    status: okCount > 0 ? "ok" : "error",
+    ...(severityClassifier === "typesafe" ? { severityClassification: summarizeSeverityEvaluations(settledSubagents) } : {}),
+    status: coverage.incomplete === 0 ? "ok" : errorCount === partitions.length ? "error" : "incomplete",
     findings,
     summary,
     costUsd: totalCostUsd,
     aiCallEvidence,
     model: model || null,
     durationMs: Date.now() - startedAt,
-    error: okCount > 0 ? null : settledSubagents.find((result) => result.error)?.error || null,
+    error: coverage.incomplete === 0 ? null : settledSubagents.find((result) => result.error)?.error || "Requested partition coverage is incomplete.",
     swarm: {
       runId: swarmRunId,
       decision,
       subagentCount: settledSubagents.length,
       ok: okCount,
       error: errorCount,
+      coverage,
       partitionSizes: partitions.map((files) => files.length),
       blackboardEntries: blackboard.length,
       subagents: settledSubagents.map((result) => ({
@@ -919,6 +950,9 @@ async function runOmarPersonaSwarm({
         billing: result.billing || null,
         durationMs: result.durationMs || 0,
         error: result.error || null,
+        reason: result.reason || null,
+        reviewValidity: result.reviewValidity || null,
+        verified: dryRun ? null : Number(result.aiCallEvidence?.confirmedCalls || 0) > 0,
         artifacts: result.artifacts || null,
       })),
     },
@@ -934,7 +968,7 @@ async function runOmarPersonaSwarm({
  * @param {number} [options.maxParallel] - Max concurrent persona calls (default 4)
  * @param {string} [options.provider] - LLM provider override
  * @param {string} [options.model] - LLM model override
- * @param {number} [options.maxCostUsd] - Global cost ceiling (default 5.0)
+ * @param {number} [options.maxCostUsd] - Completed-persona cost stop threshold (default 5.0), not a pre-dispatch spending cap
  * @param {boolean} [options.dryRun] - Dry-run mode (no LLM calls)
  * @param {string} [options.outputDir] - Output directory override
  * @param {object} [options.deterministic] - Deterministic scan results
@@ -951,6 +985,7 @@ export async function runOmarGateOrchestrator({
   maxParallel = 4,
   provider = "",
   model = "",
+  severityClassifier = "off",
   maxCostUsd = 5.0,
   dryRun = false,
   outputDir = "",
@@ -963,6 +998,8 @@ export async function runOmarGateOrchestrator({
   usageRecorder = undefined,
   aiReviewRunner = runAiReviewLayer,
 } = {}) {
+  normalizeSeverityClassifier(severityClassifier);
+  if (severityClassifier === "typesafe") maxCostUsd = parseSeverityEvaluationMaxCost(maxCostUsd, 5);
   const runId = `omargate-${Date.now()}-${randomUUID().slice(0, 8)}`;
   const startTime = Date.now();
 
@@ -980,6 +1017,12 @@ export async function runOmarGateOrchestrator({
   const { mode, personas: basePersonas } = resolved;
   const droppedPersonas = resolved.dropped || [];
   const unknownPersonas = resolved.unknown || [];
+  if (unknownPersonas.length > 0) {
+    throw new Error("Unknown requested Omar persona IDs; the requested review cannot be completed.");
+  }
+  if (basePersonas.length === 0) {
+    throw new Error("Requested Omar persona roster is empty; AI coverage cannot be completed.");
+  }
 
   if (onEvent && (droppedPersonas.length > 0 || unknownPersonas.length > 0)) {
     onEvent(createAgentEvent({
@@ -1003,6 +1046,9 @@ export async function runOmarGateOrchestrator({
     manualInclude: Array.isArray(includeOnly) && includeOnly.length > 0,
   });
   const personas = personaRouting.effectivePersonas;
+  if (personas.length === 0) {
+    throw new Error("Effective Omar persona roster is empty; AI coverage cannot be completed.");
+  }
 
   if (onEvent && personaRouting.enabled) {
     onEvent(createAgentEvent({
@@ -1052,7 +1098,8 @@ export async function runOmarGateOrchestrator({
   const detFindings = deterministic?.findings || [];
 
   // Per-persona cost budget = global / effective persona count (with minimum floor).
-  const perPersonaCost = personas.length > 0 ? Math.max(0.25, maxCostUsd / personas.length) : 0;
+  const evaluationWithoutCostCap = severityClassifier === "typesafe" && maxCostUsd === 0;
+  const perPersonaCost = evaluationWithoutCostCap ? 0 : personas.length > 0 ? Math.max(0.25, maxCostUsd / personas.length) : 0;
   let runningCostUsd = 0;
 
   const personaResults = await runWithConcurrency(personas, maxParallel, async (personaId) => {
@@ -1067,7 +1114,7 @@ export async function runOmarGateOrchestrator({
     };
 
     // Global budget check — skip remaining personas if exhausted
-    if (runningCostUsd >= maxCostUsd) {
+    if (!evaluationWithoutCostCap && runningCostUsd >= maxCostUsd) {
       if (onEvent) {
         onEvent(createAgentEvent({
           event: "persona_skipped",
@@ -1128,6 +1175,7 @@ export async function runOmarGateOrchestrator({
         outputDir,
         provider,
         model,
+        severityClassifier,
         perPersonaCost,
         dryRun,
         onEvent,
@@ -1151,6 +1199,7 @@ export async function runOmarGateOrchestrator({
                 identity,
                 error: swarmResult.error || "all subagents failed",
                 swarm: swarmResult.swarm,
+                status: swarmResult.status,
               },
               runId,
             }));
@@ -1163,6 +1212,7 @@ export async function runOmarGateOrchestrator({
                 identity,
                 findings: swarmResult.findings.length,
                 summary: swarmResult.summary,
+                status: swarmResult.status,
                 costUsd: personaCost,
                 durationMs: Date.now() - personaStart,
                 swarm: swarmResult.swarm,
@@ -1203,6 +1253,7 @@ export async function runOmarGateOrchestrator({
         outputDir,
         provider: provider || undefined,
         model: model || undefined,
+        ...(severityClassifier === "typesafe" ? { severityClassifier } : {}),
         sessionId: usageSessionId || `${runId}-${personaId}-ai`,
         maxCostUsd: perPersonaCost,
         systemPrompt,
@@ -1231,6 +1282,7 @@ export async function runOmarGateOrchestrator({
       }));
       const personaCost = resolveAiResultCostUsd(result);
       const aiCallEvidence = buildAiCallEvidence(result, { dryRun });
+      const incompleteReason = incompleteReviewReason(result);
 
       if (onEvent) {
         for (const finding of findings) {
@@ -1262,6 +1314,7 @@ export async function runOmarGateOrchestrator({
             personaId,
             identity,
             findings: findings.length,
+            status: incompleteReason ? "incomplete" : "ok",
             summary: result?.summary || {},
             costUsd: personaCost,
             durationMs: Date.now() - personaStart,
@@ -1274,13 +1327,16 @@ export async function runOmarGateOrchestrator({
 
       return {
         personaId,
-        status: "ok",
+        status: incompleteReason ? "incomplete" : "ok",
         findings,
         summary: result?.summary || { P0: 0, P1: 0, P2: 0, P3: 0 },
         costUsd: personaCost,
         aiCallEvidence,
+        reason: incompleteReason,
+        reviewValidity: result.reviewValidity || null,
         model: result?.model || model || null,
         billing: result?.billing || null,
+        ...(severityClassifier === "typesafe" ? { severityClassification: result?.severityClassification || null } : {}),
         artifacts: result?.artifacts || null,
         durationMs: Date.now() - personaStart,
       };
@@ -1366,6 +1422,7 @@ export async function runOmarGateOrchestrator({
   // billing can still carry token-bearing usage and provider-cost receipts.
   const personaErrorCount = settled.filter((r) => r.status === "error").length;
   const personaSkippedCount = settled.filter((r) => r.status === "skipped").length;
+  const personaIncompleteCount = settled.filter((r) => r.status === "incomplete").length;
   const personaOkCount = settled.filter((r) => r.status === "ok").length;
   const personaVerifiedOkCount = settled.filter(
     (r) => r.status === "ok" && Number(r.aiCallEvidence?.confirmedCalls || 0) > 0
@@ -1373,34 +1430,44 @@ export async function runOmarGateOrchestrator({
   const personaUnverifiedOkCount = personaOkCount - personaVerifiedOkCount;
   const totalPersonas = settled.length;
   const errorRatio = totalPersonas > 0 ? personaErrorCount / totalPersonas : 0;
-  const aiCoverageHealthy =
-    totalPersonas === 0 ||
-    (personaOkCount > 0 && personaUnverifiedOkCount === 0 && errorRatio < 0.5 && !dryRun);
+  const aiCoverageHealthy = personaOkCount === totalPersonas &&
+    (dryRun || personaUnverifiedOkCount === 0);
+  const coverage = {
+    status: aiCoverageHealthy ? (dryRun ? "simulated" : "complete") : "incomplete",
+    requestedPersonas: totalPersonas,
+    completedPersonas: dryRun ? personaOkCount : personaVerifiedOkCount,
+  };
 
   const personaHealth = {
     ok: personaOkCount,
     error: personaErrorCount,
     skipped: personaSkippedCount,
+    incomplete: personaIncompleteCount,
     total: totalPersonas,
     verifiedOk: personaVerifiedOkCount,
     unverifiedOk: personaUnverifiedOkCount,
     errorRatio,
     totalCostUsd: totalCost,
     aiCallEvidence,
-    healthy: aiCoverageHealthy || dryRun,
+    healthy: aiCoverageHealthy,
     warnings: [],
   };
-  if (!dryRun && totalPersonas > 0) {
-    if (personaOkCount === 0 && personaErrorCount > 0) {
+  if (totalPersonas > 0) {
+    if (personaErrorCount === totalPersonas) {
       personaHealth.warnings.push(
         `ALL ${totalPersonas} personas errored. AI coverage is ZERO. Re-check auth (sl auth login) or LLM proxy config.`
       );
-    } else if (errorRatio >= 0.5) {
+    } else if (personaErrorCount > 0) {
       personaHealth.warnings.push(
         `${personaErrorCount}/${totalPersonas} personas errored (${Math.round(errorRatio * 100)}%). AI coverage is degraded.`
       );
     }
-    if (personaUnverifiedOkCount > 0) {
+    if (personaSkippedCount > 0 || personaIncompleteCount > 0) {
+      personaHealth.warnings.push(
+        `${personaSkippedCount} requested personas skipped; ${personaIncompleteCount} returned incomplete partition, budget, or structured-response coverage. Full AI coverage is incomplete.`
+      );
+    }
+    if (!dryRun && personaUnverifiedOkCount > 0) {
       personaHealth.warnings.push(
         `${personaUnverifiedOkCount}/${personaOkCount} successful personas lacked token-bearing usage, billing-ledger, or priced-call evidence.`
       );
@@ -1416,6 +1483,7 @@ export async function runOmarGateOrchestrator({
   const result = {
     runId,
     mode,
+    ...(severityClassifier === "typesafe" ? { severityClassification: summarizeSeverityEvaluations(settled) } : {}),
     basePersonas,
     roster,
     personaRouting,
@@ -1430,11 +1498,15 @@ export async function runOmarGateOrchestrator({
       durationMs: r.durationMs,
       model: r.model || null,
       billing: r.billing || null,
+      ...(severityClassifier === "typesafe" ? { severityClassification: r.severityClassification || null } : {}),
       error: r.error || null,
+      reason: r.reason || null,
+      reviewValidity: r.reviewValidity || null,
       swarm: r.swarm || null,
       artifacts: r.artifacts || null,
     })),
     personaHealth,
+    coverage,
     findings: reconciledFindings,
     findingsBySource: {
       deterministic: detFindings.length,

package/src/review/replay.js

@@ -1,3 +1,4 @@
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 import { spawnSync } from "node:child_process";
 import fsp from "node:fs/promises";
 import path from "node:path";
@@ -74,6 +75,7 @@ function normalizeInvocation(invocation = {}) {
 }
 
 export async function writeReviewRunContext({
+  outputFs,
   runDirectory,
   runId,
   targetPath,
@@ -81,6 +83,7 @@ export async function writeReviewRunContext({
   invocation = {},
   replay = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const normalizedRunDirectory = path.resolve(String(runDirectory || "."));
   const context = {
     schemaVersion: "1.0.0",
@@ -96,8 +99,8 @@ export async function writeReviewRunContext({
     },
   };
   const contextPath = path.join(normalizedRunDirectory, REVIEW_RUN_CONTEXT_FILE);
-  await fsp.mkdir(normalizedRunDirectory, { recursive: true });
-  await fsp.writeFile(contextPath, `${JSON.stringify(context, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(normalizedRunDirectory, { recursive: true });
+  await outputFs.writeFile(contextPath, `${JSON.stringify(context, null, 2)}\n`, "utf-8");
   return {
     context,
     contextPath,
@@ -208,11 +211,13 @@ function sanitizeRunId(value) {
 }
 
 export async function writeReviewComparisonArtifact({
+  outputFs,
   runDirectory,
   baseRunId,
   candidateRunId,
   comparison,
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const normalizedRunDirectory = path.resolve(String(runDirectory || "."));
   const fileName = `REVIEW_COMPARISON_${sanitizeRunId(baseRunId)}_vs_${sanitizeRunId(
     candidateRunId
@@ -225,8 +230,8 @@ export async function writeReviewComparisonArtifact({
     candidateRunId: normalizeString(candidateRunId),
     comparison,
   };
-  await fsp.mkdir(normalizedRunDirectory, { recursive: true });
-  await fsp.writeFile(artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(normalizedRunDirectory, { recursive: true });
+  await outputFs.writeFile(artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
   return {
     artifactPath,
     payload,

package/src/review/report.js

@@ -4,7 +4,8 @@ import fsp from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { resolveOutputRoot } from "../config/service.js";
+import { resolveOutputRoot, resolveOutputContext } from "../config/service.js";
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
 
 const REVIEW_REPORT_JSON = "REVIEW_REPORT.json";
 const REVIEW_REPORT_MD = "REVIEW_REPORT.md";
@@ -523,16 +524,18 @@ export async function buildUnifiedReviewReport({
 }
 
 export async function writeUnifiedReviewArtifacts({
+  outputFs,
   runDirectory,
   report,
   markdown,
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const normalizedRunDirectory = path.resolve(String(runDirectory || "."));
-  await fsp.mkdir(normalizedRunDirectory, { recursive: true });
+  await outputFs.mkdir(normalizedRunDirectory, { recursive: true });
   const reportJsonPath = path.join(normalizedRunDirectory, REVIEW_REPORT_JSON);
   const reportMarkdownPath = path.join(normalizedRunDirectory, REVIEW_REPORT_MD);
-  await fsp.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(reportMarkdownPath, `${String(markdown || "").trim()}\n`, "utf-8");
+  await outputFs.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(reportMarkdownPath, `${String(markdown || "").trim()}\n`, "utf-8");
   return {
     reportJsonPath,
     reportMarkdownPath,
@@ -617,6 +620,7 @@ export async function loadUnifiedReviewReport({
   outputDir = "",
   env,
 } = {}) {
+  const { outputFs } = await resolveOutputContext({ cwd: path.resolve(String(targetPath || ".")), outputDirOverride: outputDir, env });
   const runDirectory = await resolveRunDirectory({ targetPath, runId, outputDir, env });
   const reportJsonPath = path.join(runDirectory, REVIEW_REPORT_JSON);
   const reportMarkdownPath = path.join(runDirectory, REVIEW_REPORT_MD);
@@ -624,14 +628,14 @@ export async function loadUnifiedReviewReport({
   const decisionsPath = path.join(runDirectory, REVIEW_DECISIONS_JSON);
   const decisions = await loadDecisions(decisionsPath);
   const resolvedReport = applyDecisionsToReport(report, decisions.decisions);
-  return {
+  return bindOutputFileSystem({
     runDirectory,
     reportJsonPath,
     reportMarkdownPath,
     decisionsPath,
     decisions,
     report: resolvedReport,
-  };
+  }, outputFs);
 }
 
 export async function recordReviewDecision({
@@ -659,6 +663,7 @@ export async function recordReviewDecision({
     outputDir,
     env,
   });
+  const { outputFs } = loaded;
   const finding = (loaded.report.findings || []).find((item) => item.findingId === normalizedFindingId);
   if (!finding) {
     throw new Error(`Finding '${normalizedFindingId}' not found in run ${loaded.report.runId}.`);
@@ -678,12 +683,12 @@ export async function recordReviewDecision({
       [normalizedFindingId]: decision,
     },
   };
-  await fsp.writeFile(loaded.decisionsPath, `${JSON.stringify(nextDecisions, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(loaded.decisionsPath, `${JSON.stringify(nextDecisions, null, 2)}\n`, "utf-8");
 
   const nextReport = applyDecisionsToReport(loaded.report, nextDecisions.decisions);
   const nextMarkdown = composeReportMarkdown(nextReport);
-  await fsp.writeFile(loaded.reportJsonPath, `${JSON.stringify(nextReport, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(loaded.reportMarkdownPath, `${nextMarkdown.trim()}\n`, "utf-8");
+  await outputFs.writeFile(loaded.reportJsonPath, `${JSON.stringify(nextReport, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(loaded.reportMarkdownPath, `${nextMarkdown.trim()}\n`, "utf-8");
 
   return {
     runId: nextReport.runId,
@@ -821,10 +826,14 @@ export async function exportUnifiedReviewReport({
     outputDir,
     env,
   });
-  const resolvedOutputPath = normalizeString(outputFile)
-    ? path.resolve(path.resolve(String(targetPath || ".")), outputFile)
+  const explicitOutput = normalizeString(outputFile)
+    ? await resolveOutputContext({ cwd: path.resolve(String(targetPath || ".")), outputDirOverride: outputFile, env })
+    : null;
+  const resolvedOutputPath = explicitOutput
+    ? explicitOutput.outputRoot
     : resolveDefaultExportPath(loaded.runDirectory, normalizedFormat);
 
+  const outputFs = requireOutputFileSystem(explicitOutput ? explicitOutput.outputFs : loaded.outputFs);
   let serialized = "";
   if (normalizedFormat === "json") {
     serialized = `${JSON.stringify(loaded.report, null, 2)}\n`;
@@ -836,8 +845,8 @@ export async function exportUnifiedReviewReport({
     serialized = `${buildGithubAnnotations(loaded.report)}\n`;
   }
 
-  await fsp.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
-  await fsp.writeFile(resolvedOutputPath, serialized, "utf-8");
+  await outputFs.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+  await outputFs.writeFile(resolvedOutputPath, serialized, "utf-8");
 
   return {
     runId: loaded.report.runId,