@cassiomc1/forgeloop 1.6.2 → 1.6.4

package/src/core/attestation.js

@@ -0,0 +1,263 @@
+import { canonicalFingerprint, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
+import { assertSchema, readSchema } from "./schema-validation.js";
+import { assertSecretFree } from "./receipt.js";
+import { getPackageRoot } from "./templates.js";
+import { readCodeManifest, validateCodeManifestBindings } from "./code-manifest.js";
+import {
+  taskAttestationStatementPath,
+  taskAttestationStatementHistoryPath,
+  taskAttestationBundlePath,
+} from "./task-paths.js";
+import { appendProtocolEvent } from "./events.js";
+import { ensureWithin, fileExists } from "./filesystem.js";
+import { E_ATTESTATION_CONFIGURATION_INVALID } from "./error-codes.js";
+
+const STATEMENT_TYPE = "https://in-toto.io/Statement/v1";
+const PREDICATE_TYPE = "https://forgeloop.dev/attestation/v1";
+
+function attestationError(code, message, artifacts = []) {
+  const error = new Error(message);
+  error.name = "AttestationError";
+  error.code = code;
+  error.artifacts = artifacts;
+  return error;
+}
+
+export async function validateAttestationPredicate(predicate, packageRoot = getPackageRoot()) {
+  try {
+    assertSchema(predicate, await readSchema("code-attestation", packageRoot), "ForgeLoop attestation predicate");
+    assertSecretFree(predicate);
+    return predicate;
+  } catch (error) {
+    throw attestationError("E_ATTESTATION_STATEMENT_INVALID", error.message);
+  }
+}
+
+export async function validateAttestationStatement(statement, packageRoot = getPackageRoot()) {
+  try {
+    assertSchema(statement, await readSchema("in-toto-statement", packageRoot), "in-toto statement");
+    if (statement._type !== STATEMENT_TYPE || statement.predicateType !== PREDICATE_TYPE) {
+      throw attestationError("E_ATTESTATION_STATEMENT_INVALID", "Statement type or predicate type is not the ForgeLoop v1 contract");
+    }
+    await validateAttestationPredicate(statement.predicate, packageRoot);
+    const subject = statement.subject[0];
+    if (subject.name !== `forgeloop-task:${statement.predicate.task.taskId}`) {
+      throw attestationError("E_ATTESTATION_SUBJECT_MISMATCH", "Statement subject does not match the attested task");
+    }
+    if (subject.digest.sha256 !== statement.predicate.content.contentDigest) {
+      throw attestationError("E_ATTESTATION_SUBJECT_MISMATCH", "Statement subject digest does not match the predicate content digest");
+    }
+    assertSecretFree(statement);
+    return statement;
+  } catch (error) {
+    if (error.code?.startsWith("E_ATTESTATION_")) throw error;
+    throw attestationError("E_ATTESTATION_STATEMENT_INVALID", error.message);
+  }
+}
+
+export async function buildAttestationStatement({
+  target,
+  packageRoot = getPackageRoot(),
+  taskId,
+  completionResult = null,
+  auditResult = null,
+  revisionProvider = null,
+} = {}) {
+  const manifestArtifact = await readCodeManifest({ target, packageRoot, taskId });
+  const binding = await validateCodeManifestBindings({
+    target,
+    packageRoot,
+    taskId,
+    manifest: manifestArtifact.value,
+    revisionProvider: revisionProvider ?? manifestArtifact.value.capture.revisionProvider,
+  });
+  let completion = completionResult;
+  if (!completion) {
+    const { evaluateCompletion } = await import("./completion.js");
+    completion = await evaluateCompletion({ target, packageRoot, taskId });
+  }
+  if (completion.status !== "VALID") throw attestationError("E_ATTESTATION_STATEMENT_INVALID", "A VALID completion result is required before creating an attestation statement");
+  let audit = auditResult;
+  if (!audit) {
+    const { evaluateAudit } = await import("./audit.js");
+    audit = await evaluateAudit({ target, packageRoot, taskId });
+  }
+  if (audit.status !== "VALID") throw attestationError("E_ATTESTATION_STATEMENT_INVALID", "A VALID audit result is required before creating an attestation statement");
+  const manifest = binding.manifest;
+  const evidence = manifest.bindings;
+  const coveredPaths = [...new Set(manifest.entries.flatMap((entry) => [entry.path, entry.sourcePath].filter(Boolean)))].sort();
+  const predicate = await validateAttestationPredicate({
+    schemaVersion: 1,
+    protocol: { name: "ForgeLoop", protocolVersion: 1 },
+    task: { taskId, verificationCycle: manifest.verificationCycle },
+    content: {
+      manifestFingerprint: manifestArtifact.fingerprint,
+      contentDigest: manifest.contentDigest,
+      coveredPaths,
+    },
+    evidence: {
+      contractFingerprint: evidence.contractFingerprint,
+      routeFingerprint: evidence.routeFingerprint,
+      stateFingerprint: evidence.stateFingerprint,
+      receiptFingerprint: evidence.receiptFingerprint,
+      ledgerSeq: evidence.ledgerSeq,
+      ledgerHash: evidence.ledgerHash,
+    },
+    verification: { completion: "VALID", audit: "VALID" },
+  }, packageRoot);
+  const statement = await validateAttestationStatement({
+    schemaVersion: 1,
+    _type: STATEMENT_TYPE,
+    subject: [{ name: `forgeloop-task:${taskId}`, digest: { sha256: manifest.contentDigest } }],
+    predicateType: PREDICATE_TYPE,
+    predicate,
+  }, packageRoot);
+  return {
+    statement,
+    fingerprint: canonicalFingerprint(statement),
+    manifest: manifestArtifact,
+    completion,
+    audit,
+  };
+}
+
+export async function readAttestationStatement({ target, packageRoot = getPackageRoot(), taskId } = {}) {
+  const relativePath = taskAttestationStatementPath(taskId);
+  try {
+    const artifact = await readJsonArtifact(target, relativePath, "in-toto-statement", packageRoot);
+    await validateAttestationStatement(artifact.value, packageRoot);
+    return artifact;
+  } catch (error) {
+    if (error.code === "ARTIFACT_MISSING") throw attestationError("E_ATTESTATION_STATEMENT_MISSING", `Attestation statement is missing: ${relativePath}`, [relativePath]);
+    if (error.code?.startsWith("E_ATTESTATION_")) throw error;
+    throw attestationError("E_ATTESTATION_STATEMENT_INVALID", error.message, [relativePath]);
+  }
+}
+
+export async function writeAttestationStatement({ target, packageRoot = getPackageRoot(), taskId, statement } = {}) {
+  await validateAttestationStatement(statement, packageRoot);
+  const relativePath = taskAttestationStatementPath(taskId);
+  if (await fileExists(ensureWithin(target, relativePath))) {
+    let previous;
+    try {
+      previous = await readAttestationStatement({ target, packageRoot, taskId });
+    } catch (error) {
+      throw attestationError("E_ATTESTATION_STATEMENT_INVALID", `Existing attestation statement cannot be versioned safely: ${error.message}`, [relativePath]);
+    }
+    const previousCycle = previous.value.predicate.task.verificationCycle;
+    const nextCycle = statement.predicate.task.verificationCycle;
+    if (nextCycle <= previousCycle) {
+      throw attestationError("E_ATTESTATION_STATEMENT_INVALID", "Attestation statement is immutable within a verification cycle", [relativePath]);
+    }
+    const historyPath = taskAttestationStatementHistoryPath(taskId, previousCycle);
+    if (!(await fileExists(ensureWithin(target, historyPath)))) {
+      await writeJsonArtifact(target, historyPath, previous.value, "in-toto-statement", packageRoot, { taskId, operation: "attestation-statement-history" });
+    }
+  }
+  const artifact = await writeJsonArtifact(target, relativePath, statement, "in-toto-statement", packageRoot, { taskId, operation: "attestation-create" });
+  await appendProtocolEvent(target, {
+    taskId,
+    event: "ATTESTATION_STATEMENT_CREATED",
+    fingerprint: artifact.fingerprint,
+    details: { statementFingerprint: artifact.fingerprint, manifestFingerprint: statement.predicate.content.manifestFingerprint },
+  }, packageRoot, { taskId });
+  return { path: relativePath, fingerprint: artifact.fingerprint, statement };
+}
+
+export async function resolveAttestationStatus({ target, packageRoot = getPackageRoot(), taskId, revisionProvider = null, bundlePath = null, requireSignature = false, signingProvider = null, signerPolicy = {} } = {}) {
+  const result = {
+    taskId,
+    status: "MISSING",
+    level: "PROCESSED",
+    content: "NOT_CHECKED",
+    receipt: "NOT_CHECKED",
+    ledger: "NOT_CHECKED",
+    signature: requireSignature ? "REQUIRED" : "NOT_CHECKED",
+    signer: null,
+    files: 0,
+    subject: null,
+    errors: [],
+  };
+  let effectiveRequireSignature = requireSignature === true;
+  let effectiveSigningProvider = signingProvider;
+  let effectiveSignerPolicy = { ...signerPolicy };
+  let effectiveBundlePath = bundlePath;
+  try {
+    const { readConfig } = await import("./config.js");
+    const config = await readConfig(target, packageRoot);
+    const configuredSigning = config.attestation?.signing ?? {};
+    effectiveRequireSignature ||= configuredSigning.required === true;
+    effectiveSigningProvider ??= configuredSigning.provider;
+    effectiveSignerPolicy = {
+      ...(configuredSigning.policy ?? {}),
+      ...signerPolicy,
+    };
+    if (effectiveRequireSignature && !effectiveBundlePath) effectiveBundlePath = taskAttestationBundlePath(taskId);
+    result.signature = effectiveRequireSignature ? "REQUIRED" : "NOT_CHECKED";
+    if ((config.attestation?.mode ?? "off") === "off" && !bundlePath && !effectiveRequireSignature) {
+      result.status = "DISABLED";
+      result.level = "PROCESSED";
+      result.signature = "NOT_CHECKED";
+      return result;
+    }
+  } catch (error) {
+    if (error.code !== "ARTIFACT_MISSING") {
+      result.status = "INVALID";
+      result.errors.push({ code: E_ATTESTATION_CONFIGURATION_INVALID, message: error.message });
+      return result;
+    }
+  }
+  result.signature = effectiveRequireSignature ? "REQUIRED" : "NOT_CHECKED";
+  if (effectiveRequireSignature && !effectiveBundlePath) effectiveBundlePath = taskAttestationBundlePath(taskId);
+  try {
+    const statement = await readAttestationStatement({ target, packageRoot, taskId });
+    const manifest = await readCodeManifest({ target, packageRoot, taskId });
+    const provider = revisionProvider ?? manifest.value.capture.revisionProvider;
+    await validateCodeManifestBindings({ target, packageRoot, taskId, manifest: manifest.value, revisionProvider: provider });
+    const { assertAttestationStatementBindings, verifyCodeManifestContent } = await import("./attestation-verifier.js");
+    assertAttestationStatementBindings(statement.value, manifest.value, taskId, manifest.fingerprint);
+    await verifyCodeManifestContent({
+      target,
+      manifest: manifest.value,
+      revisionProvider: provider,
+      revision: manifest.value.capture.mode === "WORKTREE" ? "WORKTREE" : manifest.value.capture.observedRevision,
+    });
+    result.status = "VALID";
+    result.level = "VERIFIED";
+    result.content = "VALID";
+    result.receipt = "VALID";
+    result.ledger = "VALID";
+    result.files = statement.value.predicate.content.coveredPaths.length;
+    result.subject = `sha256:${statement.value.subject[0].digest.sha256}`;
+    if (effectiveRequireSignature && !(await fileExists(ensureWithin(target, effectiveBundlePath)))) {
+      result.signature = "UNSIGNED";
+      result.status = "INVALID";
+      result.errors.push({ code: "E_ATTESTATION_UNSIGNED", message: `Required attestation signature bundle is missing: ${effectiveBundlePath}` });
+      return result;
+    }
+    if (effectiveBundlePath) {
+      const { assertSigningProvider, resolveSigningProvider } = await import("./signing/provider.js");
+      const { SIGNING_PROVIDERS } = await import("./signing/registry.js");
+      const signer = typeof effectiveSigningProvider === "object"
+        ? assertSigningProvider(effectiveSigningProvider)
+        : await resolveSigningProvider({ providerName: effectiveSigningProvider ?? effectiveSignerPolicy.provider ?? (effectiveBundlePath ? "sigstore" : "none"), registry: SIGNING_PROVIDERS });
+      const verified = await signer.verify({ target, statementPath: taskAttestationStatementPath(taskId), bundlePath: effectiveBundlePath, policy: effectiveSignerPolicy });
+      result.signature = verified.status;
+      result.signer = verified.signer ?? null;
+      if (verified.status === "VALID") result.level = "ATTESTED";
+      else if (effectiveRequireSignature) {
+        result.status = "INVALID";
+        result.errors.push({ code: verified.code ?? (verified.status === "UNSIGNED" ? "E_ATTESTATION_UNSIGNED" : "E_ATTESTATION_SIGNATURE_INVALID"), message: verified.message ?? "Signature verification failed" });
+      }
+    }
+  } catch (error) {
+    if (["E_ATTESTATION_STATEMENT_MISSING", "E_ATTESTATION_MANIFEST_MISSING"].includes(error.code)) {
+      result.status = "MISSING";
+      result.level = "PROCESSED";
+    } else {
+      result.status = "INVALID";
+    }
+    result.errors.push({ code: error.code ?? "E_ATTESTATION_STATEMENT_INVALID", message: error.message });
+  }
+  return result;
+}

package/src/core/audit.js

@@ -8,6 +8,9 @@ import { validateReadyProtocolConsistency } from "./preflight.js";
 import { taskArtifactPath } from "./task-paths.js";
 import { findTaskById } from "./task-discovery.js";
 import { validateActionLedgerConsistency } from "./actions.js";
+import { readCodeManifest } from "./code-manifest.js";
+import { readAttestationStatement, validateAttestationStatement } from "./attestation.js";
+import { assertAttestationStatementBindings, verifyCodeManifestContent } from "./attestation-verifier.js";
 
 function sortErrors(errors) {
   return [...errors].sort((left, right) => left.code.localeCompare(right.code)
@@ -55,6 +58,55 @@ async function compareChangedPaths(target, packageRoot, options = {}) {
   };
 }
 
+async function evaluateLocalAttestation({ target, packageRoot, taskId, completion }) {
+  const configured = completion.attestation ?? { mode: "off" };
+  const base = {
+    mode: configured.mode ?? "off",
+    manifest: configured.mode === "off" ? "NOT_CHECKED" : configured.status === "CAPTURED" ? "VALID" : configured.status ?? "MISSING",
+    statement: "NOT_CHECKED",
+    signature: "NOT_CHECKED",
+    coverage: "NOT_CHECKED",
+    errors: [],
+  };
+  if (configured.mode === "off") return { ...base, status: "DISABLED" };
+  if (configured.status !== "CAPTURED") {
+    return { ...base, status: configured.status === "UNAVAILABLE" ? "UNAVAILABLE" : "MISSING" };
+  }
+
+  let manifest;
+  try {
+    manifest = await readCodeManifest({ target, packageRoot, taskId });
+    await verifyCodeManifestContent({
+      target,
+      manifest: manifest.value,
+      revisionProvider: manifest.value.capture.revisionProvider,
+      revision: manifest.value.capture.mode === "WORKTREE" ? "WORKTREE" : manifest.value.capture.observedRevision,
+    });
+    base.coverage = "VALID";
+  } catch (error) {
+    base.manifest = "INVALID";
+    base.status = "INVALID";
+    base.errors.push({ code: error.code ?? "E_ATTESTATION_CONTENT_MISMATCH", message: error.message });
+    return base;
+  }
+
+  try {
+    const statement = await readAttestationStatement({ target, packageRoot, taskId });
+    await validateAttestationStatement(statement.value, packageRoot);
+    assertAttestationStatementBindings(statement.value, manifest.value, taskId, manifest.fingerprint);
+    base.statement = "VALID";
+  } catch (error) {
+    if (error.code === "E_ATTESTATION_STATEMENT_MISSING") {
+      return { ...base, status: "VALID" };
+    }
+    base.statement = "INVALID";
+    base.status = "INVALID";
+    base.errors.push({ code: error.code ?? "E_ATTESTATION_STATEMENT_INVALID", message: error.message });
+    return base;
+  }
+  return { ...base, status: "VALID" };
+}
+
 export async function evaluateAudit({
   target,
   packageRoot,
@@ -83,6 +135,7 @@ export async function evaluateAudit({
     eventsPath,
     preflightPath,
   });
+  const attestation = await evaluateLocalAttestation({ target, packageRoot, taskId, completion });
   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);
@@ -118,7 +171,12 @@ export async function evaluateAudit({
       artifacts: error.artifacts ?? [taskArtifactPath(taskId, "recovery"), taskArtifactPath(taskId, "events")],
     }))
     : [];
-  const errors = sortErrors([...completion.errors, ...readyConsistencyErrors, ...ownershipErrors]);
+  const errors = sortErrors([
+    ...completion.errors,
+    ...readyConsistencyErrors,
+    ...ownershipErrors,
+    ...attestation.errors,
+  ]);
   if (taskId) {
     for (const actionError of await validateActionLedgerConsistency(target, { packageRoot, taskId })) {
       errors.push({ ...actionError, artifacts: [taskArtifactPath(taskId, "actions"), taskArtifactPath(taskId, "events")] });
@@ -199,6 +257,14 @@ export async function evaluateAudit({
     },
     policy: policyStatus,
     completion,
+    attestation: {
+      mode: attestation.mode,
+      manifest: attestation.manifest,
+      statement: attestation.statement,
+      signature: attestation.signature,
+      coverage: attestation.coverage,
+      status: attestation.status,
+    },
     recovery: taskInfo?.recovery ?? null,
     claims: taskInfo ? {
       state: taskInfo.claimState,

package/src/core/bundles.js

@@ -1,16 +1,24 @@
 import { readdir } from "node:fs/promises";
 
-import { ARTIFACT_PATHS, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
+import { ARTIFACT_PATHS, canonicalFingerprint, readJsonArtifact, writeJsonArtifact } from "./artifacts.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 { validateEventLedger } from "./events.js";
 import { taskArtifactPath, taskDirectory } from "./task-paths.js";
 import { resolveTaskClaimState } from "./task-claim-state.js";
 import { E_TASK_CLAIM_OWNERSHIP_INCONSISTENT } from "./error-codes.js";
 import { listActions } from "./actions.js";
+import { validateCanonicalHandoff } from "./handoff.js";
+import { validateVerificationScope } from "./verification-scope.js";
+import { validateResponsibilityContract } from "./responsibility.js";
+import { validateWorkspaceBinding } from "./workspace-binding.js";
+import { validateCodeManifest, validateCodeManifestBindings } from "./code-manifest.js";
+import { assertAttestationStatementBindings } from "./attestation-verifier.js";
+import { validateAttestationStatement } from "./attestation.js";
 
 export const BUNDLE_SCHEMA_VERSION = 1;
 const BUNDLE_ROOT = ".forgeloop/tasks";
@@ -28,6 +36,34 @@ function bundleDirectory(taskId) {
   return `${BUNDLE_ROOT}/${safeTaskId(taskId)}`;
 }
 
+function bundleBindingError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function assertBundledCodeManifestBindings({ loaded, ledger, taskId }) {
+  const manifest = loaded.codeManifest;
+  if (!manifest) return;
+  const comparisons = [
+    ["taskId", manifest.taskId, taskId, "E_BUNDLE_TASK_MISMATCH"],
+    ["contractFingerprint", manifest.bindings.contractFingerprint, loaded.contract ? canonicalFingerprint(loaded.contract) : null, "E_ATTESTATION_CONTRACT_MISMATCH"],
+    ["routeFingerprint", manifest.bindings.routeFingerprint, loaded.route ? canonicalFingerprint(loaded.route) : null, "E_ATTESTATION_ROUTE_MISMATCH"],
+    ["stateFingerprint", manifest.bindings.stateFingerprint, loaded.state ? canonicalFingerprint(loaded.state) : null, "E_ATTESTATION_STATE_MISMATCH"],
+    ["receiptFingerprint", manifest.bindings.receiptFingerprint, loaded.receipt ? canonicalFingerprint(loaded.receipt) : null, "E_ATTESTATION_RECEIPT_MISMATCH"],
+  ];
+  for (const [name, expected, actual, code] of comparisons) {
+    if (expected !== actual) throw bundleBindingError(code, `Bundled code manifest binding does not match ${name}`);
+  }
+  if (!ledger?.valid) {
+    throw bundleBindingError("E_ATTESTATION_LEDGER_MISMATCH", "A valid bundled event ledger is required by the code manifest");
+  }
+  const completion = ledger.events.findLast((event) => event.taskId === taskId && event.event === "COMPLETION_VALIDATED");
+  if (!completion || completion.seq !== manifest.bindings.ledgerSeq || completion.hash !== manifest.bindings.ledgerHash) {
+    throw bundleBindingError("E_ATTESTATION_LEDGER_MISMATCH", "Bundled code manifest does not match the COMPLETION_VALIDATED ledger checkpoint");
+  }
+}
+
 async function copyJson(target, sourcePath, destinationPath, schemaName, packageRoot, artifacts, relativeName) {
   try {
     const value = await readJsonArtifact(target, sourcePath, schemaName, packageRoot);
@@ -40,6 +76,23 @@ async function copyJson(target, sourcePath, destinationPath, schemaName, package
   }
 }
 
+async function copyOptionalJson(target, taskPath, legacyPath, destinationPath, schemaName, packageRoot, artifacts, relativeName) {
+  const candidates = [taskPath, legacyPath].filter(Boolean);
+  for (const sourcePath of candidates) {
+    if (!(await fileExists(ensureWithin(target, sourcePath)))) continue;
+    return copyJson(target, sourcePath, destinationPath, schemaName, packageRoot, artifacts, relativeName);
+  }
+  return null;
+}
+
+async function copyRawFile(target, sourcePath, destinationPath, artifacts, relativeName) {
+  if (!(await fileExists(ensureWithin(target, sourcePath)))) return false;
+  await assertSafePath(target, destinationPath);
+  await writeFileAtomic(ensureWithin(target, destinationPath), await readBytes(ensureWithin(target, sourcePath)));
+  artifacts.push(relativeName);
+  return true;
+}
+
 async function tryReadJson(target, taskPath, legacyPath, schemaName, packageRoot) {
   try {
     return await readJsonArtifact(target, taskPath, schemaName, packageRoot);
@@ -117,19 +170,89 @@ export async function exportTaskBundle(target, taskId, packageRoot) {
     [ARTIFACT_PATHS.config, null, "config.json", "config"],
     [taskArtifactPath(taskId, "continuity"), ARTIFACT_PATHS.continuity, "continuity.json", "continuity"],
     [taskArtifactPath(taskId, "recovery"), null, "recovery.json", "task-recovery"],
+    [taskArtifactPath(taskId, "workspaceBinding"), null, "workspace-binding.json", "workspace-binding"],
+    [taskArtifactPath(taskId, "responsibility"), null, "responsibility.json", "responsibility"],
+    [taskArtifactPath(taskId, "verificationScope"), null, "verification-scope.json", "verification-scope"],
+    [taskArtifactPath(taskId, "attestations") + "/code-manifest.json", null, "attestations/code-manifest.json", "code-manifest"],
+    [taskArtifactPath(taskId, "attestations") + "/statement.json", null, "attestations/statement.json", "in-toto-statement"],
   ];
+  let exportedWorkspaceBinding = null;
+  let exportedResponsibility = null;
+  let exportedVerificationScope = null;
+  let exportedManifest = null;
+  let exportedStatement = null;
   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);
-      }
-    }
+    const copied = await copyOptionalJson(target, taskRel, legacyRel, `${directory}/${destinationName}`, schemaName, packageRoot, artifacts, destinationName);
     if (copied && !artifacts.includes(destinationName)) artifacts.push(destinationName);
+    if (destinationName === "attestations/code-manifest.json") exportedManifest = copied;
+    if (destinationName === "attestations/statement.json") exportedStatement = copied;
+    if (destinationName === "workspace-binding.json") exportedWorkspaceBinding = copied;
+    if (destinationName === "responsibility.json") exportedResponsibility = copied;
+    if (destinationName === "verification-scope.json") exportedVerificationScope = copied;
+  }
+
+  if (exportedWorkspaceBinding?.value) {
+    exportedWorkspaceBinding.value = await validateWorkspaceBinding(exportedWorkspaceBinding.value, packageRoot);
+    if (exportedWorkspaceBinding.value.taskId !== taskId) {
+      const error = new Error("Workspace binding taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+  }
+  if (exportedResponsibility?.value) {
+    exportedResponsibility.value = await validateResponsibilityContract(exportedResponsibility.value, packageRoot);
+    if (exportedResponsibility.value.taskId !== taskId) {
+      const error = new Error("Responsibility taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+  }
+  if (exportedVerificationScope?.value) {
+    exportedVerificationScope.value = await validateVerificationScope(exportedVerificationScope.value, packageRoot);
+    if (exportedVerificationScope.value.taskId !== taskId) {
+      const error = new Error("Verification scope taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+  }
+
+  const handoffDirectory = taskArtifactPath(taskId, "handoffs");
+  if (await fileExists(ensureWithin(target, handoffDirectory))) {
+    const handoffEntries = await readdir(ensureWithin(target, handoffDirectory), { withFileTypes: true });
+    for (const entry of handoffEntries
+      .filter((item) => item.isFile() && /^handoff-[A-Za-z0-9_-]+\.json$/u.test(item.name))
+      .sort((left, right) => left.name.localeCompare(right.name))) {
+      const sourcePath = `${handoffDirectory}/${entry.name}`;
+      const handoff = await readJsonArtifact(target, sourcePath, "handoff-envelope", packageRoot);
+      await validateCanonicalHandoff(target, handoff.value, { taskId, packageRoot });
+      const destination = `handoffs/${entry.name}`;
+      await writeJsonArtifact(target, `${directory}/${destination}`, handoff.value, "handoff-envelope", packageRoot);
+      artifacts.push(destination);
+    }
   }
 
+  const rawAttestationBundle = `${taskArtifactPath(taskId, "attestations")}/statement.sigstore.json`;
+  await copyRawFile(target, rawAttestationBundle, `${directory}/attestations/statement.sigstore.json`, artifacts, "attestations/statement.sigstore.json");
+  if (exportedManifest?.value) {
+    exportedManifest.value = await validateCodeManifest(exportedManifest.value, packageRoot);
+    if (exportedManifest.value.taskId !== taskId) {
+      const error = new Error("Code manifest taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+    await validateCodeManifestBindings({ target, packageRoot, taskId, manifest: exportedManifest.value });
+  }
+  if (exportedStatement?.value) {
+    await validateAttestationStatement(exportedStatement.value, packageRoot);
+    if (exportedStatement.value.predicate.task.taskId !== taskId) {
+      const error = new Error("Attestation statement taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+  }
+  if (exportedManifest?.value && exportedStatement?.value) {
+    assertAttestationStatementBindings(exportedStatement.value, exportedManifest.value, taskId, canonicalFingerprint(exportedManifest.value));
+  }
   const actionArtifacts = await listActions(target, { packageRoot, taskId });
   for (const action of actionArtifacts) {
     const destination = `${directory}/actions/${action.actionId}.json`;
@@ -203,6 +326,11 @@ export async function readTaskBundle(target, taskId, packageRoot) {
     "continuity.json": ["continuity", "continuity"],
     "task.json": ["descriptor", "task-descriptor"],
     "recovery.json": ["recovery", "task-recovery"],
+    "workspace-binding.json": ["workspaceBinding", "workspace-binding"],
+    "responsibility.json": ["responsibility", "responsibility"],
+    "verification-scope.json": ["verificationScope", "verification-scope"],
+    "attestations/code-manifest.json": ["codeManifest", "code-manifest"],
+    "attestations/statement.json": ["attestationStatement", "in-toto-statement"],
     ...Object.fromEntries(manifest.value.artifacts.filter((artifact) => artifact.startsWith("actions/")).map((artifact) => [artifact, ["action", "action"]])),
   };
   const executions = {};
@@ -218,6 +346,24 @@ export async function readTaskBundle(target, taskId, packageRoot) {
       loaded.actions[action.value.actionId] = action.value;
       continue;
     }
+    if (artifact.startsWith("handoffs/") && artifact.endsWith(".json")) {
+      const handoff = await readJsonArtifact(target, `${directory}/${artifact}`, "handoff-envelope", packageRoot);
+      await validateCanonicalHandoff(target, handoff.value, { taskId, packageRoot });
+      loaded.handoffs ??= [];
+      loaded.handoffs.push(handoff.value);
+      continue;
+    }
+    if (artifact === "attestations/statement.sigstore.json") {
+      const raw = await readBytes(ensureWithin(target, `${directory}/${artifact}`));
+      try {
+        loaded.attestationBundle = JSON.parse(raw.toString("utf8"));
+      } catch (error) {
+        const invalid = new Error(`Attestation signature bundle is not valid JSON: ${error.message}`);
+        invalid.code = "E_ATTESTATION_SIGNATURE_INVALID";
+        throw invalid;
+      }
+      continue;
+    }
     const mapping = mappings[artifact];
     if (!mapping) continue;
     const loadedArtifact = await readJsonArtifact(target, `${directory}/${artifact}`, mapping[1], packageRoot);
@@ -227,8 +373,63 @@ export async function readTaskBundle(target, taskId, packageRoot) {
     if (mapping[1] === "continuity") {
       assertContinuitySemantics(loadedArtifact.value);
     }
+    if (mapping[1] === "workspace-binding" && loadedArtifact.value.taskId !== taskId) {
+      const error = new Error("Workspace binding taskId does not match its bundle task");
+      error.code = "E_BUNDLE_TASK_MISMATCH";
+      throw error;
+    }
+    if (mapping[1] === "workspace-binding") {
+      loadedArtifact.value = await validateWorkspaceBinding(loadedArtifact.value, packageRoot);
+    }
+    if (mapping[1] === "responsibility") {
+      loadedArtifact.value = await validateResponsibilityContract(loadedArtifact.value, packageRoot);
+      if (loadedArtifact.value.taskId !== taskId) {
+        const error = new Error("Responsibility taskId does not match its bundle task");
+        error.code = "E_BUNDLE_TASK_MISMATCH";
+        throw error;
+      }
+    }
+    if (mapping[1] === "verification-scope") {
+      loadedArtifact.value = await validateVerificationScope(loadedArtifact.value, packageRoot);
+      if (loadedArtifact.value.taskId !== taskId) {
+        const error = new Error("Verification scope taskId does not match its bundle task");
+        error.code = "E_BUNDLE_TASK_MISMATCH";
+        throw error;
+      }
+    }
+    if (mapping[1] === "code-manifest") {
+      loadedArtifact.value = await validateCodeManifest(loadedArtifact.value, packageRoot);
+      if (loadedArtifact.value.taskId !== taskId) {
+        const error = new Error("Code manifest taskId does not match its bundle task");
+        error.code = "E_BUNDLE_TASK_MISMATCH";
+        throw error;
+      }
+    }
+    if (mapping[1] === "in-toto-statement") {
+      await validateAttestationStatement(loadedArtifact.value, packageRoot);
+      if (loadedArtifact.value.predicate.task.taskId !== taskId) {
+        const error = new Error("Attestation statement taskId does not match its bundle task");
+        error.code = "E_BUNDLE_TASK_MISMATCH";
+        throw error;
+      }
+    }
     loaded[mapping[0]] = loadedArtifact.value;
   }
+  const bundledLedger = loaded.codeManifest && manifest.value.artifacts.includes("events.ndjson")
+    ? await validateEventLedger(target, packageRoot, { taskId, eventsPath: `${directory}/events.ndjson` })
+    : null;
+  assertBundledCodeManifestBindings({ loaded, ledger: bundledLedger, taskId });
+  if (loaded.attestationStatement && !loaded.codeManifest) {
+    throw bundleBindingError("E_ATTESTATION_MANIFEST_MISSING", "A bundled attestation statement requires its code manifest");
+  }
+  if (loaded.codeManifest && loaded.attestationStatement) {
+    assertAttestationStatementBindings(
+      loaded.attestationStatement,
+      loaded.codeManifest,
+      taskId,
+      canonicalFingerprint(loaded.codeManifest),
+    );
+  }
   if (Object.keys(executions).length > 0) loaded.executions = executions;
   if (loaded.state?.checks) {
     await validateChecksExecutionProvenance(loaded.state.checks, {