create-agdf 0.4.9 → 0.5.0

package/README.md

@@ -155,17 +155,18 @@ Use `delivery-path-search` only for high-impact planning decisions with several
 npx --yes @agdf/cli@latest delivery-path-search --surface codex --json
 ```
 
-The first release uses bounded best-first Delivery Path Search, not MCTS. It is read-only and advisory: the result must be checked by canonical `gate-check`. Codex is the executable reference adapter; Claude Code, Copilot and OpenCode reuse the same skill and contracts while declaring whether enforcement is full, tool-enforced or instruction-only.
+The runtime uses bounded best-first Delivery Path Search, not MCTS. It is read-only and advisory: the result must be checked by canonical `gate-check`. Codex and Claude Code are executable, tool-enforced evaluator adapters and support opt-in `--generate-candidates`; generated proposals supplement the deterministic baseline and are deterministically validated before evaluation. Copilot and OpenCode reuse the same skill and contracts as instruction-only surfaces until conforming executable adapters are available.
 
 Requirements and boundaries:
 
 - run it only in a repository with live `.agdf/control/AGDF_RUN.md` state
 - the current control state must expose legal next actions
 - Codex CLI must be installed and authenticated for `--surface codex`
-- `--model <id>` optionally selects the Codex evaluator model
+- Claude Code CLI must be installed and authenticated for `--surface claude`
+- `--model <id>` optionally selects the Codex or Claude evaluator model
 - `--persist` writes redacted `DELIVERY_PATH_SEARCH.json` and `.md` evidence under the current scope
 - `--fixture <path>` is for deterministic contract tests, not a production evaluator
-- Claude Code, Copilot and OpenCode have shared workflow mappings but no executable native evaluator in this release
+- Copilot and OpenCode have shared workflow mappings but no executable native evaluator in this release
 - cost units are rubric values used for bounded comparison, not measured provider currency
 
 The result is either one recommendation or `no_safe_recommendation`. In both cases run canonical `gate-check` afterwards.

package/bin/create-agdf.js

@@ -11,6 +11,9 @@ import { runDeliveryPathSearch } from "../lib/delivery-path-search/search-engine
 import { codexEvaluator } from "../lib/delivery-path-search/evaluators/codex.js";
 import { claudeEvaluator } from "../lib/delivery-path-search/evaluators/claude.js";
 import { fixtureEvaluator } from "../lib/delivery-path-search/evaluators/protocol.js";
+import { codexGenerator } from "../lib/delivery-path-search/generators/codex.js";
+import { claudeGenerator } from "../lib/delivery-path-search/generators/claude.js";
+import { fixtureGenerator } from "../lib/delivery-path-search/generators/protocol.js";
 import { enforcementForSurface } from "../lib/delivery-path-search/surfaces/capabilities.js";
 import { persistSearchResult } from "../lib/delivery-path-search/persistence.js";
 
@@ -213,6 +216,13 @@ Options:
                  Use deterministic evaluator/candidate fixtures instead of a live evaluator
   --persist      Persist the redacted Delivery Path Search result under the current scope
   --model <id>   Optional Codex evaluator model
+  --generate-candidates
+                 Add one bounded AI-native candidate-generation call before evaluation
+  --generator-model <id>
+                 Optional candidate-generator model override
+  --max-generated-candidates <1-5>
+  --generation-timeout-ms <1-30000>
+  --generation-cost-units <1-5>
   --help         Show this help
 `);
 }
@@ -281,6 +291,11 @@ function parseArgs(argv) {
   let fixture;
   let persist = false;
   let model;
+  let generateCandidates = false;
+  let generatorModel;
+  let maxGeneratedCandidates = 5;
+  let generationTimeoutMs = 30000;
+  let generationCostUnits = 5;
 
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
@@ -311,7 +326,12 @@ function parseArgs(argv) {
       continue;
     }
 
-    if (["--surface", "--fixture", "--model"].includes(arg)) {
+    if (arg === "--generate-candidates") {
+      generateCandidates = true;
+      continue;
+    }
+
+    if (["--surface", "--fixture", "--model", "--generator-model", "--max-generated-candidates", "--generation-timeout-ms", "--generation-cost-units"].includes(arg)) {
       const next = args[i + 1];
       if (!next) {
         console.error(`Missing value for ${arg}`);
@@ -324,7 +344,19 @@ function parseArgs(argv) {
         }
         surface = next;
       } else if (arg === "--fixture") fixture = next;
-      else model = next;
+      else if (arg === "--model") model = next;
+      else if (arg === "--generator-model") generatorModel = next;
+      else {
+        const value = Number(next);
+        const maximum = arg === "--generation-timeout-ms" ? 30000 : 5;
+        if (!Number.isInteger(value) || value < 1 || value > maximum) {
+          console.error(`${arg} must be an integer from 1 to ${maximum}.`);
+          process.exit(1);
+        }
+        if (arg === "--max-generated-candidates") maxGeneratedCandidates = value;
+        else if (arg === "--generation-timeout-ms") generationTimeoutMs = value;
+        else generationCostUnits = value;
+      }
       i += 1;
       continue;
     }
@@ -395,6 +427,11 @@ function parseArgs(argv) {
     fixture: fixture ? resolve(process.cwd(), fixture) : null,
     persist,
     model,
+    generateCandidates,
+    generatorModel,
+    maxGeneratedCandidates,
+    generationTimeoutMs,
+    generationCostUnits,
   };
 }
 
@@ -2198,7 +2235,27 @@ function printDeliveryMapReport(report, json) {
 async function executeDeliveryPathSearch(options) {
   const fixture = options.fixture ? JSON.parse(readFileSync(options.fixture, "utf8")) : null;
   const enforcement = fixture?.input?.enforcement ?? enforcementForSurface(options.surface);
-  const input = fixture?.input ?? searchInputFromControl(options.dir, { enforcement });
+  const fixtureGeneration = fixture?.generator_response;
+  const generationEnabled = Boolean(fixtureGeneration || options.generateCandidates);
+  const baseInput = fixture?.input ?? searchInputFromControl(options.dir, {
+    enforcement,
+    generation: generationEnabled ? {
+      enabled: true,
+      maxProposals: options.maxGeneratedCandidates,
+      maxDurationMs: options.generationTimeoutMs,
+      maxCostUnits: options.generationCostUnits,
+    } : undefined,
+  });
+  const input = generationEnabled && !baseInput.generation ? {
+    ...baseInput,
+    generation: {
+      enabled: true,
+      max_calls: 1,
+      max_proposals: options.maxGeneratedCandidates,
+      max_duration_ms: options.generationTimeoutMs,
+      max_cost_units: options.generationCostUnits,
+    },
+  } : baseInput;
   const evaluator = fixture
     ? fixtureEvaluator(fixture.evaluations ?? {})
     : options.surface === "codex"
@@ -2209,7 +2266,17 @@ async function executeDeliveryPathSearch(options) {
   if (!evaluator) {
     throw new Error(`${options.surface} has no executable evaluator in this release. Codex and Claude are the reference adapters; --fixture is available for deterministic contract testing.`);
   }
-  const result = await runDeliveryPathSearch(input, evaluator, { candidates: fixture?.candidates });
+  const generator = fixtureGeneration
+    ? fixtureGenerator(fixtureGeneration)
+    : options.generateCandidates && options.surface === "codex"
+      ? codexGenerator({ cwd: options.dir, model: options.generatorModel, timeoutMs: options.generationTimeoutMs })
+      : options.generateCandidates && options.surface === "claude"
+        ? claudeGenerator({ cwd: options.dir, model: options.generatorModel, timeoutMs: options.generationTimeoutMs })
+        : null;
+  if (options.generateCandidates && !generator) {
+    throw new Error(`${options.surface} has no executable candidate generator; Codex and Claude are tool-enforced reference transports.`);
+  }
+  const result = await runDeliveryPathSearch(input, evaluator, { candidates: fixture?.candidates, generator });
   if (options.persist) result.persistence = persistSearchResult(options.dir, result);
   if (options.json) {
     console.log(JSON.stringify(result, null, 2));
@@ -2220,6 +2287,9 @@ async function executeDeliveryPathSearch(options) {
   console.log(`Enforcement: ${result.enforcement.level}`);
   console.log(`Recommendation: ${result.recommendation?.action ?? "none"}`);
   console.log(`Evaluations: ${result.budgets.evaluations}`);
+  console.log(`Generation: ${result.generation.status} (${result.generation.accepted}/${result.generation.returned} accepted)`);
+  console.log(`Generation budget: ${result.generation.cost_units} cost units, ${result.generation.duration_ms} ms`);
+  if (result.generation.failure_code) console.log(`Generation failure: ${result.generation.failure_code}`);
   console.log(`Stopping reason: ${result.stopping_reason}`);
   console.log(result.next_gate_action);
   return result;

package/generated/.github/skills/agdf-delivery-path-search/SKILL.md

@@ -37,6 +37,17 @@ Skip for routine questions, obvious local fixes and approved implementation with
 npx --yes @agdf/cli@latest delivery-path-search --surface <surface> --json
 ```
 
+Optional AI-native candidate generation is explicit:
+
+```bash
+npx --yes @agdf/cli@latest delivery-path-search \
+  --surface codex \
+  --generate-candidates \
+  --json
+```
+
+It supplements the deterministic baseline with at most one bounded generator call. Treat proposals as untrusted until the canonical core validates schema, gate action, scope, duplicates and material diversity. Report generation provenance, budgets, rejections and failure. Never hide deterministic fallback or switch providers automatically.
+
 5. Treat facts, repository evidence, assumptions and model judgements separately.
 6. Return exactly one recommendation or `no_safe_recommendation`.
 7. Run canonical AGDF gate-check after search. Never translate a recommendation into permission.
@@ -73,3 +84,6 @@ Persist only the redacted decision summary when durable evidence is required. Do
 - Do not invent default scores for invalid evaluator output.
 - Do not implement, approve or release based on search output.
 - Do not create agent-specific scoring, gate logic or skill copies.
+- Do not replace deterministic candidates with generated proposals.
+- Do not send secrets, full artefacts, source snapshots, raw prompts or hidden reasoning to a generator.
+- Do not claim executable generation for instruction-only surfaces.

package/generated/.github/skills/agdf-runtime-contract.md

@@ -91,6 +91,12 @@ Delivery Path Search is an optional read-only planning step for high-impact deci
 - Search output is evidence only. Canonical `agdf-gate-check` independently decides what may proceed.
 - The bounded first-release algorithm must not be labelled MCTS.
 - Surface adapters may translate transport and presentation, but must not fork scoring, search or gate semantics.
+- Optional AI-native candidate generation supplements the deterministic candidate baseline; it never replaces it.
+- Generated proposals are untrusted. The core must validate schema, exact canonical gate action, scope, duplicates and material diversity before evaluation.
+- Generation is opt-in and bounded to one call, five proposals, 30 seconds and five abstract cost units by default, within whole-run budgets.
+- External generation receives only bounded normalized control summaries and references, never secrets, full artefacts, raw prompts, hidden reasoning or source snapshots.
+- Generator status, provenance, accepted/rejected counts, separate budget use and typed failure must remain visible. Failure retains the deterministic baseline; automatic provider fallback is forbidden.
+- Codex and Claude Code may provide tool-enforced generator transports. Copilot, OpenCode and generic surfaces remain instruction-only without conforming evidence.
 
 The field names above are the stable machine-readable contract used by JSON
 reports and automation. Human-facing Markdown must present the same projection

package/generated/.opencode/agdf-runtime-contract.md

@@ -91,6 +91,12 @@ Delivery Path Search is an optional read-only planning step for high-impact deci
 - Search output is evidence only. Canonical `agdf-gate-check` independently decides what may proceed.
 - The bounded first-release algorithm must not be labelled MCTS.
 - Surface adapters may translate transport and presentation, but must not fork scoring, search or gate semantics.
+- Optional AI-native candidate generation supplements the deterministic candidate baseline; it never replaces it.
+- Generated proposals are untrusted. The core must validate schema, exact canonical gate action, scope, duplicates and material diversity before evaluation.
+- Generation is opt-in and bounded to one call, five proposals, 30 seconds and five abstract cost units by default, within whole-run budgets.
+- External generation receives only bounded normalized control summaries and references, never secrets, full artefacts, raw prompts, hidden reasoning or source snapshots.
+- Generator status, provenance, accepted/rejected counts, separate budget use and typed failure must remain visible. Failure retains the deterministic baseline; automatic provider fallback is forbidden.
+- Codex and Claude Code may provide tool-enforced generator transports. Copilot, OpenCode and generic surfaces remain instruction-only without conforming evidence.
 
 The field names above are the stable machine-readable contract used by JSON
 reports and automation. Human-facing Markdown must present the same projection

package/generated/.opencode/agents/agdf-delivery-path-search.md

@@ -37,6 +37,17 @@ Skip for routine questions, obvious local fixes and approved implementation with
 npx --yes @agdf/cli@latest delivery-path-search --surface <surface> --json
 ```
 
+Optional AI-native candidate generation is explicit:
+
+```bash
+npx --yes @agdf/cli@latest delivery-path-search \
+  --surface codex \
+  --generate-candidates \
+  --json
+```
+
+It supplements the deterministic baseline with at most one bounded generator call. Treat proposals as untrusted until the canonical core validates schema, gate action, scope, duplicates and material diversity. Report generation provenance, budgets, rejections and failure. Never hide deterministic fallback or switch providers automatically.
+
 5. Treat facts, repository evidence, assumptions and model judgements separately.
 6. Return exactly one recommendation or `no_safe_recommendation`.
 7. Run canonical AGDF gate-check after search. Never translate a recommendation into permission.
@@ -73,4 +84,7 @@ Persist only the redacted decision summary when durable evidence is required. Do
 - Do not invent default scores for invalid evaluator output.
 - Do not implement, approve or release based on search output.
 - Do not create agent-specific scoring, gate logic or skill copies.
+- Do not replace deterministic candidates with generated proposals.
+- Do not send secrets, full artefacts, source snapshots, raw prompts or hidden reasoning to a generator.
+- Do not claim executable generation for instruction-only surfaces.
 

package/generated/plugins/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Codex-first operating system for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Codex-first operating system for governed AI-assisted delivery.",

package/generated/plugins/agdf/meta/agdf-runtime-contract.md

@@ -91,6 +91,12 @@ Delivery Path Search is an optional read-only planning step for high-impact deci
 - Search output is evidence only. Canonical `gate-check` independently decides what may proceed.
 - The bounded first-release algorithm must not be labelled MCTS.
 - Surface adapters may translate transport and presentation, but must not fork scoring, search or gate semantics.
+- Optional AI-native candidate generation supplements the deterministic candidate baseline; it never replaces it.
+- Generated proposals are untrusted. The core must validate schema, exact canonical gate action, scope, duplicates and material diversity before evaluation.
+- Generation is opt-in and bounded to one call, five proposals, 30 seconds and five abstract cost units by default, within whole-run budgets.
+- External generation receives only bounded normalized control summaries and references, never secrets, full artefacts, raw prompts, hidden reasoning or source snapshots.
+- Generator status, provenance, accepted/rejected counts, separate budget use and typed failure must remain visible. Failure retains the deterministic baseline; automatic provider fallback is forbidden.
+- Codex and Claude Code may provide tool-enforced generator transports. Copilot, OpenCode and generic surfaces remain instruction-only without conforming evidence.
 
 The field names above are the stable machine-readable contract used by JSON
 reports and automation. Human-facing Markdown must present the same projection

package/generated/plugins/agdf/skills/delivery-path-search/SKILL.md

@@ -37,6 +37,17 @@ Skip for routine questions, obvious local fixes and approved implementation with
 npx --yes @agdf/cli@latest delivery-path-search --surface <surface> --json
 ```
 
+Optional AI-native candidate generation is explicit:
+
+```bash
+npx --yes @agdf/cli@latest delivery-path-search \
+  --surface codex \
+  --generate-candidates \
+  --json
+```
+
+It supplements the deterministic baseline with at most one bounded generator call. Treat proposals as untrusted until the canonical core validates schema, gate action, scope, duplicates and material diversity. Report generation provenance, budgets, rejections and failure. Never hide deterministic fallback or switch providers automatically.
+
 5. Treat facts, repository evidence, assumptions and model judgements separately.
 6. Return exactly one recommendation or `no_safe_recommendation`.
 7. Run canonical AGDF gate-check after search. Never translate a recommendation into permission.
@@ -73,3 +84,6 @@ Persist only the redacted decision summary when durable evidence is required. Do
 - Do not invent default scores for invalid evaluator output.
 - Do not implement, approve or release based on search output.
 - Do not create agent-specific scoring, gate logic or skill copies.
+- Do not replace deterministic candidates with generated proposals.
+- Do not send secrets, full artefacts, source snapshots, raw prompts or hidden reasoning to a generator.
+- Do not claim executable generation for instruction-only surfaces.

package/lib/delivery-path-search/candidate-policy.js

@@ -1,12 +1,37 @@
 import { validateCandidate } from "./contracts.js";
 
 function normalized(value) {
-  return String(value).toLowerCase().replace(/[`*_]/g, "").replace(/\s+/g, " ").trim();
+  return String(value).normalize("NFKC").toLowerCase().replace(/[`*_]/g, "").replace(/[^\p{L}\p{N}\s-]/gu, " ").replace(/\s+/g, " ").trim();
+}
+
+const STOP_WORDS = new Set(["a", "an", "and", "der", "die", "das", "ein", "eine", "the", "to", "und", "zu"]);
+
+function tokens(value) {
+  return new Set(normalized(value).split(/\s+/).filter((item) => item && !STOP_WORDS.has(item)));
+}
+
+function jaccard(left, right) {
+  const union = new Set([...left, ...right]);
+  if (!union.size) return 1;
+  let intersection = 0;
+  for (const item of left) if (right.has(item)) intersection += 1;
+  return intersection / union.size;
+}
+
+function signature(candidate) {
+  return JSON.stringify({
+    gate_action: normalized(candidate.gate_action ?? candidate.action),
+    affected_boundaries: [...(candidate.affected_boundaries ?? [])].map(normalized).sort(),
+    evidence: [...(candidate.expected_evidence ?? [])].map(normalized).sort(),
+    tests: [...(candidate.tests ?? [])].map(normalized).sort(),
+    risk_strategy: normalized(candidate.risk_strategy ?? ""),
+    reversibility: normalized(candidate.reversibility ?? ""),
+  });
 }
 
 export function candidateLegality(candidateValue, input) {
   const candidate = validateCandidate(candidateValue);
-  const action = normalized(candidate.action);
+  const action = normalized(candidate.gate_action ?? candidate.action);
   const forbiddenMatch = input.forbidden_actions.find((item) => {
     const forbidden = normalized(item);
     return forbidden && action === forbidden;
@@ -32,3 +57,43 @@ export function candidatesFromInput(input) {
     parent_id: null,
   }));
 }
+
+export function generatedCandidatesFromResponse(response, input, existingCandidates = []) {
+  const accepted = [];
+  const rejected = [];
+  for (const proposal of response.proposals) {
+    const candidate = {
+      id: `generated-${proposal.proposal_id}`,
+      action: proposal.intent,
+      source: "generated",
+      gate_action: proposal.gate_action,
+      intent: proposal.intent,
+      expected_evidence: proposal.expected_evidence,
+      tests: proposal.tests,
+      assumptions: proposal.assumptions,
+      affected_boundaries: proposal.affected_boundaries,
+      risk_strategy: proposal.risk_strategy,
+      reversibility: proposal.reversibility,
+      generator_proposal_id: proposal.proposal_id,
+      depth: 0,
+      parent_id: null,
+    };
+    const legality = candidateLegality(candidate, input);
+    if (!legality.legal) {
+      rejected.push({ proposal_id: proposal.proposal_id, reason: legality.reason });
+      continue;
+    }
+    const peers = [...existingCandidates, ...accepted].filter((item) => normalized(item.gate_action ?? item.action) === normalized(candidate.gate_action));
+    const duplicate = peers.find((item) => {
+      const same = normalized(item.intent ?? item.action) === normalized(candidate.intent);
+      const sameDecision = signature(item) === signature(candidate);
+      return same || sameDecision || jaccard(tokens(item.intent ?? item.action), tokens(candidate.intent)) >= 0.8;
+    });
+    if (duplicate) {
+      rejected.push({ proposal_id: proposal.proposal_id, reason: "cosmetic_or_material_duplicate" });
+      continue;
+    }
+    accepted.push(candidate);
+  }
+  return { accepted, rejected };
+}

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

@@ -1,4 +1,5 @@
 export const CONTRACT_VERSION = "1";
+export const GENERATOR_CONTRACT_VERSION = "1";
 export const SCORING_POLICY_VERSION = "1";
 export const SCORE_DIMENSIONS = [
   "scope_fit",
@@ -25,6 +26,39 @@ function stringArray(value, label) {
   return value.map((item) => item.trim()).filter(Boolean);
 }
 
+function optionalBoundedString(value, label, maxLength = 1000) {
+  if (value === undefined) return undefined;
+  const result = requireString(value, label);
+  if (result.length > maxLength) throw new Error(`${label} must be at most ${maxLength} characters`);
+  return result;
+}
+
+function rejectUnknownKeys(value, allowed, label) {
+  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unknown.length) throw new Error(`${label} contains unknown fields: ${unknown.join(", ")}`);
+}
+
+function generationConfig(value, wholeRunBudgets) {
+  if (value === undefined) return undefined;
+  const generation = requireObject(value, "generation");
+  if (typeof generation.enabled !== "boolean") throw new Error("generation.enabled must be a boolean");
+  const limits = {
+    max_calls: 1,
+    max_proposals: 5,
+    max_duration_ms: 30000,
+    max_cost_units: 5,
+  };
+  for (const [key, maximum] of Object.entries(limits)) {
+    if (!Number.isInteger(generation[key]) || generation[key] < 1 || generation[key] > maximum) {
+      throw new Error(`generation.${key} must be an integer from 1 to ${maximum}`);
+    }
+  }
+  if (generation.max_calls !== 1) throw new Error("generation.max_calls must equal 1 in this contract version");
+  if (generation.max_duration_ms > wholeRunBudgets.max_duration_ms) throw new Error("generation.max_duration_ms cannot exceed budgets.max_duration_ms");
+  if (generation.max_cost_units > wholeRunBudgets.max_cost_units) throw new Error("generation.max_cost_units cannot exceed budgets.max_cost_units");
+  return structuredClone(generation);
+}
+
 export function validateSearchInput(value) {
   const input = requireObject(value, "search input");
   if (input.contract_version !== CONTRACT_VERSION) throw new Error(`unsupported search input contract_version: ${input.contract_version}`);
@@ -43,6 +77,7 @@ export function validateSearchInput(value) {
   for (const key of ["max_candidates", "max_depth", "max_evaluations", "max_duration_ms", "max_cost_units", "stability_window"]) {
     if (!Number.isInteger(budgets[key]) || budgets[key] < 1) throw new Error(`budgets.${key} must be a positive integer`);
   }
+  generationConfig(input.generation, budgets);
   return structuredClone(input);
 }
 
@@ -53,9 +88,101 @@ export function validateCandidate(value) {
   stringArray(candidate.expected_evidence ?? [], "candidate.expected_evidence");
   stringArray(candidate.tests ?? [], "candidate.tests");
   stringArray(candidate.assumptions ?? [], "candidate.assumptions");
+  if (candidate.source !== undefined && !["deterministic", "generated", "expanded"].includes(candidate.source)) {
+    throw new Error("candidate.source must be deterministic, generated or expanded");
+  }
+  optionalBoundedString(candidate.gate_action, "candidate.gate_action");
+  optionalBoundedString(candidate.intent, "candidate.intent");
+  stringArray(candidate.affected_boundaries ?? [], "candidate.affected_boundaries");
+  optionalBoundedString(candidate.risk_strategy, "candidate.risk_strategy");
+  optionalBoundedString(candidate.reversibility, "candidate.reversibility");
+  optionalBoundedString(candidate.generator_proposal_id, "candidate.generator_proposal_id", 200);
   return structuredClone(candidate);
 }
 
+export function validateGeneratorRequest(value) {
+  const request = requireObject(value, "generator request");
+  rejectUnknownKeys(request, ["contract_version", "scope_key", "objective", "scope_summary", "current_gate", "allowed_actions", "forbidden_actions", "artefact_refs", "evidence", "missing_evidence", "risks", "constraints", "enforcement", "budgets"], "generator request");
+  if (request.contract_version !== GENERATOR_CONTRACT_VERSION) throw new Error(`unsupported generator contract_version: ${request.contract_version}`);
+  requireString(request.scope_key, "generator scope_key");
+  optionalBoundedString(request.objective, "generator objective", 2000);
+  optionalBoundedString(request.scope_summary, "generator scope_summary", 2000);
+  requireString(request.current_gate, "generator current_gate");
+  for (const key of ["allowed_actions", "forbidden_actions", "artefact_refs", "evidence", "missing_evidence", "risks", "constraints"]) {
+    const items = stringArray(request[key] ?? [], `generator ${key}`);
+    if (items.length > 20 || items.some((item) => item.length > 500)) throw new Error(`generator ${key} exceeds context bounds`);
+  }
+  validateEnforcement(request.enforcement);
+  const budgets = requireObject(request.budgets, "generator budgets");
+  generationConfig({ enabled: true, ...budgets }, { max_duration_ms: 120000, max_cost_units: 20 });
+  const serialized = JSON.stringify(request);
+  if (/(secret|credential|environment|raw_prompt|hidden_reasoning|source_snapshot)/i.test(serialized)) {
+    throw new Error("generator request contains disallowed context");
+  }
+  return structuredClone(request);
+}
+
+export function validateGeneratorResponse(value) {
+  const response = requireObject(value, "generator response");
+  rejectUnknownKeys(response, ["contract_version", "proposals", "cost_units", "metadata"], "generator response");
+  if (response.contract_version !== GENERATOR_CONTRACT_VERSION) throw new Error(`unsupported generator contract_version: ${response.contract_version}`);
+  if (!Array.isArray(response.proposals) || response.proposals.length > 5) throw new Error("generator proposals must be an array with at most 5 items");
+  if (!Number.isInteger(response.cost_units) || response.cost_units < 0 || response.cost_units > 5) throw new Error("generator cost_units must be an integer from 0 to 5");
+  if (response.metadata !== undefined) {
+    const metadata = requireObject(response.metadata, "generator metadata");
+    rejectUnknownKeys(metadata, ["name", "runtime", "model"], "generator metadata");
+    for (const [key, item] of Object.entries(metadata)) optionalBoundedString(item, `generator metadata.${key}`, 500);
+  }
+  const proposals = response.proposals.map((proposal, index) => {
+    const item = requireObject(proposal, `proposal ${index}`);
+    rejectUnknownKeys(item, ["proposal_id", "gate_action", "intent", "expected_evidence", "tests", "assumptions", "affected_boundaries", "risk_strategy", "reversibility"], `proposal ${index}`);
+    const normalized = {
+      proposal_id: requireString(item.proposal_id, `proposal ${index}.proposal_id`),
+      gate_action: requireString(item.gate_action, `proposal ${index}.gate_action`),
+      intent: requireString(item.intent, `proposal ${index}.intent`),
+      expected_evidence: stringArray(item.expected_evidence ?? [], `proposal ${index}.expected_evidence`),
+      tests: stringArray(item.tests ?? [], `proposal ${index}.tests`),
+      assumptions: stringArray(item.assumptions ?? [], `proposal ${index}.assumptions`),
+      affected_boundaries: stringArray(item.affected_boundaries ?? [], `proposal ${index}.affected_boundaries`),
+      risk_strategy: requireString(item.risk_strategy, `proposal ${index}.risk_strategy`),
+      reversibility: requireString(item.reversibility, `proposal ${index}.reversibility`),
+    };
+    if (JSON.stringify(normalized).length > 5000) throw new Error(`proposal ${index} exceeds size limit`);
+    if (/(^|\s)(rm|sudo|curl|wget|bash|sh|exec)\s/i.test(normalized.intent)) throw new Error(`proposal ${index} contains executable instructions`);
+    return normalized;
+  });
+  return {
+    contract_version: response.contract_version,
+    proposals,
+    cost_units: response.cost_units,
+    metadata: response.metadata ? structuredClone(response.metadata) : {},
+  };
+}
+
+export function generatorOutputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["contract_version", "proposals", "cost_units"],
+    properties: {
+      contract_version: { type: "string", const: GENERATOR_CONTRACT_VERSION },
+      cost_units: { type: "integer", minimum: 0, maximum: 5 },
+      proposals: {
+        type: "array", maxItems: 5, items: {
+          type: "object", additionalProperties: false,
+          required: ["proposal_id", "gate_action", "intent", "expected_evidence", "tests", "assumptions", "affected_boundaries", "risk_strategy", "reversibility"],
+          properties: {
+            proposal_id: { type: "string", minLength: 1 }, gate_action: { type: "string", minLength: 1 }, intent: { type: "string", minLength: 1 },
+            expected_evidence: { type: "array", items: { type: "string" } }, tests: { type: "array", items: { type: "string" } },
+            assumptions: { type: "array", items: { type: "string" } }, affected_boundaries: { type: "array", items: { type: "string" } },
+            risk_strategy: { type: "string", minLength: 1 }, reversibility: { type: "string", minLength: 1 },
+          },
+        },
+      },
+    },
+  };
+}
+
 export function validateEvaluation(value, candidateId) {
   const evaluation = requireObject(value, "evaluation");
   if (evaluation.contract_version !== CONTRACT_VERSION) throw new Error(`unsupported evaluator contract_version: ${evaluation.contract_version}`);

package/lib/delivery-path-search/evaluators/claude.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { evaluatorOutputSchema, validateEvaluation } from "../contracts.js";
+import { guardedExecFileSync } from "../transports/read-only-guard.js";
 
 export function claudeEvaluator(options = {}) {
   const claudeBin = options.claudeBin ?? "claude";
@@ -8,18 +9,6 @@ export function claudeEvaluator(options = {}) {
     runtime = execFileSync(claudeBin, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {}
 
-  function gitState() {
-    try {
-      return execFileSync("git", ["status", "--porcelain=v1", "-z"], {
-        cwd: options.cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-    } catch {
-      return null;
-    }
-  }
-
   return {
     name: "claude",
     metadata: { name: "claude", runtime, model: options.model ?? "configured-default" },
@@ -41,15 +30,12 @@ export function claudeEvaluator(options = {}) {
       ];
       if (options.model) args.push("--model", options.model);
       args.push(prompt);
-      const before = gitState();
-      const raw = execFileSync(claudeBin, args, {
+      const raw = guardedExecFileSync(claudeBin, args, {
         cwd: options.cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],
         timeout: options.timeoutMs ?? 120000,
       });
-      const after = gitState();
-      if (before !== null && after !== before) throw new Error("repository mutation detected during read-only evaluator run");
       const response = JSON.parse(raw);
       if (response.is_error) throw new Error(`claude evaluator returned an error: ${response.result ?? "unknown error"}`);
       return validateEvaluation(JSON.parse(response.result), candidate.id);

package/lib/delivery-path-search/evaluators/codex.js

@@ -3,6 +3,7 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { evaluatorOutputSchema, validateEvaluation } from "../contracts.js";
+import { guardedExecFileSync } from "../transports/read-only-guard.js";
 
 export function codexEvaluator(options = {}) {
   const codexBin = options.codexBin ?? "codex";
@@ -11,18 +12,6 @@ export function codexEvaluator(options = {}) {
     runtime = execFileSync(codexBin, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {}
 
-  function gitState() {
-    try {
-      return execFileSync("git", ["status", "--porcelain=v1", "-z"], {
-        cwd: options.cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-    } catch {
-      return null;
-    }
-  }
-
   return {
     name: "codex",
     metadata: { name: "codex", runtime, model: options.model ?? "configured-default" },
@@ -49,15 +38,12 @@ export function codexEvaluator(options = {}) {
         ];
         if (options.model) args.push("--model", options.model);
         args.push(prompt);
-        const before = gitState();
-        execFileSync(codexBin, args, {
+        guardedExecFileSync(codexBin, args, {
           cwd: options.cwd,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "pipe"],
           timeout: options.timeoutMs ?? 120000,
         });
-        const after = gitState();
-        if (before !== null && after !== before) throw new Error("repository mutation detected during read-only evaluator run");
         return validateEvaluation(JSON.parse(readFileSync(outputPath, "utf8")), candidate.id);
       } finally {
         rmSync(temp, { recursive: true, force: true });

package/lib/delivery-path-search/generators/claude.js

@@ -0,0 +1,40 @@
+import { execFileSync } from "node:child_process";
+import { generatorOutputSchema, validateGeneratorRequest, validateGeneratorResponse } from "../contracts.js";
+import { guardedExecFileSync } from "../transports/read-only-guard.js";
+
+export function claudeGenerator(options = {}) {
+  const claudeBin = options.claudeBin ?? "claude";
+  const execute = options.execute ?? guardedExecFileSync;
+  let runtime = options.runtime ?? "claude version unavailable";
+  if (!options.runtime) try { runtime = execFileSync(claudeBin, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim(); } catch {}
+  return {
+    name: "claude",
+    metadata: { name: "claude", runtime, model: options.model ?? "configured-default" },
+    async generate(requestValue) {
+      const request = validateGeneratorRequest(requestValue);
+      const prompt = [
+        "Generate bounded advisory delivery-path proposals. Do not use tools, execute commands, or modify files.",
+        "Return only JSON matching the supplied schema. Do not include hidden reasoning.",
+        `Normalized request: ${JSON.stringify(request)}`,
+      ].join("\n");
+      const args = ["-p", "--disallowedTools", "Edit,Write,Bash", "--output-format", "json", "--json-schema", JSON.stringify(generatorOutputSchema())];
+      if (options.model) args.push("--model", options.model);
+      args.push(prompt);
+      let raw;
+      try {
+        raw = execute(claudeBin, args, { cwd: options.cwd, timeout: options.timeoutMs ?? request.budgets.max_duration_ms });
+      } catch (error) {
+        const providerOutput = String(error?.stdout ?? "");
+        if (/not logged in|unauthorized|authentication/i.test(providerOutput)) {
+          const authentication = new Error("claude generator authentication failed");
+          authentication.code = "GENERATOR_AUTHENTICATION_FAILED";
+          throw authentication;
+        }
+        throw error;
+      }
+      const response = JSON.parse(raw);
+      if (response.is_error) throw new Error(`claude generator returned an error: ${response.result ?? "unknown error"}`);
+      return validateGeneratorResponse(JSON.parse(response.result));
+    },
+  };
+}

package/lib/delivery-path-search/generators/codex.js

@@ -0,0 +1,38 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { generatorOutputSchema, validateGeneratorRequest, validateGeneratorResponse } from "../contracts.js";
+import { guardedExecFileSync } from "../transports/read-only-guard.js";
+
+export function codexGenerator(options = {}) {
+  const codexBin = options.codexBin ?? "codex";
+  const execute = options.execute ?? guardedExecFileSync;
+  let runtime = options.runtime ?? "codex version unavailable";
+  if (!options.runtime) try { runtime = execFileSync(codexBin, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim(); } catch {}
+  return {
+    name: "codex",
+    metadata: { name: "codex", runtime, model: options.model ?? "configured-default" },
+    async generate(requestValue) {
+      const request = validateGeneratorRequest(requestValue);
+      const temp = mkdtempSync(join(tmpdir(), "agdf-dps-generator-"));
+      const schemaPath = join(temp, "schema.json");
+      const outputPath = join(temp, "output.json");
+      try {
+        writeFileSync(schemaPath, `${JSON.stringify(generatorOutputSchema(), null, 2)}\n`, "utf8");
+        const prompt = [
+          "Generate bounded advisory delivery-path proposals. Do not use tools, execute commands, or modify files.",
+          "Return only JSON matching the supplied schema. Do not include hidden reasoning.",
+          `Normalized request: ${JSON.stringify(request)}`,
+        ].join("\n");
+        const args = ["exec", "--sandbox", "read-only", "--ephemeral", "--ignore-user-config", "--output-schema", schemaPath, "--output-last-message", outputPath, "--color", "never"];
+        if (options.model) args.push("--model", options.model);
+        args.push(prompt);
+        execute(codexBin, args, { cwd: options.cwd, timeout: options.timeoutMs ?? request.budgets.max_duration_ms });
+        return validateGeneratorResponse(JSON.parse(readFileSync(outputPath, "utf8")));
+      } finally {
+        rmSync(temp, { recursive: true, force: true });
+      }
+    },
+  };
+}

package/lib/delivery-path-search/generators/protocol.js

@@ -0,0 +1,12 @@
+import { validateGeneratorRequest, validateGeneratorResponse } from "../contracts.js";
+
+export function fixtureGenerator(response, metadata = { name: "fixture-generator" }) {
+  return {
+    name: metadata.name,
+    metadata,
+    async generate(request) {
+      validateGeneratorRequest(request);
+      return validateGeneratorResponse(response);
+    },
+  };
+}

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

@@ -25,6 +25,11 @@ export function persistSearchResult(targetDir, result) {
     `- recommendation: ${recommendation}`,
     `- stopping_reason: ${safe.stopping_reason}`,
     `- evaluations: ${safe.budgets.evaluations}`,
+    `- generation_status: ${safe.generation?.status ?? "legacy_deterministic"}`,
+    `- generated_candidates: ${safe.generation ? `${safe.generation.accepted}/${safe.generation.returned}` : "0/0"}`,
+    `- generation_cost_units: ${safe.generation?.cost_units ?? 0}`,
+    `- generation_duration_ms: ${safe.generation?.duration_ms ?? 0}`,
+    ...(safe.generation?.failure_code ? [`- generation_failure: ${safe.generation.failure_code}`] : []),
     `- next_gate_action: ${safe.next_gate_action}`,
     "",
     "This summary contains model judgements, not measured facts. Canonical AGDF gate-check remains authoritative.",

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

@@ -1,11 +1,24 @@
 import { CONTRACT_VERSION, SCORING_POLICY_VERSION, validateEvaluation, validateSearchInput } from "./contracts.js";
-import { candidateLegality, candidatesFromInput } from "./candidate-policy.js";
+import { candidateLegality, candidatesFromInput, generatedCandidatesFromResponse } from "./candidate-policy.js";
 import { scoreEvaluation } from "./scoring.js";
+import { generatorRequestFromInput } from "./state-adapter.js";
+
+function generatorFailureCode(error) {
+  if (error?.code === "GENERATOR_MUTATION_DETECTED") return "generator_mutation_detected";
+  if (error?.code === "GENERATOR_TIMEOUT") return "generator_timeout";
+  if (error?.code === "GENERATOR_AUTHENTICATION_FAILED") return "generator_authentication_failed";
+  if (error?.code === "ENOENT") return "generator_unavailable";
+  if (/auth/i.test(error?.message ?? "")) return "generator_authentication_failed";
+  if (/context|disallowed/i.test(error?.message ?? "")) return "generator_context_rejected";
+  if (/budget/i.test(error?.message ?? "")) return "generator_budget_exceeded";
+  return "generator_schema_invalid";
+}
 
 export async function runDeliveryPathSearch(inputValue, evaluator, options = {}) {
   const input = validateSearchInput(inputValue);
   const startedAt = Date.now();
-  const queue = [...(options.candidates ?? candidatesFromInput(input))];
+  const baseline = [...(options.candidates ?? candidatesFromInput(input))];
+  const queue = [...baseline];
   const rejected = [];
   const evaluated = [];
   let evaluations = 0;
@@ -13,6 +26,53 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
   let lastLeaderId = null;
   let stableComparisons = 0;
   let stoppingReason = "candidate_queue_exhausted";
+  const generation = {
+    status: input.generation?.enabled ? "failed" : "disabled",
+    adapter: options.generator?.metadata ?? null,
+    budgets: input.generation ?? null,
+    returned: 0,
+    accepted: 0,
+    rejected: [],
+    cost_units: 0,
+    duration_ms: 0,
+    failure_code: null,
+  };
+
+  if (input.generation?.enabled) {
+    if (!options.generator) {
+      generation.failure_code = "generator_unavailable";
+    } else {
+      const generationStartedAt = Date.now();
+      try {
+        const response = await options.generator.generate(generatorRequestFromInput(input));
+        const elapsed = Date.now() - generationStartedAt;
+        generation.returned = response.proposals.length;
+        generation.cost_units = response.cost_units;
+        costUnits += response.cost_units;
+        if (elapsed > input.generation.max_duration_ms) {
+          const error = new Error("generator duration budget exceeded");
+          error.code = "GENERATOR_TIMEOUT";
+          throw error;
+        }
+        if (response.cost_units > input.generation.max_cost_units || response.proposals.length > input.generation.max_proposals) {
+          const error = new Error("generator response exceeds configured budget");
+          error.code = "GENERATOR_BUDGET_EXCEEDED";
+          throw error;
+        }
+        const filtered = generatedCandidatesFromResponse(response, input, baseline);
+        generation.accepted = filtered.accepted.length;
+        generation.rejected = filtered.rejected;
+        queue.push(...filtered.accepted.slice(0, input.generation.max_proposals));
+        generation.status = filtered.accepted.length === response.proposals.length ? "success" : "partial";
+        if (!filtered.accepted.length) generation.failure_code = "generator_no_diverse_proposals";
+      } catch (error) {
+        generation.failure_code = generatorFailureCode(error);
+        if (generation.failure_code === "generator_mutation_detected") throw error;
+      } finally {
+        generation.duration_ms = Date.now() - generationStartedAt;
+      }
+    }
+  }
 
   while (queue.length > 0) {
     if (evaluations >= input.budgets.max_evaluations) { stoppingReason = "evaluation_budget_exhausted"; break; }
@@ -46,6 +106,7 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
             parent_id: candidate.id,
             depth: (candidate.depth ?? 0) + 1,
             action,
+            source: "expanded",
             expected_evidence: [],
             tests: [],
             assumptions: evaluation.assumptions,
@@ -85,6 +146,7 @@ export async function runDeliveryPathSearch(inputValue, evaluator, options = {})
     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.",

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

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { CONTRACT_VERSION } from "./contracts.js";
+import { CONTRACT_VERSION, GENERATOR_CONTRACT_VERSION, validateGeneratorRequest } from "./contracts.js";
 
 function section(content, heading) {
   return content.match(new RegExp(`## ${heading}\\r?\\n([\\s\\S]*?)(?=\\r?\\n## |$)`))?.[1] ?? "";
@@ -35,7 +35,7 @@ export function searchInputFromControl(targetDir, options = {}) {
   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);
-  return {
+  const result = {
     contract_version: CONTRACT_VERSION,
     scope_key: options.scopeKey ?? meta.run_id ?? "unknown-scope",
     objective: section(content, "Objective").trim(),
@@ -55,4 +55,36 @@ 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,
+  };
+  return result;
+}
+
+export function generatorRequestFromInput(input) {
+  return validateGeneratorRequest({
+    contract_version: GENERATOR_CONTRACT_VERSION,
+    scope_key: input.scope_key,
+    objective: input.objective,
+    scope_summary: input.objective,
+    current_gate: input.current_gate,
+    allowed_actions: input.allowed_actions,
+    forbidden_actions: input.forbidden_actions,
+    artefact_refs: [],
+    evidence: input.evidence_refs ?? [],
+    missing_evidence: [],
+    risks: input.risks ?? [],
+    constraints: ["advisory only", "canonical gate-check remains authoritative"],
+    enforcement: input.enforcement,
+    budgets: {
+      max_calls: input.generation.max_calls,
+      max_proposals: input.generation.max_proposals,
+      max_duration_ms: input.generation.max_duration_ms,
+      max_cost_units: input.generation.max_cost_units,
+    },
+  });
 }

package/lib/delivery-path-search/transports/read-only-guard.js

@@ -0,0 +1,43 @@
+import { execFileSync } from "node:child_process";
+
+export function repositoryState(cwd) {
+  try {
+    return execFileSync("git", ["status", "--porcelain=v1", "-z"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function guardedExecFileSync(file, args, options = {}) {
+  const before = repositoryState(options.cwd);
+  let output;
+  let failure;
+  try {
+    output = execFileSync(file, args, {
+      ...options,
+      encoding: options.encoding ?? "utf8",
+      stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
+      timeout: options.timeout ?? 30000,
+      killSignal: "SIGTERM",
+    });
+  } catch (error) {
+    failure = error;
+  }
+  const after = repositoryState(options.cwd);
+  if (before !== null && after !== before) {
+    const error = new Error("repository mutation detected during read-only run");
+    error.code = "GENERATOR_MUTATION_DETECTED";
+    throw error;
+  }
+  if (failure?.code === "ETIMEDOUT" || failure?.signal === "SIGTERM") {
+    const timeout = new Error("read-only process timed out");
+    timeout.code = "GENERATOR_TIMEOUT";
+    throw timeout;
+  }
+  if (failure) throw failure;
+  return output;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -23,8 +23,9 @@
     "sync-package-assets": "node ./scripts/sync-package-assets.js",
     "test:delivery-path-search": "node ./scripts/delivery-path-search-test.js",
     "test:delivery-path-search-unit": "node ./scripts/delivery-path-search-unit-test.js",
+    "test:delivery-path-search-generator": "node ./scripts/delivery-path-search-generator-test.js",
     "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run sync-package-assets && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
+    "smoke-test": "npm run sync-package-assets && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
     "prepack": "npm run sync-package-assets"
   },
   "keywords": [