@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/gate-provenance.js

@@ -0,0 +1,124 @@
+import { canonicalFingerprint } from "./artifacts.js";
+
+export const GATE_SATISFIED_EVENT = "GATE_SATISFIED";
+export const GATE_REVALIDATED_EVENT = "GATE_REVALIDATED";
+const CONTRACT_REVISED_EVENT = "CONTRACT_REVISED";
+const TRANSACTION_COMMITTED_EVENT = "TRANSACTION_COMMITTED";
+
+function eventHash(event) {
+  const { hash, ...body } = event ?? {};
+  return canonicalFingerprint(body);
+}
+
+export function assertGateSatisfiedDetails(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)
+    || Object.keys(details).length !== 1
+    || typeof details.gate !== "string"
+    || details.gate.trim().length === 0) {
+    const error = new Error("GATE_SATISFIED requires exactly one non-empty gate detail");
+    error.code = "E_EVENT_INVALID";
+    throw error;
+  }
+  return details;
+}
+
+export function assertGateRevalidatedDetails(details) {
+  const keys = ["gate", "previousGateFingerprint", "gateFingerprint", "stalePaths"];
+  if (!details || typeof details !== "object" || Array.isArray(details)
+    || Object.keys(details).length !== keys.length
+    || keys.some((key) => !Object.prototype.hasOwnProperty.call(details, key))
+    || typeof details.gate !== "string"
+    || details.gate.trim().length === 0
+    || !/^[a-z0-9][a-z0-9-]*$/.test(details.gate)
+    || !/^[a-f0-9]{64}$/.test(details.previousGateFingerprint)
+    || !/^[a-f0-9]{64}$/.test(details.gateFingerprint)
+    || !Array.isArray(details.stalePaths)
+    || details.stalePaths.length === 0
+    || details.stalePaths.some((value) => typeof value !== "string" || value.trim().length === 0)
+    || [...details.stalePaths].sort().join("\0") !== details.stalePaths.join("\0")
+    || new Set(details.stalePaths).size !== details.stalePaths.length) {
+    const error = new Error("GATE_REVALIDATED requires a gate, two fingerprints, and sorted stale paths");
+    error.code = "E_GATE_REVALIDATION_INVALID";
+    throw error;
+  }
+  return details;
+}
+
+function gateIndex(events, gateEvent, eventName) {
+  return events.findIndex((event) => event === gateEvent
+    || (event?.seq === gateEvent?.seq
+      && event?.taskId === gateEvent?.taskId
+      && event?.event === eventName));
+}
+
+function isValidGateCommit(gateEvent, commitEvent, operation) {
+  return commitEvent?.event === TRANSACTION_COMMITTED_EVENT
+    && commitEvent.taskId === gateEvent.taskId
+    && commitEvent.seq === gateEvent.seq + 1
+    && commitEvent.previousHash === gateEvent.hash
+    && gateEvent.hash === eventHash(gateEvent)
+    && commitEvent.hash === eventHash(commitEvent)
+    && commitEvent.details
+    && typeof commitEvent.details === "object"
+    && !Array.isArray(commitEvent.details)
+    && Object.keys(commitEvent.details).length === 2
+    && typeof commitEvent.details.transactionId === "string"
+    && commitEvent.details.transactionId.length > 0
+    && commitEvent.details.operation === operation;
+}
+
+export function resolveGateRecordBoundary(events, gateEvent) {
+  if (!Array.isArray(events) || !gateEvent || gateEvent.event !== GATE_SATISFIED_EVENT) return null;
+  const index = gateIndex(events, gateEvent, GATE_SATISFIED_EVENT);
+  if (index < 0) return null;
+  const commitEvent = events[index + 1];
+  return isValidGateCommit(gateEvent, commitEvent, "gate-record")
+    ? { gateEvent, transactionCommitEvent: commitEvent }
+    : null;
+}
+
+export function resolveGateRevalidationBoundary(events, gateEvent) {
+  if (!Array.isArray(events) || !gateEvent || gateEvent.event !== GATE_REVALIDATED_EVENT) return null;
+  const index = gateIndex(events, gateEvent, GATE_REVALIDATED_EVENT);
+  if (index < 0) return null;
+  const commitEvent = events[index + 1];
+  return isValidGateCommit(gateEvent, commitEvent, "gate-revalidate")
+    ? { gateEvent, transactionCommitEvent: commitEvent }
+    : null;
+}
+
+export function hasCurrentGateEvidence(events, taskId, gate, latestContractRevisionSeq = 0) {
+  return events.some((event) => [GATE_SATISFIED_EVENT, GATE_REVALIDATED_EVENT].includes(event.event)
+    && event.taskId === taskId
+    && event.details?.gate === gate
+    && event.seq > latestContractRevisionSeq);
+}
+
+export function validateGateSatisfactionBindings(events = []) {
+  const errors = [];
+  for (const [index, event] of events.entries()) {
+    if (![GATE_SATISFIED_EVENT, GATE_REVALIDATED_EVENT].includes(event.event)) continue;
+    const revalidated = event.event === GATE_REVALIDATED_EVENT;
+    try {
+      if (revalidated) assertGateRevalidatedDetails(event.details);
+      else assertGateSatisfiedDetails(event.details);
+    } catch (error) {
+      errors.push({ code: error.code ?? "E_EVENT_INVALID", message: `event ${event.seq} (${event.event}): ${error.message}` });
+      continue;
+    }
+    const revisedBeforeGate = events.slice(0, index).findLast((candidate) => candidate.taskId === event.taskId
+      && candidate.event === CONTRACT_REVISED_EVENT);
+    const boundary = revalidated
+      ? resolveGateRevalidationBoundary(events, event)
+      : resolveGateRecordBoundary(events, event);
+    if ((revalidated || revisedBeforeGate) && !boundary) {
+      errors.push({
+        code: revalidated ? "E_GATE_REVALIDATION_INVALID" : "E_EVENT_INVALID",
+        message: revalidated
+          ? `event ${event.seq} must be immediately followed by its gate-revalidate transaction commit`
+          : `event ${event.seq} must be immediately followed by its gate-record transaction commit after contract revision`,
+      });
+    }
+  }
+  return errors;
+}

package/src/core/go-project.js

@@ -0,0 +1,206 @@
+import path from "node:path";
+
+import { createLanguageProject, portablePath } from "./multi-language-project.js";
+
+const GO_DIRECTIVE = /^(module|go|toolchain|godebug|require|replace|exclude|retract|tool|ignore)\b/u;
+const GO_WORK_DIRECTIVES = new Set(["go", "toolchain", "godebug", "use", "replace", "tool"]);
+
+function invalidGoResult() {
+  return {
+    valid: false,
+    module: null,
+    goVersion: null,
+    toolchain: null,
+    uses: [],
+    localReplacements: [],
+    ignorePaths: [],
+  };
+}
+
+function stripGoComment(line) {
+  const index = line.indexOf("//");
+  return (index < 0 ? line : line.slice(0, index)).trim();
+}
+
+function parseGoDirective(line) {
+  const block = line.match(/^(module|go|toolchain|godebug|require|replace|exclude|retract|use|tool|ignore)\b\s*\(\s*$/u);
+  const match = line.match(/^(module|go|toolchain|godebug|require|replace|exclude|retract|use|tool|ignore)\b\s*(?:\(([^)]*)\)|(.+))$/u);
+  if (block) return { name: block[1], value: "" };
+  if (!match) return null;
+  return {
+    name: match[1],
+    value: (match[2] ?? match[3] ?? "").trim(),
+  };
+}
+
+function collectGoBlock(lines, start) {
+  const values = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = stripGoComment(lines[index]);
+    if (line === ")") return { values, end: index, valid: true };
+    if (line !== "") values.push(line);
+  }
+  return { values, end: lines.length, valid: false };
+}
+
+function validGoDirectiveValue(name, value) {
+  if (!value || /\s{2,}/u.test(value)) return false;
+  if (name === "ignore") {
+    const portable = value.replaceAll("\\", "/");
+    const segments = portable.split("/");
+    return !value.includes("\\")
+      && !portable.startsWith("/")
+      && !/^[A-Za-z]:\//u.test(portable)
+      && !segments.includes("..")
+      && !value.includes("=>");
+  }
+  if (["require", "exclude"].includes(name)) return /^\S+\s+v\S+$/u.test(value);
+  if (name === "replace") return /^\S+(?:\s+v\S+)?\s+=>\s+\S+(?:\s+v\S+)?$/u.test(value);
+  if (name === "retract") return /^\S+(?:\s*,\s*\S+)?$/u.test(value);
+  if (name === "godebug") return /^\S+=\S+$/u.test(value);
+  if (name === "tool") return /^\S+(?:\s+v\S+)?$/u.test(value);
+  return true;
+}
+
+function parseGoModMetadataDirective(state, directive) {
+  if (directive.name === "module") {
+    if (state.module !== null || directive.value === "" || /\s/u.test(directive.value)) return false;
+    state.module = directive.value;
+    return true;
+  }
+  if (directive.name === "go") {
+    if (state.goVersion !== null || !/^\d+(?:\.\d+){1,2}$/u.test(directive.value)) return false;
+    state.goVersion = directive.value;
+    return true;
+  }
+  if (directive.name === "toolchain") {
+    if (state.toolchain !== null || !/^\S+$/u.test(directive.value)) return false;
+    state.toolchain = directive.value;
+    return true;
+  }
+  return null;
+}
+
+function parseGoModBlockDirective(lines, index, directive) {
+  const block = collectGoBlock(lines, index);
+  const valid = block.valid && block.values.every((value) => validGoDirectiveValue(directive.name, value));
+  return {
+    valid,
+    end: block.end,
+    ignorePaths: valid && directive.name === "ignore" ? block.values : [],
+  };
+}
+
+function parseGoModLine(lines, index, state) {
+  const line = stripGoComment(lines[index]);
+  if (line === "" || line.startsWith("//")) return { valid: true, end: index, ignorePaths: [] };
+  const directive = parseGoDirective(line);
+  if (!directive || !GO_DIRECTIVE.test(line)) return { valid: false, end: index, ignorePaths: [] };
+  const metadataValid = parseGoModMetadataDirective(state, directive);
+  if (metadataValid !== null) return { valid: metadataValid, end: index, ignorePaths: [] };
+  if (line.endsWith("(")) return parseGoModBlockDirective(lines, index, directive);
+  const valid = validGoDirectiveValue(directive.name, directive.value);
+  return {
+    valid,
+    end: index,
+    ignorePaths: valid && directive.name === "ignore" ? [directive.value] : [],
+  };
+}
+
+export function parseGoMod(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidGoResult();
+  const lines = text.replaceAll("\r\n", "\n").split("\n");
+  const state = { module: null, goVersion: null, toolchain: null, valid: true };
+  const ignorePaths = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const parsed = parseGoModLine(lines, index, state);
+    state.valid &&= parsed.valid;
+    ignorePaths.push(...parsed.ignorePaths);
+    index = parsed.end;
+  }
+  return {
+    valid: state.valid && state.module !== null,
+    module: state.module,
+    goVersion: state.goVersion,
+    toolchain: state.toolchain,
+    uses: [],
+    localReplacements: [],
+    ignorePaths: [...new Set(ignorePaths)],
+  };
+}
+
+export function parseGoWork(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) {
+    return { valid: false, goVersion: null, uses: [] };
+  }
+  const lines = text.replaceAll("\r\n", "\n").split("\n");
+  let goVersion = null;
+  const uses = [];
+  let valid = true;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = stripGoComment(lines[index]);
+    if (line === "") continue;
+    const directive = parseGoDirective(line);
+    if (!directive) {
+      valid = false;
+      continue;
+    }
+    if (directive.name === "go") {
+      if (goVersion !== null || !/^\d+(?:\.\d+){1,2}$/u.test(directive.value)) valid = false;
+      else goVersion = directive.value;
+      continue;
+    }
+    if (directive.name === "toolchain") {
+      if (!/^\S+$/u.test(directive.value)) valid = false;
+      continue;
+    }
+    if (!GO_WORK_DIRECTIVES.has(directive.name)) {
+      valid = false;
+      continue;
+    }
+    if (directive.name !== "use") {
+      if (line.endsWith("(")) {
+        const block = collectGoBlock(lines, index);
+        if (!block.valid || !block.values.every((value) => validGoDirectiveValue(directive.name, value))) valid = false;
+        index = block.end;
+      }
+      continue;
+    }
+    const values = line.endsWith("(") ? collectGoBlock(lines, index) : { values: [directive.value], end: index, valid: true };
+    if (!values.valid || values.values.some((value) => !validGoDirectiveValue("use", value)
+      || value.startsWith("/") || /^[A-Za-z]:/u.test(value))) {
+      valid = false;
+    } else {
+      uses.push(...values.values);
+    }
+    index = values.end;
+  }
+  return { valid: valid && goVersion !== null && uses.length > 0, goVersion, uses: [...new Set(uses)] };
+}
+
+export function inspectGoProject({ projectRoot, manifestRelative, manifestText, manifestName, targetRoot, projectFiles }) {
+  const parsed = manifestName === "go.work" ? parseGoWork(manifestText) : parseGoMod(manifestText);
+  const localUses = manifestName === "go.work"
+    ? parsed.uses.filter((use) => projectFiles.some((file) => file.kind === "go"
+      && parseGoMod(file.text).valid
+      && portablePath(targetRoot, path.dirname(file.path)) === path.posix.normalize(path.posix.join(projectRoot, use))))
+    : [];
+  const primary = parsed.valid && (manifestName === "go.mod" || localUses.length > 0);
+  const primarySignals = primary
+    ? [manifestName === "go.mod" ? `${manifestRelative}:module` : `${manifestRelative}:workspace`]
+    : [];
+  const supportingSignals = [];
+  if (parsed.goVersion) supportingSignals.push(`${manifestRelative}:go=${parsed.goVersion}`);
+  if (parsed.toolchain) supportingSignals.push(`${manifestRelative}:toolchain=${parsed.toolchain}`);
+  for (const use of localUses) supportingSignals.push(`${manifestRelative}:use=${use}`);
+  return createLanguageProject({
+    kind: "go",
+    root: projectRoot,
+    manifest: manifestRelative,
+    frameworks: primary ? ["go"] : [],
+    primary,
+    primarySignals,
+    supportingSignals,
+    internal: { ...parsed, valid: parsed.valid, manifestName, localUses },
+  });
+}

package/src/core/integration-invocation-policy.js

@@ -24,7 +24,7 @@ export const INTEGRATION_RISK_CLASSES = Object.freeze({
 });
 
 const READ_ONLY_COMMANDS = Object.freeze(new Set([
-  "protocol-info", "status", "next", "continuity", "reconcile-continuity",
+  "protocol-info", "decision-status", "decision-show", "context-plan", "model-route", "semantic-plan", "test-inventory", "status", "next", "continuity", "reconcile-continuity",
   "task-list", "task-show", "task-lock-status", "progress", "audit", "report",
   "inspect", "validate-state", "validate-protocol", "validate-receipt",
   "policy-status", "policy-diff", "rule-verify", "policy",
@@ -37,7 +37,7 @@ const READ_ONLY_COMMANDS = Object.freeze(new Set([
 ]));
 
 const LOOP_MUTATION_COMMANDS = Object.freeze(new Set([
-  "route", "preflight", "advance", "task-create", "task-scope",
+  "discover", "contract-create", "route", "preflight", "advance", "task-create", "task-scope",
   "record-continuity", "clear-continuity", "prepare-completion",
   "record-check", "record-diagnosis", "record-decision-criterion",
   "record-terminal-result", "complete",
@@ -86,7 +86,17 @@ const STATIC_RISK_CLASSES = Object.freeze({
   bundle: INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "profile-interview": INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "task-recover": INTEGRATION_RISK_CLASSES.CLAIM_RELEASE_RECOVERY,
+  "task-abandon": INTEGRATION_RISK_CLASSES.CLAIM_RELEASE_RECOVERY,
   "task-repair-legacy-recovery": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "gate-record": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "gate-revalidate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "test-utility": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "test-prune-plan": INTEGRATION_RISK_CLASSES.READ_ONLY,
+  "test-prune-probe": INTEGRATION_RISK_CLASSES.EXTERNAL_EXECUTION,
+  "task-repair-contract-bootstrap": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "task-migrate-contract-bootstrap-repair": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "checkpoint-revalidate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "contract-revise": INTEGRATION_RISK_CLASSES.MAINTENANCE,
 });
 
 // Sparse input-dependent refinements over the static table.
@@ -169,6 +179,18 @@ export function getForgeLoopCapabilities({ packageVersion = null } = {}) {
         commands: ["next", "task-show"],
         preservesDefaultOutput: true,
       },
+      auditUx: {
+        version: 1,
+        supported: true,
+        readOnly: true,
+        resource: "task/audit-view",
+        timeline: true,
+        lifecycleAuthority: false,
+        evidenceAuthority: false,
+        completionAuthority: false,
+        mutationAuthority: false,
+        externalExecution: false,
+      },
       usageTelemetry: {
         version: 1,
         supported: true,
@@ -295,6 +317,7 @@ export function getForgeLoopCapabilities({ packageVersion = null } = {}) {
       { name: "task/approvals", scope: "TASK" },
       { name: "task/metrics", scope: "TASK" },
       { name: "task/context", scope: "TASK" },
+      { name: "task/audit-view", scope: "TASK" },
       { name: "task/evaluations", scope: "TASK" },
       { name: "project/capability-policy", scope: "PROJECT" },
       { name: "repository/index-status", scope: "PROJECT" },
@@ -352,8 +375,8 @@ export function classifyForgeLoopInvocation(command, input = {}) {
     removesArtifacts: definition.removes.length > 0,
     executesExternalProcess: definition.mayExecuteExternalProcess === true,
     affectsClaimAuthority: [
-      "task-resume", "task-recover", "task-repair-legacy-recovery",
-      "task-create", "task-scope", "complete",
+      "task-resume", "task-recover", "task-repair-legacy-recovery", "task-repair-contract-bootstrap",
+      "task-create", "task-scope", "complete", "task-migrate-contract-bootstrap-repair",
     ].includes(command),
     destructive: [
       INTEGRATION_RISK_CLASSES.AUTHORITY_MUTATION,

package/src/core/integration-resources.js

@@ -21,6 +21,12 @@ import { resolveAttestationStatus } from "./attestation.js";
 import { buildExecutionProfileContext } from "./execution-profile-context.js";
 import { projectStructuralQualityStatus } from "./structural-quality/service.js";
 import { getRepositoryIndexStatus } from "../repository-index/status.js";
+import { buildAuditUxView } from "./audit-ux.js";
+import { runContextPlan } from "../commands/context-plan.js";
+import { runModelRoute } from "../commands/model-route.js";
+import { readPersistedRoute } from "./route-artifact.js";
+import { readWorkState } from "./work-state.js";
+import { readTestUtility } from "./test-intelligence/service.js";
 
 /**
  * Canonical integration resource allowlist.
@@ -86,11 +92,18 @@ export const INTEGRATION_RESOURCE_DEFINITIONS = Object.freeze({
   "task/approvals": Object.freeze({ scope: "TASK", description: "Durable approval artifacts for one task." }),
   "task/metrics": Object.freeze({ scope: "TASK", description: "Read-only trajectory metrics for one task." }),
   "task/context": Object.freeze({ scope: "TASK", description: "Read-only profile-aware task context with bounded presentation policy." }),
+  "task/audit-view": Object.freeze({ scope: "TASK", description: "Bounded read-only Audit UX projection composed from canonical task resolvers." }),
   "task/evaluations": Object.freeze({ scope: "TASK", description: "Persisted trajectory evaluations for one task." }),
+  "task/decisions": Object.freeze({ scope: "TASK", description: "Persisted, fingerprint-bound semantic decisions without lifecycle or evidence authority." }),
+  "task/context-plan": Object.freeze({ scope: "TASK", description: "Bounded non-authoritative semantic context-plan projection." }),
+  "task/model-route": Object.freeze({ scope: "TASK", description: "Deterministic model-routing floor with advisory semantic escalation." }),
+  "task/test-utility": Object.freeze({ scope: "TASK", description: "Non-evidence test inventory and utility analysis; never deletion authority." }),
   "project/capability-policy": Object.freeze({ scope: "PROJECT", description: "Project capability policy, never host authority." }),
   "repository/index-status": Object.freeze({ scope: "PROJECT", description: "Provider-neutral repository-index health and owned-server status." }),
 });
 
+const TASK_RESOURCE_URIS = new Set(Object.keys(INTEGRATION_RESOURCE_DEFINITIONS).filter((uri) => uri.startsWith("task/")));
+
 function ownershipProjection(projection) {
   return {
     taskId: projection.taskId,
@@ -120,67 +133,20 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     throw error;
   }
 
-  switch (uri) {
-    case "protocol/info": {
-      return { uri, data: await runProtocolInfo({ packageVersion }) };
-    }
-    case "project/tasks": {
-      const tasks = await discoverTasks(projectPath, packageRoot);
-      return {
-        uri,
-        data: {
-          count: tasks.length,
-          tasks: tasks.map((task) => ({
-            taskId: task.taskId,
-            healthy: task.healthy !== false,
-            phase: task.phase ?? null,
-            mutationAllowed: task.mutationAllowed !== false,
-          })),
-        },
-      };
-    }
-    case "task/status":
-    case "task/ownership":
-    case "task/contract":
-    case "task/continuity": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/workspace-binding":
-    case "task/handoffs":
-    case "task/responsibility":
-    case "task/verification-scope":
-    case "task/attestation": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/structural-quality": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/actions":
-    case "task/action":
-    case "task/approvals":
-    case "task/metrics":
-    case "task/context":
-    case "task/evaluations": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`); error.code = "E_TASK_REQUIRED"; throw error;
-      }
-      break;
-    }
+  if (uri === "protocol/info") return { uri, data: await runProtocolInfo({ packageVersion }) };
+  if (uri === "project/tasks") {
+    const tasks = await discoverTasks(projectPath, packageRoot);
+    return { uri, data: { count: tasks.length, tasks: tasks.map((task) => ({
+      taskId: task.taskId,
+      healthy: task.healthy !== false,
+      phase: task.phase ?? null,
+      mutationAllowed: task.mutationAllowed !== false,
+    })) } };
+  }
+  if (TASK_RESOURCE_URIS.has(uri) && (typeof taskId !== "string" || !taskId)) {
+    const error = new Error(`Resource ${uri} requires a taskId`);
+    error.code = "E_TASK_REQUIRED";
+    throw error;
   }
 
   if (uri === "task/ownership") {
@@ -270,6 +236,45 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     }
     return { uri, taskId, data: { evaluations } };
   }
+  if (uri === "task/decisions") {
+    const dir = path.join(projectPath, taskDirectory(taskId), "decisions");
+    let names = []; try { names = await readdir(dir); } catch { /* absent is an empty projection */ }
+    const decisions = [];
+    for (const name of names.filter((entry) => /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}\.json$/.test(entry)).sort()) {
+      decisions.push((await readJsonArtifact(projectPath, `${taskDirectory(taskId)}/decisions/${name}`, "semantic-decision", packageRoot)).value);
+    }
+    return { uri, taskId, data: { taskId, decisions } };
+  }
+  if (uri === "task/context-plan") {
+    return { uri, taskId, data: await runContextPlan({ target: projectPath, packageRoot, taskId, profile: runtimeContext?.contextProfile ?? "balanced", readOnly: true }) };
+  }
+  if (uri === "task/model-route") {
+    const state = await readWorkState(projectPath, { packageRoot, taskId });
+    const route = await readPersistedRoute(projectPath, packageRoot, { taskId });
+    return {
+      uri,
+      taskId,
+      data: await runModelRoute({
+        target: projectPath,
+        packageRoot,
+        taskId,
+        workType: route.value.input?.workType,
+        surfaces: route.value.input?.surfaces,
+        risks: route.value.input?.risks,
+        platforms: route.value.input?.platforms,
+        behaviorChange: route.value.input?.behaviorChange,
+        executableChange: route.value.input?.executableChange,
+        generationRequired: route.value.input?.generationRequired,
+        architectureChange: route.value.input?.architectureChange,
+        ambiguity: route.value.input?.ambiguity,
+        contract: { phase: state.phase },
+      }),
+    };
+  }
+  if (uri === "task/test-utility") {
+    const artifact = await readTestUtility({ target: projectPath, packageRoot, taskId });
+    return { uri, taskId, data: artifact.value };
+  }
   if (uri === "project/capability-policy") {
     return { uri, data: await loadCapabilityPolicy(projectPath, packageRoot) };
   }
@@ -292,6 +297,26 @@ async function readForgeLoopIntegrationResourceCore(uri, {
 }
 
 export async function readForgeLoopIntegrationResource(uri, options = {}) {
+  if (uri === "task/audit-view") {
+    if (typeof options.taskId !== "string" || !options.taskId) {
+      const error = new Error("Resource task/audit-view requires a taskId"); error.code = "E_TASK_REQUIRED"; throw error;
+    }
+    return {
+      uri,
+      taskId: options.taskId,
+      data: await buildAuditUxView({
+        target: options.projectPath ?? ".",
+        packageRoot: options.packageRoot,
+        taskId: options.taskId,
+        limit: options.limit,
+        beforeSequence: options.beforeSequence,
+        afterSequence: options.afterSequence,
+        categories: options.categories,
+        authorityContext: options.runtimeContext?.authorityContext,
+        runtimeContext: options.runtimeContext,
+      }),
+    };
+  }
   if (uri === "repository/index-status") {
     return {
       uri,