@cassiomc1/forgeloop 1.2.1 → 1.2.2

package/src/core/preflight-consistency.js

@@ -86,64 +86,72 @@ export async function validateReadyProtocolConsistency({
   persisted,
   current = null,
   evaluateCurrentPreflight,
+  taskId = null,
 } = {}) {
   if (persisted?.status !== "READY") return [];
-  const result = current ?? await evaluateCurrentPreflight({ target, packageRoot });
+  const result = current ?? await evaluateCurrentPreflight({ target, packageRoot, taskId });
   const errors = [...validatePersistedPreflight(persisted, result)];
 
+  const stateRel = taskId ? taskArtifactPath(taskId, "state") : ARTIFACT_PATHS.state;
+  const eventsRel = taskId ? taskArtifactPath(taskId, "events") : ARTIFACT_PATHS.events;
+  const preflightRel = taskId ? taskArtifactPath(taskId, "preflight") : ARTIFACT_PATHS.preflight;
+  const contractRel = taskId ? taskArtifactPath(taskId, "contract") : ARTIFACT_PATHS.contract;
+  const routeRel = taskId ? taskArtifactPath(taskId, "route") : ARTIFACT_PATHS.route;
+  const gatesRel = taskId ? taskArtifactPath(taskId, "gates") : ARTIFACT_PATHS.gates;
+
   let state = null;
   try {
-    state = await readWorkState(target, packageRoot);
+    state = await readWorkState(target, { packageRoot, taskId });
   } catch (error) {
-    errors.push(issue("E_STATE_INVALID", error.message, [ARTIFACT_PATHS.state]));
+    errors.push(issue("E_STATE_INVALID", error.message, [stateRel]));
   }
   if (!state) {
     errors.push(issue(
       "E_STATE_MISSING_AFTER_PREFLIGHT_READY",
       "A persisted READY preflight must have a resumable work-state checkpoint",
-      [ARTIFACT_PATHS.preflight, ARTIFACT_PATHS.state],
+      [preflightRel, stateRel],
     ));
   } else {
     if (state.taskId !== persisted.taskId) {
-      errors.push(issue("E_STATE_TASK_MISMATCH", "The resumable checkpoint does not belong to the READY preflight task", [ARTIFACT_PATHS.state, ARTIFACT_PATHS.preflight]));
+      errors.push(issue("E_STATE_TASK_MISMATCH", "The resumable checkpoint does not belong to the READY preflight task", [stateRel, preflightRel]));
     }
     if (state.contractFingerprint !== result.fingerprints.contract) {
-      errors.push(issue("E_CONTRACT_STALE", "The resumable checkpoint does not match the READY contract fingerprint", [ARTIFACT_PATHS.state, ARTIFACT_PATHS.contract]));
+      errors.push(issue("E_CONTRACT_STALE", "The resumable checkpoint does not match the READY contract fingerprint", [stateRel, contractRel]));
     }
     if (state.routeFingerprint !== result.fingerprints.routing) {
-      errors.push(issue("E_ROUTE_STALE", "The resumable checkpoint does not match the READY routing fingerprint", [ARTIFACT_PATHS.state, ARTIFACT_PATHS.route]));
+      errors.push(issue("E_ROUTE_STALE", "The resumable checkpoint does not match the READY routing fingerprint", [stateRel, routeRel]));
     }
     if (JSON.stringify(state.selectedGuides) !== JSON.stringify(result.routing.guides)) {
-      errors.push(issue("E_ROUTE_GUIDE_MISMATCH", "The resumable checkpoint guides do not match the READY routing result", [ARTIFACT_PATHS.state, ARTIFACT_PATHS.route]));
+      errors.push(issue("E_ROUTE_GUIDE_MISMATCH", "The resumable checkpoint guides do not match the READY routing result", [stateRel, routeRel]));
     }
     if (!sameStringSet(state.requiredGates ?? [], persisted.requiredGates)
       || !sameStringSet(state.satisfiedGates ?? [], persisted.satisfiedGates)) {
-      errors.push(issue("E_PREFLIGHT_GATES_STALE", "The resumable checkpoint gate sets do not match the READY preflight", [ARTIFACT_PATHS.state, ARTIFACT_PATHS.preflight, ARTIFACT_PATHS.gates]));
+      errors.push(issue("E_PREFLIGHT_GATES_STALE", "The resumable checkpoint gate sets do not match the READY preflight", [stateRel, preflightRel, gatesRel]));
     }
   }
 
-  const ledger = await validateEventLedger(target, packageRoot);
+  const ledger = await validateEventLedger(target, packageRoot, { taskId });
   if (!ledger.valid) {
-    errors.push(...ledger.errors.map((error) => issue(error.code ?? "E_EVENT_INVALID", error.message, [ARTIFACT_PATHS.events])));
+    errors.push(...ledger.errors.map((error) => issue(error.code ?? "E_EVENT_INVALID", error.message, [eventsRel])));
   }
   const events = ledger.events ?? [];
   for (const requiredEvent of ["CONTRACT_VALIDATED", "ROUTE_VALIDATED"]) {
     if (!events.some((event) => event.event === requiredEvent && event.taskId === persisted.taskId)) {
-      errors.push(issue("E_PREFLIGHT_EVENT_MISSING", `READY preflight is missing lifecycle event: ${requiredEvent}`, [ARTIFACT_PATHS.events, ARTIFACT_PATHS.preflight]));
+      errors.push(issue("E_PREFLIGHT_EVENT_MISSING", `READY preflight is missing lifecycle event: ${requiredEvent}`, [eventsRel, preflightRel]));
     }
   }
   for (const gate of persisted.satisfiedGates ?? []) {
     if (!events.some((event) => event.event === "GATE_SATISFIED"
       && event.taskId === persisted.taskId
       && event.details?.gate === gate)) {
-      errors.push(issue("E_PREFLIGHT_GATE_EVENT_MISSING", `READY preflight is missing lifecycle gate event: ${gate}`, [ARTIFACT_PATHS.events, `${ARTIFACT_PATHS.gates}/${gate}.json`]));
+      errors.push(issue("E_PREFLIGHT_GATE_EVENT_MISSING", `READY preflight is missing lifecycle gate event: ${gate}`, [eventsRel, `${gatesRel}/${gate}.json`]));
     }
   }
   const readyEvents = events.filter((event) => event.event === "PREFLIGHT_READY" && event.taskId === persisted.taskId);
   if (readyEvents.length === 0) {
-    errors.push(issue("E_PREFLIGHT_READY_EVENT_MISSING", "Persisted READY preflight is missing the matching PREFLIGHT_READY lifecycle event", [ARTIFACT_PATHS.preflight, ARTIFACT_PATHS.events]));
+    errors.push(issue("E_PREFLIGHT_READY_EVENT_MISSING", "Persisted READY preflight is missing the matching PREFLIGHT_READY lifecycle event", [preflightRel, eventsRel]));
   } else if (!readyEvents.some((event) => sameReadyPreflightEvent(event, result))) {
-    errors.push(issue("E_PREFLIGHT_READY_EVENT_MISMATCH", "PREFLIGHT_READY lifecycle details do not match the persisted READY preflight", [ARTIFACT_PATHS.preflight, ARTIFACT_PATHS.events]));
+    errors.push(issue("E_PREFLIGHT_READY_EVENT_MISMATCH", "PREFLIGHT_READY lifecycle details do not match the persisted READY preflight", [preflightRel, eventsRel]));
   }
   return sortIssues(errors);
 }

package/src/core/preflight.js

@@ -27,7 +27,7 @@ import {
 import { PROFILE_PATH } from "./target-layout.js";
 import { readPersistedRoute } from "./route-artifact.js";
 import { validateEventLedger } from "./events.js";
-import { taskArtifactPath } from "./task-paths.js";
+import { PROJECT_ARTIFACT_PATHS, taskArtifactPath } from "./task-paths.js";
 
 const PREVIEW_DECISION_LIMIT = 10;
 const PREVIEW_DECISION_MAX_LENGTH = 240;
@@ -91,6 +91,24 @@ export async function evaluatePreflight({ target, packageRoot, strict = false, t
     errors.push(issue("E_CONTRACT_STALE", "work-state references a different contract", [contractRelPath, stateRelPath]));
   }
 
+  const { detectPolicyCapability } = await import("./policy-engine.js");
+  const policyCapability = await detectPolicyCapability(target, packageRoot);
+  if (policyCapability === "INVALID") {
+    errors.push(issue(
+      "E_POLICY_INVALID",
+      "Executable policy artifacts are present but invalid.",
+      [
+        PROJECT_ARTIFACT_PATHS.policyRules,
+        PROJECT_ARTIFACT_PATHS.policyBaseline,
+        PROJECT_ARTIFACT_PATHS.policyDiscovery,
+        PROJECT_ARTIFACT_PATHS.policyLock,
+      ],
+      {
+        next: "Repair the invalid policy artifact and rerun forgeloop preflight.",
+      },
+    ));
+  }
+
   const sortedErrors = sortIssues(errors);
   const effectiveTaskId = taskId ?? contract?.value?.taskId ?? state?.taskId ?? "unknown";
   return {
@@ -178,6 +196,52 @@ export async function runPreflight({
   }
 
   if (result.taskId !== "unknown") {
+    const {
+      detectPolicyCapability,
+      loadEffectiveRules,
+      readBaseline,
+      computePolicyLockData,
+      readTaskPolicySnapshot,
+      writeTaskPolicySnapshot,
+    } = await import("./policy-engine.js");
+
+    const policyCapability = await detectPolicyCapability(target, packageRoot);
+    if (policyCapability === "INVALID") {
+      throw preflightError(
+        "E_POLICY_INVALID",
+        "Executable policy artifacts are present but invalid.",
+        [
+          PROJECT_ARTIFACT_PATHS.policyRules,
+          PROJECT_ARTIFACT_PATHS.policyBaseline,
+          PROJECT_ARTIFACT_PATHS.policyDiscovery,
+          PROJECT_ARTIFACT_PATHS.policyLock,
+        ],
+      );
+    }
+
+    if (policyCapability === "AVAILABLE") {
+      try {
+        const existingSnapshot = await readTaskPolicySnapshot(target, result.taskId, packageRoot);
+        if (!existingSnapshot) {
+          const rules = await loadEffectiveRules(target, packageRoot);
+          const baseline = await readBaseline(target, packageRoot);
+          const lock = computePolicyLockData(rules, baseline);
+          const snapshot = {
+            schemaVersion: 1,
+            policyDigest: lock.digest,
+            rules,
+            baseline: baseline ?? { schemaVersion: 1, entries: [] },
+            baselineDigest: lock.baselineDigest,
+            capturedAt: new Date().toISOString(),
+          };
+          await writeTaskPolicySnapshot(target, result.taskId, snapshot, packageRoot);
+        }
+      } catch (error) {
+        const snapRel = taskArtifactPath(result.taskId, "policySnapshot");
+        throw preflightError("E_POLICY_SNAPSHOT_WRITE_FAILED", `Failed to persist task policy snapshot: ${error.message}`, [snapRel]);
+      }
+    }
+
     await appendActivationEvents(target, packageRoot, ledger, result, { eventsPath, taskId });
     const afterEvents = await validateEventLedger(target, packageRoot, { eventsPath, taskId });
     if (!afterEvents.valid) {

package/src/core/reconcile-closure.js

@@ -0,0 +1,173 @@
+import { readContract } from "./contract.js";
+import { appendProtocolEvent, validateEventLedger } from "./events.js";
+import { runCommandExecution } from "./execution.js";
+import { currentRepositoryFingerprint } from "./repository.js";
+import { taskArtifactPath } from "./task-paths.js";
+import { classifyLoadedWorkState, readWorkState, writeWorkState } from "./work-state.js";
+
+export const RECONCILE_EVENT = "CHECKPOINT_RECONCILED";
+
+const RECONCILABLE_DRIFT = new Set(["REPOSITORY_CHANGED"]);
+
+function reconcileError(code, message, artifacts = []) {
+  const error = new Error(message);
+  error.code = code;
+  error.artifacts = artifacts;
+  return error;
+}
+
+/**
+ * Canonical recovery for an EXECUTING task whose objective is already
+ * satisfied in the current repository but whose work-state checkpoint is
+ * stale because the repository fingerprint moved.
+ *
+ * The command refreshes the checkpoint repository fingerprint only after:
+ *   - the task is EXECUTING,
+ *   - classification requires revalidation and the only drift is
+ *     REPOSITORY_CHANGED,
+ *   - the append-only event ledger is valid,
+ *   - a contract-bound verification check (exact verification item id and
+ *     requirement text, type VERIFICATION) executes successfully in the
+ *     current repository as evidence that the objective is present.
+ *
+ * Closure itself proceeds through the canonical pipeline (advance to
+ * VERIFYING, prepare-completion, record-check, complete); claims are
+ * released only by canonical COMPLETE.
+ */
+export async function runReconcileClosure({
+  target,
+  packageRoot,
+  taskId,
+  checkId,
+  requirement,
+  argv,
+  details,
+  authorityContext,
+  runtimeContext,
+} = {}) {
+  if (typeof taskId !== "string" || !taskId.trim()) {
+    throw reconcileError("E_TASK_REQUIRED", "reconcile-closure requires --task", []);
+  }
+  if (typeof checkId !== "string" || !checkId.trim()) {
+    throw reconcileError("E_RECONCILE_REQUIREMENT_UNKNOWN", "reconcile-closure requires --id", []);
+  }
+  if (typeof requirement !== "string" || !requirement.trim()) {
+    throw reconcileError("E_RECONCILE_REQUIREMENT_UNKNOWN", "reconcile-closure requires --requirement", []);
+  }
+  if (!Array.isArray(argv) || argv.length === 0) {
+    throw reconcileError("E_RECONCILE_EVIDENCE_FAILED", "reconcile-closure requires -- followed by the evidence command argv", []);
+  }
+
+  const stateRel = taskArtifactPath(taskId, "state");
+  const contractRel = taskArtifactPath(taskId, "contract");
+  const eventsRel = taskArtifactPath(taskId, "events");
+
+  const state = await readWorkState(target, { packageRoot, taskId });
+  if (!state) {
+    throw reconcileError("E_RECONCILE_PHASE_INVALID", "Cannot reconcile without work state", [stateRel]);
+  }
+  if (state.phase !== "EXECUTING") {
+    throw reconcileError(
+      "E_RECONCILE_PHASE_INVALID",
+      `reconcile-closure supports EXECUTING tasks whose objective is already satisfied; found ${state.phase}`,
+      [stateRel],
+    );
+  }
+
+  const freshness = await classifyLoadedWorkState({ target, state, contractFile: contractRel });
+  if (freshness.status !== "REVALIDATION_REQUIRED" || !freshness.reasons.includes("REPOSITORY_CHANGED")) {
+    throw reconcileError(
+      "E_RECONCILE_NOT_STALE",
+      `work-state checkpoint is ${freshness.status === "FRESH" ? "fresh" : "not revalidation-required"}; no reconciliation required`,
+      [stateRel, contractRel],
+    );
+  }
+  const unsupported = freshness.reasons.filter((reason) => !RECONCILABLE_DRIFT.has(reason));
+  if (unsupported.length > 0) {
+    throw reconcileError(
+      "E_RECONCILE_UNSUPPORTED_DRIFT",
+      `reconcile-closure only reconciles repository fingerprint drift; unresolved drift: ${unsupported.join(", ")}`,
+      [stateRel, contractRel],
+    );
+  }
+
+  const ledger = await validateEventLedger(target, packageRoot, { taskId });
+  if (!ledger.valid) {
+    const first = ledger.errors[0];
+    throw reconcileError(
+      "E_RECONCILE_LEDGER_INVALID",
+      `append-only event ledger must be valid before reconciliation: ${first?.message ?? "invalid ledger"}`,
+      [eventsRel],
+    );
+  }
+
+  const contract = await readContract(target, packageRoot, { taskId });
+  const verificationItem = (contract.value.verification ?? []).find(
+    (item) => item.type === "VERIFICATION" && item.id === checkId && item.text === requirement,
+  );
+  if (!verificationItem) {
+    throw reconcileError(
+      "E_RECONCILE_REQUIREMENT_UNKNOWN",
+      `no contract verification item matches id "${checkId}" with the exact requirement text`,
+      [contractRel],
+    );
+  }
+
+  const execution = await runCommandExecution({
+    target,
+    packageRoot,
+    taskId,
+    checkId,
+    requirement,
+    verificationCycle: state.verificationCycle ?? 1,
+    argv,
+    details,
+    authorityContext,
+    runtimeContext,
+  });
+  if (execution.execution.status !== "passed") {
+    throw reconcileError(
+      "E_RECONCILE_EVIDENCE_FAILED",
+      `objective-satisfaction evidence failed (exit ${execution.execution.exitCode ?? "not-started"}): ${execution.result}`,
+      [execution.path],
+    );
+  }
+
+  const repository = await currentRepositoryFingerprint(target);
+  const previous = state.repositoryFingerprint;
+
+  await appendProtocolEvent(target, {
+    taskId,
+    event: RECONCILE_EVENT,
+    details: {
+      previousBranch: previous?.branch ?? null,
+      previousHead: previous?.head ?? null,
+      currentBranch: repository.branch,
+      currentHead: repository.head,
+      checkId,
+      requirement,
+      command: argv.join(" "),
+      exitCode: execution.execution.exitCode ?? 0,
+      executionId: execution.execution.executionId,
+    },
+  }, packageRoot, { taskId });
+
+  await writeWorkState(target, {
+    ...state,
+    repositoryFingerprint: repository,
+    lastUpdated: new Date().toISOString(),
+  }, { packageRoot, taskId });
+
+  return {
+    taskId,
+    phase: state.phase,
+    reconciled: true,
+    previousRepositoryFingerprint: previous,
+    repositoryFingerprint: repository,
+    checkId,
+    requirement,
+    executionId: execution.execution.executionId,
+    executionPath: execution.path,
+    event: RECONCILE_EVENT,
+  };
+}

package/src/core/schema-validation.js

@@ -24,6 +24,11 @@ export const SHIPPED_SCHEMA_NAMES = Object.freeze([
   "event",
   "activation",
   "policy",
+  "policy-rules",
+  "policy-discovery",
+  "policy-baseline",
+  "policy-lock",
+  "policy-snapshot",
   "task-bundle",
   "execution",
   "authority",
@@ -40,6 +45,7 @@ export class SchemaValidationError extends Error {
 }
 
 function typeMatches(value, type) {
+  if (Array.isArray(type)) return type.some((t) => typeMatches(value, t));
   if (type === "object") return value !== null && typeof value === "object" && !Array.isArray(value);
   if (type === "array") return Array.isArray(value);
   if (type === "integer") return Number.isInteger(value);

package/src/core/task-context.js

@@ -71,6 +71,17 @@ export async function resolveTaskContext(target, {
   const tasks = await discoverTasks(target, packageRoot);
   const healthyTasks = tasks.filter((t) => t.healthy !== false);
 
+  // Fail closed: modern task namespaces exist but are all corrupt/unhealthy.
+  // Never fall back to legacy singleton state over corrupt modern state.
+  if (tasks.length > 0 && healthyTasks.length === 0) {
+    const firstInvalid = tasks.find((t) => t.healthy === false);
+    const error = new Error(
+      firstInvalid?.error?.message ?? "Task namespaces exist but none are valid",
+    );
+    error.code = firstInvalid?.error?.code ?? "E_TASK_DESCRIPTOR_INVALID";
+    throw error;
+  }
+
   if (healthyTasks.length === 1) {
     const single = healthyTasks[0];
     return createTaskContext({

package/src/core/task-discovery.js

@@ -1,12 +1,59 @@
 import { readdir } from "node:fs/promises";
 import { ensureWithin, fileExists } from "./filesystem.js";
 import { getPackageRoot } from "./templates.js";
-import { TASK_STATE_ROOT, taskArtifactPath } from "./task-paths.js";
+import { TASK_STATE_ROOT, TASK_ARTIFACT_FILES, taskArtifactPath } from "./task-paths.js";
 import { readTaskDescriptor } from "./task-descriptor.js";
 import { readJsonArtifact } from "./artifacts.js";
 import { readLockInfo } from "./task-lock.js";
 import { taskStorageKey } from "./task-identity.js";
 
+/**
+ * Explicitly recognized legacy-incidental artifacts that may legitimately
+ * exist inside a 64-hex task-state directory WITHOUT a task.json descriptor.
+ * A legacy preflight writes a task-scoped policy snapshot for a task that has
+ * no modern namespace; that directory is not a task namespace. Any other
+ * content makes the directory a corrupt modern task namespace that must fail
+ * closed.
+ */
+const LEGACY_INCIDENTAL_ARTIFACTS = new Set([
+  TASK_ARTIFACT_FILES.policySnapshot,
+]);
+
+/**
+ * Classifies a 64-hex task-state directory whose task.json is missing.
+ *
+ *   - directory contains only explicitly recognized legacy-incidental
+ *     artifacts (policy-snapshot.json) -> LEGACY_INCIDENTAL (ignored)
+ *   - anything else, including an empty directory -> CORRUPT_TASK_NAMESPACE
+ *     (no positive evidence of legitimate legacy spillover)
+ */
+async function classifyDescriptorlessTaskDirectory(target, taskKey) {
+  const directory = ensureWithin(target, `${TASK_STATE_ROOT}/${taskKey}`);
+  let entries = [];
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch {
+    return {
+      kind: "CORRUPT_TASK_NAMESPACE",
+      error: {
+        code: "E_TASK_DESCRIPTOR_INVALID",
+        message: `Task namespace ${taskKey} is missing task.json`,
+      },
+    };
+  }
+  const names = new Set(entries.map((entry) => entry.name));
+  if (names.size > 0 && [...names].every((name) => LEGACY_INCIDENTAL_ARTIFACTS.has(name))) {
+    return { kind: "LEGACY_INCIDENTAL" };
+  }
+  return {
+    kind: "CORRUPT_TASK_NAMESPACE",
+    error: {
+      code: "E_TASK_DESCRIPTOR_INVALID",
+      message: `Task namespace ${taskKey} contains task artifacts but task.json is missing`,
+    },
+  };
+}
+
 export async function discoverTasks(target, packageRoot = getPackageRoot()) {
   const rootPath = ensureWithin(target, TASK_STATE_ROOT);
   if (!(await fileExists(rootPath))) {
@@ -92,6 +139,25 @@ export async function discoverTasks(target, packageRoot = getPackageRoot()) {
         directory: `${TASK_STATE_ROOT}/${descriptor.taskKey}`,
       });
     } catch (err) {
+      // A directory without a task.json descriptor is not automatically a
+      // task namespace: classify by contents so explicitly recognized legacy
+      // spillover (policy-snapshot.json) stays compatible while any modern
+      // task artifact without a descriptor fails closed instead of silently
+      // reopening the legacy singleton fallback.
+      if (err.code === "E_TASK_NOT_FOUND" || err.code === "ARTIFACT_MISSING") {
+        const classification = await classifyDescriptorlessTaskDirectory(target, entry.name);
+        if (classification.kind === "LEGACY_INCIDENTAL") {
+          continue;
+        }
+        tasks.push({
+          taskId: null,
+          taskKey: entry.name,
+          directory: `${TASK_STATE_ROOT}/${entry.name}`,
+          healthy: false,
+          error: classification.error,
+        });
+        continue;
+      }
       // P1-2: Surface corrupt task namespaces instead of silently hiding them
       tasks.push({
         taskId: null,

package/src/core/task-paths.js

@@ -15,14 +15,22 @@ export const TASK_ARTIFACT_FILES = Object.freeze({
   gates: "gates",
   executions: "executions",
   lock: ".lock",
+  policySnapshot: "policy-snapshot.json",
 });
 
+export const POLICY_ROOT = ".forgeloop/policy";
+
 export const PROJECT_ARTIFACT_PATHS = Object.freeze({
   config: ".forgeloop/config.json",
   sources: ".forgeloop/sources.json",
   manifest: ".forgeloop/.manifest.json",
   kit: ".forgeloop/kit",
   gitignore: ".forgeloop/.gitignore",
+  policyDir: ".forgeloop/policy",
+  policyRules: ".forgeloop/policy/rules.json",
+  policyBaseline: ".forgeloop/policy/baseline.json",
+  policyLock: ".forgeloop/policy/policy.lock",
+  policyDiscovery: ".forgeloop/policy/discovery.json",
 });
 
 export const LEGACY_TASK_ARTIFACT_PATHS = Object.freeze({
@@ -92,5 +100,6 @@ export function buildTaskArtifactPaths(taskId) {
     gates: `${dir}/${TASK_ARTIFACT_FILES.gates}`,
     executions: `${dir}/${TASK_ARTIFACT_FILES.executions}`,
     lock: `${dir}/${TASK_ARTIFACT_FILES.lock}`,
+    policySnapshot: `${dir}/${TASK_ARTIFACT_FILES.policySnapshot}`,
   });
 }

package/src/core/templates.js

@@ -58,6 +58,11 @@ export const TEMPLATE_PATHS = [
   "schemas/event.schema.json",
   "schemas/activation.schema.json",
   "schemas/policy.schema.json",
+  "schemas/policy-rules.schema.json",
+  "schemas/policy-discovery.schema.json",
+  "schemas/policy-baseline.schema.json",
+  "schemas/policy-lock.schema.json",
+  "schemas/policy-snapshot.schema.json",
   "schemas/task-bundle.schema.json",
   "schemas/authority.schema.json",
   "schemas/task-descriptor.schema.json",