@cassiomc1/forgeloop 0.1.14 → 0.1.16

package/src/commands/clear-continuity.js

@@ -0,0 +1,9 @@
+import { clearContinuity } from "../core/continuity.js";
+
+export async function runClearContinuity({ target } = {}) {
+  return clearContinuity(target);
+}
+
+export function formatClearContinuityResult(result) {
+  return `${result.removed ? "cleared" : "absent"}: ${result.path}\n`;
+}

package/src/commands/continuity.js

@@ -0,0 +1,25 @@
+import { reconcileContinuity } from "../core/continuity-reconciliation.js";
+
+export async function runContinuity({ target, packageRoot } = {}) {
+  return reconcileContinuity({ target, packageRoot });
+}
+
+export function formatContinuityResult(result) {
+  const value = result.continuity;
+  const lines = [
+    "FORGELOOP EXECUTION CONTINUITY",
+    "",
+    `classification: ${result.classification}`,
+    `task: ${value?.taskId ?? "none"}`,
+    `phase: ${value?.phase ?? "none"}`,
+    `current focus: ${value?.currentFocus?.id ?? "none"}`,
+    `remaining work: ${value?.remainingWork?.length ?? 0}`,
+    `known issues: ${value?.knownIssues?.length ?? 0}`,
+    `inspect first: ${value?.inspectFirst?.join(", ") || "none"}`,
+    "",
+    "Authority: OPERATIONAL_CONTEXT_ONLY",
+    "Evidence: NONE",
+  ];
+  if (result.reasons?.length) lines.push(`Reasons: ${result.reasons.join(", ")}`);
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/doctor.js

@@ -1,4 +1,4 @@
-import { assertSafePath, fileExists, ensureWithin, readBytes } from "../core/filesystem.js";
+import { assertSafePath, fileExists, ensureWithin, readBytes, writeFileAtomic } from "../core/filesystem.js";
 import { readManifest, sha256, writeManifest } from "../core/manifest.js";
 import { readTemplateEntries } from "../core/templates.js";
 import { createEvidence } from "../core/evidence.js";
@@ -113,9 +113,10 @@ async function adoptAdapters({ target, manifest, adoptPaths, findings }) {
   return nextManifest;
 }
 
-export async function runDoctor({ target, packageRoot, adoptPaths = [], strict = false }) {
+export async function runDoctor({ target, packageRoot, adoptPaths = [], strict = false, fix = false }) {
   const findings = [];
   let manifest = null;
+  let manifestChanged = false;
   try {
     manifest = await readManifest(target);
     if (!manifest) {
@@ -186,6 +187,16 @@ export async function runDoctor({ target, packageRoot, adoptPaths = [], strict =
         ));
         continue;
       }
+      if (fix && manifest && (layoutVersion >= LAYOUT_VERSION || managedPath.startsWith(".forgeloop/"))) {
+        await writeFileAtomic(destination, entry.bytes);
+        manifest.files[managedPath] = {
+          sha256: sha256(entry.bytes),
+          preserve: entry.sourcePath === "PROJECT_PROFILE.md",
+        };
+        manifestChanged = true;
+        findings.push(finding("file-restored", "info", managedPath, "Restored missing managed template file.", "No action required."));
+        continue;
+      }
       findings.push(finding("file-missing", "error", managedPath, "Managed file is missing."));
       continue;
     }
@@ -280,6 +291,10 @@ export async function runDoctor({ target, packageRoot, adoptPaths = [], strict =
     }
   }
 
+  if (manifestChanged && manifest) {
+    await writeManifest(target, manifest);
+  }
+
   const ok = findings.every((item) => item.severity !== "error")
     && (!strict || findings.every((item) => item.severity !== "warning"));
   return {

package/src/commands/reconcile-continuity.js

@@ -0,0 +1,23 @@
+import { reconcileContinuity } from "../core/continuity-reconciliation.js";
+
+export async function runReconcileContinuity({ target, packageRoot } = {}) {
+  return reconcileContinuity({ target, packageRoot });
+}
+
+export function formatReconcileContinuityResult(result) {
+  const lines = [
+    `Continuity: ${result.path ?? ".forgeloop/continuity.json"}`,
+    `Classification: ${result.classification}`,
+    `Task matches: ${result.taskMatches ?? "not-verified"}`,
+    `Work state matches: ${result.workStateMatches ?? "not-verified"}`,
+    `Contract matches: ${result.contractMatches ?? "not-verified"}`,
+    `Phase matches: ${result.phaseMatches ?? "not-verified"}`,
+    `Repository: ${result.repositoryComparison}`,
+    `Changed paths: ${result.changedPathComparison}`,
+    "Authority: OPERATIONAL_CONTEXT_ONLY",
+    "Evidence: NONE",
+  ];
+  if (result.reasonCodes?.length) lines.push(`Reason codes: ${result.reasonCodes.join(", ")}`);
+  if (result.reasons?.length) lines.push(`Reasons: ${result.reasons.join(", ")}`);
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/record-continuity.js

@@ -0,0 +1,63 @@
+import { writeContinuity } from "../core/continuity.js";
+
+function parseWorkItem(value, label) {
+  if (typeof value !== "string") throw new Error(`${label} must use <id>:<summary>`);
+  const separator = value.indexOf(":");
+  if (separator <= 0 || separator === value.length - 1) {
+    throw new Error(`${label} must use <id>:<summary>`);
+  }
+  return {
+    id: value.slice(0, separator).trim(),
+    summary: value.slice(separator + 1).trim(),
+  };
+}
+
+export async function runRecordContinuity({
+  target,
+  packageRoot,
+  focusId,
+  focusSummary,
+  remaining = [],
+  knownIssues = [],
+  changedAreas = [],
+  inspectFirst = [],
+  resumeNote,
+  state,
+  contract,
+  repositoryFingerprint,
+  now,
+  dryRun = false,
+} = {}) {
+  if ((focusId && !focusSummary) || (!focusId && focusSummary)) {
+    throw new Error("record-continuity requires --focus-id and --focus-summary together");
+  }
+  return writeContinuity(target, {
+    ...(focusId ? { currentFocus: { id: focusId, summary: focusSummary } } : {}),
+    remainingWork: remaining.map((item) => parseWorkItem(item, "--remaining")),
+    knownIssues: knownIssues.map((item) => parseWorkItem(item, "--known-issue")),
+    changedAreas,
+    inspectFirst,
+    ...(resumeNote ? { resumeNote } : {}),
+  }, {
+    packageRoot,
+    ...(state ? { state } : {}),
+    ...(contract ? { contract } : {}),
+    ...(repositoryFingerprint ? { repositoryFingerprint } : {}),
+    ...(now ? { now } : {}),
+    dryRun,
+  });
+}
+
+export function formatRecordContinuityResult(result) {
+  const value = result.value;
+  return [
+    `Continuity: ${result.path}`,
+    `Task: ${value.taskId}`,
+    `Phase: ${value.phase}`,
+    `Focus: ${value.currentFocus?.id ?? "none"}`,
+    `Remaining: ${value.remainingWork.length}`,
+    `Known issues: ${value.knownIssues.length}`,
+    "Authority: OPERATIONAL_CONTEXT_ONLY",
+    "Evidence: NONE",
+  ].join("\n") + "\n";
+}

package/src/commands/run-check.js

@@ -0,0 +1,83 @@
+import {
+  assertRecordCheckPrerequisites,
+  recordCheck as recordCheckArtifact,
+} from "../core/completion-artifacts.js";
+import { runCommandExecution } from "../core/execution.js";
+
+export async function runCheck({
+  target,
+  packageRoot,
+  id,
+  requirement,
+  argv,
+  details,
+  authorityContext,
+  runtimeContext,
+}) {
+  if (typeof id !== "string" || id.trim() === "" || typeof requirement !== "string" || requirement.trim() === "") {
+    const error = new Error("run-check requires non-empty id and requirement");
+    error.code = "E_CHECK_INVALID";
+    throw error;
+  }
+  const ready = await assertRecordCheckPrerequisites({
+    target,
+    packageRoot,
+    requirement,
+    status: "passed",
+    evidenceKind: "OBSERVED",
+    authorityContext,
+    runtimeContext,
+  });
+  const verificationCycle = ready.state.verificationCycle ?? 1;
+  const execution = await runCommandExecution({
+    target,
+    packageRoot,
+    taskId: ready.contract.value.taskId,
+    checkId: id,
+    requirement,
+    verificationCycle,
+    argv,
+    details,
+    authorityContext,
+    runtimeContext,
+  });
+  const status = execution.execution.status === "passed" ? "passed" : "failed";
+  const recorded = await recordCheckArtifact({
+    target,
+    packageRoot,
+    id,
+    kind: "command",
+    requirement,
+    status,
+    evidenceKind: "OBSERVED",
+    command: execution.execution.argv.join(" "),
+    result: execution.result,
+    ...(execution.execution.exitCode === null ? {} : { exitCode: execution.execution.exitCode }),
+    details,
+    executionRef: execution.execution.executionId,
+    provenance: "FORGELOOP_EXECUTED",
+    authorityContext,
+    runtimeContext,
+  });
+  return {
+    ...recorded,
+    execution: execution.execution,
+    executionPath: execution.path,
+  };
+}
+
+export function formatRunCheckResult(result) {
+  return [
+    "FORGELOOP CHECK EXECUTED",
+    `id: ${result.check.id}`,
+    `requirement: ${result.check.requirement}`,
+    `status: ${result.check.status}`,
+    `execution: ${result.execution.executionId}`,
+    `argv: ${result.execution.argv.join(" ")}`,
+    `exit code: ${result.execution.exitCode ?? "not-started"}`,
+    `artifact: ${result.executionPath}`,
+    `coverage: ${result.coverage.find((item) => item.requirement === result.check.requirement)?.status ?? "NOT_VERIFIED"}`,
+    `receipt: ${result.path}`,
+    "",
+  ].join("\n");
+}

package/src/commands/status.js

@@ -1,12 +1,17 @@
 import { readAndClassifyWorkState } from "../core/work-state.js";
 import { inspectSchemaHealth } from "../core/schema-validation.js";
+import { reconcileContinuity } from "../core/continuity-reconciliation.js";
 
 export async function runStatus({ target, packageRoot, contractFile = null }) {
   const state = await readAndClassifyWorkState({ target, packageRoot, contractFile });
-  const protocol = await inspectSchemaHealth(target);
+  const [protocol, continuity] = await Promise.all([
+    inspectSchemaHealth(target),
+    reconcileContinuity({ target, packageRoot }),
+  ]);
   return {
     ...state,
     protocol,
+    continuity,
     evidence: [...(state.evidence ?? []), ...(protocol.evidence ?? [])],
   };
 }
@@ -24,6 +29,14 @@ export function formatStatusResult(result) {
   if (result.contractComparison) lines.push(`Contract: ${result.contractComparison}`);
   if (result.artifactComparison) lines.push(`Artifacts: ${result.artifactComparison}`);
   if (result.protocol) lines.push(`Schemas: ${result.protocol.status}`);
+  if (result.continuity) {
+    const continuity = result.continuity.continuity;
+    lines.push(`Continuity: ${result.continuity.classification}`);
+    lines.push(`Continuity focus: ${continuity?.currentFocus?.id ?? "none"}`);
+    lines.push(`Continuity remaining: ${continuity?.remainingWork?.length ?? 0}`);
+    lines.push(`Continuity known issues: ${continuity?.knownIssues?.length ?? 0}`);
+    lines.push(`Continuity authority: ${result.continuity.authority ?? "OPERATIONAL_CONTEXT_ONLY"}`);
+  }
   if (result.error) lines.push(`Error: ${result.error}`);
   return `${lines.join("\n")}\n`;
 }

package/src/commands/update.js

@@ -9,9 +9,8 @@ import {
   writeManifest,
 } from "../core/manifest.js";
 import { readTemplateEntries } from "../core/templates.js";
-import { isNativeAdapterPath, LAYOUT_VERSION } from "../core/target-layout.js";
+import { isNativeAdapterPath, LAYOUT_VERSION, LEGACY_PROFILE_PATH } from "../core/target-layout.js";
 
-const PROFILE_PATH = "PROJECT_PROFILE.md";
 const LEGACY_CLEANUP_DIRECTORIES = Object.freeze(["ENG", "schemas"]);
 
 function migrationConflict(code, path, message) {
@@ -169,7 +168,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
       const legacyHash = legacyBytes ? sha256(legacyBytes) : null;
       const unchangedManagedLegacy = Boolean(legacyRecord) && legacyHash === legacyRecord.sha256;
 
-      if (entry.sourcePath === PROFILE_PATH
+      if (entry.sourcePath === LEGACY_PROFILE_PATH
         && legacyExists
         && legacyRecord
         && currentHash === legacyHash) {
@@ -179,7 +178,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
         continue;
       }
 
-      if (!hiddenMatchesSource && !destinationRecord && entry.sourcePath !== PROFILE_PATH) {
+      if (!hiddenMatchesSource && !destinationRecord && entry.sourcePath !== LEGACY_PROFILE_PATH) {
         conflicts.push(migrationConflict(
           "E_HIDDEN_KIT_MIGRATION_CONFLICT",
           entry.relativePath,
@@ -191,12 +190,12 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
         addLegacyCleanup(cleanupFiles, cleanupDirectories, entry.legacyRelativePath, legacyHash);
         nextManifest.files[entry.relativePath] = manifestRecord(
           sourceHash,
-          entry.sourcePath === PROFILE_PATH,
+          entry.sourcePath === LEGACY_PROFILE_PATH,
           legacyHash,
         );
         continue;
       } else if (hiddenMatchesSource && legacyExists) {
-        const conflict = entry.sourcePath === PROFILE_PATH
+        const conflict = entry.sourcePath === LEGACY_PROFILE_PATH
           ? migrationConflict(
             "E_PROFILE_MIGRATION_CONFLICT",
             entry.legacyRelativePath,
@@ -214,7 +213,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
       }
       nextManifest.files[entry.relativePath] = manifestRecord(
         currentHash,
-        entry.sourcePath === PROFILE_PATH
+        entry.sourcePath === LEGACY_PROFILE_PATH
           || !destinationRecord
           || Boolean(destinationRecord.preserve),
       );
@@ -224,7 +223,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
     if (!legacyExists) {
       addAction(actions, dryRun, "create", entry.relativePath);
       writes.push({ destination, bytes: entry.bytes });
-      nextManifest.files[entry.relativePath] = manifestRecord(sourceHash, entry.sourcePath === PROFILE_PATH);
+      nextManifest.files[entry.relativePath] = manifestRecord(sourceHash, entry.sourcePath === LEGACY_PROFILE_PATH);
       continue;
     }
 
@@ -232,7 +231,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
     const legacyHash = sha256(legacyBytes);
     const unchangedManaged = Boolean(legacyRecord) && legacyHash === legacyRecord.sha256;
 
-    if (entry.sourcePath === PROFILE_PATH && legacyRecord) {
+    if (entry.sourcePath === LEGACY_PROFILE_PATH && legacyRecord) {
       addAction(actions, dryRun, "move-profile", entry.legacyRelativePath, { to: entry.relativePath });
       writes.push({ destination, bytes: legacyBytes });
       addLegacyCleanup(cleanupFiles, cleanupDirectories, entry.legacyRelativePath, legacyHash);
@@ -256,7 +255,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
       continue;
     }
 
-    const conflict = entry.sourcePath === PROFILE_PATH
+    const conflict = entry.sourcePath === LEGACY_PROFILE_PATH
       ? migrationConflict(
         "E_PROFILE_MIGRATION_CONFLICT",
         entry.legacyRelativePath,
@@ -275,7 +274,7 @@ async function migrateLegacyLayout({ target, dryRun, packageVersion, currentMani
       reason: legacyRecord ? "managed-modified" : "unmanaged",
     });
     writes.push({ destination, bytes: entry.bytes });
-    nextManifest.files[entry.relativePath] = manifestRecord(sourceHash, entry.sourcePath === PROFILE_PATH);
+    nextManifest.files[entry.relativePath] = manifestRecord(sourceHash, entry.sourcePath === LEGACY_PROFILE_PATH);
   }
 
   // Apply all hidden writes and verify their bytes before changing manifest authority.
@@ -364,7 +363,7 @@ export async function runUpdate({ target, dryRun, packageRoot, packageVersion, h
         entry,
         record: {
           sha256: sourceHash,
-          preserve: entry.sourcePath === PROFILE_PATH,
+          preserve: entry.sourcePath === LEGACY_PROFILE_PATH,
           ...(record?.legacySha256 ? { legacySha256: record.legacySha256 } : {}),
         },
       });
@@ -376,7 +375,7 @@ export async function runUpdate({ target, dryRun, packageRoot, packageVersion, h
       continue;
     }
 
-    if (record.preserve || entry.sourcePath === PROFILE_PATH) {
+    if (record.preserve || entry.sourcePath === LEGACY_PROFILE_PATH) {
       actions.push({ action: "skip", path: entry.relativePath, reason: "preserved" });
       continue;
     }

package/src/commands/validate-protocol.js

@@ -9,6 +9,9 @@ import { validateTaskBrief, validateDelegatedResult } from "../core/delegation.j
 import { ARTIFACT_PATHS, readJsonArtifact } from "../core/artifacts.js";
 import { evaluatePreflight, validateReadyProtocolConsistency } from "../core/preflight.js";
 import { validateEventLedger, 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";
 
 async function readArtifact(target, relativePath, label) {
   if (!relativePath) return null;
@@ -47,6 +50,7 @@ export async function runValidateProtocol({
   stateFile = null,
   receiptFile = null,
   contractFile = null,
+  continuityFile = null,
   taskBriefFiles = [],
   delegatedResultFiles = [],
 }) {
@@ -54,6 +58,7 @@ export async function runValidateProtocol({
     ["route", routeFile],
     ["state", stateFile],
     ["receipt", receiptFile],
+    ["continuity", continuityFile],
     ...taskBriefFiles.map((file) => [`task brief:${file}`, file]),
     ...delegatedResultFiles.map((file) => [`delegated result:${file}`, file]),
   ];
@@ -67,6 +72,7 @@ export async function runValidateProtocol({
   const route = loaded.find((item) => item.label === "route")?.value ?? null;
   const state = loaded.find((item) => item.label === "state")?.value ?? null;
   const receipt = loaded.find((item) => item.label === "receipt")?.value ?? null;
+  const continuity = loaded.find((item) => item.label === "continuity")?.value ?? null;
   const taskBriefs = loaded.filter((item) => item.label.startsWith("task brief:") && item.value).map((item) => item.value);
   const delegatedResults = loaded.filter((item) => item.label.startsWith("delegated result:") && item.value).map((item) => item.value);
   const schemaErrors = [];
@@ -87,6 +93,24 @@ export async function runValidateProtocol({
   await validateLoaded(loaded.find((item) => item.label === "route"), "routing-result", async (value) => assertRouteInvariants(value));
   await validateLoaded(loaded.find((item) => item.label === "state"), "work-state", async (value) => assertWorkStateSemantics(value));
   await validateLoaded(loaded.find((item) => item.label === "receipt"), "execution-receipt", async (value) => validateReceipt(value, packageRoot));
+  await validateLoaded(loaded.find((item) => item.label === "continuity"), "continuity", async (value) => assertContinuitySemantics(value));
+  for (const [value, artifactPath] of [
+    [state, stateFile],
+    [receipt, receiptFile],
+  ]) {
+    if (!value) continue;
+    const provenanceErrors = await validateChecksExecutionProvenance(value.checks, {
+      target,
+      packageRoot,
+      taskId: value.taskId,
+      artifactPath,
+    });
+    schemaErrors.push(...provenanceErrors.map((error) => ({
+      ...error,
+      message: `Command provenance validation failed: ${error.message}`,
+      artifacts: [artifactPath, ...(error.artifacts ?? [])],
+    })));
+  }
   for (const item of loaded.filter((candidate) => candidate.label.startsWith("task brief:"))) {
     await validateLoaded(item, "task-brief", async (value) => validateTaskBrief(value, packageRoot));
   }
@@ -124,11 +148,20 @@ export async function runValidateProtocol({
       })),
     ];
   }
+  const continuityContext = continuity && state && !stateValidationError
+    ? {
+      contractFingerprint: state.contractFingerprint,
+      repositoryFingerprint: await currentRepositoryFingerprint(target),
+      changedPaths: await currentChangedPaths(target),
+    }
+    : {};
   const result = validateTaskArtifactSet({
     route,
     state,
     stateClassification,
     receipt,
+    continuity,
+    continuityContext,
     taskBriefs,
     delegatedResults,
     events: ledgerEvents,
@@ -146,6 +179,10 @@ export async function runValidateProtocol({
 
 export function formatValidateProtocolResult(result) {
   const lines = [`Protocol: ${result.status}`];
+  if (result.continuity) {
+    lines.push(`Continuity: ${result.continuity.status}`);
+    lines.push(`Continuity authority: ${result.continuity.authority}`);
+  }
   if (result.stale) {
     lines.push(`Repository: ${result.stale.repositoryComparison}`);
     lines.push(`Contract: ${result.stale.contractComparison}`);

package/src/core/artifacts.js

@@ -16,9 +16,18 @@ export const ARTIFACT_PATHS = Object.freeze({
   config: ".forgeloop/config.json",
   gates: ".forgeloop/gates",
   state: ".forgeloop/work-state.json",
+  continuity: ".forgeloop/continuity.json",
   receipt: ".forgeloop/execution-receipt.json",
+  executionDirectory: ".forgeloop/executions",
 });
 
+export function executionArtifactPath(executionId) {
+  if (typeof executionId !== "string" || !/^exec-[A-Za-z0-9_-]+$/.test(executionId)) {
+    throw new ArtifactError("E_EXECUTION_REF_INVALID", "Execution reference must be a simple execution ID");
+  }
+  return `${ARTIFACT_PATHS.executionDirectory}/${executionId}.json`;
+}
+
 export class ArtifactError extends Error {
   constructor(code, message, artifacts = []) {
     super(message);

package/src/core/bundles.js

@@ -4,6 +4,9 @@ import { ARTIFACT_PATHS, readJsonArtifact, writeJsonArtifact } from "./artifacts
 import { readContract, 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";
 
 export const BUNDLE_SCHEMA_VERSION = 1;
 const BUNDLE_ROOT = ".forgeloop/tasks";
@@ -37,6 +40,34 @@ 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);
+  let receiptSource = null;
+  try {
+    receiptSource = await readJsonArtifact(target, 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, {
+      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"],
@@ -59,11 +90,22 @@ export async function exportTaskBundle(target, taskId, packageRoot) {
     [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"],
   ];
   for (const [sourcePath, destinationName, schemaName] of optional) {
     const copied = await copyJson(target, sourcePath, `${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 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);
   if (await fileExists(eventsPath)) {
     await assertSafePath(target, `${directory}/events.ndjson`);
@@ -106,15 +148,51 @@ export async function readTaskBundle(target, taskId, packageRoot) {
     "receipt.json": ["receipt", "execution-receipt"],
     "sources.json": ["sources", "source-registry"],
     "config.json": ["config", "config"],
+    "continuity.json": ["continuity", "continuity"],
   };
+  const executions = {};
   for (const artifact of manifest.value.artifacts) {
+    if (artifact.startsWith("executions/") && artifact.endsWith(".json")) {
+      const execution = await readJsonArtifact(target, `${directory}/${artifact}`, "execution", packageRoot);
+      executions[execution.value.executionId] = execution.value;
+      continue;
+    }
     const mapping = mappings[artifact];
     if (!mapping) continue;
     const loadedArtifact = await readJsonArtifact(target, `${directory}/${artifact}`, mapping[1], packageRoot);
     if (mapping[1] === "current-contract") {
       await validateContract(loadedArtifact.value, packageRoot);
     }
+    if (mapping[1] === "continuity") {
+      assertContinuitySemantics(loadedArtifact.value);
+    }
     loaded[mapping[0]] = loadedArtifact.value;
   }
+  if (Object.keys(executions).length > 0) loaded.executions = executions;
+  const provenanceErrors = [
+    ...(await validateChecksExecutionProvenance(loaded.state?.checks, {
+      target,
+      packageRoot,
+      taskId,
+      executionArtifacts: executions,
+      allowForeignCwd: true,
+      artifactPath: "state.json",
+    })),
+    ...(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 };
 }

package/src/core/checks.js

@@ -4,6 +4,7 @@ import { validateVerificationAuthority } from "./verification-capability.js";
 export const CHECK_SCHEMA_VERSION = 1;
 export const CHECK_STATUSES = Object.freeze(["passed", "failed", "blocked", "not-run"]);
 export const CHECK_EVIDENCE_KINDS = Object.freeze(["OBSERVED", "INFERRED", "NOT_VERIFIED", "BLOCKED"]);
+export const CHECK_PROVENANCE = Object.freeze(["FORGELOOP_EXECUTED", "ACTOR_REPORTED", "MANUAL_OBSERVATION"]);
 
 function checkError(code, message, artifacts = []) {
   const error = new Error(message);
@@ -60,6 +61,8 @@ export function createCheck(input = {}, options = {}) {
     ...(input.timestamp !== undefined ? { timestamp: input.timestamp } : {}),
     ...(input.repositoryFingerprint !== undefined ? { repositoryFingerprint: input.repositoryFingerprint } : {}),
     ...(input.viewport !== undefined ? { viewport: structuredClone(input.viewport) } : {}),
+    ...(input.executionRef !== undefined ? { executionRef: input.executionRef } : {}),
+    ...(input.provenance !== undefined ? { provenance: input.provenance } : {}),
     ...(input.details !== undefined ? { details: structuredClone(input.details) } : {}),
   };
   return assertCheck(check, "check", options);
@@ -76,6 +79,19 @@ export function assertCheck(value, label = "check", options = {}) {
   string(value.kind, `${label}.kind`);
   string(value.requirement, `${label}.requirement`);
   string(value.source, `${label}.source`);
+  optionalString(value.executionRef, `${label}.executionRef`);
+  if (value.provenance !== undefined && !CHECK_PROVENANCE.includes(value.provenance)) {
+    throw checkError("E_CHECK_INVALID", `${label}.provenance must be one of ${CHECK_PROVENANCE.join(", ")}`);
+  }
+  if (options.requireCommandProvenance === true
+    && value.kind === "command"
+    && value.evidenceKind === "OBSERVED"
+    && (value.executionRef === undefined || value.provenance !== "FORGELOOP_EXECUTED")) {
+    throw checkError(
+      "E_COMMAND_PROVENANCE_UNATTESTED",
+      `${label} observed command evidence requires ForgeLoop execution provenance`,
+    );
+  }
   if (!CHECK_STATUSES.includes(value.status)) {
     throw checkError("E_CHECK_INVALID", `${label}.status must be one of ${CHECK_STATUSES.join(", ")}`);
   }