@cassiomc1/forgeloop 0.1.0 → 0.1.2

package/src/core/sources.js

@@ -0,0 +1,86 @@
+import { PROTOCOL_VERSION } from "./protocol.js";
+
+export const SOURCE_REGISTRY_SCHEMA_VERSION = 1;
+export const SOURCE_KINDS = Object.freeze([
+  "user-request",
+  "repository-fact",
+  "observation",
+  "command",
+  "agent-decision",
+  "inference",
+  "unknown",
+]);
+
+export function createSourceRegistry(sources = {}) {
+  if (!sources || typeof sources !== "object" || Array.isArray(sources)) {
+    throw new Error("Source registry must be an object");
+  }
+  return {
+    schemaVersion: SOURCE_REGISTRY_SCHEMA_VERSION,
+    protocolVersion: PROTOCOL_VERSION,
+    sources: structuredClone(sources),
+  };
+}
+
+export function assertSourceKind(kind, label = "source.kind") {
+  if (!SOURCE_KINDS.includes(kind)) throw new Error(`${label} must be one of ${SOURCE_KINDS.join(", ")}`);
+  return kind;
+}
+
+export function assertSourceRefs(registry, refs = []) {
+  const ids = new Set(Object.keys(registry?.sources ?? {}));
+  for (const ref of refs) {
+    if (!ids.has(ref)) {
+      const error = new Error(`Unknown source ID: ${ref}`);
+      error.code = "E_PROFILE_SOURCE_UNKNOWN";
+      throw error;
+    }
+  }
+  return true;
+}
+
+export function assertSourceRegistry(registry) {
+  if (!registry || typeof registry !== "object" || Array.isArray(registry)) {
+    const error = new Error("Source registry must be an object");
+    error.code = "E_PROFILE_SOURCE_INVALID";
+    throw error;
+  }
+  if (registry.schemaVersion !== SOURCE_REGISTRY_SCHEMA_VERSION || registry.protocolVersion !== PROTOCOL_VERSION) {
+    const error = new Error("Source registry has an unsupported protocol version");
+    error.code = "E_PROFILE_SOURCE_INVALID";
+    throw error;
+  }
+  for (const [id, source] of Object.entries(registry.sources ?? {})) {
+    if (!id || !source || typeof source !== "object" || Array.isArray(source)) {
+      const error = new Error(`Invalid source entry: ${id}`);
+      error.code = "E_PROFILE_SOURCE_INVALID";
+      throw error;
+    }
+    assertSourceKind(source.kind, `sources.${id}.kind`);
+    if (typeof source.summary !== "string" || source.summary.trim() === "") {
+      const error = new Error(`Source summary is required: ${id}`);
+      error.code = "E_PROFILE_SOURCE_INVALID";
+      throw error;
+    }
+  }
+  return registry;
+}
+
+export function assertSourceProvenance(registry, refs = [], { expectedKind } = {}) {
+  assertSourceRegistry(registry);
+  assertSourceRefs(registry, refs);
+  const expectedKinds = expectedKind === undefined
+    ? null
+    : new Set(Array.isArray(expectedKind) ? expectedKind : [expectedKind]);
+  if (expectedKinds) {
+    for (const ref of refs) {
+      const source = registry.sources[ref];
+      if (!expectedKinds.has(source.kind)) {
+        const error = new Error(`Source ${ref} has kind ${source.kind}, expected ${[...expectedKinds].join(", ")}`);
+        error.code = "E_PROFILE_SOURCE_MISCLASSIFIED";
+        throw error;
+      }
+    }
+  }
+  return true;
+}

package/src/core/templates.js

@@ -4,6 +4,10 @@ import { fileURLToPath } from "node:url";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 
+const TEMPLATE_SOURCE_PATHS = Object.freeze({
+  ".forgeloop/.gitignore": ".forgeloop/forgeloop.gitignore",
+});
+
 export const TEMPLATE_PATHS = [
   ".forgeloop/.gitignore",
   "AGENTS.md",
@@ -40,6 +44,17 @@ export const TEMPLATE_PATHS = [
   "schemas/task-brief.schema.json",
   "schemas/delegated-result.schema.json",
   "schemas/evidence.schema.json",
+  "schemas/current-contract.schema.json",
+  "schemas/gate.schema.json",
+  "schemas/source-registry.schema.json",
+  "schemas/config.schema.json",
+  "schemas/preflight.schema.json",
+  "schemas/check.schema.json",
+  "schemas/evidence-coverage.schema.json",
+  "schemas/event.schema.json",
+  "schemas/activation.schema.json",
+  "schemas/policy.schema.json",
+  "schemas/task-bundle.schema.json",
 ];
 
 export function getPackageRoot() {
@@ -48,9 +63,12 @@ export function getPackageRoot() {
 
 export async function readTemplateEntries(packageRoot = PACKAGE_ROOT) {
   return Promise.all(
-    TEMPLATE_PATHS.map(async (relativePath) => ({
-      relativePath,
-      bytes: await readFile(path.join(packageRoot, relativePath)),
-    })),
+    TEMPLATE_PATHS.map(async (relativePath) => {
+      const sourcePath = TEMPLATE_SOURCE_PATHS[relativePath] ?? relativePath;
+      return {
+        relativePath,
+        bytes: await readFile(path.join(packageRoot, sourcePath)),
+      };
+    }),
   );
 }

package/src/core/work-state.js

@@ -16,6 +16,8 @@ import { getPackageRoot } from "./templates.js";
 import { currentRepositoryFingerprint } from "./repository.js";
 import { createEvidence } from "./evidence.js";
 import { assertJsonBytes } from "./json-safety.js";
+import { assertCoverageList } from "./coverage.js";
+import { canonicalFingerprint } from "./artifacts.js";
 
 export const WORK_STATE_PATH = ".forgeloop/work-state.json";
 
@@ -27,20 +29,8 @@ export class WorkStateError extends Error {
   }
 }
 
-function canonicalize(value) {
-  if (Array.isArray(value)) return value.map(canonicalize);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]),
-    );
-  }
-  return value;
-}
-
 export function contractFingerprint(contract) {
-  return createHash("sha256")
-    .update(JSON.stringify(canonicalize(contract)))
-    .digest("hex");
+  return canonicalFingerprint(contract);
 }
 
 function assertFingerprint(value, label) {
@@ -101,6 +91,7 @@ export function assertWorkStateSemantics(state) {
     throw new WorkStateError("Work state taskId is required");
   }
   assertFingerprint(state.contractFingerprint, "contractFingerprint");
+  if (state.routeFingerprint !== undefined) assertFingerprint(state.routeFingerprint, "routeFingerprint");
   if (!state.repositoryFingerprint || typeof state.repositoryFingerprint !== "object" || Array.isArray(state.repositoryFingerprint)) {
     throw new WorkStateError("repositoryFingerprint is required");
   }
@@ -117,6 +108,34 @@ export function assertWorkStateSemantics(state) {
   if (new Set(state.selectedGuides).size !== state.selectedGuides.length) {
     throw new WorkStateError("selectedGuides must not contain duplicates");
   }
+  for (const key of ["requiredGates", "satisfiedGates"]) {
+    if (state[key] !== undefined) {
+      assertStringArray(state[key], key);
+      if (new Set(state[key]).size !== state[key].length) {
+        throw new WorkStateError(`${key} must not contain duplicates`);
+      }
+    }
+  }
+  if (state.satisfiedGates?.some((gate) => !state.requiredGates?.includes(gate))) {
+    throw new WorkStateError("satisfiedGates must be a subset of requiredGates");
+  }
+  if (state.complianceMode !== undefined && !["advisory", "standard", "strict"].includes(state.complianceMode)) {
+    throw new WorkStateError(`Unknown compliance mode: ${state.complianceMode}`);
+  }
+  if (state.publicationStatus !== undefined
+    && !["not-published", "local-only", "committed", "pushed", "published", "deployed"].includes(state.publicationStatus)) {
+    throw new WorkStateError(`Unknown publication status: ${state.publicationStatus}`);
+  }
+  if (state.evidenceCoverage !== undefined && !Array.isArray(state.evidenceCoverage)) {
+    throw new WorkStateError("evidenceCoverage must be an array");
+  }
+  if (state.evidenceCoverage !== undefined) {
+    try {
+      assertCoverageList(state.evidenceCoverage);
+    } catch (error) {
+      throw new WorkStateError(error.message);
+    }
+  }
   assertStringArray(state.completedSteps, "completedSteps");
   assertStringArray(state.pendingSteps, "pendingSteps");
   normalizeRequiredArtifacts(state.requiredArtifacts);
@@ -126,6 +145,9 @@ export function assertWorkStateSemantics(state) {
   if (state.phase === "COMPLETE" && state.verificationEvidence.length === 0) {
     throw new WorkStateError("COMPLETE requires verification evidence");
   }
+  if (state.phase === "COMPLETE" && state.evidenceCoverage?.some((item) => item.status !== "COVERED")) {
+    throw new WorkStateError("COMPLETE requires covered evidence for every recorded criterion");
+  }
   if (state.phase === "BLOCKED" && state.blockers.length === 0) {
     throw new WorkStateError("BLOCKED requires a blocker");
   }
@@ -151,9 +173,15 @@ export function createWorkState(input) {
     protocolVersion: PROTOCOL_VERSION,
     taskId: input.taskId,
     contractFingerprint: input.contractFingerprint,
+    ...(input.routeFingerprint !== undefined ? { routeFingerprint: input.routeFingerprint } : {}),
     repositoryFingerprint: input.repositoryFingerprint ?? { branch: null, head: null },
     phase: input.phase,
     selectedGuides: [...(input.selectedGuides ?? [])],
+    ...(input.requiredGates !== undefined ? { requiredGates: [...input.requiredGates] } : {}),
+    ...(input.satisfiedGates !== undefined ? { satisfiedGates: [...input.satisfiedGates] } : {}),
+    ...(input.complianceMode !== undefined ? { complianceMode: input.complianceMode } : {}),
+    ...(input.evidenceCoverage !== undefined ? { evidenceCoverage: [...input.evidenceCoverage] } : {}),
+    ...(input.publicationStatus !== undefined ? { publicationStatus: input.publicationStatus } : {}),
     completedSteps: [...(input.completedSteps ?? [])],
     pendingSteps: [...(input.pendingSteps ?? [])],
     requiredArtifacts: normalizeRequiredArtifacts(input.requiredArtifacts),