@cassiomc1/forgeloop 1.0.0 → 1.1.0

package/src/core/audit.js

@@ -5,20 +5,40 @@ import { PROTOCOL_VERSION } from "./protocol.js";
 import { readJsonArtifact } from "./artifacts.js";
 import { currentChangedPaths } from "./repository.js";
 import { validateReadyProtocolConsistency } from "./preflight.js";
+import { taskArtifactPath } from "./task-paths.js";
+import { readTaskDescriptor } from "./task-descriptor.js";
 
 function sortErrors(errors) {
   return [...errors].sort((left, right) => left.code.localeCompare(right.code)
     || left.message.localeCompare(right.message));
 }
 
-async function compareChangedPaths(target, packageRoot) {
+async function compareChangedPaths(target, packageRoot, options = {}) {
+  const receiptRel = options.receiptPath ?? (options.taskId ? taskArtifactPath(options.taskId, "receipt") : ARTIFACT_PATHS.receipt);
   let receipt;
   try {
-    receipt = (await readJsonArtifact(target, ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot)).value;
+    receipt = (await readJsonArtifact(target, receiptRel, "execution-receipt", packageRoot)).value;
   } catch {
     return { status: "NOT_VERIFIED", expected: [], observed: [], missing: [], unexpected: [] };
   }
-  const observed = await currentChangedPaths(target);
+
+  let writeClaims = [];
+  if (options.taskId) {
+    try {
+      const desc = await readTaskDescriptor(target, options.taskId, packageRoot);
+      writeClaims = desc.value.writeClaims ?? [];
+    } catch {
+      // ignore
+    }
+  }
+
+  let observed;
+  if (writeClaims.length > 0) {
+    observed = await currentChangedPaths(target, { paths: writeClaims });
+  } else {
+    observed = await currentChangedPaths(target);
+  }
+
   if (observed === null) {
     return { status: "NOT_VERIFIED", expected: receipt.changedPaths ?? [], observed: [], missing: [], unexpected: [] };
   }
@@ -34,8 +54,40 @@ async function compareChangedPaths(target, packageRoot) {
   };
 }
 
-export async function evaluateAudit({ target, packageRoot, strict = false, authorityContext, runtimeContext } = {}) {
-  const completion = await evaluateCompletion({ target, packageRoot, strict, authorityContext, runtimeContext });
+export async function evaluateAudit({
+  target,
+  packageRoot,
+  strict = false,
+  authorityContext,
+  runtimeContext,
+  taskId = null,
+  contractPath = null,
+  routePath = null,
+  statePath = null,
+  receiptPath = null,
+  eventsPath = null,
+  preflightPath = null,
+} = {}) {
+  const completion = await evaluateCompletion({
+    target,
+    packageRoot,
+    strict,
+    authorityContext,
+    runtimeContext,
+    taskId,
+    contractPath,
+    routePath,
+    statePath,
+    receiptPath,
+    eventsPath,
+    preflightPath,
+  });
+  const preflightRel = preflightPath ?? (taskId ? taskArtifactPath(taskId, "preflight") : ARTIFACT_PATHS.preflight);
+  const receiptRel = receiptPath ?? (taskId ? taskArtifactPath(taskId, "receipt") : ARTIFACT_PATHS.receipt);
+  const stateRel = statePath ?? (taskId ? taskArtifactPath(taskId, "state") : ARTIFACT_PATHS.state);
+  const contractRel = contractPath ?? (taskId ? taskArtifactPath(taskId, "contract") : ARTIFACT_PATHS.contract);
+  const routeRel = routePath ?? (taskId ? taskArtifactPath(taskId, "route") : ARTIFACT_PATHS.route);
+
   let manifest = null;
   let manifestError = null;
   try {
@@ -45,25 +97,26 @@ export async function evaluateAudit({ target, packageRoot, strict = false, autho
   }
   let readyConsistencyErrors = [];
   try {
-    const persistedPreflight = await readJsonArtifact(target, ARTIFACT_PATHS.preflight, "preflight", packageRoot);
+    const persistedPreflight = await readJsonArtifact(target, preflightRel, "preflight", packageRoot);
     if (persistedPreflight.value.status === "READY") {
       readyConsistencyErrors = await validateReadyProtocolConsistency({
         target,
         packageRoot,
         persisted: persistedPreflight.value,
         current: completion.preflight,
+        taskId,
       });
     }
   } catch {
     // Completion already reports missing or invalid preflight artifacts.
   }
   const errors = sortErrors([...completion.errors, ...readyConsistencyErrors]);
-  const changedPaths = await compareChangedPaths(target, packageRoot);
+  const changedPaths = await compareChangedPaths(target, packageRoot, { taskId, receiptPath });
   if (changedPaths.status === "MISMATCH") {
     errors.push({
       code: "E_RECEIPT_PATH_MISMATCH",
       message: "Receipt changedPaths do not match observed repository paths",
-      artifacts: [ARTIFACT_PATHS.receipt],
+      artifacts: [receiptRel],
       missing: changedPaths.missing,
       unexpected: changedPaths.unexpected,
       next: "Run forgeloop prepare-completion to refresh changed paths, then rerun audit.",
@@ -94,10 +147,10 @@ export async function evaluateAudit({ target, packageRoot, strict = false, autho
     publicationStatus: completion.publicationStatus,
     productionReadiness: completion.productionReadiness,
     artifacts: {
-      contract: ARTIFACT_PATHS.contract,
-      route: ARTIFACT_PATHS.route,
-      state: ARTIFACT_PATHS.state,
-      receipt: ARTIFACT_PATHS.receipt,
+      contract: contractRel,
+      route: routeRel,
+      state: stateRel,
+      receipt: receiptRel,
     },
   };
 }

package/src/core/bundles.js

@@ -1,12 +1,13 @@
 import { readdir } from "node:fs/promises";
 
 import { ARTIFACT_PATHS, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
-import { readContract, validateContract } from "./contract.js";
+import { validateContract } from "./contract.js";
 import { assertSafePath, ensureWithin, fileExists, readBytes, writeFileAtomic } from "./filesystem.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
 import { validateChecksExecutionProvenance } from "./completion-artifacts.js";
 import { readExecutionArtifact } from "./execution.js";
 import { assertContinuitySemantics } from "./continuity.js";
+import { taskArtifactPath, taskDirectory } from "./task-paths.js";
 
 export const BUNDLE_SCHEMA_VERSION = 1;
 const BUNDLE_ROOT = ".forgeloop/tasks";
@@ -36,88 +37,116 @@ async function copyJson(target, sourcePath, destinationPath, schemaName, package
   }
 }
 
+async function tryReadJson(target, taskPath, legacyPath, schemaName, packageRoot) {
+  try {
+    return await readJsonArtifact(target, taskPath, schemaName, packageRoot);
+  } catch (error) {
+    if (error.code === "ARTIFACT_MISSING" && legacyPath) {
+      return await readJsonArtifact(target, legacyPath, schemaName, packageRoot);
+    }
+    throw error;
+  }
+}
+
 export async function exportTaskBundle(target, taskId, packageRoot) {
   safeTaskId(taskId);
   const directory = bundleDirectory(taskId);
   const artifacts = [];
-  const stateSource = await readJsonArtifact(target, ARTIFACT_PATHS.state, "work-state", packageRoot);
+
+  const stateSource = await tryReadJson(target, taskArtifactPath(taskId, "state"), ARTIFACT_PATHS.state, "work-state", packageRoot);
   let receiptSource = null;
   try {
-    receiptSource = await readJsonArtifact(target, ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot);
+    receiptSource = await tryReadJson(target, taskArtifactPath(taskId, "receipt"), ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot);
   } catch (error) {
     if (error.code !== "ARTIFACT_MISSING") throw error;
   }
-  const provenanceErrors = [
-    ...(await validateChecksExecutionProvenance(stateSource.value.checks, {
-      target,
-      packageRoot,
-      taskId,
-      artifactPath: ARTIFACT_PATHS.state,
-    })),
-    ...(await validateChecksExecutionProvenance(receiptSource?.value?.checks, {
+
+  await validateChecksExecutionProvenance(stateSource.value.checks, {
+    target,
+    packageRoot,
+    taskId,
+    artifactPath: ARTIFACT_PATHS.state,
+  });
+  if (receiptSource?.value?.checks) {
+    await validateChecksExecutionProvenance(receiptSource.value.checks, {
       target,
       packageRoot,
       taskId,
       artifactPath: ARTIFACT_PATHS.receipt,
-    })),
-  ];
-  if (provenanceErrors.length > 0) {
-    const first = provenanceErrors[0];
-    const error = new Error(first.message);
-    error.code = first.code;
-    error.artifacts = first.artifacts;
-    throw error;
+    });
   }
+
   const required = [
-    [ARTIFACT_PATHS.contract, "contract.json", "current-contract"],
-    [ARTIFACT_PATHS.route, "route.json", "routing-result"],
-    [ARTIFACT_PATHS.state, "state.json", "work-state"],
+    [taskArtifactPath(taskId, "contract"), ARTIFACT_PATHS.contract, "contract.json", "current-contract"],
+    [taskArtifactPath(taskId, "route"), ARTIFACT_PATHS.route, "route.json", "routing-result"],
+    [taskArtifactPath(taskId, "state"), ARTIFACT_PATHS.state, "state.json", "work-state"],
   ];
-  for (const [sourcePath, destinationName, schemaName] of required) {
-    const source = schemaName === "current-contract"
-      ? await readContract(target, packageRoot)
-      : await readJsonArtifact(target, sourcePath, schemaName, packageRoot);
+  for (const [taskRel, legacyRel, destinationName, schemaName] of required) {
+    const source = await tryReadJson(target, taskRel, legacyRel, schemaName, packageRoot);
+    if (schemaName === "current-contract") {
+      await validateContract(source.value, packageRoot);
+    }
     if (source.value.taskId !== undefined && source.value.taskId !== taskId) {
-      const error = new Error(`${sourcePath} belongs to ${source.value.taskId}, not ${taskId}`);
+      const error = new Error(`${taskRel} belongs to ${source.value.taskId}, not ${taskId}`);
       error.code = "E_BUNDLE_TASK_MISMATCH";
       throw error;
     }
     await writeJsonArtifact(target, `${directory}/${destinationName}`, source.value, schemaName, packageRoot);
     artifacts.push(destinationName);
   }
+
   const optional = [
-    [ARTIFACT_PATHS.preflight, "preflight.json", "preflight"],
-    [ARTIFACT_PATHS.receipt, "receipt.json", "execution-receipt"],
-    [ARTIFACT_PATHS.sources, "sources.json", "source-registry"],
-    [ARTIFACT_PATHS.config, "config.json", "config"],
-    [ARTIFACT_PATHS.continuity, "continuity.json", "continuity"],
+    [taskArtifactPath(taskId, "preflight"), ARTIFACT_PATHS.preflight, "preflight.json", "preflight"],
+    [taskArtifactPath(taskId, "receipt"), ARTIFACT_PATHS.receipt, "receipt.json", "execution-receipt"],
+    [taskArtifactPath(taskId, "descriptor"), null, "task.json", "task-descriptor"],
+    [ARTIFACT_PATHS.sources, null, "sources.json", "source-registry"],
+    [ARTIFACT_PATHS.config, null, "config.json", "config"],
+    [taskArtifactPath(taskId, "continuity"), ARTIFACT_PATHS.continuity, "continuity.json", "continuity"],
   ];
-  for (const [sourcePath, destinationName, schemaName] of optional) {
-    const copied = await copyJson(target, sourcePath, `${directory}/${destinationName}`, schemaName, packageRoot, artifacts, destinationName);
+  for (const [taskRel, legacyRel, destinationName, schemaName] of optional) {
+    let copied = null;
+    try {
+      copied = await copyJson(target, taskRel, `${directory}/${destinationName}`, schemaName, packageRoot, artifacts, destinationName);
+    } catch {
+      if (legacyRel) {
+        copied = await copyJson(target, legacyRel, `${directory}/${destinationName}`, schemaName, packageRoot, artifacts, destinationName);
+      }
+    }
     if (copied && !artifacts.includes(destinationName)) artifacts.push(destinationName);
   }
+
   const executionRefs = [...new Set([
     ...(stateSource.value.checks ?? []),
     ...(receiptSource?.value?.checks ?? []),
   ].map((check) => check?.executionRef).filter(Boolean))].sort();
   for (const executionRef of executionRefs) {
-    const execution = await readExecutionArtifact({ target, executionRef, packageRoot });
+    const execution = await readExecutionArtifact({ target, executionRef, packageRoot, taskId });
     const destination = `${directory}/executions/${execution.value.executionId}.json`;
     await writeJsonArtifact(target, destination, execution.value, "execution", packageRoot);
     artifacts.push(`executions/${execution.value.executionId}.json`);
   }
-  const eventsPath = ensureWithin(target, ARTIFACT_PATHS.events);
+
+  // Events
+  let eventsPath = ensureWithin(target, taskArtifactPath(taskId, "events"));
+  if (!(await fileExists(eventsPath))) {
+    eventsPath = ensureWithin(target, ARTIFACT_PATHS.events);
+  }
   if (await fileExists(eventsPath)) {
     await assertSafePath(target, `${directory}/events.ndjson`);
     await writeFileAtomic(ensureWithin(target, `${directory}/events.ndjson`), await readBytes(eventsPath));
     artifacts.push("events.ndjson");
   }
-  const gateDirectory = ensureWithin(target, ARTIFACT_PATHS.gates);
+
+  // Gates
+  let gateDirectory = ensureWithin(target, `${taskDirectory(taskId)}/gates`);
+  if (!(await fileExists(gateDirectory))) {
+    gateDirectory = ensureWithin(target, ARTIFACT_PATHS.gates);
+  }
   if (await fileExists(gateDirectory)) {
     const entries = await readdir(gateDirectory, { withFileTypes: true });
     for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".json")).sort((left, right) => left.name.localeCompare(right.name))) {
       const gateName = entry.name.slice(0, -5);
-      const sourcePath = `${ARTIFACT_PATHS.gates}/${entry.name}`;
+      const sourcePath = `${gateDirectory.replace(target + "/", "")}/${entry.name}`;
       const destinationPath = `${directory}/gates/${entry.name}`;
       const gate = await readJsonArtifact(target, sourcePath, "gate", packageRoot);
       if (gate.value.taskId !== taskId) continue;
@@ -125,6 +154,7 @@ export async function exportTaskBundle(target, taskId, packageRoot) {
       artifacts.push(`gates/${gateName}.json`);
     }
   }
+
   artifacts.sort();
   const manifest = {
     schemaVersion: BUNDLE_SCHEMA_VERSION,
@@ -149,6 +179,7 @@ export async function readTaskBundle(target, taskId, packageRoot) {
     "sources.json": ["sources", "source-registry"],
     "config.json": ["config", "config"],
     "continuity.json": ["continuity", "continuity"],
+    "task.json": ["descriptor", "task-descriptor"],
   };
   const executions = {};
   for (const artifact of manifest.value.artifacts) {
@@ -169,30 +200,25 @@ export async function readTaskBundle(target, taskId, packageRoot) {
     loaded[mapping[0]] = loadedArtifact.value;
   }
   if (Object.keys(executions).length > 0) loaded.executions = executions;
-  const provenanceErrors = [
-    ...(await validateChecksExecutionProvenance(loaded.state?.checks, {
+  if (loaded.state?.checks) {
+    await validateChecksExecutionProvenance(loaded.state.checks, {
       target,
       packageRoot,
       taskId,
       executionArtifacts: executions,
       allowForeignCwd: true,
       artifactPath: "state.json",
-    })),
-    ...(await validateChecksExecutionProvenance(loaded.receipt?.checks, {
+    });
+  }
+  if (loaded.receipt?.checks) {
+    await validateChecksExecutionProvenance(loaded.receipt.checks, {
       target,
       packageRoot,
       taskId,
       executionArtifacts: executions,
       allowForeignCwd: true,
       artifactPath: "receipt.json",
-    })),
-  ];
-  if (provenanceErrors.length > 0) {
-    const first = provenanceErrors[0];
-    const error = new Error(first.message);
-    error.code = first.code;
-    error.artifacts = first.artifacts;
-    throw error;
+    });
   }
   return { manifest: manifest.value, artifacts: loaded };
 }