create-agdf 0.14.1 → 0.14.3

package/lib/delivery-path-search/search-engine.js

@@ -1,4 +1,4 @@
-import { CONTRACT_VERSION, SCORING_POLICY_VERSION, validateEvaluation, validateSearchInput } from "./contracts.js";
+import { CONTRACT_VERSION, SCORING_POLICY_VERSION, validateEvaluation, validateSearchInput, validateSearchResult } from "./contracts.js";
 import { candidateLegality, candidatesFromInput, generatedCandidatesFromResponse } from "./candidate-policy.js";
 import { scoreEvaluation } from "./scoring.js";
 import { generatorRequestFromInput } from "./state-adapter.js";
@@ -14,6 +14,30 @@ function generatorFailureCode(error) {
   return "generator_schema_invalid";
 }
 
+function evaluatorFailureCode(error) {
+  if (error?.code === "ENOENT") return "evaluator_unavailable";
+  if (/auth/i.test(error?.message ?? "")) return "evaluator_authentication_failed";
+  if (/unavailable|not found|not configured/i.test(error?.message ?? "")) return "evaluator_unavailable";
+  return "evaluator_output_invalid";
+}
+
+export function classifyTerminalOutcome({
+  inputUnavailable = false,
+  legalCandidates = 0,
+  evaluationAttempts = 0,
+  validEvaluations = 0,
+  invalidEvaluations = 0,
+  evaluatorUnavailable = false,
+  leader = null,
+}) {
+  if (inputUnavailable) return { status: "input_unavailable", outcome_phase: "input" };
+  if (legalCandidates === 0) return { status: "no_legal_candidates", outcome_phase: "candidate" };
+  if (validEvaluations === 0 && evaluatorUnavailable) return { status: "evaluator_unavailable", outcome_phase: "evaluation" };
+  if (validEvaluations === 0 && legalCandidates > 0) return { status: "evaluator_error", outcome_phase: "evaluation" };
+  if (leader) return { status: "recommendation", outcome_phase: "search" };
+  return { status: "no_safe_recommendation", outcome_phase: "search" };
+}
+
 export async function runDeliveryPathSearch(inputValue, evaluator, options = {}) {
   const input = validateSearchInput(inputValue);
   const startedAt = Date.now();
@@ -22,12 +46,18 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
   const rejected = [];
   const evaluated = [];
   let evaluations = 0;
+  let evaluationAttempts = 0;
+  let invalidEvaluations = 0;
+  let legalCandidates = 0;
+  let rejectedCandidates = 0;
+  let evaluatorUnavailable = false;
+  let evaluationFailureCode = null;
   let costUnits = 0;
   let lastLeaderId = null;
   let stableComparisons = 0;
   let stoppingReason = "candidate_queue_exhausted";
   const generation = {
-    status: input.generation?.enabled ? "failed" : "disabled",
+    status: input.generation?.enabled ? "not_run" : "disabled",
     adapter: options.generator?.metadata ?? null,
     budgets: input.generation ?? null,
     returned: 0,
@@ -38,7 +68,66 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
     failure_code: null,
   };
 
+  const finish = ({ leader = null, outcome, failureCode = null, recoveryAction = null }) => {
+    evaluated.sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+    const result = {
+      contract_version: CONTRACT_VERSION,
+      scoring_policy_version: SCORING_POLICY_VERSION,
+      scope_key: input.scope_key,
+      scope_revision: input.scope_revision ?? "unversioned",
+      objective: input.objective,
+      current_gate: input.current_gate,
+      outcome_phase: outcome.outcome_phase,
+      status: outcome.status,
+      recommendation: outcome.status === "recommendation" && leader ? {
+        candidate_id: leader.candidate.id,
+        action: leader.candidate.action,
+        score: leader.score,
+        rationale: leader.evaluation.rationale,
+        expected_evidence: leader.candidate.expected_evidence,
+        tests: leader.candidate.tests,
+        risks: leader.evaluation.risks,
+        assumptions: leader.evaluation.assumptions,
+      } : null,
+      alternatives: outcome.outcome_phase === "search" ? evaluated.slice(1).map((item) => ({
+        candidate_id: item.candidate.id,
+        action: item.candidate.action,
+        score: item.score,
+        rejection_reason: `ranked_below_${leader?.candidate.id ?? "search_policy"}`,
+      })) : [],
+      rejected,
+      provenance: {
+        baseline_candidates: baseline.length,
+        generated_candidates: generation.accepted,
+        legal_candidates: legalCandidates,
+        rejected_candidates: rejectedCandidates + generation.rejected.length,
+        evaluation_attempts: evaluationAttempts,
+        valid_evaluations: evaluations,
+        invalid_evaluations: invalidEvaluations,
+      },
+      enforcement: input.enforcement,
+      evaluator: evaluator?.metadata ?? { name: evaluator?.name ?? "unknown" },
+      generation,
+      budgets: { configured: input.budgets, evaluations, cost_units: costUnits, stable_comparisons: stableComparisons, duration_ms: Date.now() - startedAt },
+      stopping_reason: stoppingReason,
+      failure_code: failureCode,
+      next_action: recoveryAction ?? "Run canonical AGDF gate-check; search does not grant permission.",
+      next_gate_action: recoveryAction ?? "Run canonical AGDF gate-check; search does not grant permission.",
+    };
+    return validateSearchResult(result);
+  };
+
+  if (input.input_failure_code || input.allowed_actions.length === 0) {
+    stoppingReason = input.input_failure_code || "canonical_actions_unavailable";
+    return finish({
+      outcome: classifyTerminalOutcome({ inputUnavailable: true }),
+      failureCode: input.input_failure_code || "canonical_actions_unavailable",
+      recoveryAction: input.input_recovery_action || "Run canonical AGDF gate-check and repair the selected control state.",
+    });
+  }
+
   if (input.generation?.enabled) {
+    generation.status = "failed";
     if (!options.generator) {
       generation.failure_code = "generator_unavailable";
     } else {
@@ -75,17 +164,20 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
   }
 
   while (queue.length > 0) {
-    if (evaluations >= input.budgets.max_evaluations) { stoppingReason = "evaluation_budget_exhausted"; break; }
-    if (costUnits >= input.budgets.max_cost_units) { stoppingReason = "cost_budget_exhausted"; break; }
-    if (Date.now() - startedAt >= input.budgets.max_duration_ms) { stoppingReason = "duration_budget_exhausted"; break; }
     const candidate = queue.shift();
     const legality = candidateLegality(candidate, input);
     if (!legality.legal) {
+      rejectedCandidates += 1;
       rejected.push({ candidate_id: candidate.id, action: candidate.action, reason: legality.reason });
       continue;
     }
+    legalCandidates += 1;
+    if (evaluations >= input.budgets.max_evaluations) { stoppingReason = "evaluation_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
+    if (costUnits >= input.budgets.max_cost_units) { stoppingReason = "cost_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
+    if (Date.now() - startedAt >= input.budgets.max_duration_ms) { stoppingReason = "duration_budget_exhausted"; evaluationFailureCode = stoppingReason; break; }
 
     try {
+      evaluationAttempts += 1;
       const evaluation = validateEvaluation(await evaluator.evaluate(input, candidate), candidate.id);
       evaluations += 1;
       costUnits += evaluation.cost;
@@ -115,41 +207,39 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
       }
     } catch (error) {
       if (error?.fatalEvaluator === true) throw error;
+      invalidEvaluations += 1;
+      evaluationFailureCode = evaluatorFailureCode(error);
+      evaluatorUnavailable ||= evaluationFailureCode === "evaluator_unavailable" || evaluationFailureCode === "evaluator_authentication_failed";
       rejected.push({ candidate_id: candidate.id, action: candidate.action, reason: `invalid_evaluation: ${error.message}` });
+      if (evaluatorUnavailable) break;
     }
   }
 
   evaluated.sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
   const leader = evaluated[0];
-  if (!leader) stoppingReason = rejected.length ? "no_safe_candidate" : stoppingReason;
-  return {
-    contract_version: CONTRACT_VERSION,
-    scoring_policy_version: SCORING_POLICY_VERSION,
-    scope_key: input.scope_key,
-    current_gate: input.current_gate,
-    status: leader ? "recommendation" : "no_safe_recommendation",
-    recommendation: leader ? {
-      candidate_id: leader.candidate.id,
-      action: leader.candidate.action,
-      score: leader.score,
-      rationale: leader.evaluation.rationale,
-      expected_evidence: leader.candidate.expected_evidence,
-      tests: leader.candidate.tests,
-      risks: leader.evaluation.risks,
-      assumptions: leader.evaluation.assumptions,
-    } : null,
-    alternatives: evaluated.slice(1).map((item) => ({
-      candidate_id: item.candidate.id,
-      action: item.candidate.action,
-      score: item.score,
-      rejection_reason: `ranked_below_${leader?.candidate.id ?? "safety_threshold"}`,
-    })),
-    rejected,
-    enforcement: input.enforcement,
-    evaluator: evaluator.metadata ?? { name: evaluator.name ?? "unknown" },
-    generation,
-    budgets: { configured: input.budgets, evaluations, cost_units: costUnits, stable_comparisons: stableComparisons, duration_ms: Date.now() - startedAt },
-    stopping_reason: stoppingReason,
-    next_gate_action: "Run canonical AGDF gate-check; search does not grant permission.",
-  };
+  const outcome = classifyTerminalOutcome({
+    legalCandidates,
+    evaluationAttempts,
+    validEvaluations: evaluations,
+    invalidEvaluations,
+    evaluatorUnavailable,
+    leader,
+  });
+  if (!leader) {
+    stoppingReason = outcome.status === "no_legal_candidates"
+      ? "no_legal_candidates"
+      : outcome.status === "evaluator_unavailable"
+        ? "evaluator_unavailable"
+        : outcome.status === "evaluator_error"
+          ? "evaluator_error"
+          : stoppingReason;
+  }
+  return finish({
+    leader,
+    outcome,
+    failureCode: outcome.outcome_phase === "evaluation" ? evaluationFailureCode : null,
+    recoveryAction: outcome.outcome_phase === "evaluation"
+      ? "Repair the declared evaluator capability and retry from a fresh canonical control snapshot."
+      : null,
+  });
 }

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

@@ -1,11 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import {
   CONTRACT_VERSION,
   GENERATOR_CONTRACT_VERSION,
   validateGeneratorRequest,
 } from "./contracts.js";
-import { resolveRuns, verifyLegacyProjection } from "../control-state/index.js";
+import { evaluateGateCheck } from "../control-evaluation/gate-check.js";
+import { readRunState } from "../control-evaluation/run-state.js";
 
 function section(content, heading) {
   return (
@@ -15,100 +14,44 @@ function section(content, heading) {
   );
 }
 
-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];
-  }
-  return answers;
-}
-
-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];
-  }
-  return card;
+function metaField(content, name) {
+  return content.match(new RegExp(`^- ${name}:\\s*(.+)$`, "m"))?.[1]
+    ?.replace(/^`|`$/g, "")
+    .trim() ?? "";
 }
 
-function listCell(value) {
-  return String(value ?? "")
-    .split(/\s*;\s*/)
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-export function searchInputFromControl(targetDir, options = {}) {
-  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}`);
-    }
+export function searchInputFromControl(targetDir, options = {}, dependencies = {}) {
+  const evaluate = dependencies.evaluateGateCheck ?? evaluateGateCheck;
+  const readRun = dependencies.readRunState ?? readRunState;
+  const selection = options.scopeKey ? { runId: options.scopeKey } : {};
+  const gate = evaluate(targetDir, selection);
+  const run = readRun(targetDir, selection);
+  const content = run.content ?? "";
+  const evaluatedRunId = gate.status_card?.run_id ?? "";
+  const evaluatedRevision = gate.status_presentation?.revision_id ?? "";
+  const runId = metaField(content, "run_id");
+  const runRevision = metaField(content, "revision_id");
+  const runGate = metaField(content, "current_gate");
+  let inputFailureCode = "";
+  if (!content || run.resolution_error) inputFailureCode = "canonical_control_unavailable";
+  else if (!evaluatedRunId || !evaluatedRevision) inputFailureCode = "canonical_snapshot_identity_missing";
+  else if (evaluatedRunId !== runId || evaluatedRevision !== runRevision || gate.current_gate !== runGate) {
+    inputFailureCode = "stale_control_snapshot";
+  } else if (!Array.isArray(gate.allowed) || gate.allowed.length === 0) {
+    inputFailureCode = "canonical_actions_unavailable";
   }
-  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 answers = tableAnswers(content);
-  const card = statusCard(content);
   const result = {
     contract_version: CONTRACT_VERSION,
-    scope_key: options.scopeKey ?? meta.run_id ?? "unknown-scope",
-    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()),
+    scope_key: evaluatedRunId || runId || options.scopeKey || "unknown-scope",
+    scope_revision: evaluatedRevision || runRevision || "unversioned",
+    objective: section(content, "Objective").trim() || "Canonical Delivery Path Search input unavailable",
+    current_gate: gate.current_gate || runGate || "unknown",
+    allowed_actions: inputFailureCode ? [] : [...gate.allowed],
+    forbidden_actions: Array.isArray(gate.forbidden) ? [...gate.forbidden] : [],
+    evidence_refs: Array.isArray(gate.evidence_refs)
+      ? gate.evidence_refs.map((item) => `${item.evidence}: ${item.source}`)
+      : [],
+    risks: Array.isArray(run.risks) ? run.risks.map((item) => item.risk).filter(Boolean) : [],
     enforcement: options.enforcement ?? {
       level: "instruction_only",
       evidence: ["surface instruction prohibits implementation during search"],
@@ -122,6 +65,11 @@ export function searchInputFromControl(targetDir, options = {}) {
       stability_window: options.stabilityWindow ?? 3,
     },
   };
+  if (inputFailureCode) {
+    result.input_failure_code = inputFailureCode;
+    result.input_failure_detail = run.resolution_error || (gate.blocking_reason !== "none" ? gate.blocking_reason : "") || "canonical input is not ready";
+    result.input_recovery_action = gate.next_allowed_action || "Run canonical AGDF gate-check and repair the selected control state.";
+  }
   if (options.generation?.enabled)
     result.generation = {
       enabled: true,