sentinelayer-cli 0.46.4 → 0.48.0

package/src/agents/devtestbot/tool.js

@@ -3,7 +3,8 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 
 import { getIdentityById } from "../../ai/identity-store.js";
-import { resolveOutputRoot } from "../../config/service.js";
+import { resolveOutputContext } from "../../config/service.js";
+import { requireOutputFileSystem } from "../../config/output-filesystem.js";
 import { createAgentEvent } from "../../events/schema.js";
 import { DEVTESTBOT_DEFINITION, DEVTESTBOT_LANES } from "./config/definition.js";
 import { launch } from "./runner.js";
@@ -63,7 +64,7 @@ export async function executeDevTestBotRunSessionTool(input = {}, ctx = {}) {
 
 export async function runDevTestBotSession(input = {}, ctx = {}) {
   const targetPath = path.resolve(String(input.targetPath || ctx.targetPath || process.cwd()));
-  const outputRoot = await resolveOutputRoot({
+  const { outputRoot, outputFs: resolvedOutputFs } = await resolveOutputContext({
     cwd: targetPath,
     outputDirOverride: input.outputRoot || ctx.outputRoot || "",
     env: ctx.env || process.env,
@@ -74,10 +75,13 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
   const recordVideo = input.recordVideo !== undefined ? Boolean(input.recordVideo) : true;
   const baseUrl = normalizeString(input.baseUrl || ctx.baseUrl);
   const identityId = normalizeString(input.identityId || ctx.identityId);
-  const artifactRoot = path.resolve(
-    input.outputDir || ctx.outputDir || path.join(outputRoot, "runs", runId, "devtestbot")
-  );
-  await fsp.mkdir(artifactRoot, { recursive: true });
+  const explicitOutputDir = input.outputDir || ctx.outputDir;
+  const artifactOutput = explicitOutputDir
+    ? await resolveOutputContext({ cwd: targetPath, outputDirOverride: explicitOutputDir, env: ctx.env || process.env })
+    : { outputRoot: path.join(outputRoot, "runs", runId, "devtestbot"), outputFs: resolvedOutputFs };
+  const artifactRoot = artifactOutput.outputRoot;
+  const outputFs = ctx.outputFs === undefined ? artifactOutput.outputFs : requireOutputFileSystem(ctx.outputFs);
+  await outputFs.mkdir(artifactRoot, { recursive: true });
 
   const { registryPath, identity } = await resolveIdentity({
     outputRoot,
@@ -142,6 +146,7 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
         scope,
         baseUrl,
         artifactRoot,
+        outputFs,
         sensitiveValues,
       });
       for (const finding of dryRun.findings) {
@@ -168,6 +173,7 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
         completed: true,
         dryRun: true,
         artifactRoot,
+        outputFs,
         artifactBundle: dryRun.artifactBundle,
         artifacts: dryRun.artifacts,
         findings: dryRun.findings,
@@ -183,6 +189,7 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
       baseUrl: normalizedBaseUrl,
       identityCreds,
       outputDir: artifactRoot,
+      outputFs,
       recordVideo,
       runLighthouse: input.runLighthouse !== undefined ? Boolean(input.runLighthouse) : true,
       lighthouseTimeoutMs: input.lighthouseTimeoutMs,
@@ -229,6 +236,7 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
       completed: true,
       dryRun: false,
       artifactRoot,
+      outputFs,
       artifacts,
       findings,
       laneSummaries,
@@ -249,6 +257,7 @@ export async function runDevTestBotSession(input = {}, ctx = {}) {
       completed: false,
       dryRun: !execute,
       artifactRoot,
+      outputFs,
       artifacts: {},
       findings: [],
       laneSummaries: {},
@@ -351,7 +360,8 @@ async function driveScope({ runner, scope }) {
   }
 }
 
-async function buildDryRunResult({ runId, scope, baseUrl, artifactRoot, sensitiveValues }) {
+async function buildDryRunResult({ runId, scope, baseUrl, artifactRoot, sensitiveValues, outputFs }) {
+  const writeJson = (...args) => writeJsonWithFs(outputFs, ...args);
   const artifacts = {
     manifestPath: path.join(artifactRoot, "manifest.json"),
   };
@@ -561,6 +571,7 @@ function normalizeFinding(input, sensitiveValues) {
 }
 
 async function writeDevTestBotResult({
+  outputFs,
   runId,
   scope,
   completed,
@@ -574,6 +585,7 @@ async function writeDevTestBotResult({
   sensitiveValues,
   error = "",
 }) {
+  const writeJson = (...args) => writeJsonWithFs(outputFs, ...args);
   const findingsPath = path.join(artifactRoot, "findings.json");
   const eventsPath = path.join(artifactRoot, "events.ndjson");
   const resultPath = path.join(artifactRoot, "devtestbot-result.json");
@@ -586,7 +598,7 @@ async function writeDevTestBotResult({
     artifacts: sanitizeArtifacts(artifacts || artifactBundle?.artifacts || {}, sensitiveValues),
   };
   await writeJson(findingsPath, findings);
-  await fsp.writeFile(eventsPath, `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf-8");
+  await outputFs.writeFile(eventsPath, `${events.map((event) => JSON.stringify(event)).join("\n")}\n`, "utf-8");
   const result = sanitizeJson({
     schemaVersion: 1,
     runId,
@@ -701,7 +713,8 @@ async function readJsonIfPresent(filePath) {
   }
 }
 
-async function writeJson(filePath, payload) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+async function writeJsonWithFs(outputFs, filePath, payload) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }

package/src/agents/jules/fix-cycle.js

@@ -2,10 +2,16 @@
 // Jules passes its own identity; any persona can use the same lifecycle.
 import { runFixCycle as _runFixCycle } from "../../daemon/fix-cycle.js";
 import { JULES_DEFINITION } from "./config/definition.js";
+import { resolveOutputContext } from "../../config/service.js";
+import { requireOutputFileSystem } from "../../config/output-filesystem.js";
 
-export function runFixCycle(opts) {
+export async function runFixCycle(opts = {}) {
+  const outputFs = Object.hasOwn(opts, "outputFs")
+    ? requireOutputFileSystem(opts.outputFs)
+    : (await resolveOutputContext({ cwd: opts.rootPath || process.cwd(), outputDirOverride: ".sentinelayer" })).outputFs;
   return _runFixCycle({
     ...opts,
+    outputFs,
     agentIdentity: {
       id: JULES_DEFINITION.id,
       persona: JULES_DEFINITION.persona,

package/src/agents/jules/tools/runtime-audit.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import fs from "node:fs";
 import os from "node:os";
 import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
 import { credentialedRequest, isAuthenticated } from "../../../auth/credential-destinations.js";
 import { urlPathSegment } from "../../../net/url-path.js";
 import { assertPermittedAuditTarget } from "./url-policy.js";
@@ -52,16 +53,24 @@ const RUNTIME_DISPATCH = {
 /**
  * How Lighthouse runs. No shell: the target URL can come from the repository (package.json,
  * vercel.json, .env files), and a shell would expand variables and operators inside it. Credentials
- * are removed from npx's environment, so a repository .npmrc cannot place them in a request.
- * On Windows, where npx is a .cmd file, npm's npx script runs under this Node.js instead.
+ * are removed from the child environment. Resolve the installed Lighthouse dependency and run
+ * its CLI with Node directly, so this fallback cannot download another Lighthouse version.
  */
 function lighthouseInvocation(
   targetUrl,
   outputPath,
-  { platform = process.platform, execPath = process.execPath, exists = fs.existsSync, env = process.env } = {},
+  { execPath = process.execPath, exists = fs.existsSync, resolve = import.meta.resolve, env = process.env } = {},
 ) {
+  let lighthouseCli;
+  try {
+    lighthouseCli = fileURLToPath(resolve("lighthouse/cli/index.js"));
+  } catch {
+    return null;
+  }
+  if (!exists(lighthouseCli)) return null;
+
   const args = [
-    "--yes", "lighthouse@12", targetUrl,
+    lighthouseCli, targetUrl,
     "--output", "json", "--output-path", outputPath,
     "--chrome-flags=--headless --no-sandbox --disable-gpu", "--quiet",
   ];
@@ -71,17 +80,13 @@ function lighthouseInvocation(
     stdio: ["pipe", "pipe", "pipe"],
     env: buildScrubbedEnv(env),
   };
-  if (platform !== "win32") {
-    return { file: "npx", args, options };
-  }
-  const npxCli = path.join(path.dirname(execPath), "node_modules", "npm", "bin", "npx-cli.js");
-  return exists(npxCli) ? { file: execPath, args: [npxCli, ...args], options } : null;
+  return { file: execPath, args, options };
 }
 
 export const __runtimeAuditForTests = Object.freeze({ lighthouseInvocation, detectDeployedUrl });
 
 /**
- * Run Lighthouse via npx (no install required).
+ * Run the installed Lighthouse CLI.
  * Returns performance, accessibility, best-practices, SEO scores + key metrics.
  */
 async function lighthouseScan(input) {
@@ -92,7 +97,7 @@ async function lighthouseScan(input) {
   const targetUrl = resolveRuntimeTargetUrl(url, input, "lighthouse_scan");
 
   // Prefer SentinelLayer API scanner (authenticated, server-side Lighthouse).
-  // Falls back to local npx lighthouse if API unavailable.
+  // Falls back to the local Lighthouse dependency if API unavailable.
   try {
     const apiResult = await callScannerApi(targetUrl);
     if (apiResult.available) return apiResult;
@@ -110,7 +115,7 @@ async function lighthouseScan(input) {
 
     const invocation = lighthouseInvocation(targetUrl, outputPath);
     if (!invocation) {
-      return { available: false, reason: "npx is not available next to this Node.js" };
+      return { available: false, reason: "Lighthouse is not installed locally" };
     }
     execFileSync(invocation.file, invocation.args, invocation.options);
 

package/src/agents/shared-tools/dispatch-core.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { bindOutputFileSystem, requireOutputFileSystem } from "../../config/output-filesystem.js";
 import { evaluateBudget } from "../../cost/budget.js";
 import {
   normalizeRunEvent,
@@ -28,6 +29,7 @@ export function createToolDispatcher(toolMap, readOnlyTools) {
   const READ_ONLY_TOOLS = new Set(readOnlyTools || []);
 
   async function dispatchTool(toolName, input, ctx) {
+    if (ctx.artifactDir) requireOutputFileSystem(ctx.outputFs);
     const handler = TOOL_MAP[toolName];
     if (!handler) {
       throw new ToolDispatchError(`Unknown tool: ${toolName}`);
@@ -186,9 +188,9 @@ export function createToolDispatcher(toolMap, readOnlyTools) {
     const serialized = JSON.stringify(result);
     if (serialized.length > RESULT_PERSIST_THRESHOLD && ctx.artifactDir) {
       const refPath = `${ctx.artifactDir}/tool-results/${eventId}.json`;
-      const fsp = await import("node:fs/promises");
-      await fsp.mkdir(`${ctx.artifactDir}/tool-results`, { recursive: true });
-      await fsp.writeFile(refPath, serialized, "utf-8");
+      const outputFs = requireOutputFileSystem(ctx.outputFs);
+      await outputFs.mkdir(`${ctx.artifactDir}/tool-results`, { recursive: true });
+      await outputFs.writeFile(refPath, serialized, "utf-8");
       return {
         _persisted: true,
         _refPath: refPath,
@@ -224,9 +226,11 @@ export function createAgentContext({
   sessionId,
   runId,
   artifactDir,
+  outputFs,
   onEvent,
 }) {
-  return {
+  if (artifactDir || outputFs !== undefined) requireOutputFileSystem(outputFs);
+  const context = {
     agentIdentity,
     budget: {
       maxCostUsd: budget?.maxCostUsd ?? 5.0,
@@ -250,6 +254,7 @@ export function createAgentContext({
     lastToolName: null,
     onEvent,
   };
+  return outputFs === undefined ? context : bindOutputFileSystem(context, outputFs);
 }
 
 function snapshotUsage(ctx) {
@@ -295,7 +300,7 @@ async function safeAppendEvent(ctx, eventData) {
     });
     if (ctx.artifactDir) {
       await appendRunEvent(
-        { targetPath: ctx.artifactDir, outputDir: ctx.artifactDir },
+        { targetPath: ctx.artifactDir, outputDir: ctx.artifactDir, outputFs: ctx.outputFs },
         normalized,
       );
     }

package/src/ai/aidenid.js

@@ -440,7 +440,9 @@ export async function revokeIdentity({
   });
 
   const response = await fetchImpl(
-    `${normalizedApiUrl}/v1/identities/${urlPathSegment(normalizedIdentityId, { label: "identityId" })}/revoke`,
+    // AIdenID has no single-identity /revoke route: POST /{identity_id}/squash is the revoke (it records SQUASHED
+    // and schedules cleanup). /revoke-children (cascade) is a separate, unchanged route.
+    `${normalizedApiUrl}/v1/identities/${urlPathSegment(normalizedIdentityId, { label: "identityId" })}/squash`,
     {
       method: "POST",
       headers: requestHeaders,
@@ -450,7 +452,7 @@ export async function revokeIdentity({
   if (!response.ok) {
     const details = await parseErrorBody(response);
     throw new Error(
-      `AIdenID revoke request failed with status ${response.status}${details ? `: ${details}` : ""}`
+      `AIdenID squash (revoke) request failed with status ${response.status}${details ? `: ${details}` : ""}`
     );
   }
 

package/src/ai/domain-target-store.js

@@ -1,5 +1,6 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 
 const REGISTRY_SCHEMA_VERSION = "1.0.0";
 
@@ -104,15 +105,16 @@ async function loadRegistryInternal(filePath) {
   }
 }
 
-async function writeRegistryInternal(filePath, registry = {}) {
+async function writeRegistryInternal(filePath, registry = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: REGISTRY_SCHEMA_VERSION,
     generatedAt: new Date().toISOString(),
     domains: Array.isArray(registry.domains) ? registry.domains.map(normalizeDomainRecord) : [],
     targets: Array.isArray(registry.targets) ? registry.targets.map(normalizeTargetRecord) : [],
   };
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
   return normalized;
 }
 
@@ -153,11 +155,13 @@ export async function getTargetById({ outputRoot, targetId } = {}) {
 }
 
 export async function recordDomainProofResponse({
+  outputFs,
   outputRoot,
   domain = {},
   proof = {},
   context = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const domainId = normalizeString(domain.id || context.domainId);
   if (!domainId) {
     throw new Error("Cannot record domain without domain.id.");
@@ -201,7 +205,7 @@ export async function recordDomainProofResponse({
     registry.domains.push(nextRecord);
   }
 
-  const saved = await writeRegistryInternal(registryPath, registry);
+  const saved = await writeRegistryInternal(registryPath, registry, outputFs);
   const record = saved.domains.find((item) => item.domainId === domainId) || null;
   return {
     registryPath,
@@ -210,11 +214,13 @@ export async function recordDomainProofResponse({
 }
 
 export async function recordTargetProofResponse({
+  outputFs,
   outputRoot,
   target = {},
   proof = {},
   context = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const targetId = normalizeString(target.id || context.targetId);
   if (!targetId) {
     throw new Error("Cannot record target without target.id.");
@@ -259,7 +265,7 @@ export async function recordTargetProofResponse({
     registry.targets.push(nextRecord);
   }
 
-  const saved = await writeRegistryInternal(registryPath, registry);
+  const saved = await writeRegistryInternal(registryPath, registry, outputFs);
   const record = saved.targets.find((item) => item.targetId === targetId) || null;
   return {
     registryPath,

package/src/ai/identity-store.js

@@ -1,5 +1,6 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 
 const REGISTRY_SCHEMA_VERSION = "1.0.0";
 const TERMINAL_IDENTITY_STATUSES = new Set(["SQUASHED"]);
@@ -96,14 +97,15 @@ async function loadRegistryInternal(filePath) {
   }
 }
 
-async function writeRegistryInternal(filePath, registry = {}) {
+async function writeRegistryInternal(filePath, registry = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: REGISTRY_SCHEMA_VERSION,
     generatedAt: new Date().toISOString(),
     identities: Array.isArray(registry.identities) ? registry.identities.map(normalizeIdentityRecord) : [],
   };
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
   return normalized;
 }
 
@@ -130,10 +132,12 @@ export async function getIdentityById({ outputRoot, identityId } = {}) {
 }
 
 export async function recordProvisionedIdentity({
+  outputFs,
   outputRoot,
   response = {},
   context = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const registryPath = resolveIdentityRegistryPath({ outputRoot });
   const registry = await loadRegistryInternal(registryPath);
   const identityId = normalizeString(response.id);
@@ -180,7 +184,7 @@ export async function recordProvisionedIdentity({
     registry.identities.push(nextRecord);
   }
 
-  const saved = await writeRegistryInternal(registryPath, registry);
+  const saved = await writeRegistryInternal(registryPath, registry, outputFs);
   const identity = saved.identities.find((item) => item.identityId === identityId) || null;
   return {
     registryPath,
@@ -189,6 +193,7 @@ export async function recordProvisionedIdentity({
 }
 
 export async function updateIdentityStatus({
+  outputFs,
   outputRoot,
   identityId,
   status,
@@ -196,6 +201,7 @@ export async function updateIdentityStatus({
   squashedAt = "",
   metadataPatch = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const normalizedIdentityId = normalizeString(identityId);
   if (!normalizedIdentityId) {
     throw new Error("identityId is required.");
@@ -226,7 +232,7 @@ export async function updateIdentityStatus({
     },
   });
 
-  const saved = await writeRegistryInternal(registryPath, registry);
+  const saved = await writeRegistryInternal(registryPath, registry, outputFs);
   return {
     registryPath,
     identity: saved.identities[index],

package/src/ai/site-store.js

@@ -1,5 +1,6 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 
 const REGISTRY_SCHEMA_VERSION = "1.0.0";
 
@@ -60,14 +61,15 @@ async function loadRegistryInternal(filePath) {
   }
 }
 
-async function writeRegistryInternal(filePath, registry = {}) {
+async function writeRegistryInternal(filePath, registry = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: REGISTRY_SCHEMA_VERSION,
     generatedAt: new Date().toISOString(),
     sites: Array.isArray(registry.sites) ? registry.sites.map(normalizeSiteRecord) : [],
   };
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
   return normalized;
 }
 
@@ -85,10 +87,12 @@ export async function listSites({ outputRoot, identityId = "" } = {}) {
 }
 
 export async function recordTemporarySite({
+  outputFs,
   outputRoot,
   site = {},
   context = {},
 } = {}) {
+  requireOutputFileSystem(outputFs);
   const siteId = normalizeString(site.id || context.siteId);
   if (!siteId) {
     throw new Error("Cannot record temporary site without site.id.");
@@ -136,7 +140,7 @@ export async function recordTemporarySite({
     registry.sites.push(nextRecord);
   }
 
-  const saved = await writeRegistryInternal(registryPath, registry);
+  const saved = await writeRegistryInternal(registryPath, registry, outputFs);
   const savedSite = saved.sites.find((item) => item.siteId === siteId) || null;
   return {
     registryPath,

package/src/audit/orchestrator.js

@@ -4,7 +4,8 @@ import path from "node:path";
 
 import { resolveAgentIdPath } from "../agents/agent-id-path.js";
 import { userCredential } from "../auth/credential-destinations.js";
-import { resolveOutputRoot } from "../config/service.js";
+import { resolveOutputContext } from "../config/service.js";
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
 import { createAgentEvent } from "../events/schema.js";
 import { resolveCodebaseIngest } from "../ingest/engine.js";
 import { runDeterministicReviewPipeline } from "../review/local-review.js";
@@ -271,7 +272,9 @@ async function buildSpecialistSeed({
   deterministicBaseline,
   ingest,
   agentsDirectory,
+  outputFs,
 }) {
+  requireOutputFileSystem(outputFs);
   let findings = [];
   let summary = severitySummary(findings);
   let confidence = computeConfidenceFloor(agent.confidenceFloor, findings.length);
@@ -285,7 +288,7 @@ async function buildSpecialistSeed({
     summary = securitySpecialist.summary;
     confidence = securitySpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "SECURITY_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderSecuritySpecialistMarkdown(securitySpecialist).trim()}\n`,
       "utf-8"
@@ -299,7 +302,7 @@ async function buildSpecialistSeed({
     summary = architectureSpecialist.summary;
     confidence = architectureSpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "ARCHITECTURE_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderArchitectureSpecialistMarkdown(architectureSpecialist).trim()}\n`,
       "utf-8"
@@ -313,7 +316,7 @@ async function buildSpecialistSeed({
     summary = testingSpecialist.summary;
     confidence = testingSpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "TESTING_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderTestingSpecialistMarkdown(testingSpecialist).trim()}\n`,
       "utf-8"
@@ -327,7 +330,7 @@ async function buildSpecialistSeed({
     summary = performanceSpecialist.summary;
     confidence = performanceSpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "PERFORMANCE_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderPerformanceSpecialistMarkdown(performanceSpecialist).trim()}\n`,
       "utf-8"
@@ -341,7 +344,7 @@ async function buildSpecialistSeed({
     summary = complianceSpecialist.summary;
     confidence = complianceSpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "COMPLIANCE_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderComplianceSpecialistMarkdown(complianceSpecialist).trim()}\n`,
       "utf-8"
@@ -355,7 +358,7 @@ async function buildSpecialistSeed({
     summary = documentationSpecialist.summary;
     confidence = documentationSpecialist.confidence;
     specialistReportPath = path.join(agentsDirectory, "DOCUMENTATION_AGENT_REPORT.md");
-    await fsp.writeFile(
+    await outputFs.writeFile(
       specialistReportPath,
       `${renderDocumentationSpecialistMarkdown(documentationSpecialist).trim()}\n`,
       "utf-8"
@@ -388,7 +391,7 @@ export async function runAuditOrchestrator({
   const isolationMode = normalizeIsolationMode(isolation);
   const useDeterministicSeed = seedFromDeterministic !== false;
   const requestedOmarGateReuse = normalizeString(reuseOmarGate);
-  const outputRoot = await resolveOutputRoot({
+  const { outputRoot, outputFs } = await resolveOutputContext({
     cwd: normalizedTargetPath,
     outputDirOverride: outputDir,
     env: process.env,
@@ -402,7 +405,7 @@ export async function runAuditOrchestrator({
   const agentPaths = new Map(
     agents.map((agent) => [agent, resolveAgentIdPath(agentsDirectory, agent.id, ".json")])
   );
-  await fsp.mkdir(agentsDirectory, { recursive: true });
+  await outputFs.mkdir(agentsDirectory, { recursive: true });
   const blackboard = createBlackboard({
     runId,
     scope: "audit-orchestrator",
@@ -655,6 +658,7 @@ export async function runAuditOrchestrator({
           deterministicBaseline,
           ingest,
           agentsDirectory,
+          outputFs,
         })
       : {
           findings: [],
@@ -682,6 +686,7 @@ export async function runAuditOrchestrator({
         sharedContext,
         hybridContext,
         artifactDir: agentsDirectory,
+        outputFs,
         provider,
         onEvent,
         clientFactory,
@@ -761,7 +766,7 @@ export async function runAuditOrchestrator({
       confidence,
     });
     const agentPath = agentPaths.get(agent);
-    await fsp.writeFile(agentPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+    await outputFs.writeFile(agentPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
     emitAuditLifecycleEvent(
       onEvent,
       runId,
@@ -844,6 +849,7 @@ export async function runAuditOrchestrator({
     `Reconcile complete: ${uniqueFindings.length} unique finding(s).`
   );
   const sharedMemoryArtifact = await writeBlackboardArtifact(blackboard, {
+    outputFs,
     outputRoot,
   });
   const sharedMemorySummary = summarizeBlackboard(blackboard);
@@ -907,9 +913,10 @@ export async function runAuditOrchestrator({
 
   const reportJsonPath = path.join(runDirectory, "AUDIT_REPORT.json");
   const reportMarkdownPath = path.join(runDirectory, "AUDIT_REPORT.md");
-  await fsp.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(reportMarkdownPath, `${buildAuditMarkdown(report).trim()}\n`, "utf-8");
+  await outputFs.writeFile(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(reportMarkdownPath, `${buildAuditMarkdown(report).trim()}\n`, "utf-8");
   const ddPackage = await writeDdPackage({
+    outputFs,
     report,
     runDirectory,
   });
@@ -930,11 +937,11 @@ export async function runAuditOrchestrator({
     `Audit orchestrator complete: P0=${summary.P0} P1=${summary.P1} P2=${summary.P2} P3=${summary.P3}.`
   );
 
-  return {
+  return bindOutputFileSystem({
     ...report,
     reportJsonPath,
     reportMarkdownPath,
     ddPackage,
-  };
+  }, outputFs);
 }
 

package/src/audit/package.js

@@ -1,3 +1,4 @@
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 import fsp from "node:fs/promises";
 import path from "node:path";
 
@@ -116,7 +117,8 @@ export function buildDdPackageManifest(report = {}) {
   };
 }
 
-export async function writeDdPackage({ report = {}, runDirectory } = {}) {
+export async function writeDdPackage({ report = {}, runDirectory, outputFs } = {}) {
+  requireOutputFileSystem(outputFs);
   const resolvedRunDirectory = normalizeRunDirectory(runDirectory || report.runDirectory);
   const manifest = buildDdPackageManifest({
     ...report,
@@ -138,9 +140,9 @@ export async function writeDdPackage({ report = {}, runDirectory } = {}) {
     findingsIndex,
   });
 
-  await fsp.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(findingsIndexPath, `${JSON.stringify(findingsIndex, null, 2)}\n`, "utf-8");
-  await fsp.writeFile(executiveSummaryPath, `${executiveSummary.trim()}\n`, "utf-8");
+  await outputFs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(findingsIndexPath, `${JSON.stringify(findingsIndex, null, 2)}\n`, "utf-8");
+  await outputFs.writeFile(executiveSummaryPath, `${executiveSummary.trim()}\n`, "utf-8");
 
   return {
     manifest,