sentinelayer-cli 0.46.5 → 0.48.0

package/src/daemon/ast-drift.js

@@ -12,6 +12,7 @@
 // ast-parser-layer.js so we don't spawn Python for the JS/TS majority.
 
 import fsp from "node:fs/promises";
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 import path from "node:path";
 import process from "node:process";
 
@@ -452,24 +453,27 @@ export async function detectAstDrift({
 }
 
 export async function writeAstSnapshot({
+  outputFs,
   rootPath = process.cwd(),
   snapshotPath = "",
   snapshot,
 } = {}) {
+  requireOutputFileSystem(outputFs);
   if (!snapshot || typeof snapshot !== "object") {
     throw new Error("snapshot is required.");
   }
   const resolvedSnapshotPath = snapshotPath
     ? path.resolve(rootPath, snapshotPath)
     : path.join(rootPath, DEFAULT_AST_SNAPSHOT_RELATIVE_PATH);
-  await fsp.mkdir(path.dirname(resolvedSnapshotPath), { recursive: true });
+  await outputFs.assertFilePath(resolvedSnapshotPath);
+  await outputFs.mkdir(path.dirname(resolvedSnapshotPath), { recursive: true });
   const tmpPath = `${resolvedSnapshotPath}.${process.pid}.${Date.now()}.tmp`;
-  await fsp.writeFile(
+  await outputFs.writeFile(
     tmpPath,
     `${JSON.stringify(snapshot, null, 2)}\n`,
     "utf-8"
   );
-  await fsp.rename(tmpPath, resolvedSnapshotPath);
+  await outputFs.rename(tmpPath, resolvedSnapshotPath);
   return resolvedSnapshotPath;
 }
 

package/src/daemon/budget-governor.js

@@ -1,6 +1,7 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
 import { resolveAssignmentLedgerStorage } from "./assignment-ledger.js";
 import { resolveErrorDaemonStorage } from "./error-worker.js";
 
@@ -179,14 +180,16 @@ async function loadJsonFile(filePath, defaultFactory) {
   }
 }
 
-async function writeJsonFile(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+async function writeJsonFile(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }
 
-async function appendEvent(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
+async function appendEvent(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
 }
 
 async function loadQueue(queuePath, nowIso = new Date().toISOString()) {
@@ -202,12 +205,13 @@ async function loadQueue(queuePath, nowIso = new Date().toISOString()) {
   };
 }
 
-async function writeQueue(queuePath, queue = {}, nowIso = new Date().toISOString()) {
+async function writeQueue(queuePath, queue = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   await writeJsonFile(queuePath, {
     schemaVersion: QUEUE_SCHEMA_VERSION,
     generatedAt: normalizeIsoTimestamp(nowIso, nowIso),
     items: Array.isArray(queue.items) ? queue.items : [],
-  });
+  }, outputFs);
 }
 
 async function loadAssignmentLedger(ledgerPath, nowIso = new Date().toISOString()) {
@@ -218,12 +222,13 @@ async function loadAssignmentLedger(ledgerPath, nowIso = new Date().toISOString(
   }));
 }
 
-async function writeAssignmentLedger(ledgerPath, ledger = {}, nowIso = new Date().toISOString()) {
+async function writeAssignmentLedger(ledgerPath, ledger = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   await writeJsonFile(ledgerPath, {
     ...ledger,
     generatedAt: normalizeIsoTimestamp(nowIso, nowIso),
     assignments: Array.isArray(ledger.assignments) ? ledger.assignments : [],
-  });
+  }, outputFs);
 }
 
 export function evaluateDaemonBudget({
@@ -371,12 +376,12 @@ export async function resolveBudgetGovernorStorage({
     env,
     homeDir,
   });
-  return {
+  return bindOutputFileSystem({
     ...daemonStorage,
     budgetStatePath: path.join(daemonStorage.baseDir, "budget-state.json"),
     budgetEventsPath: path.join(daemonStorage.baseDir, "budget-events.ndjson"),
     budgetRunsDir: path.join(daemonStorage.baseDir, "budget-runs"),
-  };
+  }, daemonStorage.outputFs);
 }
 
 async function loadBudgetState(filePath, nowIso = new Date().toISOString()) {
@@ -392,7 +397,8 @@ async function loadBudgetState(filePath, nowIso = new Date().toISOString()) {
   };
 }
 
-async function writeBudgetState(filePath, state = {}, nowIso = new Date().toISOString()) {
+async function writeBudgetState(filePath, state = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: BUDGET_STATE_SCHEMA_VERSION,
     generatedAt: normalizeIsoTimestamp(nowIso, nowIso),
@@ -402,7 +408,7 @@ async function writeBudgetState(filePath, state = {}, nowIso = new Date().toISOS
           .filter((record) => record.workItemId)
       : [],
   };
-  await writeJsonFile(filePath, normalized);
+  await writeJsonFile(filePath, normalized, outputFs);
   return normalized;
 }
 
@@ -529,9 +535,9 @@ export async function applyDaemonBudgetCheck({
   }
 
   const [savedState] = await Promise.all([
-    writeBudgetState(storage.budgetStatePath, budgetState, normalizedNow),
-    writeQueue(storage.queuePath, queue, normalizedNow),
-    writeAssignmentLedger(assignmentStorage.ledgerPath, assignmentLedger, normalizedNow),
+    writeBudgetState(storage.budgetStatePath, budgetState, normalizedNow, storage.outputFs),
+    writeQueue(storage.queuePath, queue, normalizedNow, storage.outputFs),
+    writeAssignmentLedger(assignmentStorage.ledgerPath, assignmentLedger, normalizedNow, assignmentStorage.outputFs),
   ]);
 
   await appendEvent(storage.budgetEventsPath, {
@@ -543,9 +549,9 @@ export async function applyDaemonBudgetCheck({
     warningCodes: evaluation.warnings.map((item) => item.code),
     stopCodes: evaluation.stopReasons.map((item) => item.code),
     quarantineUntil: evaluation.quarantineUntil,
-  });
+  }, storage.outputFs);
 
-  await fsp.mkdir(storage.budgetRunsDir, { recursive: true });
+  await storage.outputFs.mkdir(storage.budgetRunsDir, { recursive: true });
   const runId = `budget-check-${normalizedNow.replace(/[:.]/g, "-")}-${String(
     budgetState.records.length
   ).padStart(4, "0")}`;
@@ -562,7 +568,7 @@ export async function applyDaemonBudgetCheck({
     usage: evaluation.usage,
     quarantineStartedAt: evaluation.quarantineStartedAt,
     quarantineUntil: evaluation.quarantineUntil,
-  });
+  }, storage.outputFs);
 
   return {
     ...storage,

package/src/daemon/error-worker.js

@@ -2,7 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import fsp from "node:fs/promises";
 import path from "node:path";
 
-import { resolveOutputRoot } from "../config/service.js";
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
+import { resolveOutputContext } from "../config/service.js";
 import { createAgentEvent } from "../events/schema.js";
 import { appendToStream } from "../session/stream.js";
 
@@ -290,7 +291,8 @@ async function loadQueueFile(queuePath, nowIso = new Date().toISOString()) {
   }
 }
 
-async function writeQueueFile(queuePath, queue = {}, nowIso = new Date().toISOString()) {
+async function writeQueueFile(queuePath, queue = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: QUEUE_SCHEMA_VERSION,
     generatedAt: normalizeIsoTimestamp(nowIso, nowIso),
@@ -300,8 +302,8 @@ async function writeQueueFile(queuePath, queue = {}, nowIso = new Date().toISOSt
           .filter((item) => normalizeString(item.fingerprint))
       : [],
   };
-  await fsp.mkdir(path.dirname(queuePath), { recursive: true });
-  await fsp.writeFile(queuePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(path.dirname(queuePath), { recursive: true });
+  await outputFs.writeFile(queuePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
   return normalized;
 }
 
@@ -327,7 +329,8 @@ async function loadWorkerStateFile(statePath, nowIso = new Date().toISOString())
   }
 }
 
-async function writeWorkerStateFile(statePath, state = {}, nowIso = new Date().toISOString()) {
+async function writeWorkerStateFile(statePath, state = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: STATE_SCHEMA_VERSION,
     updatedAt: normalizeIsoTimestamp(nowIso, nowIso),
@@ -338,8 +341,8 @@ async function writeWorkerStateFile(statePath, state = {}, nowIso = new Date().t
     totalQueuedItems: normalizeNonNegativeInteger(state.totalQueuedItems, 0),
     totalDedupeHits: normalizeNonNegativeInteger(state.totalDedupeHits, 0),
   };
-  await fsp.mkdir(path.dirname(statePath), { recursive: true });
-  await fsp.writeFile(statePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  await outputFs.mkdir(path.dirname(statePath), { recursive: true });
+  await outputFs.writeFile(statePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
   return normalized;
 }
 
@@ -427,15 +430,16 @@ export async function resolveErrorDaemonStorage({
   env,
   homeDir,
 } = {}) {
-  const outputRoot = await resolveOutputRoot({
+  const { outputRoot, outputFs } = await resolveOutputContext({
     cwd: path.resolve(String(targetPath || ".")),
     outputDirOverride: outputDir,
     env,
     homeDir,
   });
+  requireOutputFileSystem(outputFs);
   const observabilityRoot = path.join(outputRoot, "observability");
   const baseDir = path.join(observabilityRoot, "error-daemon");
-  return {
+  return bindOutputFileSystem({
     outputRoot,
     observabilityRoot,
     baseDir,
@@ -445,7 +449,7 @@ export async function resolveErrorDaemonStorage({
     intakeDir: path.join(baseDir, "intake"),
     runsDir: path.join(baseDir, "runs"),
     sweepsDir: path.join(baseDir, "sweeps"),
-  };
+  }, outputFs);
 }
 
 export async function appendAdminErrorEvent({
@@ -464,15 +468,15 @@ export async function appendAdminErrorEvent({
     homeDir,
   });
 
-  await fsp.mkdir(storage.baseDir, { recursive: true });
-  await fsp.appendFile(storage.streamPath, `${JSON.stringify(normalizedEvent)}\n`, "utf-8");
+  await storage.outputFs.mkdir(storage.baseDir, { recursive: true });
+  await storage.outputFs.appendFile(storage.streamPath, `${JSON.stringify(normalizedEvent)}\n`, "utf-8");
 
-  await fsp.mkdir(storage.intakeDir, { recursive: true });
+  await storage.outputFs.mkdir(storage.intakeDir, { recursive: true });
   const intakePath = path.join(
     storage.intakeDir,
     `intake-${stableTimestampForFile(new Date(normalizedEvent.recordedAt))}-${normalizedEvent.eventId.slice(0, 8)}.json`
   );
-  await fsp.writeFile(
+  await storage.outputFs.writeFile(
     intakePath,
     `${JSON.stringify(
       {
@@ -506,9 +510,10 @@ async function writeWorkItemIntakeArtifact(
     nowIso = new Date().toISOString(),
   } = {}
 ) {
+  requireOutputFileSystem(storage.outputFs);
   const normalizedNow = normalizeIsoTimestamp(nowIso, new Date().toISOString());
   const intakePath = resolveWorkItemIntakePath(storage, queueItem, normalizedNow);
-  await fsp.mkdir(path.dirname(intakePath), { recursive: true });
+  await storage.outputFs.mkdir(path.dirname(intakePath), { recursive: true });
   const normalizedRequestIds = normalizeRequestIds(queueItem.requestIds || []);
   const payload = {
     schemaVersion: "1.0.0",
@@ -537,7 +542,7 @@ async function writeWorkItemIntakeArtifact(
     status: queueItem.status,
     message: queueItem.message,
   };
-  await fsp.writeFile(intakePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+  await storage.outputFs.writeFile(intakePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
   return {
     intakePath,
     payload,
@@ -696,7 +701,7 @@ export async function runErrorDaemonWorker({
   }
 
   queue.generatedAt = normalizedNow;
-  const savedQueue = await writeQueueFile(storage.queuePath, queue, normalizedNow);
+  const savedQueue = await writeQueueFile(storage.queuePath, queue, normalizedNow, storage.outputFs);
 
   const savedState = await writeWorkerStateFile(
     storage.statePath,
@@ -710,7 +715,8 @@ export async function runErrorDaemonWorker({
       totalQueuedItems: savedQueue.items.length,
       totalDedupeHits: state.totalDedupeHits + dedupedCount,
     },
-    normalizedNow
+    normalizedNow,
+    storage.outputFs
   );
 
   const intakeArtifacts = [];
@@ -759,10 +765,10 @@ export async function runErrorDaemonWorker({
     }
   }
 
-  await fsp.mkdir(storage.runsDir, { recursive: true });
+  await storage.outputFs.mkdir(storage.runsDir, { recursive: true });
   const runId = `error-daemon-run-${stableTimestampForFile(new Date(normalizedNow))}-${randomUUID().slice(0, 8)}`;
   const runPath = path.join(storage.runsDir, `${runId}.json`);
-  await fsp.writeFile(
+  await storage.outputFs.writeFile(
     runPath,
     `${JSON.stringify(
       {
@@ -893,9 +899,9 @@ export async function scheduledErrorSweep({
     })),
   };
 
-  await fsp.mkdir(storage.sweepsDir, { recursive: true });
+  await storage.outputFs.mkdir(storage.sweepsDir, { recursive: true });
   const sweepPath = path.join(storage.sweepsDir, `${runId}.json`);
-  await fsp.writeFile(sweepPath, `${JSON.stringify(digest, null, 2)}\n`, "utf-8");
+  await storage.outputFs.writeFile(sweepPath, `${JSON.stringify(digest, null, 2)}\n`, "utf-8");
 
   let sweepEvent = null;
   if (normalizedSessionId) {

package/src/daemon/fix-cycle.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import path from "node:path";
-import fsp from "node:fs/promises";
+import { requireOutputFileSystem } from "../config/output-filesystem.js";
 import { startJiraLifecycle, commentJiraIssue, transitionJiraIssue } from "./jira-lifecycle.js";
 import { claimAssignment, heartbeatAssignment, releaseAssignment } from "./assignment-ledger.js";
 import { createAgentEvent } from "../events/schema.js";
@@ -23,7 +23,8 @@ const HEARTBEAT_INTERVAL_MS = 300000;
 const OMAR_POLL_INTERVAL_MS = 15000;
 const OMAR_POLL_MAX_ATTEMPTS = 40; // 10 minutes max wait
 
-export async function runFixCycle({ workItemId, workItem, rootPath, scopeMap, findings, onEvent, agentIdentity }) {
+export async function runFixCycle({ workItemId, workItem, rootPath, scopeMap, findings, onEvent, agentIdentity, outputFs }) {
+  requireOutputFileSystem(outputFs);
   const agentDef = agentIdentity || { id: "unknown", persona: "Unknown Agent", color: "white", avatar: "", signature: "" };
   const emit = (ev, pl) => {
     if (onEvent) onEvent(createAgentEvent({
@@ -40,7 +41,7 @@ export async function runFixCycle({ workItemId, workItem, rootPath, scopeMap, fi
   };
 
   const artDir = path.join(rootPath, ".sentinelayer", "observability", "fixes", workItemId);
-  await fsp.mkdir(artDir, { recursive: true });
+  await outputFs.mkdir(artDir, { recursive: true });
 
   let jiraKey = null;
   let prNumber = null;
@@ -202,7 +203,7 @@ export async function runFixCycle({ workItemId, workItem, rootPath, scopeMap, fi
       findingsAddressed: findings?.length || 0,
       signature: agentDef.signature,
     };
-    await fsp.writeFile(
+    await outputFs.writeFile(
       path.join(artDir, "fix-result.json"),
       JSON.stringify(result, null, 2),
     );

package/src/daemon/hybrid-mapper.js

@@ -1,6 +1,7 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
 import { parseAstModuleSpecifiers } from "./ast-parser-layer.js";
 import { buildCallgraphOverlay } from "./callgraph-overlay.js";
 import { collectCodebaseIngest } from "../ingest/engine.js";
@@ -110,14 +111,16 @@ async function readJsonFile(filePath, defaultFactory) {
   }
 }
 
-async function writeJsonFile(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+async function writeJsonFile(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }
 
-async function appendJsonLine(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
+async function appendJsonLine(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
 }
 
 function tokenizeWorkItem(queueItem = {}) {
@@ -364,7 +367,7 @@ export async function resolveHybridMappingStorage({
     homeDir,
   });
   const mappingDir = path.join(daemonStorage.baseDir, "mapping");
-  return {
+  return bindOutputFileSystem({
     ...daemonStorage,
     mappingDir,
     mapIndexPath: path.join(mappingDir, "hybrid-map-index.json"),
@@ -373,7 +376,7 @@ export async function resolveHybridMappingStorage({
     handoffIndexPath: path.join(mappingDir, "hybrid-handoff-index.json"),
     handoffEventsPath: path.join(mappingDir, "hybrid-handoff-events.ndjson"),
     handoffRunsDir: path.join(mappingDir, "handoffs"),
-  };
+  }, daemonStorage.outputFs);
 }
 
 export async function buildHybridScopeMap({
@@ -577,8 +580,8 @@ export async function buildHybridScopeMap({
     },
   };
 
-  await fsp.mkdir(storage.mapRunsDir, { recursive: true });
-  await writeJsonFile(runPath, runPayload);
+  await storage.outputFs.mkdir(storage.mapRunsDir, { recursive: true });
+  await writeJsonFile(runPath, runPayload, storage.outputFs);
 
   const rawIndex = await readJsonFile(storage.mapIndexPath, () => createInitialMapIndex(normalizedNow));
   const index = normalizeMapIndex(rawIndex, normalizedNow);
@@ -600,7 +603,7 @@ export async function buildHybridScopeMap({
     ...index.maps.filter((entry) => entry.runId !== runId),
   ].slice(0, 2000);
   await Promise.all([
-    writeJsonFile(storage.mapIndexPath, index),
+    writeJsonFile(storage.mapIndexPath, index, storage.outputFs),
     appendJsonLine(storage.mapEventsPath, {
       timestamp: normalizedNow,
       eventType: "hybrid_scope_map",
@@ -618,7 +621,7 @@ export async function buildHybridScopeMap({
       callGraphParsedFileCount: callGraphOverlay.summary.parsedFileCount,
       callGraphFallbackParsedFileCount: callGraphOverlay.summary.fallbackParsedFileCount,
       callGraphParseErrorCount: callGraphOverlay.summary.parseErrorCount,
-    }),
+    }, storage.outputFs),
   ]);
 
   return {
@@ -791,8 +794,8 @@ export async function buildHybridHandoffPackage({
     },
     files: handoffFiles,
   };
-  await fsp.mkdir(storage.handoffRunsDir, { recursive: true });
-  await writeJsonFile(handoffPath, payload);
+  await storage.outputFs.mkdir(storage.handoffRunsDir, { recursive: true });
+  await writeJsonFile(handoffPath, payload, storage.outputFs);
 
   const rawIndex = await readJsonFile(storage.handoffIndexPath, () => createInitialHandoffIndex(normalizedNow));
   const index = normalizeHandoffIndex(rawIndex, normalizedNow);
@@ -812,7 +815,7 @@ export async function buildHybridHandoffPackage({
   ].slice(0, 2000);
 
   await Promise.all([
-    writeJsonFile(storage.handoffIndexPath, index),
+    writeJsonFile(storage.handoffIndexPath, index, storage.outputFs),
     appendJsonLine(storage.handoffEventsPath, {
       timestamp: normalizedNow,
       eventType: "hybrid_handoff_package",
@@ -822,7 +825,7 @@ export async function buildHybridHandoffPackage({
       assignee: normalizedAssignee,
       scopedFileCount: handoffFiles.length,
       estimatedInputTokens: budgets.estimatedInputTokens,
-    }),
+    }, storage.outputFs),
   ]);
 
   return {

package/src/daemon/ingest-refresh.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { resolveOutputContext } from "../config/service.js";
 import { collectCodebaseIngest, generateCodebaseIngest } from "../ingest/engine.js";
 import { createAgentEvent } from "../events/schema.js";
 import {
@@ -74,6 +75,7 @@ export function detectIngestDrift(targetPath) {
  * @returns {Promise<{ refreshed: boolean, reason: string, durationMs: number }>}
  */
 export async function refreshIngestIfNeeded(targetPath, options = {}) {
+  const { outputFs } = await resolveOutputContext({ cwd: path.resolve(targetPath), outputDirOverride: ".sentinelayer" });
   const maxDurationMs = options.maxDurationMs || DEFAULT_MAX_DURATION_MS;
   const driftMode = options.driftMode === "ast" ? "ast" : "file-count";
   let astOutcome = null;
@@ -137,6 +139,7 @@ export async function refreshIngestIfNeeded(targetPath, options = {}) {
     let ingest;
     try {
       ingest = await generateCodebaseIngest({
+        outputFs,
         rootPath: targetPath,
         outputDir: path.join(targetPath, ".sentinelayer"),
         refresh: true,
@@ -152,6 +155,7 @@ export async function refreshIngestIfNeeded(targetPath, options = {}) {
     if (driftMode === "ast" && astOutcome?.currentSnapshot) {
       try {
         await writeAstSnapshot({
+          outputFs,
           rootPath: targetPath,
           snapshot: astOutcome.currentSnapshot,
         });

package/src/daemon/jira-lifecycle.js

@@ -1,6 +1,7 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 
+import { bindOutputFileSystem, requireOutputFileSystem } from "../config/output-filesystem.js";
 import { createAgentEvent } from "../events/schema.js";
 import { appendToStream } from "../session/stream.js";
 import { resolveAssignmentLedgerStorage } from "./assignment-ledger.js";
@@ -165,14 +166,16 @@ async function loadJsonFile(filePath, defaultFactory) {
   }
 }
 
-async function writeJsonFile(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+async function writeJsonFile(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }
 
-async function appendEvent(filePath, payload = {}) {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
+async function appendEvent(filePath, payload = {}, outputFs) {
+  requireOutputFileSystem(outputFs);
+  await outputFs.mkdir(path.dirname(filePath), { recursive: true });
+  await outputFs.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf-8");
 }
 
 async function loadQueue(queuePath, nowIso = new Date().toISOString()) {
@@ -200,7 +203,8 @@ async function loadLifecycle(lifecyclePath, nowIso = new Date().toISOString()) {
   };
 }
 
-async function writeLifecycle(lifecyclePath, lifecycle = {}, nowIso = new Date().toISOString()) {
+async function writeLifecycle(lifecyclePath, lifecycle = {}, nowIso = new Date().toISOString(), outputFs) {
+  requireOutputFileSystem(outputFs);
   const normalized = {
     schemaVersion: LIFECYCLE_SCHEMA_VERSION,
     generatedAt: normalizeIsoTimestamp(nowIso, nowIso),
@@ -211,7 +215,7 @@ async function writeLifecycle(lifecyclePath, lifecycle = {}, nowIso = new Date()
           .filter((issue) => issue.workItemId && issue.issueKey)
       : [],
   };
-  await writeJsonFile(lifecyclePath, normalized);
+  await writeJsonFile(lifecyclePath, normalized, outputFs);
   return normalized;
 }
 
@@ -284,7 +288,7 @@ async function syncIssueKeyToAssignment({
     ...rawLedger,
     generatedAt: nowIso,
     assignments,
-  });
+  }, assignmentStorage.outputFs);
 }
 
 export async function resolveJiraLifecycleStorage({
@@ -299,11 +303,11 @@ export async function resolveJiraLifecycleStorage({
     env,
     homeDir,
   });
-  return {
+  return bindOutputFileSystem({
     ...daemonStorage,
     lifecyclePath: path.join(daemonStorage.baseDir, "jira-lifecycle.json"),
     eventsPath: path.join(daemonStorage.baseDir, "jira-events.ndjson"),
-  };
+  }, daemonStorage.outputFs);
 }
 
 export async function emitJiraLifecycleEvent(
@@ -453,7 +457,7 @@ export async function openJiraIssue({
     normalizedNow
   );
   lifecycle.issues.push(issue);
-  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow);
+  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow, storage.outputFs);
   await appendEvent(storage.eventsPath, {
     timestamp: normalizedNow,
     eventType: "create_issue",
@@ -461,7 +465,7 @@ export async function openJiraIssue({
     workItemId: normalizedWorkItemId,
     issueKey: normalizedIssueKey,
     status: "OPEN",
-  });
+  }, storage.outputFs);
   await syncIssueKeyToAssignment({
     targetPath,
     outputDir,
@@ -536,7 +540,7 @@ export async function commentJiraIssue({
   existing.latestCommentAt = normalizedNow;
   existing.updatedAt = normalizedNow;
   lifecycle.issues[issueIndex] = normalizeIssue(existing, normalizedNow);
-  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow);
+  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow, storage.outputFs);
   await appendEvent(storage.eventsPath, {
     timestamp: normalizedNow,
     eventType: "comment",
@@ -545,7 +549,7 @@ export async function commentJiraIssue({
     issueKey: existing.issueKey,
     type: comment.type,
     message: comment.message,
-  });
+  }, storage.outputFs);
   if (normalizedSessionId) {
     await emitJiraLifecycleEvent(normalizedSessionId, {
       phase: comment.type === "plan" ? "plan_comment" : "checkpoint",
@@ -613,7 +617,7 @@ export async function transitionJiraIssue({
   existing.transitions = [...existing.transitions, transition];
   existing.updatedAt = normalizedNow;
   lifecycle.issues[issueIndex] = normalizeIssue(existing, normalizedNow);
-  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow);
+  const savedLifecycle = await writeLifecycle(storage.lifecyclePath, lifecycle, normalizedNow, storage.outputFs);
   await appendEvent(storage.eventsPath, {
     timestamp: normalizedNow,
     eventType: "transition",
@@ -623,7 +627,7 @@ export async function transitionJiraIssue({
     from: transition.from,
     to: transition.to,
     reason: transition.reason,
-  });
+  }, storage.outputFs);
   if (normalizedSessionId) {
     await emitJiraLifecycleEvent(normalizedSessionId, {
       phase: resolveTransitionPhase(nextStatus),