@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.2

package/src/commands/status.js

@@ -1,10 +1,15 @@
+import { withProjectReadSnapshot } from "../storage/project-read-snapshot.js";
 import { readAndClassifyWorkState } from "../core/work-state.js";
 import { inspectSchemaHealth } from "../core/schema-validation.js";
 import { reconcileContinuity } from "../core/continuity-reconciliation.js";
 import { withResolvedTask } from "../core/task-command.js";
 import { findTaskById } from "../core/task-discovery.js";
 
-export async function runStatus({ target, packageRoot, contractFile = null, taskId, task } = {}) {
+export async function runStatus(options = {}) {
+  return withProjectReadSnapshot(options.target, () => runSelectedStatus(options));
+}
+
+async function runSelectedStatus({ target, packageRoot, contractFile = null, taskId, task } = {}) {
   return withResolvedTask(target, { taskId: taskId ?? task, packageRoot }, async (ctx) => {
     const effectiveTaskId = ctx?.taskId ?? null;
     const state = await readAndClassifyWorkState({ target, packageRoot, contractFile, taskId: effectiveTaskId });

package/src/commands/storage-backup.js

@@ -0,0 +1,15 @@
+import { getOperationalStore } from "../storage/operational-context.js";
+import { assertSafePath } from "../core/filesystem.js";
+
+export async function runStorageBackup({ target, destination, includeAttachments = false } = {}) {
+  if (typeof destination !== "string" || !destination) throw Object.assign(new Error("storage-backup requires --destination"), { code: "E_CLI_INVOCATION_INVALID" });
+  const store = getOperationalStore(target);
+  if (!store) throw Object.assign(new Error("storage-backup requires an explicitly migrated SQLite project"), { code: "E_STORAGE_MIGRATION_REQUIRED" });
+  const filename = await assertSafePath(target, destination);
+  if (includeAttachments) {
+    const { backupProjectStorage } = await import("../storage/project-backup.js");
+    return backupProjectStorage(store.db, target, filename);
+  }
+  const { backupStorageDatabase } = await import("../storage/backup.js");
+  return backupStorageDatabase(store.db, filename);
+}

package/src/commands/storage-migrate.js

@@ -0,0 +1,5 @@
+import { migrateProjectStorage } from "../storage/migration.js";
+
+export async function runStorageMigrate({ target, destination, writersQuiesced = false, packageRoot } = {}) {
+  return migrateProjectStorage(target, { destination, writersQuiesced, packageRoot });
+}

package/src/commands/storage-migration-resume.js

@@ -0,0 +1,5 @@
+import { resumeProjectStorageMigration } from "../storage/migration.js";
+
+export async function runStorageMigrationResume({ target, destination, expectedOwnerId, writersQuiesced = false, acknowledgeUnboundHandoff = false, packageRoot } = {}) {
+  return resumeProjectStorageMigration(target, { destination, expectedOwnerId, writersQuiesced, acknowledgeUnboundHandoff, packageRoot });
+}

package/src/commands/storage-migration-status.js

@@ -0,0 +1,44 @@
+import { lstat } from "node:fs/promises";
+import { assertSafePath } from "../core/filesystem.js";
+import { readMaintenanceOwner } from "../storage/maintenance-owner.js";
+
+async function present(target, relativePath) {
+  try { await lstat(await assertSafePath(target, relativePath)); return true; }
+  catch (error) { if (error.code === "ENOENT") return false; throw error; }
+}
+
+async function inspectOwner(target) {
+  const marker = await assertSafePath(target, ".forgeloop/.storage-maintenance");
+  if (!(await lstat(marker)).isDirectory()) return { status: "MALFORMED", owner: null };
+  try {
+    const { value } = await readMaintenanceOwner(target);
+    return {
+      status: "RETAINED",
+      owner: { ownerId: value.ownerId, pid: value.pid, acquiredAt: value.acquiredAt, ...(value.hostname ? { hostname: value.hostname } : {}) },
+      ownerLiveness: "NOT_VERIFIED",
+      handoffPresent: await present(target, ".forgeloop/.storage-maintenance/handoff")
+        || await present(target, `.forgeloop/storage-maintenance-history/handoffs/${value.ownerId}.json`),
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") return { status: "INCOMPLETE", owner: null };
+    if (error.code === "E_STORAGE_MAINTENANCE_OWNER_INVALID") return { status: "MALFORMED", owner: null };
+    throw error;
+  }
+}
+
+/** Inspect bootstrap layout even when ordinary database dispatch is excluded. */
+export async function runStorageMigrationStatus({ target }) {
+  const databasePresent = await present(target, ".forgeloop/state.sqlite");
+  const legacyOperationalPaths = [];
+  for (const relativePath of [".forgeloop/task-state", ".forgeloop/work-state.json", ".forgeloop/events.ndjson", ".forgeloop/.txn"]) {
+    if (await present(target, relativePath)) legacyOperationalPaths.push(relativePath);
+  }
+  const maintenance = await present(target, ".forgeloop/.storage-maintenance")
+    ? await inspectOwner(target) : { status: "NONE", owner: null };
+  return {
+    schemaVersion: 1,
+    layout: databasePresent ? legacyOperationalPaths.length ? "MIXED" : "SQLITE_PRESENT" : "FILESYSTEM",
+    databasePresent, legacyOperationalPaths, maintenance,
+    databaseValidation: "NOT_RUN", publicationValidation: "NOT_VERIFIED",
+  };
+}

package/src/commands/storage-restore-resume.js

@@ -0,0 +1,7 @@
+import { resumeProjectStorageRestore } from "../storage/project-restore.js";
+import { resumeActiveProjectReplacement } from "../storage/project-replacement.js";
+
+export async function runStorageRestoreResume({ target, operationId, expectedOwnerId, writersQuiesced = false, replaceActive = false, packageRoot } = {}) {
+  const resume = replaceActive === true ? resumeActiveProjectReplacement : resumeProjectStorageRestore;
+  return resume(target, { operationId, expectedOwnerId, writersQuiesced, packageRoot });
+}

package/src/commands/storage-restore.js

@@ -0,0 +1,8 @@
+import path from "node:path";
+import { restoreProjectStorageToFreshProject } from "../storage/project-restore.js";
+import { replaceActiveProjectStorage } from "../storage/project-replacement.js";
+
+export async function runStorageRestore({ target, source, writersQuiesced = false, replaceActive = false, packageRoot } = {}) {
+  const restore = replaceActive === true ? replaceActiveProjectStorage : restoreProjectStorageToFreshProject;
+  return restore(path.resolve(target, source), target, { writersQuiesced, packageRoot });
+}

package/src/commands/task-abandon.js

@@ -153,7 +153,7 @@ export async function runTaskAbandon({
       const inspection = await inspectTaskConflictState(target, {
         taskId: effectiveTaskId,
         packageRoot,
-        ignoredLockId: transaction.lock.lockId,
+        ignoredLockId: transaction.lock?.lockId ?? null,
       });
       assertInspectionAbandonable(effectiveTaskId, inspection);
       assertSnapshotUnchanged(before, snapshot(inspection), effectiveTaskId);

package/src/commands/task-list.js

@@ -1,60 +1,25 @@
-import { discoverTasks } from "../core/task-discovery.js";
+import { discoverTaskListPage } from "../core/task-discovery.js";
 import { WORK_PHASES } from "../core/protocol.js";
 
 export async function runTaskList({ target, packageRoot, phase = null, active = false, limit = null, offset = 0 } = {}) {
-  const tasks = await discoverTasks(target, packageRoot);
   const normalizedPhase = typeof phase === "string" && phase.trim() !== "" ? phase.trim().toUpperCase() : null;
+  const start = Number.isInteger(offset) && offset >= 0 ? offset : 0;
+  const pageLimit = Number.isInteger(limit) && limit >= 0 ? limit : null;
+  const { tasks: projected, total } = await discoverTaskListPage(target, packageRoot, { phase: normalizedPhase, active, offset: start, limit: pageLimit });
   if (normalizedPhase && !WORK_PHASES.includes(normalizedPhase)) {
     const error = new Error(`Unknown task phase filter: ${phase}`);
     error.code = "E_TASK_PHASE_INVALID";
     throw error;
   }
-  const phaseFiltered = normalizedPhase ? tasks.filter((task) => task.phase === normalizedPhase) : tasks;
-  const filtered = active
-    ? phaseFiltered.filter((task) => task.claimState === "ACTIVE" && task.mutationAllowed === true)
-    : phaseFiltered;
-  const start = Number.isInteger(offset) && offset >= 0 ? offset : 0;
-  const end = Number.isInteger(limit) && limit >= 0 ? start + limit : undefined;
-  const projected = filtered.slice(start, end);
+  const end = pageLimit === null ? undefined : start + pageLimit;
   return {
-    tasks: projected.map((task) => {
-      if (task.healthy === false) {
-        return {
-          taskId: task.taskId ?? null,
-          taskKey: task.taskKey,
-          directory: task.directory,
-          healthy: false,
-          error: task.error,
-        };
-      }
-      return {
-        taskId: task.taskId,
-        taskKey: task.taskKey,
-        directory: task.directory,
-        healthy: true,
-        phase: task.phase,
-        writeClaims: task.writeClaims ?? [],
-        historicalWriteClaims: task.historicalWriteClaims ?? [],
-        effectiveWriteClaims: task.effectiveWriteClaims ?? [],
-        claimState: task.claimState,
-        recovery: task.recovery,
-        mutationAllowed: task.mutationAllowed,
-        ownershipValid: task.ownershipValid,
-        ownershipErrors: task.ownershipErrors ?? task.errors ?? [],
-        reasonCodes: task.reasonCodes ?? [],
-        locked: task.locked,
-        hasContinuity: task.hasContinuity,
-        hasReceipt: task.hasReceipt,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-      };
-    }),
+    tasks: projected,
     ...(normalizedPhase ? { phase: normalizedPhase } : {}),
     ...(active ? { active: true } : {}),
     offset: start,
     ...(Number.isInteger(limit) && limit >= 0 ? { limit } : {}),
-    total: filtered.length,
-    hasMore: end !== undefined ? end < filtered.length : false,
+    total,
+    hasMore: end !== undefined ? end < total : false,
   };
 }
 

package/src/commands/task-migrate.js

@@ -1,7 +1,7 @@
-import { migrateLegacyLayout } from "../core/task-migration.js";
+import { migrateLegacyTaskStorage } from "../core/task-storage-migration.js";
 
-export async function runTaskMigrate({ target, packageRoot, dryRun = false } = {}) {
-  const result = await migrateLegacyLayout(target, { packageRoot, dryRun });
+export async function runTaskMigrate({ target, packageRoot, dryRun = false, destination, writersQuiesced = false } = {}) {
+  const result = await migrateLegacyTaskStorage(target, { packageRoot, dryRun, destination, writersQuiesced });
   return result;
 }
 

package/src/commands/task-recover.js

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import { resolveTaskContext } from "../core/task-context.js";
 import { inspectTaskConflictState } from "../core/task-conflict-inspection.js";
 import { appendProtocolEvent } from "../core/events.js";
-import { withTaskTransaction } from "../core/transaction.js";
+import { getTaskTransaction, withTaskTransaction } from "../core/transaction.js";
 import { currentRepositoryFingerprint } from "../core/repository.js";
 import {
   readLockInfo,
@@ -86,6 +86,7 @@ export async function runTaskRecover({
   acknowledgeRecovery = false,
   operatorAuthorized = false,
 } = {}) {
+  const nested = Boolean(await getTaskTransaction(target));
   const context = await resolveTaskContext(target, { taskId, packageRoot, explicitRequired: true });
   const effectiveTaskId = context.taskId;
 
@@ -130,7 +131,7 @@ export async function runTaskRecover({
       const inspection = await inspectTaskConflictState(target, {
         taskId: effectiveTaskId,
         packageRoot,
-        ignoredLockId: transaction.lock.lockId,
+        ignoredLockId: transaction.lock?.lockId ?? null,
       });
       assertRecoveryAllowed(effectiveTaskId, inspection);
       if (inspection.evidence.workStateRevision !== inspectionBeforeLock.evidence.workStateRevision
@@ -194,6 +195,13 @@ export async function runTaskRecover({
         message: `Task ${effectiveTaskId} recovered by caller acknowledgement; write claims released without completion claim`,
       };
     });
+  }).catch(async error => {
+    if (error.code === "E_STATE_REVISION_CONFLICT" && !nested) {
+      // The failed transaction has rolled back. Report a competing validated
+      // recovery through the existing domain error; never replay claim release.
+      await assertConsistentRecoverableOwnership(target, effectiveTaskId, packageRoot);
+    }
+    throw error;
   });
 }
 

package/src/commands/task-scope.js

@@ -1,3 +1,6 @@
+import { withEventLedgerAudit } from "../core/events.js";
+import { getOperationalStore } from "../storage/operational-context.js";
+import { needsExistingProjectScope, withExistingProjectScope } from "../storage/existing-project-scope.js";
 import { resolveTaskContext } from "../core/task-context.js";
 import { readTaskDescriptor, writeTaskDescriptor } from "../core/task-descriptor.js";
 import { normalizeWriteClaims, assertScopeClean, assertScopeNotFrozen } from "../core/task-scope.js";
@@ -18,8 +21,20 @@ function taskError(code, message, artifacts = []) {
   return error;
 }
 
-export async function runTaskScope({ target, packageRoot, taskId, claims } = {}) {
+export async function runTaskScope(options = {}) {
+  const { target, packageRoot, taskId, claims } = options;
+  const readOnly = claims === undefined || claims === null;
+  if (readOnly && await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => runTaskScope(options), { readOnly: true });
+  }
   const context = await resolveTaskContext(target, { taskId, packageRoot, explicitRequired: true });
+  if (readOnly && getOperationalStore(target)) {
+    return withEventLedgerAudit(target, packageRoot, { taskId: context.taskId }, () => runResolvedTaskScope(options, context));
+  }
+  return runResolvedTaskScope(options, context);
+}
+
+async function runResolvedTaskScope({ target, packageRoot, claims }, context) {
   const effectiveTaskId = context.taskId;
 
   let descriptorArtifact;
@@ -38,6 +53,7 @@ export async function runTaskScope({ target, packageRoot, taskId, claims } = {})
     return withProjectClaimsLock(target, async () => {
       return withTaskLock(target, effectiveTaskId, "task-scope", async () => {
         await assertTaskNotRecovered(target, { taskId: effectiveTaskId, packageRoot });
+        const lockedDescriptor = (await readTaskDescriptor(target, effectiveTaskId, packageRoot)).value;
         const state = await readWorkState(target, { packageRoot, taskId: effectiveTaskId });
         if (state?.phase) {
           assertScopeNotFrozen(state.phase);
@@ -51,7 +67,7 @@ export async function runTaskScope({ target, packageRoot, taskId, claims } = {})
         }
 
         const updatedDescriptor = {
-          ...descriptor,
+          ...lockedDescriptor,
           writeClaims: normalizedClaims,
           updatedAt: new Date().toISOString(),
         };

package/src/commands/task-show.js

@@ -9,6 +9,9 @@ import { E_TASK_NOT_FOUND } from "../core/error-codes.js";
 import { resolveTaskClaimState } from "../core/task-claim-state.js";
 import { readPersistedRoute } from "../core/route-artifact.js";
 import { projectExecutionProfile } from "../core/execution-profile.js";
+import { withEventLedgerAudit } from "../core/events.js";
+import { needsExistingProjectScope, withExistingProjectScope } from "../storage/existing-project-scope.js";
+import { getOperationalStore, operationalArtifactExists } from "../storage/operational-context.js";
 
 function taskError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -17,8 +20,19 @@ function taskError(code, message, artifacts = []) {
   return error;
 }
 
-export async function runTaskShow({ target, packageRoot, taskId, compact = false } = {}) {
+export async function runTaskShow(options = {}) {
+  const { target, packageRoot, taskId } = options;
+  if (await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => runTaskShow(options), { readOnly: true });
+  }
   const context = await resolveTaskContext(target, { taskId, packageRoot, explicitRequired: true, selectionMode: TASK_SELECTION_MODES.READ });
+  if (getOperationalStore(target)) {
+    return withEventLedgerAudit(target, packageRoot, { taskId: context.taskId }, () => projectTaskShow(options, context));
+  }
+  return projectTaskShow(options, context);
+}
+
+async function projectTaskShow({ target, packageRoot, compact = false }, context) {
   const effectiveTaskId = context.taskId;
 
   let descriptor = null;
@@ -54,7 +68,7 @@ export async function runTaskShow({ target, packageRoot, taskId, compact = false
     const rel = taskArtifactPath(effectiveTaskId, name);
     artifacts[name] = {
       path: rel,
-      exists: await fileExists(ensureWithin(target, rel)),
+      exists: operationalArtifactExists(target, rel) ?? await fileExists(ensureWithin(target, rel)),
     };
   }
 

package/src/commands/validate-protocol.js

@@ -8,17 +8,20 @@ import { validateReceipt } from "../core/receipt.js";
 import { validateTaskBrief, validateDelegatedResult } from "../core/delegation.js";
 import { ARTIFACT_PATHS, readJsonArtifact } from "../core/artifacts.js";
 import { evaluatePreflight, validateReadyProtocolConsistency } from "../core/preflight.js";
-import { validateEventLedger, validateStateLedgerCoherence } from "../core/events.js";
+import { withEventLedgerAudit, validateStateLedgerCoherence } from "../core/events.js";
 import { validateChecksExecutionProvenance } from "../core/completion-artifacts.js";
 import { assertContinuitySemantics } from "../core/continuity.js";
 import { currentChangedPaths, currentRepositoryFingerprint } from "../core/repository.js";
 import { resolveTaskClaimState } from "../core/task-claim-state.js";
+import { getOperationalStore, readOperationalText } from "../storage/operational-context.js";
+import { withProjectReadSnapshot } from "../storage/project-read-snapshot.js";
 
 async function readArtifact(target, relativePath, label) {
   if (!relativePath) return null;
   await assertSafePath(target, relativePath);
   const artifactPath = ensureWithin(target, relativePath);
-  if (!(await fileExists(artifactPath))) {
+  const operational = readOperationalText(target, relativePath);
+  if (operational.selected ? operational.text === null : !(await fileExists(artifactPath))) {
     return {
       error: {
         code: "ARTIFACT_MISSING",
@@ -27,7 +30,7 @@ async function readArtifact(target, relativePath, label) {
       },
     };
   }
-  const bytes = await readBytes(artifactPath);
+  const bytes = operational.selected ? Buffer.from(operational.text, "utf8") : await readBytes(artifactPath);
   try {
     assertJsonBytes(bytes, label);
     const value = JSON.parse(bytes.toString("utf8"));
@@ -51,7 +54,11 @@ function isOptionalContinuityAbsence(item) {
 import { taskArtifactPath } from "../core/task-paths.js";
 import { withResolvedTask } from "../core/task-command.js";
 
-export async function runValidateProtocol({
+export async function runValidateProtocol(options) {
+  return withProjectReadSnapshot(options.target, () => validateSelectedProtocol(options));
+}
+
+async function validateSelectedProtocol({
   target,
   packageRoot,
   routeFile = null,
@@ -63,9 +70,17 @@ export async function runValidateProtocol({
   delegatedResultFiles = [],
   taskId = null,
   task = null,
-}) {
+}, ownedLedger = null) {
   return withResolvedTask(target, { taskId: taskId ?? task, packageRoot }, async (ctx) => {
     const effectiveTaskId = ctx?.taskId ?? null;
+    if (effectiveTaskId && getOperationalStore(target) && !ownedLedger) {
+      // Keep the complete final proof local to this immutable projection.
+      // Nested preflight audits retain their own rules and share its source.
+      return withEventLedgerAudit(target, packageRoot, { taskId: effectiveTaskId }, ledger => validateSelectedProtocol({
+        target, packageRoot, routeFile, stateFile, receiptFile, contractFile, continuityFile,
+        taskBriefFiles, delegatedResultFiles, taskId: effectiveTaskId,
+      }, ledger));
+    }
     const effectiveRouteFile = routeFile ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "route") : ARTIFACT_PATHS.route);
     const effectiveStateFile = stateFile ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "state") : ARTIFACT_PATHS.state);
     const effectiveReceiptFile = receiptFile ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "receipt") : ARTIFACT_PATHS.receipt);
@@ -169,19 +184,15 @@ export async function runValidateProtocol({
   } catch {
     // A missing or invalid preflight is already outside the optional protocol set.
   }
-  let ledgerEvents = [];
-  let ledgerErrors = [];
-  if (state && !stateValidationError) {
-    const ledger = await validateEventLedger(target, packageRoot, { taskId: effectiveTaskId, eventsPath: effectiveEventsFile });
-    ledgerEvents = ledger.events ?? [];
-    ledgerErrors = [
+  const finish = async (ledger) => {
+    const ledgerEvents = ledger.events ?? [];
+    const ledgerErrors = state && !stateValidationError ? [
       ...ledger.errors.map((error) => ({ ...error, artifacts: [effectiveEventsFile] })),
-      ...validateStateLedgerCoherence(state, ledger.events).map((error) => ({
+      ...validateStateLedgerCoherence(state, ledgerEvents).map((error) => ({
         ...error,
         artifacts: [effectiveStateFile, effectiveEventsFile],
       })),
-    ];
-  }
+    ] : [];
   const recoveryErrors = [];
   if (effectiveTaskId) {
     try {
@@ -225,6 +236,10 @@ export async function runValidateProtocol({
       };
     }
     return result;
+  };
+  return state && !stateValidationError
+    ? ownedLedger ? finish(ownedLedger) : withEventLedgerAudit(target, packageRoot, { taskId: effectiveTaskId, eventsPath: effectiveEventsFile }, finish)
+    : finish({ events: [], errors: [] });
   });
 }
 

package/src/commands/validate-receipt.js

@@ -4,13 +4,17 @@ import { assertJsonBytes, assertJsonLimits } from "../core/json-safety.js";
 import { ARTIFACT_PATHS } from "../core/artifacts.js";
 import { taskArtifactPath } from "../core/task-paths.js";
 import { withResolvedTask } from "../core/task-command.js";
+import { readOperationalText } from "../storage/operational-context.js";
+import { isOperationalArtifactPath, needsExistingProjectScope, withExistingProjectScope } from "../storage/existing-project-scope.js";
 
 async function validateReceiptFile(target, packageRoot, relativeFile) {
   await assertSafePath(target, relativeFile);
   const receiptPath = ensureWithin(target, relativeFile);
   let receipt;
   try {
-    const bytes = await readBytes(receiptPath);
+    const operational = readOperationalText(target, relativeFile);
+    if (operational.selected && operational.text === null) throw new Error("Receipt is missing from canonical storage");
+    const bytes = operational.selected ? Buffer.from(operational.text, "utf8") : await readBytes(receiptPath);
     assertJsonBytes(bytes, relativeFile);
     receipt = JSON.parse(bytes.toString("utf8"));
     assertJsonLimits(receipt, relativeFile);
@@ -43,6 +47,9 @@ export async function runValidateReceipt({
   file = null,
   taskId = null,
 } = {}) {
+  if ((!file || isOperationalArtifactPath(file)) && await needsExistingProjectScope(target)) {
+    return withExistingProjectScope(target, () => runValidateReceipt({ target, packageRoot, file, taskId }), { readOnly: true });
+  }
   if (file) {
     return validateReceiptFile(target, packageRoot, file);
   }

package/src/config/guides.json

@@ -86,5 +86,9 @@
   "swift": {
     "path": "ENG/swift-development-eng.md",
     "install": true
+  },
+  "python": {
+    "path": "ENG/python-development-eng.md",
+    "install": true
   }
 }

package/src/core/action-ledger-projection.js

@@ -1,4 +1,4 @@
-import { readEvents } from "./events.js";
+import { iterateEvents } from "./events.js";
 import { assertActionTransition, assertActionAuthorizationDetails } from "./action-model.js";
 import { E_ACTION_EVIDENCE_INVALID } from "./error-codes.js";
 
@@ -27,6 +27,14 @@ function hasCanonicalVerificationEvidence(details) {
   );
 }
 
+async function readActionChronology(target, packageRoot, taskId, actionId) {
+  const chronology = [];
+  for await (const event of iterateEvents(target, packageRoot, { taskId })) {
+    if (event.details?.actionId === actionId) chronology.push(event);
+  }
+  return chronology;
+}
+
 function issue(code, message) {
   return { code, message };
 }
@@ -49,8 +57,7 @@ export async function projectActionLedger({
   actionId,
   artifact = null,
 }) {
-  const events = await readEvents(target, packageRoot, { taskId });
-  const chronology = events.filter((event) => event.details?.actionId === actionId);
+  const chronology = await readActionChronology(target, packageRoot, taskId, actionId);
   const errors = [];
 
   const proposed = chronology.find((event) => event.event === "ACTION_PROPOSED");