@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.4

package/src/core/reflection.js

@@ -1,7 +1,9 @@
+import { ledgerEventsOfTypes } from "./ledger-event-collection.js";
+import { ledgerRelationMap, ledgerRelationSet, ledgerGroupedSet } from "./ledger-relations.js";
 import { buildTaskTrace } from "./trace.js";
 import { readEvents } from "./events.js";
 import { findTaskById } from "./task-discovery.js";
-import { projectHypothesisStates } from "./hypothesis-projection.js";
+import { projectHypothesisStates, summarizeOpenHypotheses } from "./hypothesis-projection.js";
 import {
   buildInformationGainProjection,
   evaluateStructuredDiagnosticStall,
@@ -64,11 +66,9 @@ export function evaluateInterventionEffectiveness(trace, surfacesByCycle) {
 }
 
 function failedRequirementSurfacesFromEvents(events = [], state = null) {
-  const byCycle = new Map();
+  const byCycle = ledgerGroupedSet();
   const record = (cycle, requirement) => {
-    if (!requirement) return;
-    if (!byCycle.has(cycle)) byCycle.set(cycle, new Set());
-    byCycle.get(cycle).add(requirement);
+    if (requirement) byCycle.add(cycle, requirement);
   };
   for (const event of events) {
     if (event.event !== "VERIFICATION_RECORDED") continue;
@@ -95,88 +95,83 @@ function signatureSetsByCycle(trace) {
   return byCycle;
 }
 
-export function deriveDiagnosticContext(events = [], state = null) {
-  const cycle = state?.verificationCycle ?? null;
-  const taskEvents = events.filter((event) => !state?.taskId || event.taskId === state.taskId);
-
-  // Canonical failure-signature hashes for the active verification cycle.
-  const activeFailureSignatures = [...new Set(
-    taskEvents
-      .filter((event) => event.event === "VERIFICATION_RECORDED"
-        && ["failed", "blocked"].includes(event.details?.status)
-        && (cycle === null || event.details?.verificationCycle === cycle))
-      .map((event) => {
-        const d = event.details;
-        return computeFailureSignature({
-          requirement: d.requirement ?? d.id ?? d.checkId,
-          status: d.status,
-          exitCode: Number.isInteger(d.exitCode) ? d.exitCode : null,
-          failureToken: typeof d.failureToken === "string" && d.failureToken
-            ? d.failureToken
-            : (typeof d.details?.failureToken === "string" ? d.details.failureToken : null),
-        });
-      }),
-  )].sort();
-
-  const activeFailedRequirements = [...new Set(
-    [
-      ...taskEvents
-        .filter((event) => event.event === "VERIFICATION_RECORDED"
-          && ["failed", "blocked"].includes(event.details?.status)
-          && (cycle === null || event.details?.verificationCycle === cycle))
-        .map((event) => event.details?.requirement ?? event.details?.id ?? event.details?.checkId),
-      ...((state?.checks ?? []))
-        .filter((check) => ["failed", "blocked"].includes(check.status)
-          && (cycle === null || check.details?.verificationCycle === cycle))
-        .map((check) => check.requirement ?? check.id ?? check.checkId),
-    ].filter(Boolean),
-  )].sort();
+function* contextEvents(events, types, taskId) {
+  for (const event of ledgerEventsOfTypes(events, types)) if (!taskId || event.taskId === taskId) yield event;
+}
 
-  const projection = projectHypothesisStates(taskEvents);
-  const openHypotheses = [...projection.openHypotheses].sort();
+function contextFailureSignature(details) {
+  return computeFailureSignature({ requirement: details.requirement ?? details.id ?? details.checkId,
+    status: details.status, exitCode: Number.isInteger(details.exitCode) ? details.exitCode : null,
+    failureToken: typeof details.failureToken === "string" && details.failureToken
+      ? details.failureToken : (typeof details.details?.failureToken === "string" ? details.details.failureToken : null) });
+}
 
-  const interventions = taskEvents.filter((event) => event.event === "INTERVENTION_RECORDED");
-  const latestIntervention = interventions.at(-1)?.details?.intervention?.id ?? null;
+function activeFailure(details, cycle, observedCycle) {
+  return ["failed", "blocked"].includes(details?.status) && (cycle === null || observedCycle === cycle);
+}
 
-  // doNotRepeat requires semantic repetition AND at least two completed
-  // post-intervention verification cycles AND unchanged failure surface.
-  const surfacesByCycle = failedRequirementSurfacesFromEvents(taskEvents, state);
-  const completedCycles = [...new Set(
-    taskEvents.filter((event) => event.event === "VERIFICATION_STARTED")
-      .map((event) => event.details?.verificationCycle)
-      .filter(Number.isInteger),
-  )].sort((a, b) => a - b);
+function activeContextFailures(events, state, cycle) {
+  const signatures = new Set();
+  const requirements = new Set();
+  for (const event of contextEvents(events, ["VERIFICATION_RECORDED"], state?.taskId)) {
+    const details = event.details;
+    if (!activeFailure(details, cycle, details?.verificationCycle)) continue;
+    signatures.add(contextFailureSignature(details));
+    const requirement = details.requirement ?? details.id ?? details.checkId;
+    if (requirement) requirements.add(requirement);
+  }
+  for (const check of state?.checks ?? []) {
+    if (!activeFailure(check, cycle, check.details?.verificationCycle)) continue;
+    const requirement = check.requirement ?? check.id ?? check.checkId;
+    if (requirement) requirements.add(requirement);
+  }
+  return { activeFailureSignatures: [...signatures].sort(), activeFailedRequirements: [...requirements].sort() };
+}
 
-  const fingerprintGroups = new Map();
-  for (const event of interventions) {
+function contextInterventions(events, taskId) {
+  const groups = ledgerRelationMap();
+  const lastCycles = ledgerRelationMap();
+  const invalidCycles = ledgerRelationSet();
+  let latestIntervention = null;
+  for (const event of contextEvents(events, ["INTERVENTION_RECORDED"], taskId)) {
+    latestIntervention = event.details?.intervention?.id ?? null;
     const fingerprint = event.details?.interventionSemanticFingerprint;
     if (!fingerprint) continue;
-    if (!fingerprintGroups.has(fingerprint)) fingerprintGroups.set(fingerprint, []);
-    fingerprintGroups.get(fingerprint).push(event);
+    groups.set(fingerprint, (groups.get(fingerprint) ?? 0) + 1);
+    const cycle = Number(event.details?.verificationCycle ?? 1);
+    if (!Number.isFinite(cycle)) invalidCycles.add(fingerprint);
+    else lastCycles.set(fingerprint, Math.max(lastCycles.get(fingerprint) ?? -Infinity, cycle));
   }
+  return { groups, lastCycles, invalidCycles, latestIntervention };
+}
 
+export function deriveDiagnosticContext(events = [], state = null) {
+  const cycle = state?.verificationCycle ?? null;
+  const failures = activeContextFailures(events, state, cycle);
+  const openHypotheses = summarizeOpenHypotheses(events, state?.taskId).sort();
+  const relevant = { *[Symbol.iterator]() {
+    yield* contextEvents(events, ["VERIFICATION_RECORDED"], state?.taskId);
+  } };
+  const surfacesByCycle = failedRequirementSurfacesFromEvents(relevant, state);
+  const cycles = new Set();
+  for (const event of contextEvents(events, ["VERIFICATION_STARTED"], state?.taskId)) {
+    if (Number.isInteger(event.details?.verificationCycle)) cycles.add(event.details.verificationCycle);
+  }
+  const completedCycles = [...cycles].sort((a, b) => a - b);
+  const { groups, lastCycles, invalidCycles, latestIntervention } = contextInterventions(events, state?.taskId);
   const doNotRepeat = [];
-  for (const [fingerprint, group] of fingerprintGroups.entries()) {
-    if (group.length < 2) continue;
-    const lastInterventionCycle = Math.max(...group.map((event) => event.details?.verificationCycle ?? 1));
-    const postCycles = completedCycles.filter((completed) => completed > lastInterventionCycle);
-    if (postCycles.length < 2) continue;
-    const firstSurface = [...(surfacesByCycle.get(lastInterventionCycle) ?? [])].sort();
-    const latestSurface = [...(surfacesByCycle.get(postCycles.at(-1)) ?? [])].sort();
-    if (JSON.stringify(firstSurface) === JSON.stringify(latestSurface)) {
-      doNotRepeat.push(fingerprint);
-    }
+  for (const [fingerprint, countOfInterventions] of groups) {
+    if (countOfInterventions < 2 || invalidCycles.has(fingerprint)) continue;
+    const lastCycle = lastCycles.get(fingerprint);
+    let count = 0;
+    let latestCycle = null;
+    for (const completed of completedCycles) if (completed > lastCycle) { count++; latestCycle = completed; }
+    if (count < 2) continue;
+    const firstSurface = [...(surfacesByCycle.values(lastCycle))].sort();
+    const latestSurface = [...(surfacesByCycle.values(latestCycle))].sort();
+    if (JSON.stringify(firstSurface) === JSON.stringify(latestSurface)) doNotRepeat.push(fingerprint);
   }
-  doNotRepeat.sort();
-
-  return {
-    activeFailureSignatures,
-    activeFailedRequirements,
-    openHypotheses,
-    latestIntervention,
-    nextExperiment: null,
-    doNotRepeat,
-  };
+  return { ...failures, openHypotheses, latestIntervention, nextExperiment: null, doNotRepeat: doNotRepeat.sort() };
 }
 
 export async function buildTaskReflection({ target, packageRoot, taskId = null } = {}) {

package/src/core/responsibility.js

@@ -10,7 +10,9 @@ import { resolveTaskClaimState } from "./task-claim-state.js";
 import { normalizeWriteClaims } from "./task-scope.js";
 import { taskResponsibilityPath } from "./task-paths.js";
 import { ensureWithin, fileExists } from "./filesystem.js";
-import { appendProtocolEvent } from "./events.js";
+import { getOperationalStore, operationalArtifactExists } from "../storage/operational-context.js";
+import { withNativeReadScope } from "./native-storage.js";
+import { appendProtocolEvent, withEventLedgerAudit } from "./events.js";
 import { withTaskTransaction } from "./transaction.js";
 import { assertTaskMutationAllowed } from "./task-claim-state.js";
 import { assertWorkspaceBinding } from "./workspace-binding.js";
@@ -118,17 +120,19 @@ export async function validateResponsibilityContract(value, packageRoot = getPac
 }
 
 export async function readResponsibility(target, { taskId, packageRoot = getPackageRoot() } = {}) {
-  const relativePath = taskResponsibilityPath(taskId);
-  if (!(await fileExists(ensureWithin(target, relativePath)))) return null;
-  try {
-    const artifact = await readJsonArtifact(target, relativePath, "responsibility", packageRoot);
-    const value = await validateResponsibilityContract(artifact.value, packageRoot);
-    if (value.taskId !== taskId) throw responsibilityError("E_RESPONSIBILITY_INVALID", "Responsibility taskId does not match its task namespace", [relativePath]);
-    return { ...artifact, value };
-  } catch (error) {
-    if (error.code === "E_RESPONSIBILITY_INVALID") throw error;
-    throw responsibilityError("E_RESPONSIBILITY_INVALID", `Responsibility contract is invalid: ${error.message}`, [relativePath]);
-  }
+  return withNativeReadScope(target, async () => {
+    const relativePath = taskResponsibilityPath(taskId);
+    if (!(operationalArtifactExists(target, relativePath) ?? await fileExists(ensureWithin(target, relativePath)))) return null;
+    try {
+      const artifact = await readJsonArtifact(target, relativePath, "responsibility", packageRoot);
+      const value = await validateResponsibilityContract(artifact.value, packageRoot);
+      if (value.taskId !== taskId) throw responsibilityError("E_RESPONSIBILITY_INVALID", "Responsibility taskId does not match its task namespace", [relativePath]);
+      return { ...artifact, value };
+    } catch (error) {
+      if (error.code === "E_RESPONSIBILITY_INVALID") throw error;
+      throw responsibilityError("E_RESPONSIBILITY_INVALID", `Responsibility contract is invalid: ${error.message}`, [relativePath]);
+    }
+  });
 }
 
 async function currentResponsibilityInputs(target, { taskId, packageRoot }) {
@@ -173,6 +177,14 @@ export function validateResponsibilityChecks(responsibility, state) {
 }
 
 export async function resolveResponsibilityStatus(target, { taskId, packageRoot = getPackageRoot() } = {}) {
+  const read = () => resolveLoadedResponsibilityStatus(target, { taskId, packageRoot });
+  return withNativeReadScope(target, () => {
+    if (getOperationalStore(target)) return withEventLedgerAudit(target, packageRoot, { taskId }, read);
+    return read();
+  });
+}
+
+async function resolveLoadedResponsibilityStatus(target, { taskId, packageRoot }) {
   const artifact = await readResponsibility(target, { taskId, packageRoot });
   if (!artifact) return { status: "NOT_APPLICABLE", taskId, path: taskResponsibilityPath(taskId), responsibility: null, errors: [] };
   let inputs;
@@ -245,7 +257,7 @@ export async function setResponsibilityContract(target, options = {}) {
   return withTaskTransaction({ target, taskId, packageRoot, operation: "responsibility-set", recordCommitEvent: true }, async () => {
     await assertTaskMutationAllowed(target, { taskId, packageRoot });
     await assertWorkspaceBinding(target, { taskId, packageRoot, operation: "responsibility-set" });
-    if (await fileExists(ensureWithin(target, relativePath))) {
+    if (operationalArtifactExists(target, relativePath) ?? await fileExists(ensureWithin(target, relativePath))) {
       throw responsibilityError("E_RESPONSIBILITY_INVALID", "Responsibility contract is immutable during a pass", [relativePath]);
     }
     const state = await readWorkState(target, { packageRoot, taskId });

package/src/core/route-artifact.js

@@ -4,17 +4,24 @@ import { readContract } from "./contract.js";
 import { ensureResumableState, synchronizePersistedRouteState } from "./resumability.js";
 import { readWorkState } from "./work-state.js";
 import { taskArtifactPath } from "./task-paths.js";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 
 
 export async function persistRoute(target, route, packageRoot, options = {}) {
+  if (!options.taskId) return persistRouteInTransaction(target, route, packageRoot, options);
+  return withTaskTransaction({ target, taskId: options.taskId, packageRoot, operation: "route" }, () => persistRouteInTransaction(target, route, packageRoot, options));
+}
+
+async function persistRouteInTransaction(target, route, packageRoot, options) {
   assertRouteInvariants(route);
-  const { contractFingerprint, ...writeOptions } = options;
+  const { contractFingerprint: suppliedFingerprint, ...writeOptions } = options;
+  let contractFingerprint = suppliedFingerprint;
   let contractArtifact = null;
-  if (contractFingerprint === undefined) {
+  if (contractFingerprint === undefined || !options.taskId) {
     try {
       contractArtifact = await readContract(target, packageRoot, options);
-      contractFingerprint = contractArtifact.fingerprint;
+      if (contractFingerprint === undefined) contractFingerprint = contractArtifact.fingerprint;
     } catch (error) {
       if (error.code !== "ARTIFACT_MISSING") throw error;
     }
@@ -24,6 +31,9 @@ export async function persistRoute(target, route, packageRoot, options = {}) {
     : { ...route, contractFingerprint };
   assertRouteInvariants(value);
   const taskId = options.taskId ?? contractArtifact?.value?.taskId ?? null;
+  if (taskId && !(await getTaskTransaction(target))) {
+    return withTaskTransaction({ target, taskId, packageRoot, operation: "route" }, () => persistRouteInTransaction(target, route, packageRoot, { ...options, taskId }));
+  }
   let existingState = null;
   if (taskId) {
     try {

package/src/core/runtime-context.js

@@ -1,3 +1,4 @@
+import { attachStorageConnectionOwner } from "./storage-runtime-registry.js";
 import {
   E_VERIFICATION_ISOLATION_UNAVAILABLE,
   isVerificationExecutionAdapter,
@@ -220,5 +221,9 @@ export function createForgeLoopContext(options = {}) {
   if (options?.securityReviewProviders !== undefined) {
     configureSecurityReviewProviders(context, options.securityReviewProviders);
   }
+  if (options?.persistentStorage !== undefined && typeof options.persistentStorage !== "boolean") {
+    throw Object.assign(new Error("persistentStorage must be a boolean"), { code: "E_STORAGE_RUNTIME_CONFIGURATION_INVALID" });
+  }
+  if (options?.persistentStorage === true) context.close = attachStorageConnectionOwner(context);
   return Object.freeze(context);
 }

package/src/core/schema-validation.js

@@ -123,7 +123,6 @@ function validate(value, schema, location, errors, rootSchema = schema) {
       return candidateErrors.length === 0;
     });
     if (matches.length !== 1) errors.push(`${location}: expected exactly one matching schema`);
-    return;
   }
 
   if (schema.type && !typeMatches(value, schema.type)) {
@@ -213,6 +212,12 @@ export async function readSchema(name, packageRoot = getPackageRoot()) {
   return schema;
 }
 
+function schemaHealthVersion(schema, name) {
+  const versions = schema?.properties?.schemaVersion?.enum ?? null;
+  const version = schema?.properties?.schemaVersion?.const ?? (name === "task-bundle" && JSON.stringify(versions) === "[1,2]" ? 2 : null);
+  return version;
+}
+
 export async function inspectSchemaHealth(packageRoot = getPackageRoot()) {
   const schemas = [];
   for (const name of SHIPPED_SCHEMA_NAMES) {
@@ -223,13 +228,13 @@ export async function inspectSchemaHealth(packageRoot = getPackageRoot()) {
       assertJsonBytes(bytes, filename);
       const schema = JSON.parse(bytes.toString("utf8"));
       assertJsonLimits(schema, filename);
-      const version = schema?.properties?.schemaVersion?.const ?? null;
+      const version = schemaHealthVersion(schema, name);
       let status = "valid";
       let error = null;
       if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
         status = "invalid";
         error = "schema root must be an object";
-      } else if (version !== 1) {
+      } else if (version !== 1 && !(name === "task-bundle" && version === 2)) {
         status = "unsupported-version";
         error = `schemaVersion ${version ?? "missing"} is not supported`;
       }

package/src/core/settlement.js

@@ -1,3 +1,4 @@
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 import { readContract } from "./contract.js";
 import { appendProtocolEvent, validateEventLedger } from "./events.js";
 import {
@@ -18,7 +19,17 @@ export {
   normalizeDecisionText,
 };
 
-export async function recordDecisionCriterion({
+export async function recordDecisionCriterion(options) {
+  normalizeDecisionCriterionInput(options);
+  if (await getTaskTransaction(options.target)) return recordCriterion(options);
+  const contract = await readContract(options.target, options.packageRoot, { taskId: options.taskId, contractPath: options.contractPath });
+  const taskId = options.taskId ?? contract?.value?.taskId;
+  if (!taskId) return recordCriterion(options);
+  return withTaskTransaction({ target: options.target, packageRoot: options.packageRoot,
+    taskId, operation: "record-decision-criterion" }, () => recordCriterion({ ...options, taskId }));
+}
+
+async function recordCriterion({
   target,
   packageRoot,
   decision,

package/src/core/signing/bundle-file.js

@@ -0,0 +1,53 @@
+import { isOperationalArtifactPath, needsExistingProjectScope, withExistingProjectScope } from "../../storage/existing-project-scope.js";
+import { constants } from "node:fs";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { assertSafePath, ensureWithin } from "../filesystem.js";
+import { getOperationalStore, readOperationalText } from "../../storage/operational-context.js";
+import { signatureReferenceId } from "./bundle-reference.js";
+
+/** External signing finishes before immutable bytes enter the prepared commit. */
+export async function withSigningBundleFile(target, destinationPath, statementPath, callback) {
+  if (await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => withSigningBundleFile(target, destinationPath, statementPath, callback));
+  }
+  const store = getOperationalStore(target);
+  if (!store) {
+    if (isOperationalArtifactPath(destinationPath)) throw Object.assign(new Error("Operational signature bundles require canonical SQLite preparation"), { code: "E_STORAGE_OPERATION_UNSUPPORTED" });
+    await assertSafePath(target, destinationPath);
+    await callback(ensureWithin(target, destinationPath));
+    return { path: destinationPath };
+  }
+  const transaction = store.transaction;
+  if (!transaction || store.db.isTransaction) {
+    throw Object.assign(new Error("SQLite signing requires an active preparation outside the native writer"), { code: "E_ATTESTATION_SIGNATURE_INVALID" });
+  }
+  const source = readOperationalText(target, statementPath);
+  if (!source.selected || source.text === null) {
+    throw Object.assign(new Error("SQLite signing requires a canonical statement"), { code: "E_ATTESTATION_STATEMENT_INVALID" });
+  }
+  const directory = await mkdtemp(path.join(os.tmpdir(), "forgeloop-signing-bundle-"));
+  try {
+    const filename = path.join(directory, "bundle.json");
+    await callback(filename);
+    if (readOperationalText(target, statementPath).text !== source.text) {
+      throw Object.assign(new Error("Canonical statement changed during signing"), { code: "E_ATTESTATION_STATEMENT_INVALID" });
+    }
+    let handle;
+    try {
+      await assertSafePath(directory, "bundle.json");
+      handle = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+    } catch {
+      throw Object.assign(new Error("Signer did not produce a safe signature bundle"), { code: "E_ATTESTATION_SIGNATURE_INVALID" });
+    }
+    try {
+      if (!(await handle.stat()).isFile()) throw new Error("Signer output must be a regular file");
+      const attachment = await transaction.stageAttachment({
+        referenceId: signatureReferenceId(source.text),
+        readable: handle.createReadStream({ autoClose: false }),
+      });
+      return { path: attachment.path, attachment };
+    } finally { await handle.close(); }
+  } finally { await rm(directory, { recursive: true, force: true }); }
+}

package/src/core/signing/bundle-reference.js

@@ -0,0 +1,15 @@
+import { createHash, randomUUID } from "node:crypto";
+
+/** Bind signature discovery to the exact statement bytes, not mutable filenames. */
+export function signatureReferencePrefix(statementText) {
+  return `sigstore:${createHash("sha256").update(statementText, "utf8").digest("hex")}:`;
+}
+
+export function signatureReferenceId(statementText) {
+  return `${signatureReferencePrefix(statementText)}${randomUUID()}`;
+}
+
+/** Historical logical paths remain addressable without changing ledger bytes. */
+export function legacyAttachmentReferenceId(relativePath) {
+  return `legacy-path:${createHash("sha256").update(relativePath, "utf8").digest("hex")}`;
+}

package/src/core/signing/sigstore.js

@@ -1,13 +1,30 @@
+import { needsExistingProjectScope, withExistingProjectScope } from "../../storage/existing-project-scope.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
 import path from "node:path";
 import { ensureWithin, assertSafePath } from "../filesystem.js";
+import { withSigningStatementFile } from "./statement-file.js";
+import { withSigningBundleFile } from "./bundle-file.js";
+import { getOperationalStore } from "../../storage/operational-context.js";
+import { withOperationalAttachmentFile } from "../../storage/operational-attachments.js";
 
 const execFileAsync = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
 
+async function withExistingSigningReadScope(target, read) {
+  if (await needsExistingProjectScope(target)) return withExistingProjectScope(target, read, { readOnly: true });
+  return read();
+}
+
+function signingTaskId(target, statementPath) {
+  const store = getOperationalStore(target);
+  const taskKey = /^\.forgeloop\/task-state\/([a-f0-9]{64})\/attestations\/statement\.json$/u.exec(statementPath)?.[1];
+  const taskId = store && taskKey ? store.taskRow(taskKey)?.task_id : null;
+  return taskId;
+}
+
 export function createSigstoreSigningProvider({
   command = "cosign",
   execFileImpl = execFileAsync,
@@ -21,7 +38,7 @@ export function createSigstoreSigningProvider({
     killSignal: "SIGTERM",
     maxBuffer: MAX_OUTPUT_BYTES,
   });
-  return {
+  const provider = {
     name: "sigstore",
     async detect() {
       try {
@@ -43,13 +60,13 @@ export function createSigstoreSigningProvider({
       try {
         await assertSafePath(target, statementPath);
         await assertSafePath(target, destinationPath);
-        await run([
+        const signed = await withSigningBundleFile(target, destinationPath, statementPath, bundleAbsolute => withSigningStatementFile(target, statementPath, statementAbsolute => run([
           "attest-blob",
-          "--statement", ensureWithin(target, statementPath),
-          "--bundle", ensureWithin(target, destinationPath),
+          "--statement", statementAbsolute,
+          "--bundle", bundleAbsolute,
           "--yes",
-        ], { cwd: path.resolve(target) });
-        return { status: "VALID", path: destinationPath };
+        ], { cwd: path.resolve(target) })));
+        return { status: "VALID", ...signed };
       } catch (error) {
         const unavailable = error.code === "ENOENT" || error.cause?.code === "ENOENT";
         const timedOut = error.code === "ETIMEDOUT" || error.killed === true || error.signal === "SIGTERM";
@@ -67,33 +84,42 @@ export function createSigstoreSigningProvider({
     async verify({ target, statementPath, bundlePath, policy = {} } = {}) {
       if (!bundlePath) return { status: "UNSIGNED", signer: null };
       try {
-        await assertSafePath(target, statementPath);
-        await assertSafePath(target, bundlePath);
-        const statementAbsolute = ensureWithin(target, statementPath);
-        const bundleAbsolute = ensureWithin(target, bundlePath);
-        const args = [
-          "verify-blob-attestation",
-          "--statement", statementAbsolute,
-          "--bundle", bundleAbsolute,
-        ];
-        const identities = Array.isArray(policy.identities)
-          ? [...new Set(policy.identities.filter((value) => typeof value === "string" && value.length > 0))]
-          : [];
-        if (policy.identity) args.push("--certificate-identity", policy.identity);
-        else if (identities.length === 1) args.push("--certificate-identity", identities[0]);
-        else if (identities.length > 1) {
-          const exactAlternatives = identities
-            .map((value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"))
-            .join("|");
-          args.push("--certificate-identity-regexp", `^(?:${exactAlternatives})$`);
-        }
-        if (policy.issuer) args.push("--certificate-oidc-issuer", policy.issuer);
-        if (policy.trustedRoot) {
-          await assertSafePath(target, policy.trustedRoot);
-          args.push("--trusted-root", ensureWithin(target, policy.trustedRoot));
-        }
-        await run(args, { cwd: path.resolve(target) });
-        return { status: "VALID", signer: policy.identity ?? (identities.length === 1 ? identities[0] : null) };
+        return await withExistingSigningReadScope(target, async () => {
+          await assertSafePath(target, statementPath);
+          await assertSafePath(target, bundlePath);
+          const taskId = signingTaskId(target, statementPath);
+          const statementAbsolute = ensureWithin(target, statementPath);
+          const bundleAbsolute = ensureWithin(target, bundlePath);
+          const args = [
+            "verify-blob-attestation",
+            "--statement", statementAbsolute,
+            "--bundle", bundleAbsolute,
+          ];
+          const identities = Array.isArray(policy.identities)
+            ? [...new Set(policy.identities.filter((value) => typeof value === "string" && value.length > 0))]
+            : [];
+          if (policy.identity) args.push("--certificate-identity", policy.identity);
+          else if (identities.length === 1) args.push("--certificate-identity", identities[0]);
+          else if (identities.length > 1) {
+            const exactAlternatives = identities
+              .map((value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"))
+              .join("|");
+            args.push("--certificate-identity-regexp", `^(?:${exactAlternatives})$`);
+          }
+          if (policy.issuer) args.push("--certificate-oidc-issuer", policy.issuer);
+          if (policy.trustedRoot) {
+            await assertSafePath(target, policy.trustedRoot);
+            args.push("--trusted-root", ensureWithin(target, policy.trustedRoot));
+          }
+          await withSigningStatementFile(target, statementPath, statementFilename => {
+            args[args.indexOf("--statement") + 1] = statementFilename;
+            return withOperationalAttachmentFile(target, bundlePath, taskId, bundleFilename => {
+              args[args.indexOf("--bundle") + 1] = bundleFilename;
+              return run(args, { cwd: path.resolve(target) });
+            });
+          });
+          return { status: "VALID", signer: policy.identity ?? (identities.length === 1 ? identities[0] : null) };
+        });
       } catch (error) {
         if (error.code === "E_ATTESTATION_SIGNER_UNAVAILABLE") throw error;
         const unavailable = error.code === "ENOENT" || error.cause?.code === "ENOENT";
@@ -126,6 +152,7 @@ export function createSigstoreSigningProvider({
       }
     },
   };
+  return provider;
 }
 
 /**

package/src/core/signing/statement-file.js

@@ -0,0 +1,27 @@
+import { needsExistingProjectScope, withExistingProjectScope } from "../../storage/existing-project-scope.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { assertSafePath, ensureWithin, writeFileAtomic } from "../filesystem.js";
+import { getOperationalStore, readOperationalText } from "../../storage/operational-context.js";
+
+/** Present selected canonical bytes to external signers without a legacy mirror. */
+export async function withSigningStatementFile(target, statementPath, callback) {
+  if (await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => withSigningStatementFile(target, statementPath, callback), { readOnly: true });
+  }
+  await assertSafePath(target, statementPath);
+  const source = readOperationalText(target, statementPath);
+  if (!source.selected) return callback(ensureWithin(target, statementPath));
+  const invalid = message => Object.assign(new Error(message), { code: "E_ATTESTATION_STATEMENT_INVALID" });
+  if (source.text === null) throw invalid("Selected attestation statement is missing");
+  if (getOperationalStore(target).db.isTransaction) throw invalid("External signing cannot run inside a SQLite write transaction");
+  const directory = await mkdtemp(path.join(os.tmpdir(), "forgeloop-signing-statement-"));
+  try {
+    const filename = path.join(directory, "statement.json");
+    await writeFileAtomic(filename, source.text);
+    const result = await callback(filename);
+    if (readOperationalText(target, statementPath).text !== source.text) throw invalid("Attestation statement changed during external signing");
+    return result;
+  } finally { await rm(directory, { recursive: true, force: true }); }
+}

package/src/core/storage-runtime-registry.js

@@ -0,0 +1,41 @@
+const owners = new WeakMap();
+function closed(message) { return Object.assign(new Error(message), { code: "E_STORAGE_RUNTIME_CLOSED" }); }
+
+/** Register lazy ownership without importing a SQLite implementation. */
+export function attachStorageConnectionOwner(context) {
+  let owner;
+  let loading;
+  let closing = false;
+  let closePromise;
+  const pending = new Set();
+  const getOwner = () => loading ??= import("../storage/connection-owner.js").then(module => {
+    owner = module.createStorageConnectionOwner();
+    return owner;
+  });
+  const proxy = {
+    run(target, callback, options) {
+      if (closing) return Promise.reject(closed("Persistent storage runtime is closing or closed"));
+      const request = getOwner().then(value => value.run(target, callback, options));
+      pending.add(request);
+      const finished = () => { pending.delete(request); };
+      request.then(finished, finished);
+      return request;
+    },
+    close() {
+      if (owner?.isActive()) return Promise.reject(closed("Close the runtime outside an active command"));
+      if (closePromise) return closePromise;
+      closing = true;
+      closePromise = (async () => {
+        await Promise.all([...pending].map(request => request.catch(() => undefined)));
+        if (loading) await (await loading).close();
+      })();
+      return closePromise;
+    },
+  };
+  owners.set(context, proxy);
+  return proxy.close;
+}
+
+export function getStorageConnectionOwner(context) {
+  return context && typeof context === "object" ? owners.get(context) ?? null : null;
+}