@cassiomc1/forgeloop 1.1.1 → 1.2.2

package/src/core/settlement.js

@@ -0,0 +1,78 @@
+import { readContract } from "./contract.js";
+import { appendProtocolEvent, validateEventLedger } from "./events.js";
+import {
+  assertDecisionCriterionDetails,
+  criterionForDecision,
+  decisionCriterionEvents,
+  decisionId,
+  normalizeDecisionCriterionInput,
+  normalizeDecisionText,
+} from "./settlement-model.js";
+
+export {
+  assertDecisionCriterionDetails,
+  criterionForDecision,
+  decisionCriterionEvents,
+  decisionId,
+  normalizeDecisionCriterionInput,
+  normalizeDecisionText,
+};
+
+export async function recordDecisionCriterion({
+  target,
+  packageRoot,
+  decision,
+  settledBy,
+  taskId = null,
+  contractPath = null,
+  eventsPath = null,
+}) {
+  const normalized = normalizeDecisionCriterionInput({ decision, settledBy });
+  const contract = await readContract(target, packageRoot, { taskId, contractPath });
+  if (!contract || !contract.value) {
+    const error = new Error("Current contract not found");
+    error.code = "E_CONTRACT_MISSING";
+    throw error;
+  }
+
+  const unresolved = contract.value.unresolvedDecisions ?? [];
+  if (!unresolved.includes(normalized.decision)) {
+    const error = new Error(`Decision "${normalized.decision}" is not present in current unresolvedDecisions`);
+    error.code = "E_DECISION_NOT_UNRESOLVED";
+    throw error;
+  }
+
+  const ledger = await validateEventLedger(target, packageRoot, { taskId: taskId ?? null, eventsPath });
+  if (!ledger.valid) {
+    const first = ledger.errors[0];
+    const error = new Error(first.message);
+    error.code = first.code;
+    throw error;
+  }
+
+  const decId = decisionId(normalized.decision);
+  const details = {
+    decision: normalized.decision,
+    decisionId: decId,
+    settledBy: normalized.settledBy,
+    contractFingerprint: contract.fingerprint,
+  };
+
+  assertDecisionCriterionDetails(details);
+
+  const event = await appendProtocolEvent(
+    target,
+    {
+      taskId: contract.value.taskId,
+      event: "DECISION_CRITERION_RECORDED",
+      details,
+    },
+    packageRoot,
+    { taskId: taskId ?? null, eventsPath },
+  );
+
+  return {
+    event,
+    criterion: details,
+  };
+}

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",