@cassiomc1/forgeloop 1.1.1 → 1.2.2

package/src/core/execution-prerequisites.js

@@ -5,6 +5,7 @@ import { evaluatePreflight, validatePersistedPreflight } from "./preflight.js";
 import { readPersistedRoute } from "./route-artifact.js";
 import { stateIdentityErrors } from "./completion-relationships.js";
 import { classifyLoadedWorkState } from "./work-state.js";
+import { taskArtifactPath } from "./task-paths.js";
 
 const START_EXECUTION_EVENTS = Object.freeze([
   "CONTRACT_VALIDATED",
@@ -128,34 +129,51 @@ function prerequisiteLedgerErrors(ledger, taskId, preflight, route) {
   return errors;
 }
 
-export async function evaluateStartExecutionPrerequisites({ target, state, packageRoot } = {}) {
+export async function evaluateStartExecutionPrerequisites({
+  target,
+  state,
+  packageRoot,
+  taskId = null,
+  contractPath = null,
+  routePath = null,
+  statePath = null,
+  preflightPath = null,
+  eventsPath = null,
+} = {}) {
+  const effectiveTaskId = taskId ?? null;
+  const contractRel = contractPath ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "contract") : ARTIFACT_PATHS.contract);
+  const routeRel = routePath ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "route") : ARTIFACT_PATHS.route);
+  const stateRel = statePath ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "state") : ARTIFACT_PATHS.state);
+  const preflightRel = preflightPath ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "preflight") : ARTIFACT_PATHS.preflight);
+  const eventsRel = eventsPath ?? (effectiveTaskId ? taskArtifactPath(effectiveTaskId, "events") : ARTIFACT_PATHS.events);
+
   const errors = [];
   const requiredArtifacts = [
-    ARTIFACT_PATHS.state,
-    ARTIFACT_PATHS.contract,
-    ARTIFACT_PATHS.route,
-    ARTIFACT_PATHS.preflight,
-    ARTIFACT_PATHS.events,
+    stateRel,
+    contractRel,
+    routeRel,
+    preflightRel,
+    eventsRel,
   ];
   if (!state) {
     return {
-      errors: [issue("E_PHASE_PREREQUISITE_MISSING", "EXECUTING requires a work state", [ARTIFACT_PATHS.state])],
+      errors: [issue("E_PHASE_PREREQUISITE_MISSING", "EXECUTING requires a work state", [stateRel])],
       requiredArtifacts,
     };
   }
 
   const contract = await load(
-    () => readContract(target, packageRoot),
+    () => readContract(target, packageRoot, { taskId: effectiveTaskId, contractPath }),
     "E_PHASE_PREREQUISITE_MISSING",
-    `EXECUTING requires ${ARTIFACT_PATHS.contract}`,
-    [ARTIFACT_PATHS.contract],
+    `EXECUTING requires ${contractRel}`,
+    [contractRel],
     errors,
   );
   const route = await load(
-    () => readPersistedRoute(target, packageRoot),
+    () => readPersistedRoute(target, packageRoot, { taskId: effectiveTaskId, routePath }),
     "E_PHASE_PREREQUISITE_MISSING",
-    `EXECUTING requires ${ARTIFACT_PATHS.route}`,
-    [ARTIFACT_PATHS.route],
+    `EXECUTING requires ${routeRel}`,
+    [routeRel],
     errors,
   );
   if (!contract || !route) return { errors, requiredArtifacts, contract, route };
@@ -164,7 +182,7 @@ export async function evaluateStartExecutionPrerequisites({ target, state, packa
     errors.push(issue(
       "E_ROUTE_STALE",
       "EXECUTING requires work state and route to match the current contract",
-      [ARTIFACT_PATHS.state, ARTIFACT_PATHS.route, ARTIFACT_PATHS.contract],
+      [stateRel, routeRel, contractRel],
     ));
   }
   errors.push(...stateIdentityErrors({ contract, route, state }));
@@ -172,14 +190,14 @@ export async function evaluateStartExecutionPrerequisites({ target, state, packa
   const freshness = await classifyLoadedWorkState({
     target,
     state,
-    contractFile: ARTIFACT_PATHS.contract,
+    contractFile: contractRel,
   });
   errors.push(...freshnessErrors(state, freshness));
 
-  const preflight = await evaluatePreflight({ target, packageRoot });
+  const preflight = await evaluatePreflight({ target, packageRoot, taskId: effectiveTaskId, contractPath, routePath, statePath });
   let persistedPreflight = null;
   try {
-    persistedPreflight = await readJsonArtifact(target, ARTIFACT_PATHS.preflight, "preflight", packageRoot);
+    persistedPreflight = await readJsonArtifact(target, preflightRel, "preflight", packageRoot);
   } catch {
     // validatePersistedPreflight reports the stable, actionable preflight reason.
   }
@@ -189,16 +207,16 @@ export async function evaluateStartExecutionPrerequisites({ target, state, packa
     errors.push(issue(
       "E_PREFLIGHT_GATES_STALE",
       "Work state gate sets do not match the current preflight evaluation",
-      [ARTIFACT_PATHS.state, ARTIFACT_PATHS.preflight, ARTIFACT_PATHS.gates],
+      [stateRel, preflightRel, ARTIFACT_PATHS.gates],
     ));
   }
 
-  const ledger = await validateEventLedger(target, packageRoot);
+  const ledger = await validateEventLedger(target, packageRoot, { taskId: effectiveTaskId, eventsPath });
   errors.push(...prerequisiteLedgerErrors(ledger, contract.value.taskId, preflight, route));
   errors.push(...validateStateLedgerCoherence(state, ledger.events).map((error) => issue(
     error.code,
     error.message,
-    [ARTIFACT_PATHS.state, ARTIFACT_PATHS.events],
+    [stateRel, eventsRel],
   )));
   errors.push(...persistedPreflightErrors);
   return { errors, requiredArtifacts, contract, route, preflight, persistedPreflight, ledger };

package/src/core/execution.js

@@ -2,14 +2,14 @@ import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { readdir } from "node:fs/promises";
 import path from "node:path";
-import { fileExists } from "./filesystem.js";
+import { ensureWithin, fileExists } from "./filesystem.js";
 import {
   ARTIFACT_PATHS,
   executionArtifactPath,
   readJsonArtifact,
   writeJsonArtifact,
 } from "./artifacts.js";
-import { taskExecutionPath } from "./task-paths.js";
+import { taskArtifactPath, taskExecutionPath } from "./task-paths.js";
 import {
   resolveExecutionResolution,
   validateVerificationAuthority,
@@ -77,6 +77,23 @@ function executeProcess(argv, cwd) {
   });
 }
 
+/**
+ * Resolves where a new execution artifact should be written. Task-scoped
+ * execution artifacts require a real modern task namespace (a task.json
+ * descriptor). A descriptor-less task is legacy: writing task-scoped here
+ * would create a phantom `.forgeloop/task-state/<key>/executions/` namespace
+ * that corrupts task discovery. Reads already fall back across both
+ * locations, so a legacy execution stays resolvable.
+ */
+export async function resolveExecutionArtifactPath(target, taskId, executionId) {
+  if (!taskId) return executionArtifactPath(executionId);
+  const descriptorRel = taskArtifactPath(taskId, "descriptor");
+  if (await fileExists(ensureWithin(target, descriptorRel))) {
+    return taskExecutionPath(taskId, executionId);
+  }
+  return executionArtifactPath(executionId);
+}
+
 export async function runCommandExecution({
   target,
   packageRoot,
@@ -153,7 +170,7 @@ export async function runCommandExecution({
     status: processResult.exitCode === 0 && !processResult.spawnError ? "passed" : "failed",
     exitCode: processResult.exitCode,
   };
-  const execPath = executionPath ?? (taskId ? taskExecutionPath(taskId, executionId) : executionArtifactPath(executionId));
+  const execPath = executionPath ?? await resolveExecutionArtifactPath(target, taskId, executionId);
   const written = await writeJsonArtifact(target, execPath, execution, "execution", packageRoot);
   return {
     path: written.path,

package/src/core/native-adapters.js

@@ -41,10 +41,20 @@ Before changing product or executable files, establish the ForgeLoop contract,
 route, required gates, and READY preflight.
 
 Before creating or activating new lifecycle state:
-If \`.forgeloop/work-state.json\` exists, inspect the existing task,
-reconcile continuity when present, inspect the checkout, and run
-\`forgeloop next\`. A change of harness, model, provider, IDE, process,
-terminal, or session does not create a new task.
+
+1. Inspect existing ForgeLoop tasks first.
+2. Use \`forgeloop task-list --json\` to discover current task namespaces.
+3. If an existing task is selected or identifiable, use
+   \`forgeloop next --task <id> --json\` before creating another task.
+4. Reconcile continuity when the selected task has continuity state.
+5. Inspect the checkout before resuming work.
+
+A change of harness, model, provider, IDE, process, terminal, or session
+does not create a new task.
+
+Legacy singleton state such as \`.forgeloop/work-state.json\` remains
+supported only for backward compatibility and must not be treated as the
+primary modern discovery mechanism.
 
 Use the project-local ForgeLoop CLI for lifecycle-owned protocol state.
 Never manually synthesize lifecycle chronology or assign ForgeLoop COMPLETE.

package/src/core/next-action-model.js

@@ -13,13 +13,24 @@ export const NEXT_ACTIONS = Object.freeze({
   CONTINUE_IMPLEMENTATION: "CONTINUE_IMPLEMENTATION",
   RECORD_VERIFICATION: "RECORD_VERIFICATION",
   DIAGNOSE: "DIAGNOSE",
+  RECORD_DIAGNOSIS: "RECORD_DIAGNOSIS",
   CORRECT: "CORRECT",
+  CHANGE_STRATEGY: "CHANGE_STRATEGY",
   ENTER_REVIEWING: "ENTER_REVIEWING",
   RECORD_TERMINAL_RESULT: "RECORD_TERMINAL_RESULT",
   PREPARE_COMPLETION: "PREPARE_COMPLETION",
   RUN_COMPLETE: "RUN_COMPLETE",
   RESOLVE_STALE_ROUTE: "RESOLVE_STALE_ROUTE",
   RESOLVE_BLOCKER: "RESOLVE_BLOCKER",
+  RESTORE_POLICY: "RESTORE_POLICY",
+  REVERIFY_AFTER_POLICY_CHANGE: "REVERIFY_AFTER_POLICY_CHANGE",
+  VERIFY_RULE: "VERIFY_RULE",
+  RESOLVE_INERT_CHECK: "RESOLVE_INERT_CHECK",
+  RUN_REQUIRED_CHECK: "RUN_REQUIRED_CHECK",
+  REPAIR_CHECKER: "REPAIR_CHECKER",
+  REPAIR_POLICY: "REPAIR_POLICY",
+  RESTORE_BASELINE: "RESTORE_BASELINE",
+  CONTINUE_WITH_EXISTING_BASELINE: "CONTINUE_WITH_EXISTING_BASELINE",
   NONE: "NONE",
 });
 
@@ -32,13 +43,20 @@ export function result({
   commandSpecs = [],
   requiredArtifacts = [],
   missingArtifacts = [],
+  progress = undefined,
 }) {
   const normalizedReasons = reasons
-    .map((reason) => ({
-      code: reason.code ?? "E_NEXT_ACTION_BLOCKED",
-      message: reason.message ?? String(reason),
-      artifacts: uniqueSorted(reason.artifacts ?? []),
-    }))
+    .map((reason) => {
+      const base = {
+        code: reason.code ?? "E_NEXT_ACTION_BLOCKED",
+        message: reason.message ?? String(reason),
+        artifacts: uniqueSorted(reason.artifacts ?? []),
+      };
+      if (reason.resolution) {
+        base.resolution = structuredClone(reason.resolution);
+      }
+      return base;
+    })
     .sort((left, right) => left.code.localeCompare(right.code)
       || left.artifacts.join("\0").localeCompare(right.artifacts.join("\0"))
       || left.message.localeCompare(right.message));
@@ -57,6 +75,7 @@ export function result({
       .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))),
     requiredArtifacts: uniqueSorted(requiredArtifacts),
     missingArtifacts: uniqueSorted(missingArtifacts),
+    ...(progress ? { progress: structuredClone(progress) } : {}),
   };
 }
 
@@ -91,6 +110,22 @@ export function recordCheckCommandSpec(requirement) {
   };
 }
 
+export function recordDiagnosisCommandSpec() {
+  return {
+    commandId: "record-diagnosis",
+    executable: "forgeloop",
+    subcommand: "record-diagnosis",
+    argv: ["record-diagnosis"],
+    requiredInputs: [
+      { name: "hypothesis", option: "--hypothesis=<text>" },
+      { name: "failureClass", option: "--failure-class=<class>" },
+      { name: "evidenceRef", option: "--evidence-ref=<check-id>", repeatable: true },
+      { name: "settledBy", option: "--settled-by=<text>" },
+      { name: "nextSafeAction", option: "--next-safe-action=<text>" },
+    ],
+  };
+}
+
 export function recordTerminalResultCommandSpec(requirement) {
   const reqId = requirement.id ?? requirement;
   const type = requirement.type ?? "PUBLICATION";