create-agdf 0.5.0 → 0.6.1

package/lib/control-state/index.js

@@ -0,0 +1,6 @@
+export * from "./run-state-parser.js";
+export * from "./run-state-repository.js";
+export * from "./run-state-resolver.js";
+export * from "./run-state-writer.js";
+export * from "./legacy-migration.js";
+export * from "./aggregate.js";

package/lib/control-state/legacy-migration.js

@@ -0,0 +1,94 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmdirSync, unlinkSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import {
+  discoverRuns,
+  renderRunState,
+  runPath,
+} from "./run-state-repository.js";
+import {
+  parseRunState,
+  RUN_ID_PATTERN,
+  scalarFields,
+  semanticBody,
+  semanticFingerprint,
+} from "./run-state-parser.js";
+import { atomicWrite } from "./run-state-writer.js";
+export function migrateLegacy(root, requested, io = {}) {
+  const writeCanonical = io.atomicWrite ?? atomicWrite;
+  const readCanonical = io.readFile ?? readFileSync;
+  const lp = join(root, ".agdf", "control", "AGDF_RUN.md");
+  if (!existsSync(lp)) throw Error("AGDF_LEGACY_RUN_MISSING");
+  const legacy = readFileSync(lp, "utf8");
+  if (legacy.startsWith("<!-- AGDF LEGACY PROJECTION"))
+    throw Error("AGDF_LEGACY_ALREADY_PROJECTED");
+  if (!legacy.startsWith("# AGDF Run State") || !semanticBody(legacy))
+    throw Error("AGDF_LEGACY_RUN_INVALID");
+  const id = requested || scalarFields(legacy).values.get("run_id");
+  if (!RUN_ID_PATTERN.test(id ?? "")) throw Error("AGDF_RUN_ID_INVALID");
+  const legacyMeta = Object.fromEntries(scalarFields(legacy).values);
+  const dest = runPath(root, id),
+    next = renderRunState(id, semanticBody(legacy), legacyMeta);
+  if (existsSync(dest)) {
+    if (
+      semanticFingerprint(readFileSync(dest, "utf8")) ===
+      semanticFingerprint(next)
+    )
+      return { status: "already_migrated", path: dest };
+    throw Error("AGDF_RUN_COLLISION");
+  }
+  mkdirSync(dirname(dest), { recursive: true });
+  try {
+    writeCanonical(dest, next);
+    const persisted = readCanonical(dest, "utf8"),
+      parsed = parseRunState(persisted, id);
+    if (
+      !parsed.valid ||
+      semanticFingerprint(persisted) !== semanticFingerprint(next)
+    ) throw Error("AGDF_MIGRATION_VERIFICATION_FAILED");
+  } catch (error) {
+    if (existsSync(dest)) unlinkSync(dest);
+    try {
+      rmdirSync(dirname(dest));
+    } catch (cleanupError) {
+      if (!["ENOENT", "ENOTEMPTY"].includes(cleanupError.code)) throw cleanupError;
+    }
+    throw error;
+  }
+  return { status: "migrated", path: dest };
+}
+export function renderLegacyProjection(path) {
+  const content = readFileSync(path, "utf8"),
+    parsed = parseRunState(content),
+    digest = createHash("sha256").update(content).digest("hex");
+  if (!parsed.valid) throw Error("AGDF_RUN_NOT_SELECTABLE");
+  return `<!-- AGDF LEGACY PROJECTION: NON-AUTHORITATIVE -->\n<!-- canonical_source: ${path} -->\n<!-- run_id: ${parsed.meta.run_id} -->\n<!-- revision_id: ${parsed.meta.revision_id} -->\n<!-- sha256: ${digest} -->\n${content}`;
+}
+export function writeLegacyProjection(path, canonical) {
+  atomicWrite(path, renderLegacyProjection(canonical));
+}
+export function verifyLegacyProjection(root) {
+  const path = join(root, ".agdf", "control", "AGDF_RUN.md");
+  if (!existsSync(path)) return { status: "absent" };
+  const p = readFileSync(path, "utf8"),
+    source = p.match(/canonical_source:\s*(.*?)\s*-->/)?.[1],
+    runId = p.match(/<!-- run_id:\s*(.*?)\s*-->/)?.[1],
+    digest = p.match(/sha256:\s*([0-9a-f]{64})/)?.[1],
+    projectedStart = p.indexOf("# AGDF Run State"),
+    projected = projectedStart >= 0 ? p.slice(projectedStart) : undefined;
+  if (!source || !runId || !digest || projected === undefined)
+    return { status: discoverRuns(root).length ? "mixed_authority" : "legacy" };
+  const target = resolve(source),
+    rel = relative(resolve(root), target),
+    expected = relative(resolve(root), resolve(runPath(root, runId)));
+  if (rel.startsWith("..") || !rel || rel !== expected || !existsSync(target))
+    return { status: "projection_source_invalid" };
+  const canonical = readFileSync(target, "utf8"),
+    canonicalDigest = createHash("sha256").update(canonical).digest("hex");
+  return {
+    status:
+      canonicalDigest === digest && projected === canonical
+        ? "valid"
+        : "legacy_projection_drift",
+  };
+}

package/lib/control-state/run-state-parser.js

@@ -0,0 +1,196 @@
+export const RUN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+export const LIFECYCLES = new Set([
+  "active",
+  "completed",
+  "superseded",
+  "abandoned",
+]);
+export function scalarFields(content) {
+  const values = new Map(),
+    duplicates = [];
+  const runMeta = content.match(/(?:^|\n)## Run Meta\s*\n([\s\S]*?)(?=\n## |$)/)?.[1] ?? "";
+  for (const [, k, v] of runMeta.matchAll(/^- ([a-z_]+):\s*(.*?)\s*$/gm)) {
+    if (values.has(k)) duplicates.push(k);
+    else values.set(k, v.replace(/^`|`$/g, ""));
+  }
+  return { values, duplicates };
+}
+export function parseRunState(content, expected) {
+  const { values, duplicates } = scalarFields(content),
+    findings = duplicates.map((field) => ({
+      code: "AGDF_RUN_FIELD_DUPLICATE",
+      field,
+    })),
+    id = values.get("run_id") ?? "";
+  if (content.split(/\r?\n/).some((line) => line.trimStart().startsWith("|") && !line.trimEnd().endsWith("|"))) {
+    findings.push({ code: "AGDF_RUN_TABLE_INVALID" });
+  }
+  if (!RUN_ID_PATTERN.test(id)) findings.push({ code: "AGDF_RUN_ID_INVALID" });
+  if (expected && id !== expected)
+    findings.push({ code: "AGDF_RUN_PATH_MISMATCH" });
+  if (values.get("control_state_version") !== "2")
+    findings.push({ code: "AGDF_RUN_VERSION_UNSUPPORTED" });
+  if (!LIFECYCLES.has(values.get("lifecycle")))
+    findings.push({ code: "AGDF_RUN_LIFECYCLE_INVALID" });
+  if (!/^[1-9]\d*$/.test(values.get("revision") ?? ""))
+    findings.push({ code: "AGDF_RUN_REVISION_INVALID" });
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(values.get("revision_id") ?? ""))
+    findings.push({ code: "AGDF_RUN_REVISION_ID_INVALID" });
+  return {
+    content,
+    meta: Object.fromEntries(values),
+    findings,
+    valid: !findings.length,
+  };
+}
+export function semanticBody(content) {
+  return content
+    .replace(/^# AGDF Run State\s*/m, "")
+    .replace(/## Run Meta[\s\S]*?(?=\n## )/, "")
+    .trim();
+}
+export function semanticFingerprint(content) {
+  return semanticBody(content).replace(/\s+/g, " ");
+}
+
+function section(c, h) {
+  const e = h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return (
+    c.match(
+      new RegExp(`(?:^|\\n)## ${e}\\s*\\n([\\s\\S]*?)(?:\\n## |\\n# |$)`),
+    )?.[1] ?? ""
+  );
+}
+function rows(s) {
+  return s
+    .split(/\r?\n/)
+    .filter((l) => l.trim().startsWith("|"))
+    .map((l) =>
+      l
+        .split("|")
+        .slice(1, -1)
+        .map((x) => x.trim()),
+    )
+    .filter((r) => !r.every((x) => /^[-:]+$/.test(x)));
+}
+function clean(v = "") {
+  return v.replace(/^`|`$/g, "").trim();
+}
+function meaningful(v = "") {
+  return Boolean(v && !(v.startsWith("`") && v.includes("|")));
+}
+function field(c, k) {
+  return (
+    c.match(new RegExp(`^- ${k}:[^\\S\\r\\n]*(.*)$`, "m"))?.[1]?.trim() ?? ""
+  );
+}
+function sectionField(c, h, k) {
+  return field(section(c, h), k);
+}
+function dataRows(c, h, header) {
+  return rows(section(c, h)).filter(
+    (r) =>
+      r[0] !== header &&
+      (h === "Evidence" ? r.slice(0, 3).some(meaningful) : r.some(meaningful)),
+  );
+}
+export function parseControlState(
+  content,
+  { userGates = [], internalSteps = [] } = {},
+) {
+  const approvals = new Map();
+  for (const h of ["Approvals", "Gate Checklist"])
+    for (const [g, s, e] of rows(section(content, h))) {
+      if (userGates.includes(g))
+        approvals.set(g, {
+          status: clean(s) === "passed" && g === "QA" ? "approved" : clean(s),
+          evidence: e ?? "",
+        });
+    }
+  const artefacts = new Map();
+  for (const [t, p, s, n] of rows(section(content, "Artefacts"))) {
+    if (userGates.includes(t) || internalSteps.includes(t))
+      artefacts.set(t, { path: p ?? "", status: clean(s), notes: n ?? "" });
+  }
+  const mapRows = (h, header, fn) => dataRows(content, h, header).map(fn);
+  const mode = "Mode / Slice Decision",
+    source = "Source And Scope State",
+    memory = "Knowledge Persistence Decision";
+  return {
+    current_gate: field(content, "current_gate"),
+    next_allowed_action: field(content, "next_allowed_action"),
+    approvals,
+    artefacts,
+    evidence_refs: mapRows("Evidence", "Evidence", (r) => ({
+      evidence: r[0] ?? "",
+      source: r[1] ?? "",
+      covers: r[2] ?? "",
+      strength: clean(r[3]),
+    })),
+    artefact_chain: mapRows("Artefact Chain", "From", (r) => ({
+      from: r[0] ?? "",
+      relationship: clean(r[1]),
+      to: clean(r[2]),
+      evidence: r[3] ?? "",
+    })),
+    missing_evidence: mapRows("Missing Evidence", "Missing evidence", (r) => ({
+      missing_evidence: r[0] ?? "",
+      impact: clean(r[1]),
+      required_next_step: r[2] ?? "",
+    })),
+    risks: mapRows("Risks", "Risk", (r) => ({
+      risk: r[0] ?? "",
+      impact: clean(r[1]),
+      mitigation_or_owner: r[2] ?? "",
+    })),
+    context_graph: {
+      impact: clean(field(content, "context_graph_impact")),
+      refs: field(content, "context_graph_refs"),
+      required_action: clean(field(content, "context_graph_required_action")),
+      gate_effect: clean(field(content, "context_graph_gate_effect")),
+      evidence: field(content, "context_graph_evidence"),
+    },
+    quality_outlook: field(content, "quality_outlook"),
+    mode_slice_decision: {
+      decision: clean(sectionField(content, mode, "decision")),
+      required_next_gate: clean(
+        sectionField(content, mode, "required_next_gate"),
+      ),
+      scope_reason: sectionField(content, mode, "scope_reason"),
+      evidence: sectionField(content, mode, "evidence"),
+    },
+    source_scope: {
+      normative_instruction_source: sectionField(
+        content,
+        source,
+        "normative_instruction_source",
+      ),
+      multi_scope_state: clean(
+        sectionField(content, source, "multi_scope_state"),
+      ),
+      active_scope_evidence: sectionField(
+        content,
+        source,
+        "active_scope_evidence",
+      ),
+      competing_scope_lines: sectionField(
+        content,
+        source,
+        "competing_scope_lines",
+      ),
+      branch_workspace_evidence: sectionField(
+        content,
+        source,
+        "branch_workspace_evidence",
+      ),
+      branch_workspace_scope_effect: clean(
+        sectionField(content, source, "branch_workspace_scope_effect"),
+      ),
+    },
+    memory: {
+      target: clean(sectionField(content, memory, "memory_target")),
+      reason: sectionField(content, memory, "memory_reason"),
+      refs: sectionField(content, memory, "memory_refs"),
+    },
+  };
+}

package/lib/control-state/run-state-repository.js

@@ -0,0 +1,68 @@
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { parseRunState, RUN_ID_PATTERN } from "./run-state-parser.js";
+export function runPath(root, id) {
+  if (!RUN_ID_PATTERN.test(id)) throw Error(`invalid run_id: ${id}`);
+  return join(root, ".agdf", "control", "runs", id, "RUN_STATE.md");
+}
+export function discoverRuns(root) {
+  const dir = join(root, ".agdf", "control", "runs");
+  if (!existsSync(dir)) return [];
+  const rootStats = lstatSync(dir);
+  if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+    return [invalidRun("<repository>", dir)];
+  }
+  return readdirSync(dir)
+    .filter((x) => !x.startsWith("."))
+    .sort()
+    .map((id) => {
+      const d = join(dir, id),
+        path = join(d, "RUN_STATE.md");
+      const directoryStats = lstatSync(d);
+      if (
+        !RUN_ID_PATTERN.test(id) ||
+        directoryStats.isSymbolicLink() ||
+        !directoryStats.isDirectory() ||
+        !existsSync(path)
+      )
+        return invalidRun(id, path);
+
+      const stateStats = lstatSync(path);
+      if (stateStats.isSymbolicLink() || !stateStats.isFile()) {
+        return invalidRun(id, path);
+      }
+      return {
+        run_id: id,
+        path,
+        ...parseRunState(readFileSync(path, "utf8"), id),
+      };
+    });
+}
+
+function invalidRun(runId, path) {
+  return {
+    run_id: runId,
+    path,
+    valid: false,
+    findings: [{ code: "AGDF_RUN_PATH_INVALID", path }],
+  };
+}
+const DEFAULT_BODY = `## Objective\n\nDescribe the trustworthy outcome.\n\n## Current Control State\n\n| Question | Answer |\n|---|---|\n| What is known? | New run created. |\n| What is approved? | Nothing yet. |\n| What is missing? | Durable UR and exact approval. |\n| What is the next allowed action? | Draft the UR. |\n| What is explicitly forbidden right now? | Later artefacts and implementation. |\n\n## Evidence\n\n| Evidence | Source | Covers | Strength |\n|---|---|---|---|\n| Run creation | run-create | Control initialization | direct |\n\n## Closeout\n\n- next_allowed_action: Draft the UR.\n- quality_outlook: Establish evidence before later gates.\n`;
+export function renderRunState(id, body = DEFAULT_BODY, meta = {}) {
+  return `# AGDF Run State\n\n## Run Meta\n\n- control_state_version: 2\n- run_id: ${id}\n- lifecycle: ${meta.lifecycle ?? "active"}\n- revision: 1\n- revision_id: ${randomUUID()}\n- mode: ${meta.mode ?? "structured_delivery"}\n- current_gate: ${meta.current_gate ?? "UR"}\n- decision: ${meta.decision ?? "in_progress"}\n- owner: ${meta.owner ?? "agent"}\n\n${body}`;
+}
+export function createRun(root, id, body = "") {
+  const path = runPath(root, id);
+  if (existsSync(path)) throw Error("AGDF_RUN_COLLISION");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, renderRunState(id, body), { flag: "wx" });
+  return path;
+}

package/lib/control-state/run-state-resolver.js

@@ -0,0 +1,45 @@
+import { discoverRuns } from "./run-state-repository.js";
+export function resolveRuns(
+  root,
+  { runIdArg, runIdEnv, allActive = false } = {},
+) {
+  if (
+    (allActive && (runIdArg || runIdEnv)) ||
+    (runIdArg && runIdEnv && runIdArg !== runIdEnv)
+  )
+    throw Error("AGDF_SELECTOR_CONFLICT");
+  const runs = discoverRuns(root),
+    active = runs.filter((r) => r.valid && r.meta.lifecycle === "active");
+  const findings = runs
+    .filter((run) => !run.valid)
+    .flatMap((run) =>
+      run.findings.map((finding) => ({ ...finding, run_id: run.run_id })),
+    );
+  if (allActive)
+    return { selection_source: "all_active", runs: active, findings };
+  const id = runIdArg || runIdEnv;
+  if (id) {
+    const run = runs.find((r) => r.run_id === id);
+    if (!run?.valid) {
+      throw Error(
+        `AGDF_RUN_NOT_SELECTABLE:${id}; discovered=${runs.map((item) => item.run_id).join(",")}; next=select a valid run`,
+      );
+    }
+    return {
+      selection_source: runIdArg ? "cli" : "environment",
+      run,
+      active_run_ids: active.map((r) => r.run_id),
+    };
+  }
+  if (active.length !== 1)
+    throw Error(
+      active.length
+        ? `AGDF_ACTIVE_RUN_AMBIGUOUS:${active.map((r) => r.run_id)}`
+        : "AGDF_ACTIVE_RUN_MISSING",
+    );
+  return {
+    selection_source: "single_active",
+    run: active[0],
+    active_run_ids: [active[0].run_id],
+  };
+}

package/lib/control-state/run-state-writer.js

@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fsyncSync,
+  existsSync,
+  lstatSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+import { parseRunState } from "./run-state-parser.js";
+
+function fsyncDirectory(path) {
+  const descriptor = openSync(path, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+export function atomicWrite(path, content) {
+  if (existsSync(path)) {
+    const destination = lstatSync(path);
+    if (destination.isSymbolicLink() || !destination.isFile()) {
+      throw new Error("AGDF_RUN_PATH_INVALID");
+    }
+  }
+
+  const parent = lstatSync(dirname(path));
+  if (parent.isSymbolicLink() || !parent.isDirectory()) {
+    throw new Error("AGDF_RUN_PATH_INVALID");
+  }
+
+  const temp = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  let descriptor;
+
+  try {
+    descriptor = openSync(temp, "wx");
+    writeFileSync(descriptor, content, "utf8");
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = undefined;
+
+    renameSync(temp, path);
+    fsyncDirectory(dirname(path));
+  } catch (error) {
+    if (descriptor !== undefined) closeSync(descriptor);
+    try {
+      unlinkSync(temp);
+    } catch (cleanupError) {
+      if (cleanupError.code !== "ENOENT") throw cleanupError;
+    }
+    throw error;
+  }
+}
+
+export function writeRun(path, content, expectedRevisionId) {
+  const lockPath = `${path}.lock`;
+  let lockDescriptor;
+  try {
+    lockDescriptor = openSync(lockPath, "wx");
+  } catch (error) {
+    if (error.code === "EEXIST") throw new Error("AGDF_RUN_WRITE_LOCKED");
+    throw error;
+  }
+
+  try {
+    const current = parseRunState(readFileSync(path, "utf8"));
+    if (!current.valid) throw new Error("AGDF_RUN_STATE_INVALID");
+    if (current.meta.revision_id !== expectedRevisionId) {
+      throw new Error("AGDF_STALE_RUN_REVISION");
+    }
+
+    const next = content
+      .replace(
+        /^- revision:\s*.*$/m,
+        `- revision: ${Number(current.meta.revision) + 1}`,
+      )
+      .replace(/^- revision_id:\s*.*$/m, `- revision_id: ${randomUUID()}`);
+    const candidate = parseRunState(next);
+    if (!candidate.valid || candidate.meta.run_id !== current.meta.run_id) {
+      throw new Error("AGDF_RUN_STATE_INVALID");
+    }
+
+    atomicWrite(path, next);
+    return candidate;
+  } finally {
+    closeSync(lockDescriptor);
+    unlinkSync(lockPath);
+  }
+}

package/lib/delivery-path-search/state-adapter.js

@@ -1,16 +1,34 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { CONTRACT_VERSION, GENERATOR_CONTRACT_VERSION, validateGeneratorRequest } from "./contracts.js";
+import {
+  CONTRACT_VERSION,
+  GENERATOR_CONTRACT_VERSION,
+  validateGeneratorRequest,
+} from "./contracts.js";
+import { resolveRuns, verifyLegacyProjection } from "../control-state/index.js";
 
 function section(content, heading) {
-  return content.match(new RegExp(`## ${heading}\\r?\\n([\\s\\S]*?)(?=\\r?\\n## |$)`))?.[1] ?? "";
+  return (
+    content.match(
+      new RegExp(`## ${heading}\\r?\\n([\\s\\S]*?)(?=\\r?\\n## |$)`),
+    )?.[1] ?? ""
+  );
 }
 
 function tableAnswers(content) {
   const answers = {};
   for (const line of section(content, "Current Control State").split(/\r?\n/)) {
-    const cells = line.split("|").slice(1, -1).map((cell) => cell.trim());
-    if (cells.length >= 2 && cells[0] && !cells[0].startsWith("---") && cells[0] !== "Question") answers[cells[0]] = cells[1];
+    const cells = line
+      .split("|")
+      .slice(1, -1)
+      .map((cell) => cell.trim());
+    if (
+      cells.length >= 2 &&
+      cells[0] &&
+      !cells[0].startsWith("---") &&
+      cells[0] !== "Question"
+    )
+      answers[cells[0]] = cells[1];
   }
   return answers;
 }
@@ -18,21 +36,52 @@ function tableAnswers(content) {
 function statusCard(content) {
   const card = {};
   for (const line of section(content, "Run Status Card").split(/\r?\n/)) {
-    const cells = line.split("|").slice(1, -1).map((cell) => cell.trim().replace(/^`|`$/g, ""));
-    if (cells.length >= 2 && cells[0] && !cells[0].startsWith("---") && cells[0] !== "Run status") card[cells[0]] = cells[1];
+    const cells = line
+      .split("|")
+      .slice(1, -1)
+      .map((cell) => cell.trim().replace(/^`|`$/g, ""));
+    if (
+      cells.length >= 2 &&
+      cells[0] &&
+      !cells[0].startsWith("---") &&
+      cells[0] !== "Run status"
+    )
+      card[cells[0]] = cells[1];
   }
   return card;
 }
 
 function listCell(value) {
-  return String(value ?? "").split(/\s*;\s*/).map((item) => item.trim()).filter(Boolean);
+  return String(value ?? "")
+    .split(/\s*;\s*/)
+    .map((item) => item.trim())
+    .filter(Boolean);
 }
 
 export function searchInputFromControl(targetDir, options = {}) {
-  const runPath = join(targetDir, ".agdf", "control", "AGDF_RUN.md");
-  if (!existsSync(runPath)) throw new Error("missing .agdf/control/AGDF_RUN.md");
+  const canonicalRoot = join(targetDir, ".agdf", "control", "runs");
+  if (existsSync(canonicalRoot)) {
+    const projection = verifyLegacyProjection(targetDir);
+    if (!["absent", "valid"].includes(projection.status)) {
+      throw new Error(`AGDF_LEGACY_PROJECTION_DRIFT:${projection.status}`);
+    }
+  }
+  const resolved = existsSync(canonicalRoot)
+    ? resolveRuns(targetDir, {
+        runIdArg: options.scopeKey,
+        runIdEnv: process.env.AGDF_RUN_ID,
+      })
+    : null;
+  const runPath =
+    resolved?.run.path ?? join(targetDir, ".agdf", "control", "AGDF_RUN.md");
+  if (!existsSync(runPath)) throw new Error("missing AGDF run state");
   const content = readFileSync(runPath, "utf8");
-  const meta = Object.fromEntries([...content.matchAll(/^- ([a-z_]+):\s*(.+)$/gm)].map((match) => [match[1], match[2].replace(/^`|`$/g, "").trim()]));
+  const meta = Object.fromEntries(
+    [...content.matchAll(/^- ([a-z_]+):\s*(.+)$/gm)].map((match) => [
+      match[1],
+      match[2].replace(/^`|`$/g, "").trim(),
+    ]),
+  );
   const answers = tableAnswers(content);
   const card = statusCard(content);
   const result = {
@@ -41,11 +90,29 @@ export function searchInputFromControl(targetDir, options = {}) {
     objective: section(content, "Objective").trim(),
     current_gate: card["Current gate"] ?? meta.current_gate ?? "unknown",
     allowed_actions: options.allowedActions ?? listCell(card["Allowed now"]),
-    forbidden_actions: options.forbiddenActions ?? listCell(answers["What is explicitly forbidden right now?"]),
-    evidence_refs: [...content.matchAll(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*(direct|indirect)\s*\|/g)]
-      .slice(1).map((match) => `${match[1].trim()}: ${match[2].trim()}`),
-    risks: section(content, "Risks").split(/\r?\n/).filter((line) => line.startsWith("|") && !line.includes("---") && !line.includes("| Risk |")).map((line) => line.split("|")[1].trim()),
-    enforcement: options.enforcement ?? { level: "instruction_only", evidence: ["surface instruction prohibits implementation during search"] },
+    forbidden_actions:
+      options.forbiddenActions ??
+      listCell(answers["What is explicitly forbidden right now?"]),
+    evidence_refs: [
+      ...content.matchAll(
+        /\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*(direct|indirect)\s*\|/g,
+      ),
+    ]
+      .slice(1)
+      .map((match) => `${match[1].trim()}: ${match[2].trim()}`),
+    risks: section(content, "Risks")
+      .split(/\r?\n/)
+      .filter(
+        (line) =>
+          line.startsWith("|") &&
+          !line.includes("---") &&
+          !line.includes("| Risk |"),
+      )
+      .map((line) => line.split("|")[1].trim()),
+    enforcement: options.enforcement ?? {
+      level: "instruction_only",
+      evidence: ["surface instruction prohibits implementation during search"],
+    },
     budgets: {
       max_candidates: options.maxCandidates ?? 5,
       max_depth: options.maxDepth ?? 2,
@@ -55,13 +122,14 @@ export function searchInputFromControl(targetDir, options = {}) {
       stability_window: options.stabilityWindow ?? 3,
     },
   };
-  if (options.generation?.enabled) result.generation = {
-    enabled: true,
-    max_calls: 1,
-    max_proposals: options.generation.maxProposals ?? 5,
-    max_duration_ms: options.generation.maxDurationMs ?? 30000,
-    max_cost_units: options.generation.maxCostUnits ?? 5,
-  };
+  if (options.generation?.enabled)
+    result.generation = {
+      enabled: true,
+      max_calls: 1,
+      max_proposals: options.generation.maxProposals ?? 5,
+      max_duration_ms: options.generation.maxDurationMs ?? 30000,
+      max_cost_units: options.generation.maxCostUnits ?? 5,
+    };
   return result;
 }
 
@@ -78,7 +146,10 @@ export function generatorRequestFromInput(input) {
     evidence: input.evidence_refs ?? [],
     missing_evidence: [],
     risks: input.risks ?? [],
-    constraints: ["advisory only", "canonical gate-check remains authoritative"],
+    constraints: [
+      "advisory only",
+      "canonical gate-check remains authoritative",
+    ],
     enforcement: input.enforcement,
     budgets: {
       max_calls: input.generation.max_calls,