@cassiomc1/forgeloop 1.6.2 → 1.6.4

package/src/core/revision/git.js

@@ -0,0 +1,207 @@
+import { lstat, readFile, readlink } from "node:fs/promises";
+import path from "node:path";
+
+import { canonicalFingerprint } from "../artifacts.js";
+import { assertSafePath, ensureWithin } from "../filesystem.js";
+import {
+  currentRepositoryFingerprint,
+  expectedGitBlobOid,
+  repositoryBlobAtRef,
+  repositoryBlobOidAtRef,
+  repositoryDiffEntries,
+  repositoryIndexEntries,
+  repositoryObjectFormat,
+  repositoryRemoteUrl,
+  repositoryStatusEntries,
+  repositoryTreeEntry,
+  repositoryWorktreeMetadata,
+} from "../repository.js";
+import { normalizeRevisionEntry } from "./provider.js";
+
+function revisionError(code, message, cause = null) {
+  const error = new Error(message);
+  error.code = code;
+  if (cause) error.cause = cause;
+  return error;
+}
+
+function normalizeGitPath(value) {
+  return String(value).replaceAll("\\", "/").replace(/^\.\//u, "");
+}
+
+function operationFromStatus(status) {
+  const raw = String(status ?? "");
+  if (raw.includes("?")) return "ADDED";
+  const code = raw.replace(/[ ]/gu, "").slice(0, 1);
+  return {
+    A: "ADDED",
+    M: "MODIFIED",
+    D: "DELETED",
+    R: "RENAMED",
+    C: "COPIED",
+    T: "TYPE_CHANGED",
+    U: "TYPE_CHANGED",
+    "?": "ADDED",
+  }[code] ?? "MODIFIED";
+}
+
+function kindFromMode(mode) {
+  if (mode === "160000") return "GITLINK";
+  if (mode === "120000") return "SYMLINK";
+  return "FILE";
+}
+
+async function worktreeEntry(target, entry) {
+  const relativePath = normalizeGitPath(entry.path);
+  await assertSafePath(target, relativePath);
+  const absolutePath = ensureWithin(target, relativePath);
+  try {
+    const info = await lstat(absolutePath);
+    if (info.isSymbolicLink()) {
+      const linkTarget = await readlink(absolutePath, { encoding: "buffer" });
+      return { ...entry, kind: "SYMLINK", bytes: Buffer.from(linkTarget) };
+    }
+    if (info.isDirectory()) {
+      return { ...entry, kind: "GITLINK", bytes: null };
+    }
+    return { ...entry, kind: "FILE", bytes: await readFile(absolutePath) };
+  } catch (error) {
+    if (entry.operation === "DELETED" || error.code === "ENOENT") {
+      return { ...entry, operation: entry.operation === "TYPE_CHANGED" ? "TYPE_CHANGED" : "DELETED", kind: "DELETED", bytes: null };
+    }
+    throw revisionError("E_REVISION_CONTENT_UNAVAILABLE", `Cannot read worktree path ${relativePath}`, error);
+  }
+}
+
+function normalizeDiffEntry(entry) {
+  return {
+    path: normalizeGitPath(entry.path),
+    sourcePath: entry.sourcePath ? normalizeGitPath(entry.sourcePath) : null,
+    operation: operationFromStatus(entry.status),
+    kind: "FILE",
+    bytes: null,
+    providerContentId: null,
+    providerMetadata: { score: entry.score ?? null },
+  };
+}
+
+export function createGitRevisionProvider() {
+  return {
+    name: "git",
+    async detect(target) {
+      try {
+        await repositoryWorktreeMetadata(target);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async getCurrentRevision(target) {
+      try {
+        return (await currentRepositoryFingerprint(target)).head;
+      } catch (error) {
+        throw revisionError("E_REVISION_NOT_FOUND", "Current Git revision is unavailable", error);
+      }
+    },
+    async getRepositoryIdentity(target) {
+      try {
+        const metadata = await repositoryWorktreeMetadata(target);
+        return canonicalFingerprint({
+          commonDirectory: path.normalize(metadata.commonDirectory).replaceAll("\\", "/"),
+          objectFormat: metadata.objectFormat,
+        });
+      } catch (error) {
+        throw revisionError("E_REVISION_PROVIDER_UNAVAILABLE", "Git repository identity is unavailable", error);
+      }
+    },
+    async getChangedEntries({ target, baseRevision = null, headRevision = "WORKTREE", paths = null } = {}) {
+      try {
+        const rawEntries = headRevision === "WORKTREE" || headRevision === "working-tree"
+          ? await repositoryStatusEntries(target, { paths })
+          : await repositoryDiffEntries(target, { baseRevision, headRevision, paths });
+        const normalized = rawEntries
+          .map(normalizeDiffEntry)
+          .filter((entry) => !entry.path.startsWith(".forgeloop/"));
+        const complete = [];
+        for (const entry of normalized) {
+          const materialized = (headRevision === "WORKTREE" || headRevision === "working-tree")
+            ? await worktreeEntry(target, entry)
+            : entry.operation === "DELETED"
+              ? { ...entry, kind: "DELETED", bytes: null }
+              : { ...entry, bytes: await this.readContent({ target, revision: headRevision, path: entry.path }) };
+          let kind = materialized.kind;
+          let providerContentId = materialized.providerContentId;
+          if (headRevision !== "WORKTREE" && materialized.operation !== "DELETED") {
+            try {
+              const treeEntry = await repositoryTreeEntry(target, { revision: headRevision, path: entry.path });
+              kind = kindFromMode(treeEntry?.mode);
+              providerContentId = treeEntry?.objectId ?? providerContentId;
+            } catch {
+              // A provider may still return content for a mode-less fixture.
+            }
+          } else if (headRevision === "WORKTREE" && materialized.operation !== "DELETED" && kind === "FILE") {
+            try { providerContentId = await expectedGitBlobOid(target, { path: entry.path }); } catch { /* untracked files have no Git identity */ }
+          } else if (headRevision === "WORKTREE" && materialized.operation !== "DELETED" && kind === "GITLINK") {
+            try {
+              const indexEntry = (await repositoryIndexEntries(target, { paths: [entry.path] }))
+                .find((candidate) => candidate.path === entry.path);
+              providerContentId = indexEntry?.objectId ?? null;
+            } catch {
+              // A provider must reject an unresolved gitlink during manifest validation.
+            }
+          }
+          complete.push(normalizeRevisionEntry({
+            ...materialized,
+            kind,
+            providerContentId,
+            providerMetadata: { ...materialized.providerMetadata, objectFormat: await repositoryObjectFormat(target) },
+          }));
+        }
+        return complete.sort((left, right) => left.path.localeCompare(right.path));
+      } catch (error) {
+        if (error.code?.startsWith("E_REVISION_")) throw error;
+        throw revisionError("E_REVISION_PROVIDER_INVALID", `Git changed-entry discovery failed: ${error.message}`, error);
+      }
+    },
+    async readContent({ target, revision, path: repositoryPath } = {}) {
+      const safePath = normalizeGitPath(repositoryPath);
+      if (revision === "WORKTREE" || revision === "working-tree") {
+        await assertSafePath(target, safePath);
+        try { return await readFile(ensureWithin(target, safePath)); } catch (error) {
+        const wrapped = revisionError("E_REVISION_CONTENT_UNAVAILABLE", `Cannot read ${safePath} from the worktree`, error);
+        wrapped.notFound = error.code === "ENOENT";
+        throw wrapped;
+        }
+      }
+      try {
+        return await repositoryBlobAtRef(target, { ref: revision, path: safePath });
+      } catch (error) {
+        const wrapped = revisionError("E_REVISION_CONTENT_UNAVAILABLE", `Cannot read ${safePath} at ${revision}`, error);
+        wrapped.notFound = error.notFound === true;
+        throw wrapped;
+      }
+    },
+    async getContentIdentity({ target, revision, path: repositoryPath } = {}) {
+      try {
+        if (revision === "WORKTREE" || revision === "working-tree") {
+          return await expectedGitBlobOid(target, { path: repositoryPath });
+        }
+        return await repositoryBlobOidAtRef(target, { ref: revision, path: repositoryPath });
+      } catch (error) {
+        const wrapped = revisionError("E_REVISION_CONTENT_UNAVAILABLE", `Cannot resolve content identity for ${repositoryPath}`, error);
+        wrapped.notFound = error.notFound === true;
+        throw wrapped;
+      }
+    },
+    async getProviderMetadata(target) {
+      const [objectFormat, remote, fingerprint] = await Promise.all([
+        repositoryObjectFormat(target),
+        repositoryRemoteUrl(target),
+        currentRepositoryFingerprint(target),
+      ]);
+      return { objectFormat, remote, branch: fingerprint.branch, head: fingerprint.head };
+    },
+  };
+}
+
+export const GitRevisionProvider = createGitRevisionProvider;

package/src/core/revision/provider.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+
+/**
+ * Transport- and SCM-neutral revision provider contract.
+ *
+ * Providers expose opaque revision identifiers and normalized changed entries.
+ * The attestation core deliberately knows nothing about Git command syntax.
+ */
+export function assertRevisionProvider(provider) {
+  const required = [
+    "detect",
+    "getCurrentRevision",
+    "getChangedEntries",
+    "readContent",
+    "getContentIdentity",
+    "getRepositoryIdentity",
+  ];
+  if (!provider || typeof provider !== "object"
+    || required.some((method) => typeof provider[method] !== "function")) {
+    const error = new Error(`Revision provider must implement ${required.join(", ")}`);
+    error.code = "E_REVISION_PROVIDER_INVALID";
+    throw error;
+  }
+  return provider;
+}
+
+export function normalizeRevisionEntry(entry) {
+  if (!entry || typeof entry !== "object" || typeof entry.path !== "string" || !entry.path) {
+    const error = new Error("Revision entry requires a path");
+    error.code = "E_REVISION_PROVIDER_INVALID";
+    throw error;
+  }
+  const pathValue = entry.path.replaceAll("\\", "/");
+  const sourcePath = entry.sourcePath ? entry.sourcePath.replaceAll("\\", "/") : null;
+  const isSafe = (value) => typeof value === "string"
+    && value.length > 0
+    && !/[\u0000-\u001f\u007f]/u.test(value)
+    && !value.startsWith("/")
+    && path.posix.normalize(value) === value
+    && value !== "."
+    && value !== ".."
+    && !value.startsWith("../")
+    && !value.startsWith(".forgeloop/");
+  if (!isSafe(pathValue) || (sourcePath !== null && !isSafe(sourcePath))) {
+    const error = new Error(`Revision entry path is unsafe or reserved: ${pathValue}`);
+    error.code = "E_REVISION_PROVIDER_INVALID";
+    throw error;
+  }
+  return {
+    path: pathValue,
+    sourcePath,
+    operation: entry.operation,
+    kind: entry.kind,
+    bytes: entry.bytes ?? null,
+    providerContentId: entry.providerContentId ?? null,
+    providerMetadata: entry.providerMetadata ?? {},
+  };
+}
+
+export async function resolveRevisionProvider({ target, providerName = null, registry } = {}) {
+  const providers = registry ?? {};
+  if (providerName) {
+    const factory = providers[providerName];
+    if (typeof factory !== "function") {
+      const error = new Error(`Revision provider is unavailable: ${providerName}`);
+      error.code = "E_REVISION_PROVIDER_UNAVAILABLE";
+      throw error;
+    }
+    return assertRevisionProvider(await factory({ target }));
+  }
+
+  const available = [];
+  for (const [name, factory] of Object.entries(providers)) {
+    try {
+      const provider = assertRevisionProvider(await factory({ target }));
+      if (await provider.detect(target)) available.push({ name, provider });
+    } catch {
+      // Auto-detection ignores providers that cannot inspect this target.
+    }
+  }
+  if (available.length === 1) return available[0].provider;
+  if (available.length === 0) {
+    const error = new Error("No revision provider can resolve the target repository");
+    error.code = "E_REVISION_PROVIDER_UNAVAILABLE";
+    throw error;
+  }
+  const error = new Error(`Multiple revision providers match the target: ${available.map(({ name }) => name).join(", ")}`);
+  error.code = "E_REVISION_PROVIDER_AMBIGUOUS";
+  throw error;
+}

package/src/core/revision/registry.js

@@ -0,0 +1,5 @@
+import { createGitRevisionProvider } from "./git.js";
+
+export const REVISION_PROVIDERS = Object.freeze({
+  git: createGitRevisionProvider,
+});

package/src/core/route-artifact.js

@@ -6,7 +6,7 @@ import { taskArtifactPath } from "./task-paths.js";
 
 export async function persistRoute(target, route, packageRoot, options = {}) {
   assertRouteInvariants(route);
-  let { contractFingerprint, ...writeOptions } = options;
+  const { contractFingerprint, ...writeOptions } = options;
   let contractArtifact = null;
   if (contractFingerprint === undefined) {
     try {

package/src/core/schema-validation.js

@@ -42,6 +42,14 @@ export const SHIPPED_SCHEMA_NAMES = Object.freeze([
   "capability-policy",
   "trajectory-evaluation",
   "trajectory-scenario",
+  "workspace-binding",
+  "handoff-envelope",
+  "responsibility",
+  "verification-scope",
+  "code-manifest",
+  "code-attestation",
+  "attestation-verification-result",
+  "in-toto-statement",
 ]);
 
 export class SchemaValidationError extends Error {

package/src/core/signing/none.js

@@ -0,0 +1,23 @@
+export function createNoneSigningProvider() {
+  return {
+    name: "none",
+    async detect() { return true; },
+    async sign() {
+      return {
+        status: "UNAVAILABLE",
+        code: "E_ATTESTATION_SIGNER_UNAVAILABLE",
+        message: "The none signing provider cannot create an external signature",
+      };
+    },
+    async verify({ bundlePath } = {}) {
+      if (bundlePath) {
+        return {
+          status: "INVALID",
+          code: "E_ATTESTATION_SIGNER_UNAVAILABLE",
+          message: "The none signing provider cannot verify an external signature bundle",
+        };
+      }
+      return { status: "UNSIGNED", signer: null };
+    },
+  };
+}

package/src/core/signing/provider.js

@@ -0,0 +1,21 @@
+export function assertSigningProvider(provider) {
+  if (!provider || typeof provider !== "object"
+    || typeof provider.detect !== "function"
+    || typeof provider.sign !== "function"
+    || typeof provider.verify !== "function") {
+    const error = new Error("Signing provider must implement detect, sign, and verify");
+    error.code = "E_ATTESTATION_SIGNER_UNAVAILABLE";
+    throw error;
+  }
+  return provider;
+}
+
+export async function resolveSigningProvider({ providerName = "none", registry = {} } = {}) {
+  const factory = registry[providerName];
+  if (typeof factory !== "function") {
+    const error = new Error(`Signing provider is unavailable: ${providerName}`);
+    error.code = "E_ATTESTATION_SIGNER_UNAVAILABLE";
+    throw error;
+  }
+  return assertSigningProvider(await factory());
+}

package/src/core/signing/registry.js

@@ -0,0 +1,7 @@
+import { createNoneSigningProvider } from "./none.js";
+import { createSigstoreSigningProvider } from "./sigstore.js";
+
+export const SIGNING_PROVIDERS = Object.freeze({
+  none: createNoneSigningProvider,
+  sigstore: createSigstoreSigningProvider,
+});

package/src/core/signing/sigstore.js

@@ -0,0 +1,158 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import path from "node:path";
+import { ensureWithin, assertSafePath } from "../filesystem.js";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+
+export function createSigstoreSigningProvider({
+  command = "cosign",
+  execFileImpl = execFileAsync,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  const run = (args, options = {}) => execFileImpl(command, args, {
+    windowsHide: true,
+    shell: false,
+    cwd: options.cwd,
+    timeout: timeoutMs,
+    killSignal: "SIGTERM",
+    maxBuffer: MAX_OUTPUT_BYTES,
+  });
+  return {
+    name: "sigstore",
+    async detect() {
+      try {
+        await run(["version"]);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async sign({ target, statementPath, outputPath, bundlePath } = {}) {
+      const destinationPath = outputPath ?? bundlePath;
+      if (!destinationPath) {
+        return {
+          status: "INVALID",
+          code: "E_ATTESTATION_SIGNATURE_INVALID",
+          message: "A Sigstore bundle output path is required",
+        };
+      }
+      try {
+        await assertSafePath(target, statementPath);
+        await assertSafePath(target, destinationPath);
+        await run([
+          "attest-blob",
+          "--statement", ensureWithin(target, statementPath),
+          "--bundle", ensureWithin(target, destinationPath),
+          "--yes",
+        ], { cwd: path.resolve(target) });
+        return { status: "VALID", path: destinationPath };
+      } catch (error) {
+        const unavailable = error.code === "ENOENT" || error.cause?.code === "ENOENT";
+        const timedOut = error.code === "ETIMEDOUT" || error.killed === true || error.signal === "SIGTERM";
+        return {
+          status: "INVALID",
+          code: unavailable || timedOut ? "E_ATTESTATION_SIGNER_UNAVAILABLE" : "E_ATTESTATION_SIGNATURE_INVALID",
+          message: unavailable
+            ? "cosign is unavailable for Sigstore signing"
+            : timedOut
+              ? "Sigstore signing timed out"
+              : "Sigstore signing failed",
+        };
+      }
+    },
+    async verify({ target, statementPath, bundlePath, policy = {} } = {}) {
+      if (!bundlePath) return { status: "UNSIGNED", signer: null };
+      try {
+        await assertSafePath(target, statementPath);
+        await assertSafePath(target, bundlePath);
+        const statementAbsolute = ensureWithin(target, statementPath);
+        const bundleAbsolute = ensureWithin(target, bundlePath);
+        const args = [
+          "verify-blob-attestation",
+          "--statement", statementAbsolute,
+          "--bundle", bundleAbsolute,
+        ];
+        const identities = Array.isArray(policy.identities)
+          ? [...new Set(policy.identities.filter((value) => typeof value === "string" && value.length > 0))]
+          : [];
+        if (policy.identity) args.push("--certificate-identity", policy.identity);
+        else if (identities.length === 1) args.push("--certificate-identity", identities[0]);
+        else if (identities.length > 1) {
+          const exactAlternatives = identities
+            .map((value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"))
+            .join("|");
+          args.push("--certificate-identity-regexp", `^(?:${exactAlternatives})$`);
+        }
+        if (policy.issuer) args.push("--certificate-oidc-issuer", policy.issuer);
+        if (policy.trustedRoot) {
+          await assertSafePath(target, policy.trustedRoot);
+          args.push("--trusted-root", ensureWithin(target, policy.trustedRoot));
+        }
+        await run(args, { cwd: path.resolve(target) });
+        return { status: "VALID", signer: policy.identity ?? (identities.length === 1 ? identities[0] : null) };
+      } catch (error) {
+        if (error.code === "E_ATTESTATION_SIGNER_UNAVAILABLE") throw error;
+        const unavailable = error.code === "ENOENT" || error.cause?.code === "ENOENT";
+        const timedOut = error.code === "ETIMEDOUT" || error.killed === true || error.signal === "SIGTERM";
+        const outputLimit = error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+        const diagnostic = `${error.stderr ?? error.cause?.stderr ?? ""}`.toLowerCase();
+        const identityUntrusted = Boolean(policy.identity) && /identity|certificate-identity|subject/iu.test(diagnostic);
+        const issuerUntrusted = Boolean(policy.issuer) && /issuer|oidc/iu.test(diagnostic);
+        return {
+          status: "INVALID",
+          code: unavailable || timedOut || outputLimit
+            ? "E_ATTESTATION_SIGNER_UNAVAILABLE"
+            : identityUntrusted
+              ? "E_ATTESTATION_IDENTITY_UNTRUSTED"
+              : issuerUntrusted
+                ? "E_ATTESTATION_ISSUER_UNTRUSTED"
+                : "E_ATTESTATION_SIGNATURE_INVALID",
+          message: unavailable
+            ? "cosign is unavailable for Sigstore verification"
+            : timedOut
+              ? "Sigstore verification timed out"
+              : outputLimit
+                ? "Sigstore verification exceeded the output limit"
+                : identityUntrusted
+                  ? "Sigstore signer identity is not trusted"
+                  : issuerUntrusted
+                    ? "Sigstore certificate issuer is not trusted"
+              : "Sigstore signature verification failed",
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Convenience wrapper for callers that only need to verify one bundle.
+ * All process, path, timeout, and output-boundary rules remain owned by the
+ * canonical signing provider.
+ */
+export async function verifySigstoreBundle({
+  target,
+  statementPath,
+  bundlePath,
+  identity = null,
+  issuer = null,
+  trustedRootPath = null,
+  command = "cosign",
+  execFileImpl = execFileAsync,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  const provider = createSigstoreSigningProvider({ command, execFileImpl, timeoutMs });
+  return provider.verify({
+    target,
+    statementPath,
+    bundlePath,
+    policy: {
+      ...(identity ? { identity } : {}),
+      ...(issuer ? { issuer } : {}),
+      ...(trustedRootPath ? { trustedRoot: trustedRootPath } : {}),
+    },
+  });
+}

package/src/core/task-command.js

@@ -1,6 +1,7 @@
 import { resolveTaskContext, TASK_SELECTION_MODES } from "./task-context.js";
 import { withTaskTransaction } from "./transaction.js";
 import { assertTaskMutationAllowed } from "./task-claim-state.js";
+import { assertWorkspaceBinding } from "./workspace-binding.js";
 
 export async function withResolvedTask(
   target,
@@ -24,7 +25,7 @@ export async function withTaskMutation(
   options = {},
   operation = "mutation",
   callback,
-  { explicitRequired = false } = {},
+  { explicitRequired = false, skipWorkspaceBinding = false } = {},
 ) {
   const taskOption = options.taskId ?? options.task ?? null;
   const taskContext = await resolveTaskContext(target, {
@@ -37,6 +38,13 @@ export async function withTaskMutation(
   if (taskContext) {
     return withTaskTransaction({ target, taskId: taskContext.taskId, operation, packageRoot: options.packageRoot, recordCommitEvent: true }, async (transaction) => {
       await assertTaskMutationAllowed(target, { taskId: taskContext.taskId, packageRoot: options.packageRoot });
+      if (!skipWorkspaceBinding) {
+        await assertWorkspaceBinding(target, {
+          taskId: taskContext.taskId,
+          packageRoot: options.packageRoot,
+          operation,
+        });
+      }
       return callback({ ...taskContext, transaction });
     });
   }

package/src/core/task-paths.js

@@ -20,6 +20,11 @@ export const TASK_ARTIFACT_FILES = Object.freeze({
   evaluations: "evaluations",
   policySnapshot: "policy-snapshot.json",
   recovery: "recovery.json",
+  workspaceBinding: "workspace-binding.json",
+  handoffs: "handoffs",
+  responsibility: "responsibility.json",
+  verificationScope: "verification-scope.json",
+  attestations: "attestations",
 });
 
 export const POLICY_ROOT = ".forgeloop/policy";
@@ -99,6 +104,65 @@ export function taskEvaluationPath(taskId, evaluationId) {
   return `${taskDirectory(taskId)}/${TASK_ARTIFACT_FILES.evaluations}/${evaluationId}.json`;
 }
 
+function assertArtifactId(value, pattern, label) {
+  if (typeof value !== "string" || !pattern.test(value)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return value;
+}
+
+export function taskWorkspaceBindingPath(taskId) {
+  return taskArtifactPath(taskId, "workspaceBinding");
+}
+
+export function taskResponsibilityPath(taskId) {
+  return taskArtifactPath(taskId, "responsibility");
+}
+
+export function taskVerificationScopePath(taskId) {
+  return taskArtifactPath(taskId, "verificationScope");
+}
+
+export function taskHandoffDirectory(taskId) {
+  return taskArtifactPath(taskId, "handoffs");
+}
+
+export function taskHandoffPath(taskId, handoffId) {
+  assertArtifactId(handoffId, /^handoff-[A-Za-z0-9_-]+$/, "handoff ID");
+  return `${taskHandoffDirectory(taskId)}/${handoffId}.json`;
+}
+
+export function taskAttestationDirectory(taskId) {
+  return taskArtifactPath(taskId, "attestations");
+}
+
+export function taskCodeManifestPath(taskId) {
+  return `${taskAttestationDirectory(taskId)}/code-manifest.json`;
+}
+
+export function taskAttestationStatementPath(taskId) {
+  return `${taskAttestationDirectory(taskId)}/statement.json`;
+}
+
+export function taskAttestationBundlePath(taskId) {
+  return `${taskAttestationDirectory(taskId)}/statement.sigstore.json`;
+}
+
+export function taskAttestationHistoryDirectory(taskId, verificationCycle) {
+  if (!Number.isInteger(verificationCycle) || verificationCycle < 1) {
+    throw new Error(`Invalid attestation verification cycle: ${verificationCycle}`);
+  }
+  return `${taskAttestationDirectory(taskId)}/history/cycle-${verificationCycle}`;
+}
+
+export function taskCodeManifestHistoryPath(taskId, verificationCycle) {
+  return `${taskAttestationHistoryDirectory(taskId, verificationCycle)}/code-manifest.json`;
+}
+
+export function taskAttestationStatementHistoryPath(taskId, verificationCycle) {
+  return `${taskAttestationHistoryDirectory(taskId, verificationCycle)}/statement.json`;
+}
+
 export function taskLockPath(taskId) {
   assertTaskId(taskId);
   return `${TASK_LOCK_ROOT}/${taskStorageKey(taskId)}.lock`;
@@ -132,5 +196,13 @@ export function buildTaskArtifactPaths(taskId) {
     lock: taskLockPath(taskId),
     policySnapshot: `${dir}/${TASK_ARTIFACT_FILES.policySnapshot}`,
     recovery: `${dir}/${TASK_ARTIFACT_FILES.recovery}`,
+    workspaceBinding: `${dir}/${TASK_ARTIFACT_FILES.workspaceBinding}`,
+    handoffs: `${dir}/${TASK_ARTIFACT_FILES.handoffs}`,
+    responsibility: `${dir}/${TASK_ARTIFACT_FILES.responsibility}`,
+    verificationScope: `${dir}/${TASK_ARTIFACT_FILES.verificationScope}`,
+    attestations: `${dir}/${TASK_ARTIFACT_FILES.attestations}`,
+    codeManifest: taskCodeManifestPath(taskId),
+    attestationStatement: taskAttestationStatementPath(taskId),
+    attestationBundle: taskAttestationBundlePath(taskId),
   });
 }

package/src/core/templates.js

@@ -75,6 +75,14 @@ export const TEMPLATE_PATHS = [
   "schemas/capability-policy.schema.json",
   "schemas/trajectory-evaluation.schema.json",
   "schemas/trajectory-scenario.schema.json",
+  "schemas/workspace-binding.schema.json",
+  "schemas/handoff-envelope.schema.json",
+  "schemas/responsibility.schema.json",
+  "schemas/verification-scope.schema.json",
+  "schemas/code-manifest.schema.json",
+  "schemas/code-attestation.schema.json",
+  "schemas/attestation-verification-result.schema.json",
+  "schemas/in-toto-statement.schema.json",
 ];
 
 export function getPackageRoot() {