@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.4

package/src/core/structural-quality/artifacts.js

@@ -1,4 +1,6 @@
+import { needsExistingProjectScope, withExistingProjectScope } from "../../storage/existing-project-scope.js";
 import { readdir } from "node:fs/promises";
+import { listOperationalArtifactNames, operationalArtifactExists } from "../../storage/operational-context.js";
 
 import {
   canonicalFingerprint,
@@ -205,21 +207,25 @@ export async function writeStructuralQualityBaseline(
 }
 
 export async function listStructuralQualityEvaluations(target, taskId, packageRoot = getPackageRoot()) {
+  if (await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => listStructuralQualityEvaluations(target, taskId, packageRoot), { readOnly: true });
+  }
   const relativeDirectory = taskStructuralQualityEvaluationsDirectory(taskId);
-  await assertSafePath(target, relativeDirectory);
-  const absoluteDirectory = ensureWithin(target, relativeDirectory);
-  if (!(await fileExists(absoluteDirectory))) return [];
-  let entries;
-  try {
-    entries = await readdir(absoluteDirectory, { withFileTypes: true });
-  } catch (error) {
-    throw qualityArtifactError(E_STRUCTURAL_QUALITY_EVIDENCE_STALE, `Unable to list structural-quality evaluations: ${error.message}`, [relativeDirectory]);
+  let names = listOperationalArtifactNames(target, taskId, "structural-quality/evaluations");
+  if (names === null) {
+    await assertSafePath(target, relativeDirectory);
+    const absoluteDirectory = ensureWithin(target, relativeDirectory);
+    if (!(await fileExists(absoluteDirectory))) return [];
+    try {
+      names = (await readdir(absoluteDirectory, { withFileTypes: true })).filter(entry => entry.isFile()).map(entry => entry.name);
+    } catch (error) {
+      throw qualityArtifactError(E_STRUCTURAL_QUALITY_EVIDENCE_STALE, `Unable to list structural-quality evaluations: ${error.message}`, [relativeDirectory]);
+    }
   }
-  const candidates = entries
-    .filter((entry) => entry.isFile())
-    .map((entry) => {
-      const match = /^cycle-(\d+)-attempt-(\d+)\.json$/u.exec(entry.name);
-      return match ? { name: entry.name, verificationCycle: Number(match[1]), attempt: Number(match[2]) } : null;
+  const candidates = names
+    .map((name) => {
+      const match = /^cycle-(\d+)-attempt-(\d+)\.json$/u.exec(name);
+      return match ? { name, verificationCycle: Number(match[1]), attempt: Number(match[2]) } : null;
     })
     .filter(Boolean)
     .filter((item) => item.verificationCycle >= 1 && item.attempt >= 1)
@@ -267,7 +273,7 @@ export async function writeStructuralQualityEvaluation(target, taskId, verificat
     throw qualityArtifactError(E_STRUCTURAL_QUALITY_EVIDENCE_STALE, `Evaluation identity does not match ${relativePath}`, [relativePath]);
   }
   validateStructuralQualityArtifact(value, relativePath);
-  const existing = await fileExists(ensureWithin(target, relativePath));
+  const existing = operationalArtifactExists(target, relativePath) ?? await fileExists(ensureWithin(target, relativePath));
   if (existing) {
     const current = await readStructuralQualityEvaluation(target, taskId, cycle, normalizedAttempt, packageRoot);
     if (current.fingerprint === canonicalFingerprint(value)) return { ...current, existing: true, identical: true };

package/src/core/structural-quality/service.js

@@ -1,3 +1,5 @@
+import { needsExistingProjectScope } from "../../storage/existing-project-scope.js";
+import { withProjectReadSnapshot } from "../../storage/project-read-snapshot.js";
 import { canonicalFingerprint, readJsonArtifact } from "../artifacts.js";
 import { readConfig } from "../config.js";
 import { readContract } from "../contract.js";
@@ -36,6 +38,22 @@ import {
 import { appendProtocolEvent } from "../events.js";
 import { getPackageRoot } from "../templates.js";
 import { withTaskMutation } from "../task-command.js";
+import { withTaskTransaction } from "../transaction.js";
+import { getOperationalStore } from "../../storage/operational-context.js";
+
+async function withQualityMutation(target, options, operation, callback) {
+  const native = Boolean(getOperationalStore(target)) || await needsExistingProjectScope(target);
+  for (let retry = 0; ; retry += 1) {
+    try {
+      return await withTaskMutation(target, options, operation, callback);
+    } catch (error) {
+      // These callbacks persist an already captured observation. A native
+      // conflict discards their staged writes; rerun admission and bindings
+      // against current records without invoking the provider again.
+      if (!native || error.code !== "E_STATE_REVISION_CONFLICT" || retry >= 2) throw error;
+    }
+  }
+}
 import { findTaskById } from "../task-discovery.js";
 import { currentChangedPaths } from "../repository.js";
 import { assertClaimsCoverChangedPaths } from "../task-scope.js";
@@ -142,7 +160,11 @@ function normalizeScanResult(result, provider, detection, projectPath) {
   };
 }
 
-export async function resolveStructuralQualityContext({
+export async function resolveStructuralQualityContext(options = {}) {
+  return withProjectReadSnapshot(options.target, () => resolveStructuralQualityContextObservation(options));
+}
+
+async function resolveStructuralQualityContextObservation({
   target,
   packageRoot = getPackageRoot(),
   taskId,
@@ -378,31 +400,43 @@ export async function captureStructuralQualityBaseline({ target, packageRoot = g
     scope: updatedInputs.scope,
     snapshot: scan.snapshot,
   };
-  const written = await writeStructuralQualityBaseline(target, taskId, value, packageRoot, { phase: inputs.state.phase, replace, taskId });
-  if (!written.identical) {
-    await appendProtocolEvent(target, {
-      taskId,
-      event: "STRUCTURAL_QUALITY_BASELINE_RECORDED",
-      details: {
-        artifactRef: written.path,
-        artifactFingerprint: written.fingerprint,
-        providerId: scan.provider.id,
-        providerVersion: scan.provider.version,
-        replaced: Boolean(existing),
-        supersededFingerprint: existing?.fingerprint ?? null,
-      },
-    }, packageRoot, { taskId });
-  }
-  return {
-    status: written.existing ? "REPLACED" : "CAPTURED",
-    mode: policy.mode,
-    provider: scan.provider,
-    artifactRef: written.path,
-    artifactFingerprint: written.fingerprint,
-    baseline: written.value,
-    existing: written.existing,
-    identical: written.identical,
-  };
+  return withTaskTransaction({ target, taskId, packageRoot, operation: "quality-baseline" }, async () => {
+    const currentInputs = await taskInputs(target, packageRoot, taskId, { runtimeContext, timeoutMs, maxOutputBytes });
+    if (currentInputs.state.phase !== "PLANNED"
+      || currentInputs.contract.fingerprint !== inputs.contract.fingerprint
+      || currentInputs.route.fingerprint !== inputs.route.fingerprint
+      || structuralQualityPolicyFingerprint(currentInputs.policy) !== policyFingerprint
+      || currentInputs.scopeFingerprint !== inputs.scopeFingerprint) {
+      throw qualityError(E_STRUCTURAL_QUALITY_OBSERVATION_EPOCH_STALE, "Task baseline configuration changed during observation");
+    }
+    await assertReadyPreflight(target, packageRoot, taskId);
+    const currentBaseline = await readStructuralQualityBaseline(target, taskId, packageRoot);
+    const written = await writeStructuralQualityBaseline(target, taskId, value, packageRoot, { phase: currentInputs.state.phase, replace, taskId });
+    if (!written.identical) {
+      await appendProtocolEvent(target, {
+        taskId,
+        event: "STRUCTURAL_QUALITY_BASELINE_RECORDED",
+        details: {
+          artifactRef: written.path,
+          artifactFingerprint: written.fingerprint,
+          providerId: scan.provider.id,
+          providerVersion: scan.provider.version,
+          replaced: Boolean(currentBaseline),
+          supersededFingerprint: currentBaseline?.fingerprint ?? null,
+        },
+      }, packageRoot, { taskId });
+    }
+    return {
+      status: written.existing ? "REPLACED" : "CAPTURED",
+      mode: policy.mode,
+      provider: scan.provider,
+      artifactRef: written.path,
+      artifactFingerprint: written.fingerprint,
+      baseline: written.value,
+      existing: written.existing,
+      identical: written.identical,
+    };
+  });
 }
 
 async function persistEvaluationAndCheck({ target, packageRoot, taskId, inputs, persisted, authorityContext, runtimeContext }) {
@@ -443,7 +477,7 @@ async function persistEvaluationAndCheck({ target, packageRoot, taskId, inputs,
     runtimeContext,
     taskId: context?.taskId ?? taskId,
   });
-  const recorded = await withTaskMutation(target, { taskId, packageRoot }, "quality-verify-check", async (context) => {
+  const recorded = await withQualityMutation(target, { taskId, packageRoot }, "quality-verify-check", async (context) => {
     const effectiveTaskId = context?.taskId ?? taskId;
     const evaluations = await listStructuralQualityEvaluations(target, effectiveTaskId, packageRoot);
     const latest = evaluations
@@ -599,34 +633,33 @@ export async function evaluateStructuralQuality({ target, packageRoot = getPacka
 
   // Execute provider observation OUTSIDE task mutation lock
   const sourceFingerprintBefore = await computeMaterialSourceFingerprint(target);
+  // Every non-pass branch binds the same reserved task/cycle and source epoch.
+  const evaluationInputs = {
+    taskId,
+    inputs: initialInputs,
+    cycle,
+    attempt,
+    policy,
+    baseline,
+    sourceMaterialFingerprint: sourceFingerprintBefore,
+  };
   let evaluation;
 
   if (!baseline) {
     evaluation = nonPassEvaluation({
-      taskId,
-      inputs: initialInputs,
-      cycle,
-      attempt,
-      policy,
+      ...evaluationInputs,
       reasonCode: E_STRUCTURAL_QUALITY_BASELINE_MISSING,
       sourceObservation: { beforeFingerprint: sourceFingerprintBefore, afterFingerprint: sourceFingerprintBefore, stable: true },
-      sourceMaterialFingerprint: sourceFingerprintBefore,
     });
   } else {
     try {
       const scopeChanged = baseline.value.bindings?.scopeFingerprint !== initialInputs.scopeFingerprint;
       if (scopeChanged) {
         evaluation = nonPassEvaluation({
-          taskId,
-          inputs: initialInputs,
-          cycle,
-          attempt,
-          policy,
+          ...evaluationInputs,
           reasonCode: E_STRUCTURAL_QUALITY_EVALUATION_INCOMPARABLE,
           reasonCodes: ["PROVIDER_CONFIG_CHANGED"],
-          baseline,
           sourceObservation: { beforeFingerprint: sourceFingerprintBefore, afterFingerprint: sourceFingerprintBefore, stable: true },
-          sourceMaterialFingerprint: sourceFingerprintBefore,
         });
         evaluation.comparison.reasonCodes = [E_STRUCTURAL_QUALITY_EVALUATION_INCOMPARABLE, "PROVIDER_CONFIG_CHANGED"];
       } else {
@@ -643,18 +676,12 @@ export async function evaluateStructuralQuality({ target, packageRoot = getPacka
 
         if (!isStable) {
           evaluation = nonPassEvaluation({
-          taskId,
-          inputs: initialInputs,
-          cycle,
-          attempt,
-          policy,
+          ...evaluationInputs,
           reasonCode: E_STRUCTURAL_QUALITY_SOURCE_DRIFT,
           providerId: scan.provider.id,
           providerVersion: scan.provider.version,
           detection: scan.detection,
-          baseline,
           sourceObservation: { beforeFingerprint: sourceFingerprintBefore, afterFingerprint: sourceFingerprintAfter, stable: false },
-          sourceMaterialFingerprint: sourceFingerprintBefore,
           });
         } else {
           const updatedInputs = initialInputs;
@@ -699,26 +726,20 @@ export async function evaluateStructuralQuality({ target, packageRoot = getPacka
       const sourceFingerprintAfter = await computeMaterialSourceFingerprint(target).catch(() => sourceFingerprintBefore);
       const code = error.code ?? E_STRUCTURAL_QUALITY_PROVIDER_UNAVAILABLE;
       evaluation = nonPassEvaluation({
-        taskId,
-        inputs: initialInputs,
-        cycle,
-        attempt,
-        policy,
+        ...evaluationInputs,
         reasonCode: code,
         providerId: policy.provider,
-        baseline,
         sourceObservation: {
           beforeFingerprint: sourceFingerprintBefore,
           afterFingerprint: sourceFingerprintAfter,
           stable: sourceFingerprintBefore === sourceFingerprintAfter,
         },
-        sourceMaterialFingerprint: sourceFingerprintBefore,
         });
       }
   }
 
   // Commit under task mutation lock
-  const captured = await withTaskMutation(target, { taskId, packageRoot }, "quality-verify-evaluation", async (context) => {
+  const captured = await withQualityMutation(target, { taskId, packageRoot }, "quality-verify-evaluation", async (context) => {
     const lockedTaskId = context?.taskId ?? taskId;
     const inputs = await taskInputs(target, packageRoot, lockedTaskId, { runtimeContext, timeoutMs, maxOutputBytes });
     if (inputs.state.phase !== "VERIFYING") {
@@ -908,7 +929,11 @@ function projectionFromArtifacts(policy, baseline, current, state, evaluations =
   return projection;
 }
 
-export async function projectStructuralQualityStatus({ target, packageRoot = getPackageRoot(), taskId, runtimeContext } = {}) {
+export async function projectStructuralQualityStatus(options = {}) {
+  return withProjectReadSnapshot(options.target, () => projectStructuralQualityStatusObservation(options));
+}
+
+async function projectStructuralQualityStatusObservation({ target, packageRoot = getPackageRoot(), taskId, runtimeContext } = {}) {
   const config = await loadOptionalConfig(target, packageRoot);
   const policy = configuredPolicy(config);
   if (!policy || policy.mode === "off") return emptyProjection(null);

package/src/core/target-layout.js

@@ -26,7 +26,7 @@ export function targetPathForSource(sourcePath) {
 }
 
 export function legacyPathForSource(sourcePath) {
-  return sourcePath === ".forgeloop/forgeloop.gitignore" ? ".forgeloop/.gitignore" : sourcePath;
+  return sourcePath;
 }
 
 export function isKitPath(relativePath) {

package/src/core/task-claim-state.js

@@ -1,3 +1,6 @@
+import { needsExistingProjectScope } from "../storage/existing-project-scope.js";
+import { getOperationalStore } from "../storage/operational-context.js";
+import { ledgerTypeSummary } from "./ledger-event-collection.js";
 import {
   E_COMPLETION_OWNERSHIP_UNPROVEN,
   E_TASK_CLAIM_OWNERSHIP_INCONSISTENT,
@@ -6,8 +9,8 @@ import {
   E_TASK_RECOVERY_INCONSISTENT,
 } from "./error-codes.js";
 import { validateCompletionOwnershipProof } from "./completion-ownership.js";
-import { validateEventLedger, validateStateLedgerCoherence } from "./events.js";
-import { classifyRecoveryHistory } from "./recovery-history.js";
+import { validateEventLedger, validatePortableEventLedger, validateStateLedgerCoherence, withEventLedgerAudit } from "./events.js";
+import { classifyRecoveryHistory, summarizeRecoveryHistory } from "./recovery-history.js";
 import { readTaskDescriptor } from "./task-descriptor.js";
 import { normalizeWriteClaims } from "./task-scope.js";
 import {
@@ -126,7 +129,7 @@ function evolvedRepairErrors(anchor, events, state, artifacts) {
   errors.push(...lateRouteCheckpointErrors(events, state, anchor.sourceMarker));
   errors.push(...validateStateLedgerCoherence(state, events).map((error) => repairInvalid(error.message)));
   const requiredEvent = REPAIR_PHASE_EVENTS[state.phase];
-  if (requiredEvent && !events.some((event) => event.event === requiredEvent)) {
+  if (requiredEvent && !ledgerTypeSummary(events, requiredEvent).count) {
     errors.push(repairInvalid(`Current work-state phase ${state.phase} is not supported by the repair ledger history`));
   }
   return errors;
@@ -135,7 +138,7 @@ function evolvedRepairErrors(anchor, events, state, artifacts) {
 function validateContractBootstrapRepairConsistency(taskId, events, state, artifacts) {
   const anchor = resolveEffectiveContractBootstrapRepairAnchor(events);
   if (!anchor) {
-    if (!events.some((event) => event.event === CONTRACT_BOOTSTRAP_REPAIR_EVENT)) return [];
+    if (!ledgerTypeSummary(events, CONTRACT_BOOTSTRAP_REPAIR_EVENT).count) return [];
     return [repairInvalid("Contract bootstrap repair marker is invalid")];
   }
   if (!state) return [repairInvalid("Work-state is missing after a recorded contract bootstrap repair")];
@@ -184,6 +187,7 @@ async function collectContractBootstrapRepairConsistency(target, packageRoot, ta
       artifacts.contractError = "work-state contract fingerprint does not match marker contract fingerprint";
     }
   } catch (error) {
+    if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
     artifacts.contractError = error.code === "ARTIFACT_MISSING"
       ? "contract artifact is missing after a recorded repair"
       : `contract artifact is invalid after a recorded repair: ${error.message}`;
@@ -202,6 +206,7 @@ async function collectContractBootstrapRepairConsistency(target, packageRoot, ta
         artifacts.routeError = "route artifact contract binding does not match repair anchor contract fingerprint";
       }
     } catch (error) {
+      if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
       artifacts.routeError = error.code === "ARTIFACT_MISSING"
         ? "route artifact is missing after a routed repair"
         : `route artifact is invalid after a routed repair: ${error.message}`;
@@ -214,7 +219,10 @@ async function collectContractBootstrapRepairConsistency(target, packageRoot, ta
 function appendClaims(target, claims, errors, source) {
   if (claims === undefined || claims === null) return;
   try {
-    target.push(...normalizeWriteClaims(claims));
+    const normalized = normalizeWriteClaims(claims);
+    if (target instanceof Set || typeof target.add === "function") {
+      for (const claim of normalized) target.add(claim);
+    } else target.push(...normalized);
   } catch (error) {
     errors.push(ownershipError(`Invalid ${source} write claims: ${error.message}`, error));
   }
@@ -226,12 +234,12 @@ function appendClaims(target, claims, errors, source) {
  * classified recovery history. Classification is a pure function of this
  * evidence, so conflict inspection can reuse it without rereading artifacts.
  */
-export async function collectTaskClaimEvidence(target, {
+async function collectClaimEvidence(target, {
   taskId,
   packageRoot,
   descriptor: suppliedDescriptor = null,
   state: suppliedState = null,
-} = {}) {
+} = {}, suppliedLedger = null) {
   const errors = [];
   let descriptor = suppliedDescriptor;
   let state = suppliedState;
@@ -242,6 +250,7 @@ export async function collectTaskClaimEvidence(target, {
     try {
       descriptor = (await readTaskDescriptor(target, taskId, packageRoot)).value;
     } catch (error) {
+      if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
       errors.push(ownershipError(`Task descriptor cannot establish claim ownership: ${error.message}`, error));
     }
   }
@@ -249,6 +258,7 @@ export async function collectTaskClaimEvidence(target, {
     try {
       state = await readWorkState(target, { taskId, packageRoot });
     } catch (error) {
+      if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
       errors.push(ownershipError(`Task work state cannot establish claim ownership: ${error.message}`, error));
     }
   }
@@ -256,14 +266,27 @@ export async function collectTaskClaimEvidence(target, {
   try {
     recovery = (await readTaskRecovery(target, { taskId, packageRoot }))?.value ?? null;
   } catch (error) {
+    if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
     errors.push(ownershipError(`Task recovery artifact cannot establish claim ownership: ${error.message}`, error));
   }
 
   try {
-    ledger = await validateEventLedger(target, packageRoot, { taskId });
+    ledger = suppliedLedger ?? await (getOperationalStore(target) || await needsExistingProjectScope(target) ? validateEventLedger : validatePortableEventLedger)(target, packageRoot, { taskId });
   } catch (error) {
+    if (error.code === "E_STATE_REVISION_CONFLICT") throw error;
     errors.push(ownershipError(`Task event ledger cannot establish claim ownership: ${error.message}`, error));
   }
+  const repairArtifacts = await collectContractBootstrapRepairConsistency(target, packageRoot, taskId, ledger.events, state);
+  return buildTaskClaimEvidence({ taskId, descriptor, state, recovery, ledger, repairArtifacts, initialErrors: errors });
+}
+
+export async function collectTaskClaimEvidence(target, options = {}) {
+  return collectClaimEvidence(target, options);
+}
+
+/** Shared pure ownership evidence projection for filesystem and store snapshots. */
+export function buildTaskClaimEvidence({ taskId, descriptor, state, recovery, ledger, repairArtifacts = null, initialErrors = [] }) {
+  const errors = [...initialErrors];
   if (!ledger.valid) {
     for (const error of ledger.errors) {
       errors.push(ownershipError(`Task event ledger is invalid: ${error.message}`, error));
@@ -282,19 +305,19 @@ export async function collectTaskClaimEvidence(target, {
     }
   }
 
-  const repairArtifacts = await collectContractBootstrapRepairConsistency(target, packageRoot, taskId, ledger.events, state);
   const repairConsistencyErrors = validateContractBootstrapRepairConsistency(taskId, ledger.events, state, repairArtifacts);
   errors.push(...repairConsistencyErrors);
 
-  const history = classifyRecoveryHistory(ledger.events);
   const descriptorClaims = [];
   appendClaims(descriptorClaims, descriptor?.writeClaims, errors, "descriptor");
   const normalizedDescriptorClaims = normalizeWriteClaims(descriptorClaims);
 
-  const historicalClaims = [...normalizedDescriptorClaims];
-  for (const cycle of history.recoveries) {
-    appendClaims(historicalClaims, cycle.event?.details?.releasedClaims, errors, "recovery ledger");
-  }
+  const historicalClaims = new Set(normalizedDescriptorClaims);
+  const observeRecovery = cycle => appendClaims(historicalClaims, cycle.event?.details?.releasedClaims, errors, "recovery ledger");
+  const history = Array.isArray(ledger.events)
+    ? classifyRecoveryHistory(ledger.events)
+    : summarizeRecoveryHistory(ledger.events, observeRecovery);
+  if (Array.isArray(ledger.events)) for (const cycle of history.recoveries) observeRecovery(cycle);
   appendClaims(historicalClaims, recovery?.releasedClaims, errors, "recovery artifact");
 
   return {
@@ -306,7 +329,7 @@ export async function collectTaskClaimEvidence(target, {
     ledger,
     history,
     normalizedDescriptorClaims,
-    historicalWriteClaims: normalizeWriteClaims(historicalClaims),
+    historicalWriteClaims: normalizeWriteClaims([...historicalClaims]),
     errors,
   };
 }
@@ -429,7 +452,7 @@ export function classifyTaskClaimState(evidence) {
     claimState: "ACTIVE",
     mutationAllowed: true,
     recovery: null,
-    recoveryStatus: history.completedRecoveries.length > 0 ? "COMPLETED" : "ABSENT",
+    recoveryStatus: (history.completedRecoveryCount ?? history.completedRecoveries.length) > 0 ? "COMPLETED" : "ABSENT",
     valid: true,
     ownershipValid: true,
     reasonCodes: [],
@@ -443,9 +466,20 @@ export function classifyTaskClaimState(evidence) {
  * tombstone, and the complete validated task ledger. Any disagreement retains
  * every claim that can be recovered from validated inputs and fails closed.
  */
+export async function withTaskClaimEvidence(target, options, callback) {
+  let store;
+  try { store = getOperationalStore(target); } catch { /* Preserve collected fail-closed evidence for invalid contexts. */ }
+  if (store && !store.hasPreparedMutations()
+    && typeof options.taskId === "string" && options.taskId) {
+    return withEventLedgerAudit(target, options.packageRoot, { taskId: options.taskId }, async ledger => (
+      callback(await collectClaimEvidence(target, options, ledger))
+    ));
+  }
+  return callback(await collectTaskClaimEvidence(target, options));
+}
+
 export async function resolveTaskClaimState(target, options = {}) {
-  const evidence = await collectTaskClaimEvidence(target, options);
-  return classifyTaskClaimState(evidence);
+  return withTaskClaimEvidence(target, options, classifyTaskClaimState);
 }
 
 export async function assertTaskMutationAllowed(target, options = {}) {

package/src/core/task-command.js

@@ -2,6 +2,8 @@ import { resolveTaskContext, TASK_SELECTION_MODES } from "./task-context.js";
 import { withTaskTransaction } from "./transaction.js";
 import { assertTaskMutationAllowed } from "./task-claim-state.js";
 import { assertWorkspaceBinding } from "./workspace-binding.js";
+import { getOperationalStore } from "../storage/operational-context.js";
+import { withTaskLock } from "./task-lock.js";
 
 export async function withResolvedTask(
   target,
@@ -27,15 +29,33 @@ export async function withTaskMutation(
   callback,
   { explicitRequired = false, skipWorkspaceBinding = false } = {},
 ) {
+  if (!getOperationalStore(target)) {
+    const { withProjectStorage } = await import("../storage/project-boundary.js");
+    return withProjectStorage(target, () => withTaskMutation(target, options, operation, callback, { explicitRequired, skipWorkspaceBinding }));
+  }
   const taskOption = options.taskId ?? options.task ?? null;
   const taskContext = await resolveTaskContext(target, {
     taskId: taskOption,
-    explicitRequired,
+    explicitRequired: explicitRequired || Boolean(getOperationalStore(target)),
     packageRoot: options.packageRoot,
     selectionMode: TASK_SELECTION_MODES.MUTATION,
   });
 
   if (taskContext) {
+    if (getOperationalStore(target) && ["run-action", "run-check"].includes(operation)) {
+      return withTaskLock(target, taskContext.taskId, operation, async () => {
+        await withTaskTransaction({ target, taskId: taskContext.taskId, operation: `${operation}:prepare`, packageRoot: options.packageRoot }, async () => {
+          await assertTaskMutationAllowed(target, { taskId: taskContext.taskId, packageRoot: options.packageRoot });
+          if (!skipWorkspaceBinding) await assertWorkspaceBinding(target, { taskId: taskContext.taskId, packageRoot: options.packageRoot, operation });
+        });
+        // External work runs with a durable semantic reservation and no open
+        // database transaction. Its domain services commit intent/outcome in
+        // separate transactions, so a crash cannot erase a durable start.
+        const result = await callback(taskContext);
+        await withTaskTransaction({ target, taskId: taskContext.taskId, operation, packageRoot: options.packageRoot, recordCommitEvent: true }, () => undefined);
+        return result;
+      });
+    }
     return withTaskTransaction({ target, taskId: taskContext.taskId, operation, packageRoot: options.packageRoot, recordCommitEvent: true }, async (transaction) => {
       await assertTaskMutationAllowed(target, { taskId: taskContext.taskId, packageRoot: options.packageRoot });
       if (!skipWorkspaceBinding) {