@jhlee0619/codexloop 0.1.0 → 0.1.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jhlee0619/codexloop",
-  "version": "0.1.0",
-  "description": "CodexLoop \u2014 iterative improvement loop that drives OpenAI Codex as a multi-role critic (evaluate \u2192 suggest \u2192 rank \u2192 apply \u2192 validate \u2192 record).",
+  "version": "0.1.3",
+  "description": "CodexLoop — iterative improvement loop that drives OpenAI Codex as a multi-role critic (evaluate → suggest → rank → apply → validate → record).",
   "type": "module",
   "bin": {
     "cloop": "./bin/cloop"

package/prompts/evaluate.md

@@ -1,3 +1,7 @@
+<mode>
+{{PROMPT_SUFFIX}}
+</mode>
+
 <role>
 You are Codex operating as a strict code reviewer and adversarial critic for CodexLoop.
 Your job is to evaluate the current state of a repository against a specific goal and report defects, risks, and missing pieces that block acceptance.
@@ -28,6 +32,12 @@ Git diff since the loop's seed commit (or "(none)" on the first iteration):
 
 Latest test/lint/type command results (or "(none)"):
 {{CURRENT_CHECK_STATE}}
+
+Task spec (structured, or "(none)" in code mode):
+{{TASK_SPEC}}
+
+Relevant file contents (context bundle, or "(none)" in code mode):
+{{CONTEXT_BUNDLE}}
 </task>
 
 <operating_stance>

package/prompts/rank.md

@@ -1,3 +1,7 @@
+<mode>
+{{PROMPT_SUFFIX}}
+</mode>
+
 <role>
 You are Codex operating as a strict single judge that scores and ranks multiple implementation proposals against a fixed six-dimension rubric.
 </role>

package/prompts/suggest.md

@@ -1,3 +1,7 @@
+<mode>
+{{PROMPT_SUFFIX}}
+</mode>
+
 <role>
 You are Codex operating simultaneously as a solution generator, a refactoring advisor, and a test designer for CodexLoop.
 You propose concrete patches that the runtime will rank, apply, and validate.
@@ -22,6 +26,12 @@ Recent rejected proposals (do NOT re-propose these; explain in justifications if
 
 Git diff since the loop's seed commit:
 {{DIFF_SINCE_SEED}}
+
+Task spec (structured, or "(none)" in code mode):
+{{TASK_SPEC}}
+
+Relevant file contents (context bundle, or "(none)" in code mode):
+{{CONTEXT_BUNDLE}}
 </task>
 
 <proposal_rules>

package/schemas/operation.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://codexloop/operation.schema.json",
+  "title": "CodexLoop Proposal Operation",
+  "description": "A single file-editing operation in an artifact-mode proposal. Runtime translates operations into file writes + git commit, same as patch-based proposals.",
+  "type": "object",
+  "required": ["kind", "file"],
+  "properties": {
+    "kind": {
+      "type": "string",
+      "enum": ["replace_section", "insert_after_heading", "replace_file", "append_to_file"],
+      "description": "Operation type. v0.2 ships four kinds."
+    },
+    "file": {
+      "type": "string",
+      "description": "Path relative to the repo root."
+    },
+    "heading": {
+      "type": "string",
+      "description": "Markdown heading to anchor on (e.g. '## Results'). Required for replace_section and insert_after_heading."
+    },
+    "content": {
+      "type": "string",
+      "description": "New content. For replace_section, replaces the section body. For insert_after_heading, inserted after the heading line. For replace_file and append_to_file, used as-is."
+    }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "kind": { "const": "replace_section" } } },
+      "then": { "required": ["kind", "file", "heading", "content"] }
+    },
+    {
+      "if": { "properties": { "kind": { "const": "insert_after_heading" } } },
+      "then": { "required": ["kind", "file", "heading", "content"] }
+    },
+    {
+      "if": { "properties": { "kind": { "const": "replace_file" } } },
+      "then": { "required": ["kind", "file", "content"] }
+    },
+    {
+      "if": { "properties": { "kind": { "const": "append_to_file" } } },
+      "then": { "required": ["kind", "file", "content"] }
+    }
+  ]
+}

package/schemas/task-spec.schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://codexloop/task-spec.schema.json",
+  "title": "CodexLoop Task Specification",
+  "description": "Structured task spec for artifact/paper loops. Lives at cloop.task.json in the target repo root, or assembled by the interview and written to .loop/task-spec.json.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["version", "mode"],
+  "properties": {
+    "version": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Spec format version. v0.2 ships version 1."
+    },
+    "mode": {
+      "type": "string",
+      "enum": ["code", "artifact", "paper"],
+      "description": "Task mode. Determines which adapter drives the loop."
+    },
+    "required_files": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Files that MUST exist at loop completion. file_exists validator checks these."
+    },
+    "required_sections": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["file", "headings"],
+        "properties": {
+          "file": { "type": "string" },
+          "headings": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Markdown headings (including the ## prefix) that must be present."
+          }
+        }
+      },
+      "description": "Per-file heading requirements. headings_present validator checks these."
+    },
+    "placeholder_policy": {
+      "oneOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "max": {
+              "type": "integer",
+              "minimum": 0,
+              "description": "Maximum number of placeholders allowed at loop completion."
+            },
+            "disallowed_kinds": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Placeholder kinds (regex fragments) that are never acceptable."
+            }
+          }
+        }
+      ],
+      "description": "Placeholder budget and forbidden kinds. max_placeholder_count validator reads this."
+    },
+    "validators": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Name matching a registered built-in validator (e.g. 'file_exists', 'headings_present')."
+          },
+          "args": {
+            "type": "object",
+            "additionalProperties": true,
+            "description": "Validator-specific arguments passed to the run function."
+          }
+        }
+      },
+      "description": "Explicit validator list. Runs alongside mode-implicit validators."
+    }
+  }
+}

package/schemas/validator-result.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://codexloop/validator-result.schema.json",
+  "title": "CodexLoop Validator Result",
+  "description": "Output shape of a single built-in validator. Results are collected in iteration.validate.validatorResults.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "passed", "severity"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Validator name matching the registry key (e.g. 'file_exists')."
+    },
+    "passed": {
+      "type": "boolean",
+      "description": "True if the validator's condition is satisfied."
+    },
+    "severity": {
+      "type": "string",
+      "enum": ["info", "warn", "error"],
+      "description": "info/warn are reported but non-blocking. error blocks the loop (counts as validate.passed = false)."
+    },
+    "count": {
+      "type": ["integer", "null"],
+      "description": "Relevant count (e.g. number of missing headings, number of placeholders found)."
+    },
+    "details": {
+      "type": "string",
+      "description": "Human-readable summary of what was checked and what failed/passed."
+    },
+    "evidence": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "file": { "type": "string" },
+          "line": { "type": ["integer", "null"] },
+          "snippet": { "type": "string" }
+        }
+      },
+      "description": "Concrete locations that triggered the finding."
+    }
+  }
+}

package/scripts/lib/apply.mjs

@@ -16,6 +16,7 @@ import path from "node:path";
 import process from "node:process";
 
 import { runCommand } from "./process.mjs";
+import { applyOperations } from "./operations.mjs";
 
 const TEST_FILE_PATTERNS = [
   /(^|\/)tests?\//i,
@@ -142,9 +143,27 @@ function buildCommitEnv() {
   };
 }
 
-// Apply a proposal's patch to the target repo. Returns a structured record
-// the iteration layer records verbatim.
-export async function applyPatch({ cwd, proposal, iterationIndex }) {
+// Mode-keyed blocking guard sets.
+const CODE_BLOCKING_KINDS = new Set([
+  "test-file-deleted",
+  "test-disabled",
+  "missing-test-justification"
+]);
+const ARTIFACT_BLOCKING_KINDS = new Set([
+  "required-file-deleted"
+]);
+
+export function getBlockingKinds(taskMode) {
+  if (taskMode === "artifact" || taskMode === "paper") return ARTIFACT_BLOCKING_KINDS;
+  return CODE_BLOCKING_KINDS;
+}
+
+// Apply a proposal's patch OR operations to the target repo. Returns a
+// structured record the iteration layer records verbatim. Dispatches:
+//   - proposal.operations[]  → operations.mjs (artifact/paper mode)
+//   - proposal.patch         → git apply (code mode, or fallback)
+export async function applyPatch({ cwd, proposal, iterationIndex, taskMode = "code", spec = null }) {
+  const hasOperations = Array.isArray(proposal?.operations) && proposal.operations.length > 0;
   const patch = proposal?.patch ?? "";
   const record = {
     applied: false,
@@ -155,24 +174,45 @@ export async function applyPatch({ cwd, proposal, iterationIndex }) {
     hackingFindings: [],
     conflicts: null,
     error: null,
-    rolledBack: false
+    rolledBack: false,
+    usedOperations: hasOperations
   };
 
   record.preSha = getHead(cwd);
 
-  record.hackingFindings = scanPatchForRewardHacking(patch, proposal);
-  const blocking = record.hackingFindings.find(
-    (f) =>
-      f.kind === "test-file-deleted" ||
-      f.kind === "test-disabled" ||
-      f.kind === "missing-test-justification"
-  );
-  if (blocking) {
-    record.error = `reward-hacking-guard:${blocking.kind}${blocking.file ? `:${blocking.file}` : ""}`;
-    return record;
+  // Reward-hacking scan (patch path — operations are checked below separately)
+  if (!hasOperations) {
+    record.hackingFindings = scanPatchForRewardHacking(patch, proposal);
+    const blockingKinds = getBlockingKinds(taskMode);
+    const blocking = record.hackingFindings.find((f) => blockingKinds.has(f.kind));
+    if (blocking) {
+      record.error = `reward-hacking-guard:${blocking.kind}${blocking.file ? `:${blocking.file}` : ""}`;
+      return record;
+    }
+  } else {
+    // Check artifact-mode guards: required-file deletion via operations
+    if (Array.isArray(spec?.required_files)) {
+      const requiredSet = new Set(spec.required_files);
+      for (const op of proposal.operations) {
+        if (op.kind === "replace_file" && op.content === "" && requiredSet.has(op.file)) {
+          record.hackingFindings.push({
+            kind: "required-file-deleted",
+            severity: "critical",
+            file: op.file,
+            summary: `operation would empty required file ${op.file}`
+          });
+        }
+      }
+      const blocking = record.hackingFindings.find((f) => f.kind === "required-file-deleted");
+      if (blocking) {
+        record.error = `reward-hacking-guard:required-file-deleted:${blocking.file}`;
+        return record;
+      }
+    }
   }
 
-  if (!patch.trim()) {
+  // Empty check
+  if (!hasOperations && !patch.trim()) {
     record.empty = true;
     return record;
   }
@@ -184,6 +224,24 @@ export async function applyPatch({ cwd, proposal, iterationIndex }) {
     return record;
   }
 
+  // ── DISPATCH: operations vs patch ────────────────────────────────
+  if (hasOperations) {
+    const opResult = applyOperations({ cwd, operations: proposal.operations });
+    if (opResult.error) {
+      record.error = `operation-failed: ${opResult.error}`;
+      hardReset(cwd, record.preSha);
+      record.rolledBack = true;
+      return record;
+    }
+    if (!opResult.applied) {
+      record.empty = true;
+      return record;
+    }
+    record.filesTouched = opResult.filesTouched;
+    // Fall through to git add + commit below.
+  } else {
+    // Patch path (existing git apply logic)
+
   const tmpPatch = path.join(
     os.tmpdir(),
     `codexloop-patch-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.diff`
@@ -251,4 +309,43 @@ export async function applyPatch({ cwd, proposal, iterationIndex }) {
   } finally {
     try { fs.unlinkSync(tmpPatch); } catch {}
   }
+  } // end else (patch path)
+
+  // ── Operations path: files already written by applyOperations, commit them.
+  const env = buildCommitEnv();
+  const addRes = runCommand("git", ["add", "-A"], { cwd, env });
+  if (addRes.status !== 0) {
+    record.error = `git add failed: ${(addRes.stderr || "").trim().slice(0, 300)}`;
+    hardReset(cwd, record.preSha);
+    record.rolledBack = true;
+    return record;
+  }
+
+  const commitMsg = `cloop: iter ${iterationIndex} apply ${proposal?.id ?? "?"} (ops)`;
+  const commitRes = runCommand("git", ["commit", "-m", commitMsg], { cwd, env });
+  if (commitRes.status !== 0) {
+    record.error = `git commit failed: ${(commitRes.stderr || commitRes.stdout || "").trim().slice(0, 400)}`;
+    hardReset(cwd, record.preSha);
+    record.rolledBack = true;
+    return record;
+  }
+
+  record.postSha = getHead(cwd);
+  record.applied = true;
+
+  if (record.filesTouched.length === 0 && record.preSha && record.postSha) {
+    const diffFiles = runCommand(
+      "git",
+      ["diff", "--name-only", `${record.preSha}..${record.postSha}`],
+      { cwd }
+    );
+    if (diffFiles.status === 0) {
+      record.filesTouched = (diffFiles.stdout || "")
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+    }
+  }
+
+  return record;
 }

package/scripts/lib/codex-exec.mjs

@@ -173,6 +173,18 @@ export async function runCodex({
     const events = parseJsonlEvents(result.stdout);
     const usage = extractUsage(events);
 
+    // v0.2: check for item.error events in stdout even when status is 0.
+    const itemErrors = extractItemErrors(events);
+    if (itemErrors.length > 0 && result.status === 0) {
+      lastError = new CodexError(
+        `Codex emitted ${itemErrors.length} error event(s) in stdout: ${itemErrors.join("; ")}`,
+        { kind: "item-error", stderr: result.stderr, status: 0, attempts: attempt }
+      );
+      if (attempt >= maxAttempts) break;
+      await sleep(backoffMs(attempt));
+      continue;
+    }
+
     if (result.status !== 0) {
       const kind = classifyCodexFailure(result.stderr, result.status);
       lastError = new CodexError(
@@ -279,6 +291,19 @@ function extractLastAgentMessage(events) {
   return null;
 }
 
+// v0.2: detect item.error events in stdout JSONL. Some Codex CLI versions
+// emit structured errors as JSONL events rather than (or in addition to) stderr.
+function extractItemErrors(events) {
+  const errors = [];
+  for (const evt of events) {
+    if (evt?.type === "item.error" || (evt?.type === "item.completed" && evt.item?.type === "error")) {
+      const msg = evt.item?.text ?? evt.message ?? evt.error ?? JSON.stringify(evt);
+      errors.push(String(msg).slice(0, 500));
+    }
+  }
+  return errors;
+}
+
 function extractUsage(events) {
   for (let i = events.length - 1; i >= 0; i -= 1) {
     const evt = events[i];

package/scripts/lib/convergence.mjs

@@ -14,14 +14,30 @@
 //   6. budget-time
 //   7. budget-calls
 
-export const QUALITY_WEIGHTS = Object.freeze({
-  testPassRate: 0.30,
-  issueReduction: 0.20,
-  winnerConfidence: 0.15,
-  typeClean: 0.15,
-  lintClean: 0.10,
-  distanceFromGoal: 0.10
+// Mode-keyed weight tables. Code mode is byte-for-byte identical to v0.1.0.
+const ARTIFACT_WEIGHTS = Object.freeze({
+  validatorPassRate: 0.35,
+  issueReduction: 0.15,
+  distanceFromGoal: 0.20,
+  winnerConfidence: 0.10,
+  testPassRate: 0.10,
+  typeClean: 0.10
 });
+export const QUALITY_WEIGHTS_BY_MODE = Object.freeze({
+  code: Object.freeze({
+    testPassRate: 0.30,
+    issueReduction: 0.20,
+    winnerConfidence: 0.15,
+    typeClean: 0.15,
+    lintClean: 0.10,
+    distanceFromGoal: 0.10
+  }),
+  artifact: ARTIFACT_WEIGHTS,
+  paper: ARTIFACT_WEIGHTS
+});
+
+// Legacy alias for backwards compatibility in tests.
+export const QUALITY_WEIGHTS = QUALITY_WEIGHTS_BY_MODE.code;
 
 export const REGRESSION_DROP = 0.10;
 export const PLATEAU_QUALITY_THRESHOLD = 0.75;
@@ -36,7 +52,10 @@ function clamp01(x) {
 export function computeQualityScore(iteration, state) {
   const v = iteration.validate;
   const e = iteration.evaluate;
+  const taskMode = state?.taskMode ?? "code";
+  const weights = QUALITY_WEIGHTS_BY_MODE[taskMode] ?? QUALITY_WEIGHTS_BY_MODE.code;
 
+  // Compute all possible terms — some modes use subsets.
   let testPassRate = 0.5;
   if (v && Number.isFinite(v.passingTests) && Number.isFinite(v.failingTests)) {
     const total = v.passingTests + v.failingTests;
@@ -66,18 +85,33 @@ export function computeQualityScore(iteration, state) {
   const distance = clamp01(e?.distanceFromGoal ?? 0.5);
   const distanceFromGoal = 1 - distance;
 
-  const terms = {
+  // Validator pass rate for artifact/paper mode.
+  let validatorPassRate = 0.5;
+  if (Array.isArray(v?.validatorResults) && v.validatorResults.length > 0) {
+    const errorResults = v.validatorResults.filter((r) => r.severity === "error");
+    if (errorResults.length > 0) {
+      validatorPassRate = errorResults.filter((r) => r.passed).length / errorResults.length;
+    } else {
+      validatorPassRate = 1;
+    }
+  }
+
+  const allTerms = {
     testPassRate: clamp01(testPassRate),
     issueReduction: clamp01(issueReduction),
     winnerConfidence: clamp01(winnerConfidenceTerm),
     typeClean: clamp01(typeClean),
     lintClean: clamp01(lintClean),
-    distanceFromGoal: clamp01(distanceFromGoal)
+    distanceFromGoal: clamp01(distanceFromGoal),
+    validatorPassRate: clamp01(validatorPassRate)
   };
 
   let total = 0;
-  for (const key of Object.keys(QUALITY_WEIGHTS)) {
-    total += QUALITY_WEIGHTS[key] * terms[key];
+  const terms = {};
+  for (const key of Object.keys(weights)) {
+    const termValue = allTerms[key] ?? 0;
+    terms[key] = termValue;
+    total += weights[key] * termValue;
   }
   return { score: Number(total.toFixed(6)), terms };
 }

package/scripts/lib/iteration.mjs

@@ -1,9 +1,14 @@
-// Single-iteration orchestration: evaluate → suggest → rank → apply → validate → record.
+// Single-iteration orchestration:
+//   retrieve → evaluate → suggest → rank → apply → validate → record
 //
-// This is where the six-step loop lives. `runIteration` is called either
-// synchronously by /cloop:iterate or in a loop by the background worker
-// (/cloop:start --background). It loads state from disk, runs the six steps,
-// persists state, and returns the full iteration record.
+// This is where the loop lives. `runIteration` is called either synchronously
+// by /cloop:iterate or in a loop by the background worker (/cloop:start
+// --background). It loads state from disk, runs the phases, persists state,
+// and returns the full iteration record.
+//
+// v0.2: mode-aware via getModeAdapter(state.taskMode). The adapter provides
+// per-mode prompt vars, validators, quality weights, and guards. Code mode
+// is byte-for-byte identical to v0.1.0 behavior.
 
 import process from "node:process";
 
@@ -18,6 +23,8 @@ import {
   readProgressLogTail,
   computeGoalHash
 } from "./state.mjs";
+import { getModeAdapter } from "./modes/index.mjs";
+import { collectBundle, formatBundleForPrompt } from "./retrieve.mjs";
 import { recomputeWinner } from "./rank.mjs";
 import { computeQualityScore, checkStopping } from "./convergence.mjs";
 import { applyPatch, rollbackToSha } from "./apply.mjs";
@@ -84,13 +91,13 @@ function gitDiffSince(cwd, sinceSha) {
 
 function ensureGoalHash(state) {
   if (!state.goal?.goalHash) {
-    state.goal.goalHash = computeGoalHash(state.goal ?? {});
+    state.goal.goalHash = computeGoalHash(state.goal ?? {}, state.taskMode);
   }
   return state.goal.goalHash;
 }
 
 function assertGoalImmutable(state, expectedHash) {
-  const currentHash = computeGoalHash(state.goal ?? {});
+  const currentHash = computeGoalHash(state.goal ?? {}, state.taskMode);
   if (expectedHash && currentHash !== expectedHash) {
     throw new Error(
       `goal hash mismatch (expected ${expectedHash}, got ${currentHash}) — goal text may have drifted`
@@ -226,6 +233,14 @@ export async function runIteration({ repoRoot, options = {} }) {
       stopReason: i.stopReason
     }));
 
+    // ── MODE ADAPTER LOOKUP ────────────────────────────────────────
+    const adapter = getModeAdapter(state.taskMode ?? "code");
+    const adapterVars = adapter.getCommonVars(state);
+
+    // ── RETRIEVE PHASE (context bundle) ──────────────────────────
+    const bundle = collectBundle({ state, repoRoot });
+    const contextBundleText = formatBundleForPrompt(bundle);
+
     const commonVars = {
       GOAL: state.goal?.text ?? "(unspecified)",
       ACCEPTANCE_CRITERIA:
@@ -241,7 +256,14 @@ export async function runIteration({ repoRoot, options = {} }) {
           ? state.openIssues
           : "(none)",
       DIFF_SINCE_SEED: diffSinceSeed || "(none)",
-      CURRENT_CHECK_STATE: "(none)"
+      CURRENT_CHECK_STATE: "(none)",
+      // v0.2: mode-aware additions
+      TASK_MODE: state.taskMode ?? "code",
+      TASK_SPEC: state.goal?.spec ?? "(none)",
+      CONTEXT_BUNDLE: contextBundleText,
+      PROMPT_SUFFIX: adapter.getPromptSuffix(),
+      // Spread adapter-specific vars (e.g. REQUIRED_FILES, REQUIRED_SECTIONS)
+      ...adapterVars
     };
 
     const codexOpts = {
@@ -269,7 +291,9 @@ export async function runIteration({ repoRoot, options = {} }) {
         iteration.validate = await runValidation({
           cwd: repoRoot,
           goal: state.goal,
-          previousIteration: state.iterations[state.iterations.length - 1]
+          previousIteration: state.iterations[state.iterations.length - 1],
+          spec: state.goal?.spec ?? null,
+          implicitValidators: adapter.getImplicitValidators(state.goal?.spec)
         });
       } else {
         iteration.validate = { passed: null, regression: false, commands: [], skipped: "dry-run" };
@@ -366,7 +390,9 @@ export async function runIteration({ repoRoot, options = {} }) {
       iteration.apply = await applyPatch({
         cwd: repoRoot,
         proposal: winnerProposal,
-        iterationIndex: iteration.index
+        iterationIndex: iteration.index,
+        taskMode: state.taskMode ?? "code",
+        spec: state.goal?.spec ?? null
       });
 
       if (!iteration.apply.applied && !iteration.apply.empty) {
@@ -411,7 +437,9 @@ export async function runIteration({ repoRoot, options = {} }) {
       iteration.validate = await runValidation({
         cwd: repoRoot,
         goal: state.goal,
-        previousIteration: state.iterations[state.iterations.length - 1]
+        previousIteration: state.iterations[state.iterations.length - 1],
+        spec: state.goal?.spec ?? null,
+        implicitValidators: adapter.getImplicitValidators(state.goal?.spec)
       });
 
       if (iteration.validate.regression && iteration.apply.applied && iteration.apply.preSha) {