@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.4

package/src/core/information-gain-projection.js

@@ -1,5 +1,6 @@
-import { diagnosticEventsForTask } from "./diagnostic-projection.js";
-import { normalizeDiagnosticSnapshot, computeInformationGain } from "./information-gain.js";
+import { ledgerRelationSet, ledgerGroupedSet } from "./ledger-relations.js";
+import { isLedgerEventCollection, ledgerEventsOfTypes } from "./ledger-event-collection.js";
+import { normalizeDiagnosticSnapshot, compareDiagnosticCycles, classifyGain, isEffectiveGain } from "./information-gain.js";
 import { computeFailureSignature } from "./failure-signature.js";
 
 function snapshotFor(event) {
@@ -19,23 +20,43 @@ const sameSortedSet = (a, b) =>
 //   current diagnostic sequence inclusive.
 // Events inside an interval belong to the *current* cycle's knowledge state;
 // they are never attributed retroactively to the earlier diagnosis.
-function intervalEvents(taskEvents, fromExclusive, toInclusive) {
-  return taskEvents.filter((event) =>
-    event.seq > fromExclusive && event.seq <= toInclusive);
+function* intervalEvents(taskEvents, fromExclusive, toInclusive) {
+  for (const event of taskEvents) if (event.seq > fromExclusive && event.seq <= toInclusive) yield event;
+}
+
+function orderedTaskEvents(events, taskId) {
+  const belongs = event => !taskId || !event.taskId || event.taskId === taskId;
+  if (!Array.isArray(events) && isLedgerEventCollection(events)) {
+    let previous = -Infinity;
+    let ordered = true;
+    for (const event of events) {
+      if (!Number.isFinite(event.seq) || event.seq < previous) { ordered = false; break; }
+      previous = event.seq;
+    }
+    if (ordered) return { *[Symbol.iterator]() { for (const event of ledgerEventsOfTypes(events, ["DIAGNOSTIC_CASE_RECORDED", "DIAGNOSIS_RECORDED", "VERIFICATION_STARTED", "VERIFICATION_RECORDED", "INTERVENTION_RECORDED", "HYPOTHESIS_DISPOSITION_RECORDED"])) if (belongs(event)) yield event; } };
+  }
+  return [...(events ?? [])].filter(belongs).sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+}
+
+function eliminatedHypothesis(previousDiagnostic, diagnostic) {
+  if (previousDiagnostic?.event !== "DIAGNOSTIC_CASE_RECORDED" || diagnostic.event !== "DIAGNOSTIC_CASE_RECORDED") return false;
+  const previous = previousDiagnostic.details?.hypotheses ?? [];
+  const current = diagnostic.details?.hypotheses ?? [];
+  const statements = new Set(current.map(hypothesis => `${hypothesis.statement}`.trim().toLowerCase()));
+  return previous.some(hypothesis => !current.some(candidate => candidate.id === hypothesis.id)
+    && !statements.has(`${hypothesis.statement}`.trim().toLowerCase()));
 }
 
 function failureStateByCycle(taskEvents) {
-  const surfaces = new Map();
-  const signatures = new Map();
+  const surfaces = ledgerGroupedSet();
+  const signatures = ledgerGroupedSet();
   const record = (cycle, details) => {
     if (!Number.isInteger(cycle)) cycle = Number(cycle) || 1;
-    if (!surfaces.has(cycle)) surfaces.set(cycle, new Set());
-    if (!signatures.has(cycle)) signatures.set(cycle, new Set());
     const requirement = details.requirement ?? details.id ?? details.checkId;
     if (!requirement) return;
     if (details.status === "failed" || details.status === "blocked") {
-      surfaces.get(cycle).add(requirement);
-      signatures.get(cycle).add(computeFailureSignature({
+      surfaces.add(cycle, requirement);
+      signatures.add(cycle, computeFailureSignature({
         requirement,
         status: details.status,
         exitCode: Number.isInteger(details.exitCode) ? details.exitCode : null,
@@ -44,13 +65,6 @@ function failureStateByCycle(taskEvents) {
     }
   };
   for (const event of taskEvents) {
-    if (event.event === "VERIFICATION_STARTED") {
-      const cycle = event.details?.verificationCycle;
-      if (Number.isInteger(cycle)) {
-        if (!surfaces.has(cycle)) surfaces.set(cycle, new Set());
-        if (!signatures.has(cycle)) signatures.set(cycle, new Set());
-      }
-    }
     if (event.event === "VERIFICATION_RECORDED") {
       record(event.details?.verificationCycle ?? 1, event.details ?? {});
     }
@@ -102,46 +116,45 @@ function snapshotHasContentDelta(previousDetails, currentDetails) {
     || differs(prev.evidence, cur.evidence);
 }
 
-export function buildInformationGainProjection(events, taskId) {
-  const taskEvents = (events ?? [])
-    .filter((event) => !taskId || !event.taskId || event.taskId === taskId)
-    .sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+function intervalKnowledge(taskEvents, previousDiagnostic, diagnostic) {
+  const intervalStart = previousDiagnostic ? previousDiagnostic.seq : -Infinity;
+  let hypothesisDispositionChanged = false;
+  const knownUpToPrev = ledgerRelationSet();
+  for (const event of taskEvents) {
+    if (event.event === "INTERVENTION_RECORDED" && previousDiagnostic && (event.seq ?? 0) <= previousDiagnostic.seq) {
+      const fingerprint = event.details?.interventionSemanticFingerprint
+        ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase();
+      if (fingerprint) knownUpToPrev.add(fingerprint);
+    }
+  }
+  let novelIntervention = false;
+  for (const event of intervalEvents(taskEvents, intervalStart, diagnostic.seq)) {
+    if (event.event === "HYPOTHESIS_DISPOSITION_RECORDED") hypothesisDispositionChanged = true;
+    if (event.event === "INTERVENTION_RECORDED") {
+    const fingerprint = event.details?.interventionSemanticFingerprint
+      ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase();
+    if (fingerprint && !knownUpToPrev.has(fingerprint)) novelIntervention = true;
+    }
+  }
+  return { hypothesisDispositionChanged, novelIntervention };
+}
 
-  const diagnosticEvents = diagnosticEventsForTask(taskEvents, taskId)
-    .sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
-  if (diagnosticEvents.length === 0) return [];
+function* iterateInformationGainProjection(events, taskId) {
+  const taskEvents = orderedTaskEvents(events, taskId);
+  const diagnosticEvents = { *[Symbol.iterator]() {
+    for (const event of taskEvents) {
+      if (["DIAGNOSTIC_CASE_RECORDED", "DIAGNOSIS_RECORDED"].includes(event.event)
+        && (!taskId || event.taskId === taskId)) yield event;
+    }
+  } };
 
   const failure = failureStateByCycle(taskEvents);
 
-  // Build final per-cycle entries first; effectiveGain is computed once at the
-  // end from fully final dimensions (no post-mutation anywhere).
-  const built = [];
   let previousDiagnostic = null;
+  let previousSnapshot = null;
   for (const diagnostic of diagnosticEvents) {
-    const intervalStart = previousDiagnostic ? previousDiagnostic.seq : -Infinity;
-    const interval = intervalEvents(taskEvents, intervalStart, diagnostic.seq);
-
-    const hypothesisDispositionChanged =
-      interval.some((event) => event.event === "HYPOTHESIS_DISPOSITION_RECORDED");
+    const { hypothesisDispositionChanged, novelIntervention } = intervalKnowledge(taskEvents, previousDiagnostic, diagnostic);
 
-    // Intervention deltas recognize only genuinely NEW semantic interventions:
-    // recorded after the previous diagnosis, attributed to the current
-    // correction cycle, and never attempted before. Repeating an already-known
-    // intervention — or merely having executed the previous cycle's corrective
-    // action — is not new information.
-    const knownUpToPrev = new Set(
-      taskEvents
-        .filter((event) => event.event === "INTERVENTION_RECORDED"
-          && (previousDiagnostic ? (event.seq ?? 0) <= previousDiagnostic.seq : false))
-        .map((event) => event.details?.interventionSemanticFingerprint
-          ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase())
-        .filter(Boolean),
-    );
-    const novelInInterval = interval
-      .filter((event) => event.event === "INTERVENTION_RECORDED")
-      .map((event) => event.details?.interventionSemanticFingerprint
-        ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase())
-      .filter((fingerprint) => fingerprint && !knownUpToPrev.has(fingerprint));
     // A genuinely new intervention counts as information only when the
     // diagnosis itself moves: an identical re-proposal of the previous
     // diagnosis after executing its already-known corrective action carries
@@ -149,18 +162,18 @@ export function buildInformationGainProjection(events, taskId) {
     const sameSemanticsAsPrevious = Boolean(previousDiagnostic)
       && !snapshotHasContentDelta(previousDiagnostic.details ?? {}, diagnostic.details ?? {});
     const interventionChanged = Boolean(previousDiagnostic)
-      && novelInInterval.length > 0
+      && novelIntervention
       && !sameSemanticsAsPrevious;
 
     const cycle = diagnostic.details?.verificationCycle ?? 1;
     const previousCycle = previousDiagnostic?.details?.verificationCycle ?? null;
-    const surface = [...(failure.surfaces.get(cycle) ?? new Set())].sort();
-    const signatures = [...(failure.signatures.get(cycle) ?? new Set())].sort();
+    const surface = [...(failure.surfaces.values(cycle))].sort();
+    const signatures = [...(failure.signatures.values(cycle))].sort();
     const previousSurface = previousCycle !== null && previousCycle !== undefined
-      ? [...(failure.surfaces.get(previousCycle) ?? new Set())].sort()
+      ? [...(failure.surfaces.values(previousCycle))].sort()
       : null;
     const previousSignatures = previousCycle !== null && previousCycle !== undefined
-      ? [...(failure.signatures.get(previousCycle) ?? new Set())].sort()
+      ? [...(failure.signatures.values(previousCycle))].sort()
       : null;
     const hasPreviousFailureState = previousSurface !== null;
     const failureSurfaceChanged = hasPreviousFailureState
@@ -181,7 +194,7 @@ export function buildInformationGainProjection(events, taskId) {
 
     const snapshot = snapshotFor(diagnostic);
 
-    built.push({
+    const entry = {
       verificationCycle: cycle,
       sequence: diagnostic.seq ?? null,
       diagnosticSequence: diagnostic.seq ?? null,
@@ -195,62 +208,53 @@ export function buildInformationGainProjection(events, taskId) {
         failureSurfaceChanged,
         interventionChanged,
         strategyChanged,
-        hypothesisEliminated: false,
+        hypothesisEliminated: eliminatedHypothesis(previousDiagnostic, diagnostic),
       },
       evidence: {
         semanticRefs: [...(snapshot.evidenceRefs ?? [])].sort(),
         surface, signatures, strategyFingerprint,
       },
-    });
-
+    };
+    const dimensions = compareDiagnosticCycles(previousSnapshot, snapshot, entry.dimensionsInput);
+    const classification = classifyGain(dimensions, { first: previousDiagnostic === null });
+    const effectiveGain = isEffectiveGain(dimensions, classification);
+    yield finalizeGainEntry(entry, { dimensions, classification, effectiveGain });
     previousDiagnostic = diagnostic;
+    previousSnapshot = snapshot;
   }
+}
 
-  // Hypothesis elimination: an id disappearing only counts as elimination when
-  // no surviving hypothesis carries the same normalized statement — ID-only
-  // churn is artificial novelty and must never create gain.
-  for (let i = 1; i < built.length; i++) {
-    if (built[i].sourceModel !== "STRUCTURED_DIAGNOSTIC_CASE_V1"
-      || built[i - 1].sourceModel !== "STRUCTURED_DIAGNOSTIC_CASE_V1") continue;
-    const previousHypotheses = diagnosticEvents[i - 1]?.details?.hypotheses ?? [];
-    const currentHypotheses = diagnosticEvents[i]?.details?.hypotheses ?? [];
-    const currentStatements = new Set(currentHypotheses.map(
-      (hypothesis) => `${hypothesis.statement}`.trim().toLowerCase()));
-    built[i].dimensionsInput.hypothesisEliminated = previousHypotheses.some((hypothesis) => {
-      const survivedById = currentHypotheses.some((candidate) => candidate.id === hypothesis.id);
-      return !survivedById
-        && !currentStatements.has(`${hypothesis.statement}`.trim().toLowerCase());
-    });
-  }
-
-  // Final classification + single-point effectiveGain computation.
-  const entries = computeInformationGain(built.map((entry) => ({
+function finalizeGainEntry(entry, { dimensions, classification, effectiveGain }) {
+  return Object.freeze({
     verificationCycle: entry.verificationCycle,
     sequence: entry.sequence,
-    snapshot: entry.snapshot,
-    context: entry.dimensionsInput,
-  })));
-
-  return built.map((entry, index) => {
-    const { dimensions, classification, effectiveGain } = entries[index];
-    return Object.freeze({
-      verificationCycle: entry.verificationCycle,
-      sequence: entry.sequence,
-      diagnosticSequence: entry.diagnosticSequence,
-      sourceModel: entry.sourceModel,
-      evidence: Object.freeze({
-        semanticRefs: Object.freeze(entry.evidence.semanticRefs),
-        failureSurface: Object.freeze(entry.evidence.surface),
-        failureSignatures: Object.freeze(entry.evidence.signatures),
-        strategyFingerprint: entry.evidence.strategyFingerprint,
-      }),
-      dimensions: Object.freeze({ ...dimensions }),
-      classification,
-      effectiveGain,
-    });
+    diagnosticSequence: entry.diagnosticSequence,
+    sourceModel: entry.sourceModel,
+    evidence: Object.freeze({
+      semanticRefs: Object.freeze(entry.evidence.semanticRefs),
+      failureSurface: Object.freeze(entry.evidence.surface),
+      failureSignatures: Object.freeze(entry.evidence.signatures),
+      strategyFingerprint: entry.evidence.strategyFingerprint,
+    }),
+    dimensions: Object.freeze({ ...dimensions }),
+    classification,
+    effectiveGain,
   });
 }
 
+export function buildInformationGainProjection(events, taskId) {
+  return [...iterateInformationGainProjection(events, taskId)];
+}
+
+/** Internal latest-only use does not retain all diagnostic result objects. */
+export function summarizeInformationGain(events, taskId, { verificationCycle = null } = {}) {
+  let latest = null;
+  for (const entry of iterateInformationGainProjection(events, taskId)) {
+    if (verificationCycle === null || verificationCycle === undefined || entry.verificationCycle === verificationCycle) latest = entry;
+  }
+  return evaluateStructuredDiagnosticStall(latest ? [latest] : []);
+}
+
 // One canonical structured-stall policy (fail-fast):
 //   The latest comparable diagnostic state that produces no effective
 //   information gain is stalled and may not trigger another blind correction

package/src/core/inspect.js

@@ -17,6 +17,8 @@ import { evaluateProgress } from "./progress.js";
 import { readEvents } from "./events.js";
 import { taskStructuralQualityDirectory } from "./task-paths.js";
 import { projectStructuralQualityStatus } from "./structural-quality/status.js";
+import { operationalArtifactExists } from "../storage/operational-context.js";
+import { withProjectReadSnapshot } from "../storage/project-read-snapshot.js";
 
 function reasonCodesFor({ state, trace, progress }) {
   const codes = [];
@@ -169,7 +171,15 @@ function profileMetadata(bytes) {
 
 import { taskArtifactPath } from "./task-paths.js";
 
-export async function inspectTarget({ target, packageRoot, contractFile = null, authorityContext, runtimeContext, taskId = null, stateFile = null } = {}) {
+async function inspectStatePresence(target, relativePath) {
+  return operationalArtifactExists(target, relativePath) ?? await fileExists(ensureWithin(target, relativePath));
+}
+
+export async function inspectTarget(options = {}) {
+  return withProjectReadSnapshot(options.target, () => inspectSelectedTarget(options));
+}
+
+async function inspectSelectedTarget({ target, packageRoot, contractFile = null, authorityContext, runtimeContext, taskId = null, stateFile = null } = {}) {
   let manifest = null;
   let manifestError = null;
   try {
@@ -184,8 +194,7 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
     ? { ...profileMetadata(await readBytes(profilePath)), path: profileRelativePath }
     : { mode: null, status: null };
   const effectiveStateRel = stateFile ?? (taskId ? taskArtifactPath(taskId, "state") : WORK_STATE_PATH);
-  const statePath = ensureWithin(target, effectiveStateRel);
-  const statePresent = await fileExists(statePath);
+  const statePresent = await inspectStatePresence(target, effectiveStateRel);
   const classifiedState = await readAndClassifyWorkState({ target, packageRoot, contractFile, taskId, stateFile: effectiveStateRel });
   const rawState = classifiedState?.state ?? null;
   const taskInfo = taskId ? await findTaskById(target, taskId, packageRoot) : null;

package/src/core/integration-invocation-policy.js

@@ -1,3 +1,4 @@
+import { getStorageCapabilities } from "../storage/capabilities.js";
 import { CLI_COMMAND_DEFINITIONS } from "./cli-command-definitions.js";
 import { COMMAND_EXECUTORS } from "./command-executors.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
@@ -24,6 +25,7 @@ export const INTEGRATION_RISK_CLASSES = Object.freeze({
 });
 
 const READ_ONLY_COMMANDS = Object.freeze(new Set([
+  "storage-migration-status",
   "protocol-info", "decision-status", "decision-show", "context-plan", "model-route", "semantic-plan", "test-inventory", "status", "next", "continuity", "reconcile-continuity",
   "task-list", "task-show", "task-lock-status", "progress", "audit", "report",
   "inspect", "validate-state", "validate-protocol", "validate-receipt",
@@ -69,6 +71,13 @@ const STATIC_RISK_CLASSES = Object.freeze({
   "usage-record": INTEGRATION_RISK_CLASSES.LOOP_MUTATION,
   init: INTEGRATION_RISK_CLASSES.MAINTENANCE,
   update: INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-migration-resume": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-rollback-resume": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-rollback": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-migrate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-backup": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-restore": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "storage-restore-resume": INTEGRATION_RISK_CLASSES.MAINTENANCE,
   activate: INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "task-migrate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "migrate-protocol": INTEGRATION_RISK_CLASSES.MAINTENANCE,
@@ -143,6 +152,7 @@ export function getForgeLoopCapabilities({ packageVersion = null } = {}) {
     integrationApiVersion: FORGELOOP_INTEGRATION_RUNTIME_VERSION,
     executorParity: Object.keys(COMMAND_EXECUTORS).length === Object.keys(CLI_COMMAND_DEFINITIONS).length,
     features: {
+      operationalStorage: getStorageCapabilities(),
       taskClaimRecovery: {
         version: 1,
         durableRecoveryState: true,

package/src/core/integration-resources.js

@@ -1,7 +1,9 @@
 import path from "node:path";
+import { withProjectStorage } from "../storage/project-boundary.js";
+import { withProjectReadSnapshot } from "../storage/project-read-snapshot.js";
 import { runProtocolInfo } from "../commands/protocol-info.js";
 import { readContract } from "./contract.js";
-import { discoverTasks } from "./task-discovery.js";
+import { discoverTaskSummaries } from "./task-discovery.js";
 import { resolveTaskClaimState } from "./task-claim-state.js";
 import { runStatus } from "../commands/status.js";
 import { runContinuity } from "../commands/continuity.js";
@@ -10,11 +12,11 @@ import { listApprovals } from "./approvals.js";
 import { buildTrajectoryMetrics } from "./trajectory-metrics.js";
 import { loadCapabilityPolicy } from "./capability-policy.js";
 import { readdir } from "node:fs/promises";
-import { readJsonArtifact } from "./artifacts.js";
+import { getOperationalStore, listOperationalArtifactNames } from "../storage/operational-context.js";
+import { readJsonArtifact, parseCapturedJsonArtifact } from "./artifacts.js";
 import { taskDirectory } from "./task-paths.js";
 import { resolveWorkspaceBindingStatus } from "./workspace-binding.js";
-import { listCanonicalHandoffs } from "./handoff.js";
-import { readHandoffAcceptanceLedger, resolveHandoffAcceptance } from "./handoff-acceptance.js";
+import { runHandoffList } from "../commands/handoff-list.js";
 import { resolveResponsibilityStatus } from "./responsibility.js";
 import { readVerificationScope } from "./verification-scope.js";
 import { resolveAttestationStatus } from "./attestation.js";
@@ -118,6 +120,12 @@ function ownershipProjection(projection) {
   };
 }
 
+async function resourceArtifactNames(projectPath, taskId, kind, directory) {
+  const names = listOperationalArtifactNames(projectPath, taskId, kind);
+  if (names !== null) return names;
+  try { return await readdir(directory); } catch { return []; }
+}
+
 async function readForgeLoopIntegrationResourceCore(uri, {
   projectPath = ".",
   packageRoot = undefined,
@@ -135,13 +143,8 @@ async function readForgeLoopIntegrationResourceCore(uri, {
 
   if (uri === "protocol/info") return { uri, data: await runProtocolInfo({ packageVersion }) };
   if (uri === "project/tasks") {
-    const tasks = await discoverTasks(projectPath, packageRoot);
-    return { uri, data: { count: tasks.length, tasks: tasks.map((task) => ({
-      taskId: task.taskId,
-      healthy: task.healthy !== false,
-      phase: task.phase ?? null,
-      mutationAllowed: task.mutationAllowed !== false,
-    })) } };
+    const tasks = await discoverTaskSummaries(projectPath, packageRoot);
+    return { uri, data: { count: tasks.length, tasks } };
   }
   if (TASK_RESOURCE_URIS.has(uri) && (typeof taskId !== "string" || !taskId)) {
     const error = new Error(`Resource ${uri} requires a taskId`);
@@ -164,27 +167,7 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     return { uri, taskId, data: await resolveWorkspaceBindingStatus(projectPath, { packageRoot, taskId }) };
   }
   if (uri === "task/handoffs") {
-    const handoffs = await listCanonicalHandoffs(projectPath, { packageRoot, taskId });
-    const ledger = await readHandoffAcceptanceLedger(projectPath, packageRoot, { taskId });
-    const projectedHandoffs = handoffs.map((handoff) => {
-      const resolved = resolveHandoffAcceptance({
-        events: ledger.events,
-        handoff,
-        ledgerValid: ledger.valid,
-        ledgerErrors: ledger.errors,
-      });
-      return {
-        ...handoff,
-        acceptance: {
-          status: resolved.status,
-          consumerId: resolved.consumerId ?? null,
-          harness: resolved.harness ?? null,
-          acceptedAt: resolved.acceptedAt ?? null,
-          ...(resolved.reasonCodes ? { reasonCodes: [...resolved.reasonCodes] } : {}),
-        },
-      };
-    });
-    return { uri, taskId, data: { taskId, count: projectedHandoffs.length, handoffs: projectedHandoffs } };
+    return { uri, taskId, data: await runHandoffList({ target: projectPath, packageRoot, taskId }) };
   }
   if (uri === "task/responsibility") {
     return { uri, taskId, data: await resolveResponsibilityStatus(projectPath, { packageRoot, taskId }) };
@@ -229,7 +212,7 @@ async function readForgeLoopIntegrationResourceCore(uri, {
   }
   if (uri === "task/evaluations") {
     const dir = path.join(projectPath, taskDirectory(taskId), "evaluations");
-    let names = []; try { names = await readdir(dir); } catch { /* absent is an empty projection */ }
+    const names = await resourceArtifactNames(projectPath, taskId, "evaluations", dir);
     const evaluations = [];
     for (const name of names.filter((entry) => /^eval-[A-Za-z0-9_-]+\.json$/.test(entry)).sort()) {
       evaluations.push((await readJsonArtifact(projectPath, `${taskDirectory(taskId)}/evaluations/${name}`, "trajectory-evaluation", packageRoot)).value);
@@ -237,8 +220,13 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     return { uri, taskId, data: { evaluations } };
   }
   if (uri === "task/decisions") {
+    const store = getOperationalStore(projectPath);
+    if (store) {
+      const decisions = await readCapturedDecisions(store, taskId, packageRoot);
+      return { uri, taskId, data: { taskId, decisions } };
+    }
     const dir = path.join(projectPath, taskDirectory(taskId), "decisions");
-    let names = []; try { names = await readdir(dir); } catch { /* absent is an empty projection */ }
+    const names = await resourceArtifactNames(projectPath, taskId, "decisions", dir);
     const decisions = [];
     for (const name of names.filter((entry) => /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}\.json$/.test(entry)).sort()) {
       decisions.push((await readJsonArtifact(projectPath, `${taskDirectory(taskId)}/decisions/${name}`, "semantic-decision", packageRoot)).value);
@@ -297,6 +285,15 @@ async function readForgeLoopIntegrationResourceCore(uri, {
 }
 
 export async function readForgeLoopIntegrationResource(uri, options = {}) {
+  const target = options.projectPath ?? ".";
+  const read = () => readSelectedIntegrationResource(uri, options);
+  // Decisions capture their finite catalog and bytes synchronously; other
+  // task projections retain the complete committed project snapshot.
+  return withProjectStorage(target, () => TASK_RESOURCE_URIS.has(uri) && uri !== "task/decisions"
+    ? withProjectReadSnapshot(target, read) : read(), { readOnly: true, runtimeContext: options.runtimeContext });
+}
+
+async function readSelectedIntegrationResource(uri, options) {
   if (uri === "task/audit-view") {
     if (typeof options.taskId !== "string" || !options.taskId) {
       const error = new Error("Resource task/audit-view requires a taskId"); error.code = "E_TASK_REQUIRED"; throw error;
@@ -328,3 +325,13 @@ export async function readForgeLoopIntegrationResource(uri, options = {}) {
   }
   return readForgeLoopIntegrationResourceCore(uri, options);
 }
+
+
+async function readCapturedDecisions(store, taskId, packageRoot) {
+  const decisions = [];
+  for (const entry of store.captureDecisionTexts(taskId)) {
+    if (entry.error) throw entry.error;
+    decisions.push((await parseCapturedJsonArtifact(entry.text, entry.relativePath, "semantic-decision", packageRoot)).value);
+  }
+  return decisions;
+}