create-agdf 0.14.4 → 0.20.0

package/generated/plugins/agdf/runtime/create-agdf/lib/control-evaluation/gate-check.js

@@ -1,506 +0,0 @@
-import { attachApprovalOrientationSnapshot, buildArtefactRefs, buildQualityReadiness, gateTitle, localePack, renderApprovalOrientationSnapshot, renderOperationalStatusCard, resolveHumanRunTitle, validateApprovalOrientationPreconditions, validateApprovalOrientationSnapshot, validateOperationalStatusCardPreconditions } from '../interaction-presentation.js';
-import { interactionLocales, resolveConfiguredChatLanguage } from '../cli/runtime-context.js';
-import { evaluateDoctor } from './doctor.js';
-import { analyzeDeliveryMap, deriveQualityOutlook } from './delivery-map.js';
-import { transitionDecisionForRunState } from './gate-policy.js';
-import { evaluateVerifiedChange, extractField, verifiedChangeEscalationTargets } from './verified-change.js';
-import { gateApprovalStatus, modeSliceDecision, readArtefactHeading, readRunState, resolvedArtefactFile } from './run-state.js';
-import { isPlaceholderValue } from './shared.js';
-
-const nextSkillByGate = {
-  UR: "gate-check",
-  "Brownfield Review": "brownfield-analysis",
-  "Mode/Slice Decision": "gate-check",
-  "Quick Task Execution": "none",
-  "Verified Change Execution": "gate-check",
-  PRD: "gate-check",
-  SD: "gate-check",
-  TP: "gate-check",
-  "Brownfield Analysis": "brownfield-analysis",
-  "CD+Tests": "none",
-  CR: "code-review",
-  QA: "qa-gate",
-  UAT: "delivery-closeout",
-  OR: "release-or",
-};
-
-export function postApprovalTransition(missingApproval) {
-  const transitions = new Map([
-    ["Approval: UR", {
-      next_gate_after_approval: "Brownfield Review",
-      allowed_after_approval: "Run Brownfield Review and proportional routing as one internal operation; no user action is required now.",
-      internal_next_step: "Brownfield Review and proportional routing",
-      next_user_gate: "none",
-      user_action_required: "no",
-    }],
-    ["Approval: PRD", {
-      next_gate_after_approval: "SD",
-      allowed_after_approval: "Draft Solution Design; implementation remains forbidden.",
-      internal_next_step: "draft Solution Design",
-      next_user_gate: "SD",
-      user_action_required: "yes",
-    }],
-    ["Approval: SD", {
-      next_gate_after_approval: "TP",
-      allowed_after_approval: "Draft Task/Test Plan; implementation remains forbidden.",
-      internal_next_step: "draft Task/Test Plan",
-      next_user_gate: "TP",
-      user_action_required: "yes",
-    }],
-    ["Approval: TP", {
-      next_gate_after_approval: "none",
-      allowed_after_approval: "Run implementation-prep Brownfield Analysis before CD+Tests; no further user approval is required at this internal step.",
-      internal_next_step: "pre-implementation Brownfield Analysis",
-      next_user_gate: "none",
-      user_action_required: "no",
-    }],
-    ["Approval: QA", {
-      next_gate_after_approval: "UAT",
-      allowed_after_approval: "Request UAT when QA has passed; release remains gated.",
-      internal_next_step: "prepare UAT evidence",
-      next_user_gate: "UAT",
-      user_action_required: "yes",
-    }],
-    ["Approval: UAT", {
-      next_gate_after_approval: "OR",
-      allowed_after_approval: "Produce OR or delivery closeout; VCS and release actions still require explicit instruction.",
-      internal_next_step: "OR or delivery closeout",
-      next_user_gate: "none",
-      user_action_required: "no",
-    }],
-  ]);
-
-  return transitions.get(missingApproval) ?? {
-    next_gate_after_approval: "none",
-    allowed_after_approval: "none",
-  };
-}
-
-const BREADCRUMB_PATH_TEMPLATES = {
-  structured_delivery: ["UR", "PRD", "SD", "TP", "QA", "UAT"],
-  structured_slice: ["UR", "PRD", "SD", "TP", "QA", "UAT"],
-  verified_change: ["UR", "Verified Change", "OR"],
-  quick_task: ["UR", "Compact Delivery"],
-  block: ["UR", "Block"],
-  undecided: ["UR"],
-};
-
-const BREADCRUMB_STANDARD_GATES = ["UR", "PRD", "SD", "TP", "QA", "UAT"];
-
-export function isReadyUserGateApproval({ status, currentGate, missingApproval }) {
-  return status === "open"
-    && BREADCRUMB_STANDARD_GATES.includes(currentGate)
-    && missingApproval === `Approval: ${currentGate}`;
-}
-
-function buildBreadcrumbPath(modeSliceDecision, currentGate, runState) {
-  const gates = BREADCRUMB_PATH_TEMPLATES[modeSliceDecision] ?? ["UR"];
-  return gates.map((gate) => {
-    if (BREADCRUMB_STANDARD_GATES.includes(gate)) {
-      if (gateApprovalStatus(runState, gate) === "approved") return { gate, status: "fulfilled" };
-      if (gate === currentGate) return { gate, status: "current" };
-      return { gate, status: "open" };
-    }
-    if (gate === currentGate) return { gate, status: "current" };
-    if ((gate === "Verified Change" || gate === "Compact Delivery") && currentGate === "OR")
-      return { gate, status: "fulfilled" };
-    if (gate === "Verified Change" && modeSliceDecision === "verified_change")
-      return { gate, status: "current" };
-    if (gate === "Compact Delivery" && modeSliceDecision === "quick_task")
-      return { gate, status: "current" };
-    if (gate === "Block" && modeSliceDecision === "block")
-      return { gate, status: "current" };
-    if (gate === "OR" && currentGate === "OR")
-      return { gate, status: "current" };
-    return { gate, status: "open" };
-  });
-}
-
-export function buildStatusCard({
-  status,
-  currentGate,
-  allowed = [],
-  forbidden = [],
-  blockingReason = "none",
-  missingApproval = "none",
-  nextAllowedAction,
-  runState,
-  chatLanguage = "en",
-  findings = [],
-}) {
-  const qualityOutlook = deriveQualityOutlook(runState, findings);
-  const postApproval = postApprovalTransition(missingApproval);
-  const isUserGateApproval = isReadyUserGateApproval({ status, currentGate, missingApproval });
-  const lifecycle = extractField(runState.content ?? "", "lifecycle") || "unknown";
-  const nativeAttemptRequired = false;
-  const interactionKind = status === "open" && isUserGateApproval ? "gate_approval" : status === "blocked" ? "blocked" : "status";
-  return {
-    run_id: extractField(runState.content ?? "", "run_id") || "unknown",
-    presentation_language: chatLanguage,
-    mode: extractField(runState.content ?? "", "mode") || "unknown",
-    lifecycle,
-    delivery_state: lifecycle === "completed" && currentGate === "OR" ? "completed_closeout_pending" : lifecycle,
-    status,
-    current_gate: currentGate,
-    mode_slice_decision: runState.mode_slice_decision?.decision || "undecided",
-    breadcrumb: buildBreadcrumbPath(
-      runState.mode_slice_decision?.decision || "undecided",
-      currentGate,
-      runState,
-    ),
-    allowed_now: allowed,
-    forbidden_now: forbidden,
-    blocking_condition: blockingReason || "none",
-    missing_approval: missingApproval || "none",
-    next_gate_after_approval: postApproval.next_gate_after_approval,
-    allowed_after_approval: postApproval.allowed_after_approval,
-    user_visible_outcome_after_approval: postApproval.allowed_after_approval,
-    internal_next_step: postApproval.internal_next_step || (isUserGateApproval ? "none" : nextAllowedAction),
-    next_user_gate: postApproval.next_user_gate || "none",
-    user_action_required: postApproval.user_action_required || (isUserGateApproval ? "yes" : "no"),
-    evidence: runState.evidence_refs,
-    next_skill: nextSkillByGate[currentGate] ?? "gate-check",
-    next_step: nextAllowedAction,
-    quality_outlook: qualityOutlook,
-    interaction_kind: interactionKind,
-    native_attempt_required: nativeAttemptRequired,
-    native_preflight_outcome: isUserGateApproval ? "unavailable_before_invocation" : "not_applicable",
-    native_preflight_reason: isUserGateApproval ? "capability_missing" : "none",
-  };
-}
-
-function statusFromReviewArtefact(artefact) {
-  if (!artefact) return "unknown";
-  const text = `${artefact.status ?? ""} ${artefact.notes ?? ""}`.toLowerCase();
-  for (const status of ["block", "revise", "warn", "pass"]) {
-    if (new RegExp(`\\b${status}(?:ed)?\\b`).test(text)) return status;
-  }
-  return "unknown";
-}
-
-export function qualityReadinessForRunState(runState, nextAction) {
-  const artefacts = runState.artefacts;
-  const plan = artefacts.get("TP Review");
-  const clean = artefacts.get("Clean Implementation Review") ?? artefacts.get("Clean Review");
-  const code = artefacts.get("CR") ?? artefacts.get("Code Review");
-  const qa = artefacts.get("QA");
-  if (![plan, clean, code, qa].some(Boolean)) return null;
-  const reviewRows = [plan, clean, code, qa].filter(Boolean);
-  const decisive = reviewRows.find((artefact) => /\b(?:block|revise)\b/i.test(`${artefact.status ?? ""} ${artefact.notes ?? ""}`));
-  const readiness = buildQualityReadiness({
-    planCoverage: statusFromReviewArtefact(plan),
-    solutionIntegrity: statusFromReviewArtefact(clean),
-    codeQuality: statusFromReviewArtefact(code),
-    qaDecision: statusFromReviewArtefact(qa),
-    decisiveReason: decisive?.notes ?? "",
-    nextAction,
-  });
-  if (!readiness) return null;
-  return Object.freeze({ ...readiness, decisive_reference: decisive?.path ?? "" });
-}
-
-function buildHumanPresentation(targetDir, runState, currentGate, presentationLocale) {
-  const currentArtefactHeading = readArtefactHeading(targetDir, runState.artefacts.get(currentGate));
-  const urHeading = readArtefactHeading(targetDir, runState.artefacts.get("UR"));
-  return {
-    runTitle: resolveHumanRunTitle({
-      currentArtefactHeading,
-      urHeading,
-      runContent: runState.content,
-      runId: extractField(runState.content ?? "", "run_id") || "unknown",
-    }),
-    gateTitle: gateTitle(interactionLocales, presentationLocale, currentGate),
-    artefactRefs: buildArtefactRefs(runState.artefacts, interactionLocales, presentationLocale, {
-      pathExists(path) {
-        return Boolean(resolvedArtefactFile(targetDir, path));
-      },
-    }),
-  };
-}
-
-export function evaluateGateCheck(targetDir, selection = {}) {
-  const doctorReport = evaluateDoctor(targetDir, selection);
-  const runState = readRunState(targetDir, selection);
-  const verifiedChange = modeSliceDecision(runState) === "verified_change"
-    ? evaluateVerifiedChange(targetDir, runState)
-    : null;
-  const transitionDecision = transitionDecisionForRunState(runState, verifiedChange);
-  const deliveryMap = analyzeDeliveryMap(runState, {
-    loadRun: (runId) => readRunState(targetDir, { runId }),
-    resolveFile: (path) => resolvedArtefactFile(targetDir, path),
-  });
-  const doctorBlocker = doctorReport.findings.find((finding) => finding.severity === "block");
-  const doctorRevise = doctorReport.findings.find((finding) => finding.severity === "revise");
-  const routesInvalidVerifiedChange = modeSliceDecision(runState) === "verified_change"
-    && verifiedChange?.status === "invalid"
-    && verifiedChangeEscalationTargets.has(verifiedChange.escalation_target);
-
-  let status = transitionDecision.status;
-  let currentGate = transitionDecision.current_gate;
-  let blockingReason = transitionDecision.blocking_reason;
-  let missingApproval = transitionDecision.missing_approval;
-  let allowed = transitionDecision.allowed;
-  let forbidden = transitionDecision.forbidden;
-  let nextAllowedAction = modeSliceDecision(runState) === "verified_change"
-    ? transitionDecision.next_allowed_action
-    : isPlaceholderValue(runState.next_allowed_action)
-    ? transitionDecision.next_allowed_action
-    : runState.next_allowed_action;
-
-  if (doctorBlocker?.code === "AGDF_CONTROL_FILE_MISSING") {
-    status = "blocked";
-    blockingReason = doctorBlocker.code;
-    currentGate = "UR";
-    missingApproval = "Approval: UR";
-    allowed = [
-      "draft the minimal UR for the requested change in the response",
-      "request exact approval: Approval: UR",
-      "run npx --yes @agdf/cli@latest init only when durable control state or deterministic setup is explicitly needed",
-    ];
-    forbidden = ["create PRD", "create SD", "create TP", "run Brownfield Analysis", "implement code", "claim QA or release readiness"];
-    nextAllowedAction = "Draft the minimal UR for the request in the response, then ask for exact approval: Approval: UR. Do not write a full .agdf/control scaffold unless durable control state or deterministic setup is explicitly needed.";
-  } else if (doctorBlocker && !routesInvalidVerifiedChange) {
-    status = "blocked";
-    blockingReason = doctorBlocker.code;
-    allowed = ["repair the AGDF control scaffold", ...transitionDecision.allowed, "run doctor again"];
-    forbidden = ["create later-gate artefacts beyond the current allowed gate", "implement gated work", "claim QA or release readiness"];
-    nextAllowedAction = doctorBlocker.next_step;
-  } else if (doctorRevise && !routesInvalidVerifiedChange) {
-    status = "blocked";
-    blockingReason = doctorRevise.code;
-    allowed = [...new Set(["complete the current control-state fields", ...transitionDecision.allowed, "run doctor again"])];
-    forbidden = ["create later-gate artefacts beyond the current allowed gate", "implement gated work before the gate allows it", "claim QA or release readiness"];
-    nextAllowedAction = transitionDecision.current_gate === "UR"
-      ? "Fill the current UR control state, persist the UR draft, and request exact approval: Approval: UR."
-      : doctorRevise.next_step;
-  }
-
-  const postApproval = postApprovalTransition(missingApproval);
-  const presentationLocale = resolveConfiguredChatLanguage(targetDir);
-  const statusCard = buildStatusCard({
-    status,
-    currentGate,
-    allowed,
-    forbidden,
-    blockingReason,
-    missingApproval,
-    nextAllowedAction,
-    runState,
-    chatLanguage: presentationLocale,
-    findings: deliveryMap.findings,
-  });
-  const humanPresentation = buildHumanPresentation(targetDir, runState, currentGate, presentationLocale);
-  Object.defineProperty(statusCard, "humanPresentation", {
-    value: humanPresentation,
-    enumerable: false,
-  });
-  const revisionId = extractField(runState.content ?? "", "revision_id");
-  const statusPresentation = renderOperationalStatusCard(statusCard, {
-    registry: interactionLocales,
-    humanPresentation,
-    revisionId,
-  });
-  const readyForApproval = isReadyUserGateApproval({ status, currentGate, missingApproval });
-  const approvalOrientation = attachApprovalOrientationSnapshot(statusCard, {
-    ready: readyForApproval,
-    humanPresentation,
-    revisionId,
-    registry: interactionLocales,
-    requestedLocale: presentationLocale,
-  });
-  Object.defineProperty(statusCard, "runState", {
-    value: runState,
-    enumerable: false,
-  });
-
-  const approvalPresentation = renderApprovalOrientationSnapshot(approvalOrientation, {
-    registry: interactionLocales,
-    expectedIdentity: {
-      run_id: statusCard.run_id,
-      revision_id: revisionId,
-      current_gate: currentGate,
-      presentation_language: statusCard.presentation_language,
-    },
-  });
-  const presentationDiagnostics = {};
-  if (!statusPresentation) {
-    presentationDiagnostics.status_presentation_errors = [
-      ...validateOperationalStatusCardPreconditions(statusCard, {
-        registry: interactionLocales,
-        humanPresentation,
-      }).errors,
-    ];
-  }
-  if (readyForApproval && !approvalPresentation) {
-    presentationDiagnostics.approval_presentation_errors = approvalOrientation
-      ? [
-          ...validateApprovalOrientationSnapshot(approvalOrientation, {
-            registry: interactionLocales,
-            expectedIdentity: {
-              run_id: statusCard.run_id,
-              revision_id: revisionId,
-              current_gate: currentGate,
-              presentation_language: statusCard.presentation_language,
-            },
-          }).errors,
-        ]
-      : [
-          ...validateApprovalOrientationPreconditions({
-            statusCard,
-            humanPresentation,
-            registry: interactionLocales,
-            requestedLocale: presentationLocale,
-          }).errors,
-        ];
-    if (!presentationDiagnostics.approval_presentation_errors.length) {
-      presentationDiagnostics.approval_presentation_errors = ["snapshot_unavailable"];
-    }
-  }
-
-  return {
-    schema_version: "1",
-    status,
-    current_gate: currentGate,
-    blocking_reason: blockingReason,
-    missing_approval: missingApproval,
-    next_gate_after_approval: postApproval.next_gate_after_approval,
-    allowed_after_approval: postApproval.allowed_after_approval,
-    allowed,
-    forbidden,
-    next_allowed_action: nextAllowedAction,
-    doctor_status: doctorReport.status,
-    doctor_summary: doctorReport.summary,
-    evidence_refs: runState.evidence_refs,
-    quality_outlook: deriveQualityOutlook(runState, deliveryMap.findings),
-    interaction_kind: statusCard.interaction_kind,
-    native_attempt_required: statusCard.native_attempt_required,
-    candidate_runs: runState.candidate_runs ?? [],
-    status_card: statusCard,
-    status_presentation: statusPresentation,
-    approval_presentation: approvalPresentation,
-    ...(Object.keys(presentationDiagnostics).length ? { presentation_diagnostics: presentationDiagnostics } : {}),
-    delivery_map: {
-      relationships: deliveryMap.relationships,
-      mode_slice_decision: runState.mode_slice_decision,
-      context_graph: deliveryMap.context_graph,
-      source_scope: deliveryMap.source_scope,
-      memory: deliveryMap.memory,
-      parent_reconciliation: deliveryMap.parent_reconciliation,
-      programme_aggregation: deliveryMap.programme_aggregation,
-      findings: deliveryMap.findings,
-    },
-    verified_change: verifiedChange,
-    doctor_report: doctorReport,
-  };
-}
-
-function canonicalApprovalForReport(report) {
-  const gate = String(report?.current_gate ?? "").trim();
-  const approval = String(report?.missing_approval ?? "").trim();
-  return isReadyUserGateApproval({ status: report?.status, currentGate: gate, missingApproval: approval })
-    ? approval
-    : "";
-}
-
-export function printApprovalEnvelope(report, { io = console, reEvaluate } = {}) {
-  if (report?.approval_presentation) {
-    io.log(report.approval_presentation.blocks.run_status_card.markdown);
-    io.log("");
-    if (report.status_presentation?.markdown) {
-      io.log(report.status_presentation.markdown);
-    } else {
-      const pack = localePack(interactionLocales, report.approval_presentation.presentation_language || "en");
-      const codes = report.presentation_diagnostics?.status_presentation_errors ?? [];
-      io.log(codes.length ? `${pack.interaction.statusPresentationFailure} (${codes.join(", ")})` : pack.interaction.statusPresentationFailure);
-    }
-    io.log("");
-    io.log(report.approval_presentation.blocks.gate_transition_card.markdown);
-    io.log("");
-    io.log(report.approval_presentation.approval_interaction.exact_text_fallback);
-    return Object.freeze({ outcome: "rendered", requested_decision: true, status: report.status });
-  }
-
-  const initialApproval = canonicalApprovalForReport(report);
-  let refreshed = report;
-  if (initialApproval && typeof reEvaluate === "function") {
-    try {
-      refreshed = reEvaluate();
-    } catch {
-      refreshed = { ...report, status: "blocked", blocking_reason: "fresh_gate_evaluation_failed", missing_approval: "none" };
-    }
-  }
-  const pack = localePack(interactionLocales, refreshed?.status_card?.presentation_language || report?.status_card?.presentation_language || "en");
-  const refreshedApproval = canonicalApprovalForReport(refreshed);
-  if (initialApproval && refreshedApproval) {
-    const codes = refreshed?.presentation_diagnostics?.approval_presentation_errors
-      ?? report?.presentation_diagnostics?.approval_presentation_errors
-      ?? [];
-    io.log(codes.length ? `${pack.interaction.presentationFailure} (${codes.join(", ")})` : pack.interaction.presentationFailure);
-    io.log(pack.interaction.exactTextRequest.replace("{approval}", refreshedApproval));
-    return Object.freeze({ outcome: "exact_text_recovery", requested_decision: true, status: refreshed.status });
-  }
-
-  const blockingReason = String(refreshed?.blocking_reason ?? "").trim();
-  const reason = String(
-    blockingReason && blockingReason !== "none"
-      ? blockingReason
-      : refreshed?.next_allowed_action || "gate_not_ready",
-  ).trim();
-  io.log(pack.interaction.nonReadyDecision.replace("{reason}", reason));
-  return Object.freeze({ outcome: "non_ready", requested_decision: false, status: refreshed?.status || "blocked" });
-}
-
-function printGateCheckStatusCard(report, io) {
-  const card = report.status_card;
-  if (!report.status_presentation?.markdown) {
-    const failure = localePack(interactionLocales, card?.presentation_language || "en").interaction.statusPresentationFailure;
-    const codes = report.presentation_diagnostics?.status_presentation_errors ?? [];
-    io.log(codes.length ? `${failure} (${codes.join(", ")})` : failure);
-    return false;
-  }
-  io.log(report.status_presentation.markdown);
-  const primary = localePack(interactionLocales, card.presentation_language).primary;
-  const readiness = qualityReadinessForRunState(card.runState, report.next_allowed_action);
-  if (readiness) {
-    const quality = localePack(interactionLocales, card.presentation_language).qualityReadiness;
-    io.log("");
-    io.log(`${quality.title}: ${primary.status[readiness.status] ?? readiness.status}`);
-    for (const row of readiness.rows) {
-      io.log(`${quality.rows[row.id]}: ${primary.status[row.status] ?? quality.unknown}`);
-    }
-    const reason = readiness.decisive_reason
-      || (readiness.status === "pass" ? primary.none : quality.fallbackReasons[readiness.decisive_dimension] || primary.none);
-    io.log(`${quality.reason}: ${reason}`);
-    if (readiness.status !== "pass" && readiness.decisive_reference) io.log(`${quality.reference}: ${readiness.decisive_reference}`);
-    io.log(`${quality.nextAction}: ${readiness.next_action || primary.none}`);
-    io.log(`${quality.decisionOwner}: ${quality.decisionOwnerValue}`);
-  }
-  return true;
-}
-
-export function printGateCheckReport(report, json, statusCard = false, io = console) {
-  if (json) {
-    io.log(JSON.stringify(report, null, 2));
-    return true;
-  }
-
-  if (statusCard) {
-    return printGateCheckStatusCard(report, io);
-  }
-
-  io.log(`AGDF gate-check: ${report.status}`);
-  io.log(`Current gate: ${report.current_gate}`);
-  io.log(`Blocking reason: ${report.blocking_reason}`);
-  io.log(`Missing approval: ${report.missing_approval}`);
-  io.log(`Quality outlook: ${report.quality_outlook}`);
-  io.log(`Doctor: ${report.doctor_status} (${report.doctor_summary.findings} findings)`);
-  io.log("");
-  io.log("Allowed:");
-  for (const item of report.allowed) io.log(`- ${item}`);
-  io.log("");
-  io.log("Forbidden:");
-  for (const item of report.forbidden) io.log(`- ${item}`);
-  io.log("");
-  io.log(`Next allowed action: ${report.next_allowed_action}`);
-  return true;
-}

package/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-repository.js

@@ -1,68 +0,0 @@
-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/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-writer.js

@@ -1,97 +0,0 @@
-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) {
-  if (process.platform === "win32") return;
-  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);
-  }
-}