create-agdf 0.11.4 → 0.12.0

package/generated/plugins/agdf/skills/brownfield-analysis/SKILL.md

@@ -22,6 +22,7 @@ The skill answers:
 Use these focused runtime-contract modules:
 
 - `../../meta/contracts/gate-transition.md`
+- `../../meta/contracts/modes.md`
 - `../../meta/contracts/context-graph.md`
 - `../../meta/contracts/quality.md`
 
@@ -54,6 +55,19 @@ not applicable; Brownfield records cite repository evidence. Do not create a sec
 11. Large UI surfaces and state hooks must be checked for mixed render, view-model, derived state, orchestration, persistence, and recovery ownership.
 12. Context Graph impact must be curated; it is not a review log or version index.
 13. Specification archive migrations must follow the archive index if present.
+14. In `post_ur_review`, evaluate unchanged compact paths first. For a structured candidate, apply
+    only the `Structured Depth Decision` in `modes.md`; do not recreate its trigger/check matrix in
+    this skill.
+15. A positive structured decision requires `depth_policy_version: 1`,
+    `depth_facts_status: complete`, complete evidence for all seven bounded-slice checks, a primary
+    reason code, rejected alternative and evidence references. A decisive full-depth trigger may
+    support `structured_delivery`; `structured_slice` requires every bounded-slice check to pass.
+16. Missing or conflicting decisive facts without an already-evidenced full-depth trigger persist
+    the existing `block` decision with `depth_facts_missing | depth_facts_conflicting`, named facts,
+    their evidence owner where known, a Brownfield Review link and a precise next action for evidence
+    completion and Brownfield/Mode-Slice re-evaluation.
+17. Owner, file, consumer, task or derived-path counts must never select a structured depth by
+    themselves.
 
 ## When To Use
 - after `gate-check` permits `Brownfield Review` or the selected canonical run record names Brownfield Review as the next allowed action
@@ -107,6 +121,11 @@ When used as Brownfield Review after `Approval: UR`, do not recommend PRD, SD, T
 9. Check UI monolith risk for large surfaces or central hooks.
 10. Check Context Graph impact according to `../../meta/contracts/context-graph.md`.
 11. Recommend the minimal clean implementation path.
+12. In `post_ur_review`, record `depth_policy_version`, `depth_facts_status`,
+    `primary_reason_code`, `decisive_full_depth_triggers`, `rejected_alternative`,
+    `missing_or_conflicting_facts`, `depth_evidence_refs` and evidence for all seven bounded-slice
+    check IDs in the Brownfield Review. Then persist the completed review and the existing
+    Mode/Slice Decision atomically.
 
 ## Output
 Use a concise structure:
@@ -133,6 +152,13 @@ For `post_ur_review`, include the four UI/UX routing fields immediately after `s
 definition is required, its `ready | blocked | not_applicable` result must be visible before PRD
 readiness. A required `blocked` result is at least `revise` for this routing step.
 
+For a structured `post_ur_review` candidate, also include the complete `Structured Depth Evidence`
+section from `BROWNFIELD_REVIEW.md`. The decision projection must show the primary reason, decisive
+dimensions, bounded-slice result, rejected alternative, evidence and required next gate. For
+missing/conflicting facts, show product-language `depth_unresolved` while persisting `block`; name
+the gap and exact recovery action. Structural instruction checks can detect missing contract
+elements but do not prove semantic model compliance or live-host behavior.
+
 ## Pass / Revise / Block Guidance
 - `pass`: existing owners are understood, reuse path is clear, and no blocking drift or parallel structure risk remains.
 - `revise`: relevant evidence, tests, ownership, or reuse path is incomplete.

package/generated/plugins/agdf/skills/gate-check/SKILL.md

@@ -20,6 +20,7 @@ This skill must not create later artefacts such as PRD, SD, TP, CD, CR, QA, or U
 ## Runtime Contract
 Use these focused runtime-contract modules:
 
+- `../../meta/contracts/task-target-resolution.md`
 - `../../meta/contracts/gate-transition.md`
 - `../../meta/contracts/interaction.md`
 - `../../meta/contracts/control-scaffold.md`
@@ -75,6 +76,12 @@ The CLI reports are validators and JSON evidence, not the primary user experienc
 
 Plugin `AGDF_*` environment variables set by the OpenCode `shell.env` hook are convenience only and must not be used as the only proof of activation; host shell-env propagation to spawned tool shells is not guaranteed and is OpenCode-owned, not AGDF-owned. A relative glob or `grep` for `.agdf/control/config.json` must not be used as proof of presence or absence of `.agdf/control/config.json`; an absolute `read` or the canonical CLI probe is required.
 
+## OpenCode Subagent Enforcement Boundary
+
+OpenCode plugin hooks (`tool.execute.before`) do not intercept tool calls from subagents spawned via the `task` tool (anomalyco/opencode issue #5894, PR #36238 open). AGDF enforcement through plugin hooks applies to primary-agent tool calls only; in the subagent path, AGDF governance is auditing-only, not enforcement.
+
+This is a host limitation, not an AGDF-owned defect. Do not claim that AGDF gates are technically enforced in the OpenCode subagent path. Do not route work to a subagent to bypass a primary-agent gate. When subagent work touches gate-relevant files, verify the result through the canonical validator (`doctor --json`, `gate-check --json`) after the subagent returns, not during.
+
 ## Native Interaction Path
 
 `../../meta/contracts/interaction.md` is the complete normative owner for interaction kinds, locale,
@@ -84,12 +91,15 @@ do not restate or infer a surface matrix in this skill.
 
 This skill owns only these operational responsibilities:
 
-1. Select exactly one run and evaluate its current gate.
-2. Confirm that the required durable artefact is present and ready.
-3. Consume the canonical `approval_presentation` verbatim for the selected run, gate and revision.
-4. Present that projection and obtain deliberate input through the contract-selected native or exact-text path.
-5. Revalidate the same run, gate and revision immediately after the response and before persistence.
-6. Persist only a currently valid exact approval through the existing control-state workflow.
+1. Resolve or revalidate the primary task target before selecting repository control state.
+2. Derive repository activation only from the resolved governance target; an evidence source or
+   working directory is not sufficient.
+3. Select exactly one run and evaluate its current gate.
+4. Confirm that the required durable artefact is present and ready.
+5. Consume the canonical `approval_presentation` verbatim for the selected run, gate and revision.
+6. Present that projection and obtain deliberate input through the contract-selected native or exact-text path.
+7. Revalidate the same target, run, gate and revision immediately after the response and before persistence.
+8. Persist only a currently valid exact approval through the existing control-state workflow.
 
 For status, blocked, read-only or rationale interactions, consume the canonical
 `status_presentation.markdown` verbatim and apply the locale contract without asking for approval.
@@ -156,18 +166,30 @@ Use what is available:
 If a status is not explicit, do not assume it is satisfied.
 
 ## Workflow
-1. Check exact approvals.
-2. Check artefact status.
-3. Determine the earliest blocking user gate or internal mandatory step.
-4. Derive allowed and forbidden outputs.
-5. Name the exact missing approval, if any.
-6. If consent was only implicit, say it is not yet approval and provide the exact formula.
-7. Ensure the next step follows the gate transition table. In particular, never jump from `Approval: UR` to implementation.
-8. Treat a generic "start", "continue" or "leg los" request as a request to perform only the current next allowed action.
-9. After Brownfield Review, choose the smallest safe process path before creating later artefacts.
-10. If the selected path is not visibly recorded with scope reason and evidence, keep the run at `Mode/Slice Decision`.
-11. When `.agdf/control/` is missing or incomplete, make the next allowed artefact action explicit. For a fresh request, that means draft the minimal UR in the response, then request `Approval: UR`. Do not write a full control scaffold unless durable control state was explicitly requested or is already the repository's live AGDF working state.
-12. If branch, workspace and durable artefacts disagree, do not choose a scope silently; report the ambiguity and ask for the smallest clarifying gate action.
+1. Resolve or revalidate the primary target through `task-target-resolution.md`.
+2. If resolution is unresolved, consume the canonical target orientation, request only its
+   clarification/recovery action and stop before repository activation, gate evaluation or mutation.
+3. Derive the governance target from the primary target; never from `cwd` or an evidence source alone.
+4. Check exact approvals.
+5. Check artefact status.
+6. Determine the earliest blocking user gate or internal mandatory step.
+7. Derive allowed and forbidden outputs.
+8. Name the exact missing approval, if any.
+9. If consent was only implicit, say it is not yet approval and provide the exact formula.
+10. Ensure the next step follows the gate transition table. In particular, never jump from `Approval: UR` to implementation.
+11. Treat a generic "start", "continue" or "leg los" request as a request to perform only the current next allowed action.
+12. After Brownfield Review, choose the smallest safe process path before creating later artefacts.
+13. If the selected path is not visibly recorded with scope reason and evidence, keep the run at `Mode/Slice Decision`.
+14. When `.agdf/control/` is missing or incomplete, make the next allowed artefact action explicit. For a fresh request, that means draft the minimal UR in the response, then request `Approval: UR`. Do not write a full control scaffold unless durable control state was explicitly requested or is already the repository's live AGDF working state.
+15. If branch, workspace and durable artefacts disagree, do not choose a scope silently; report the ambiguity and ask for the smallest clarifying gate action.
+
+### Task Target Orientation
+
+When target/context separation is material, the target changed, or resolution is unresolved, consume
+`task_target_orientation.markdown` verbatim from `renderTaskTargetOrientation` in
+`../../meta/contracts/interaction.md`. Do not reconstruct its fields or maintain a skill-local target
+template. If the renderer returns `null`, fail closed to target clarification and do not proceed to
+repository activation, Scope Classification or gate evaluation.
 
 ### Scope Classification Output
 When this skill classifies a fresh scope as ungated (Quick Task or Trivial Change Boundary), consume

package/lib/cli/application.js

@@ -115,10 +115,19 @@ function createHandlers({ io, env, exec, prepare }) {
         const result = runLifecyclePhase("plugin_operation", () => installOpenCodeGlobalPlugin(configDir));
         runLifecyclePhase("global_surface", () => installOpenCodeGlobalSurface(configDir));
         const report = runLifecyclePhase("verification", () => evaluateOpenCodeStatus(options.dir, configDir, result.transition));
+        const alignmentHealthy = ["already_matching", "aligned"].includes(result.sdk_alignment.status);
         const verificationHealthy = report.status === "configured"
           && report.package.version_status === "current"
           && report.global_native_surface.complete
-          && report.experimental_hooks.aggregate === "declared_supported";
+          && report.experimental_hooks.aggregate === "declared_supported"
+          && report.host_sdk_version.status === "matching"
+          && alignmentHealthy;
+        const nextAction = verificationHealthy
+          ? globalInstallRestartAction(options.target)
+          : {
+              kind: "recovery",
+              text: `Retry the OpenCode installation to align @opencode-ai/plugin to ${result.sdk_alignment.target_version || "the exact host version"}; observed SDK: ${result.sdk_alignment.installed_version || "unknown"}.`,
+            };
         printLifecycleResult(createLifecycleResult({
           operation: result.transition.status === "updated" ? "update" : "install",
           result: verificationHealthy ? "success" : "partial",
@@ -140,13 +149,15 @@ function createHandlers({ io, env, exec, prepare }) {
               `plugin_sdk=${report.plugin_sdk.installed_version || "unknown"}`,
               `experimental_hooks=${report.experimental_hooks.aggregate}`,
               `host_sdk_version=${report.host_sdk_version.status};policy=${report.host_sdk_version.policy}`,
+              `sdk_alignment=${result.sdk_alignment.status};target=${result.sdk_alignment.target_version || "unknown"};installed=${result.sdk_alignment.installed_version || "unknown"}`,
             ],
           },
           restart: { required: true, reason: "host_reload" },
-          next_action: globalInstallRestartAction(options.target),
+          next_action: nextAction,
         }), { json: options.json, io });
         if (!options.json) {
           io.log(`OpenCode host / plugin SDK: ${report.host.installed_version || "unknown"} / ${report.plugin_sdk.installed_version || "unknown"} (${report.host_sdk_version.status}; ${report.host_sdk_version.policy})`);
+          io.log(`Plugin SDK alignment: ${result.sdk_alignment.status} (target ${result.sdk_alignment.target_version || "unknown"}; installed ${result.sdk_alignment.installed_version || "unknown"})`);
           io.log(`Experimental hook declarations: ${report.experimental_hooks.aggregate} (SDK declaration evidence; live invocation not observed)`);
         }
         return verificationHealthy ? 0 : 1;

package/lib/control-evaluation/gate-policy.js

@@ -29,8 +29,9 @@ export function isGateSatisfied(runState, gate) {
   return isDurableGateArtefactSatisfied(runState, gate);
 }
 
-function qaRevisionRequired(runState) {
-  return gateArtefactStatus(runState, "QA").status === "revise";
+function qaNonPassDecision(runState) {
+  const status = gateArtefactStatus(runState, "QA").status;
+  return status === "revise" || status === "block" ? status : null;
 }
 
 export function transitionDecisionForRunState(runState, verifiedChange = null) {
@@ -233,15 +234,21 @@ export function transitionDecisionForRunState(runState, verifiedChange = null) {
     };
   }
 
-  if (qaRevisionRequired(runState)) {
+  const qaNonPass = qaNonPassDecision(runState);
+  if (qaNonPass) {
+    const blocked = qaNonPass === "block";
     return {
-      status: "open",
+      status: blocked ? "blocked" : "open",
       current_gate: "QA",
-      blocking_reason: "qa_revise_required",
+      blocking_reason: blocked ? "qa_blocked" : "qa_revise_required",
       missing_approval: "none",
-      allowed: ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
+      allowed: blocked
+        ? ["route the blocking QA findings to their authoritative owner", "record the next permitted remediation or upstream decision", "rerun QA only after the blocker is resolved"]
+        : ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
       forbidden: ["request QA approval", "request UAT approval", "release", "claim delivery readiness"],
-      next_allowed_action: "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
+      next_allowed_action: blocked
+        ? "Resolve or route the blocking QA findings through their authoritative owner, then rerun the required delivery steps. Do not request Approval: QA from a block report."
+        : "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
     };
   }
 

package/lib/installers/opencode.js

@@ -116,11 +116,13 @@ export function installOpenCodeGlobalPlugin(configDir) {
     throw openCodeLifecycleError("configuration", `Failed to write OpenCode config ${configPath}: ${error.message}`, { configPath });
   }
   const installedPackage = resolveOpenCodePackage(configDir);
+  const sdkAlignment = alignOpenCodePluginSdk(configDir);
 
   return {
     configPath,
     added: !alreadyInstalled,
     transition: openCodePackageTransition(previousPackage, installedPackage),
+    sdk_alignment: sdkAlignment,
   };
 }
 
@@ -519,6 +521,131 @@ export function evaluateOpenCodeHostSdk(configDir, dependencies = {}) {
   };
 }
 
+const exactOpenCodeVersionPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+
+function openCodeSdkAlignmentResult(status, initial, overrides = {}) {
+  return {
+    status,
+    attempted: false,
+    host_version: initial.host.installed_version || null,
+    previous_version: initial.plugin_sdk.installed_version || null,
+    target_version: null,
+    installed_version: initial.plugin_sdk.installed_version || null,
+    error: "",
+    ...overrides,
+  };
+}
+
+function openCodeRegistryVersion(raw) {
+  const value = String(raw ?? "").trim();
+  if (!value) return "";
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed.trim() : "";
+  } catch {
+    return value;
+  }
+}
+
+function openCodeSdkUnavailable(error) {
+  return /(?:ETARGET|E404|404 Not Found|No matching version)/i.test(
+    (error?.stderr || error?.message || "").toString(),
+  );
+}
+
+export function alignOpenCodePluginSdk(configDir, dependencies = {}) {
+  const initial = evaluateOpenCodeHostSdk(configDir, dependencies);
+  const hostVersion = initial.host.installed_version || "";
+  const sdkVersion = initial.plugin_sdk.installed_version || "";
+  if (!initial.host.inspectable || !initial.plugin_sdk.loadable || !exactOpenCodeVersionPattern.test(hostVersion)) {
+    return openCodeSdkAlignmentResult("not_attempted", initial, {
+      target_version: exactOpenCodeVersionPattern.test(hostVersion) ? hostVersion : null,
+      error: !initial.host.inspectable
+        ? initial.host.error || "OpenCode host version is not inspectable."
+        : !initial.plugin_sdk.loadable
+          ? initial.plugin_sdk.error || "OpenCode plugin SDK is not inspectable."
+          : `OpenCode host version is not an exact semantic version: ${hostVersion || "unknown"}`,
+    });
+  }
+  if (sdkVersion === hostVersion) {
+    return openCodeSdkAlignmentResult("already_matching", initial, {
+      target_version: hostVersion,
+    });
+  }
+
+  const run = dependencies.execFileSync ?? execFileSync;
+  const packageSpecifier = `@opencode-ai/plugin@${hostVersion}`;
+  const registryInvocation = openCodeNpmInvocation(["view", packageSpecifier, "version", "--json"]);
+  try {
+    const availableVersion = openCodeRegistryVersion(run(registryInvocation.executable, registryInvocation.args, {
+      cwd: configDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15000,
+    }));
+    if (availableVersion !== hostVersion) {
+      return openCodeSdkAlignmentResult("unavailable", initial, {
+        target_version: hostVersion,
+        error: `Exact plugin SDK version is unavailable: ${packageSpecifier}`,
+      });
+    }
+  } catch (error) {
+    return openCodeSdkAlignmentResult(openCodeSdkUnavailable(error) ? "unavailable" : "failed", initial, {
+      target_version: hostVersion,
+      error: (error.stderr || error.message || "plugin SDK registry lookup failed").toString().trim(),
+    });
+  }
+
+  const installInvocation = openCodeNpmInvocation([
+    "install",
+    "--silent",
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--save-prod",
+    "--save-exact",
+    packageSpecifier,
+  ]);
+  let installError = null;
+  try {
+    run(installInvocation.executable, installInvocation.args, {
+      cwd: configDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 60000,
+    });
+  } catch (error) {
+    installError = error;
+  }
+
+  const observed = evaluateOpenCodeHostSdk(configDir, dependencies);
+  const verified = observed.plugin_sdk.installed_version === hostVersion
+    && observed.experimental_hooks.aggregate === "declared_supported";
+  if (installError) {
+    return openCodeSdkAlignmentResult("failed", initial, {
+      attempted: true,
+      target_version: hostVersion,
+      installed_version: observed.plugin_sdk.installed_version || null,
+      error: (installError.stderr || installError.message || "plugin SDK installation failed").toString().trim(),
+    });
+  }
+  if (!verified) {
+    return openCodeSdkAlignmentResult("verification_failed", initial, {
+      attempted: true,
+      target_version: hostVersion,
+      installed_version: observed.plugin_sdk.installed_version || null,
+      error: observed.plugin_sdk.installed_version !== hostVersion
+        ? `Observed plugin SDK ${observed.plugin_sdk.installed_version || "unknown"} after targeting ${hostVersion}.`
+        : `Plugin SDK ${hostVersion} does not declare all required experimental hooks.`,
+    });
+  }
+  return openCodeSdkAlignmentResult("aligned", initial, {
+    attempted: true,
+    target_version: hostVersion,
+    installed_version: observed.plugin_sdk.installed_version,
+  });
+}
+
 function openCodePackageVersionStatus(packageState) {
   if (!packageState.loadable) return "unloadable";
   if (!packageState.installed_version) return "unknown";
@@ -680,7 +807,7 @@ export function evaluateOpenCodeStatus(targetDir, configDir = defaultOpenCodeCon
       : hostSdk.experimental_hooks.aggregate === "degraded"
       ? "Use static AGDF instructions and review OpenCode compatibility before relying on dynamic hook injection."
       : hostSdk.host_sdk_version.status === "divergent"
-      ? "Review OpenCode host/plugin-SDK compatibility; AGDF reports this divergence but does not align versions automatically."
+      ? "Run npx --yes @agdf/cli@latest opencode to align the plugin SDK to the exact OpenCode host version; status itself remains read-only."
       : repositoryActivation.state === "invalid_control"
       ? "Repair .agdf/control/config.json so it contains valid artifact_language, chat_language and runtime_language values."
       : repositoryActivation.active

package/lib/interaction-presentation.js

@@ -349,6 +349,91 @@ export function renderOperationalStatusCard(statusCard, {
   });
 }
 
+export function renderTaskTargetOrientation(resolution, {
+  registry,
+  requestedLocale,
+} = {}) {
+  if (!plainObject(resolution)) return null;
+
+  const resolutionState = String(resolution.resolution_state ?? "").trim();
+  const reasonCode = String(resolution.reason_code ?? "").trim();
+  const primaryTarget = String(resolution.primary_target ?? "").trim();
+  const governanceTarget = String(resolution.governance_target ?? "").trim();
+  const workingDirectory = String(resolution.working_directory ?? "").trim();
+  const nextAction = String(resolution.next_action ?? "").trim();
+  if (typeof resolution.target_changed !== "boolean") return null;
+  const targetChanged = resolution.target_changed === true;
+  const evidenceSources = Array.isArray(resolution.evidence_sources)
+    ? resolution.evidence_sources.map((item) => String(item ?? "").trim()).filter(Boolean)
+    : null;
+
+  const resolvedReasons = new Set(["explicit_target", "continued_target"]);
+  const unresolvedReasons = new Set([
+    "multiple_plausible_targets",
+    "target_content_mismatch",
+    "target_unavailable",
+    "no_reliable_target",
+  ]);
+
+  if (!["resolved", "unresolved"].includes(resolutionState)) return null;
+  if (!workingDirectory || evidenceSources === null) return null;
+  if (resolutionState === "resolved") {
+    if (!resolvedReasons.has(reasonCode) || !primaryTarget || nextAction) return null;
+  } else if (!unresolvedReasons.has(reasonCode) || primaryTarget || governanceTarget || !nextAction || targetChanged) {
+    return null;
+  }
+
+  let locale;
+  try {
+    locale = resolvePresentationLocale(registry, requestedLocale);
+  } catch {
+    return null;
+  }
+  if (!locale) return null;
+
+  const pack = localePack(registry, locale);
+  const labels = pack?.taskTargetResolution;
+  if (!plainObject(labels) || !plainObject(labels.reasonCodes)) return null;
+  const reason = labels.reasonCodes[reasonCode];
+  if (!reason) return null;
+
+  const rows = resolutionState === "resolved"
+    ? [
+        [labels.state, labels.resolved],
+        [labels.primaryTarget, primaryTarget],
+        [labels.governanceTarget, governanceTarget || labels.none],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.reason, reason],
+        ...(targetChanged ? [[labels.targetChanged, labels.yes]] : []),
+      ]
+    : [
+        [labels.state, labels.unresolved],
+        [labels.reason, reason],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.nextAction, nextAction],
+      ];
+
+  const markdown = [
+    `## ${labels.title}`,
+    "",
+    `| ${labels.field} | ${labels.value} |`,
+    "|---|---|",
+    ...rows.map(([label, value]) => `| ${markdownCell(label)} | ${markdownCell(value)} |`),
+  ].join("\n");
+
+  return Object.freeze({
+    schema_version: "1",
+    semantic_block: "task_target_orientation",
+    presentation_language: locale,
+    resolution_state: resolutionState,
+    reason_code: reasonCode,
+    markdown,
+    authorizes: false,
+  });
+}
+
 export function renderScopeClassificationCard(classification, {
   registry,
   requestedLocale,

package/lib/live-agent/read-only-structured.js

@@ -0,0 +1,43 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { guardedExecFileSync } from "../delivery-path-search/transports/read-only-guard.js";
+
+export function executeStructuredAgent({ surface, cwd, prompt, model, outputSchema, timeoutMs = 120000 }) {
+  if (surface === "codex") {
+    const temp = mkdtempSync(join(tmpdir(), "agdf-live-codex-"));
+    try {
+      const schemaPath = join(temp, "schema.json");
+      const outputPath = join(temp, "output.json");
+      writeFileSync(schemaPath, `${JSON.stringify(outputSchema, null, 2)}\n`, "utf8");
+      const args = [
+        "exec", "--sandbox", "read-only", "--ephemeral", "--ignore-user-config",
+        "--skip-git-repo-check", "--output-schema", schemaPath,
+        "--output-last-message", outputPath, "--color", "never",
+      ];
+      if (model) args.push("--model", model);
+      args.push(prompt);
+      guardedExecFileSync("codex", args, {
+        cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs,
+      });
+      return readFileSync(outputPath, "utf8");
+    } finally {
+      rmSync(temp, { recursive: true, force: true });
+    }
+  }
+  if (surface === "claude") {
+    const args = [
+      "-p", "--disallowedTools", "Edit,Write,Bash", "--output-format", "json",
+      "--json-schema", JSON.stringify(outputSchema),
+    ];
+    if (model) args.push("--model", model);
+    args.push(prompt);
+    const raw = guardedExecFileSync("claude", args, {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs,
+    });
+    const envelope = JSON.parse(raw);
+    if (envelope.is_error) throw new Error(`claude live adapter failed: ${envelope.result ?? "unknown error"}`);
+    return envelope.result;
+  }
+  throw new Error(`unsupported live surface: ${surface}`);
+}

package/lib/proportionality-benchmark/blind-prompt.js

@@ -0,0 +1,37 @@
+import { DELIVERY_PATHS } from "./contracts.js";
+
+export function buildBlindPrompt(testCase, behaviorSources) {
+  if (testCase.profile_id === "staged-v2") {
+    return [
+      "Perform a read-only, non-authorizing AGDF benchmark classification. Do not modify files, invoke tools, persist control state, or claim a real approval.",
+      "Synthetic fixture state is measurement input only. Return only JSON matching the supplied schema.",
+      `Allowed stages: ${testCase.allowed_stages.join(", ")}.`,
+      `Allowed paths: ${DELIVERY_PATHS.join(", ")}.`,
+      `Requested axes: ${testCase.requested_axes.join(", ")}. Every requested axis must use evaluated with one non-null allowed value. Non-requested axes must be null with not_evaluable_yet.`,
+      "eventual_delivery_path is a benchmark candidate, never an operative Mode/Slice Decision.",
+      "compact_delivery requires visible approved UR, completed Brownfield analysis, and stored quick_task context in decision_grounds.",
+      `Scenario ID: ${testCase.scenario_id}`,
+      `Case ID: ${testCase.case_id}`,
+      `Lifecycle stage: ${testCase.lifecycle_stage}`,
+      `Task: ${testCase.task_summary}`,
+      `Repository context: ${testCase.repository_context}`,
+      `Control-state context: ${testCase.control_state_context}`,
+      `Evidence pack: ${JSON.stringify(testCase.evidence_pack ?? {})}`,
+      "Current canonical routing sources follow:",
+      behaviorSources,
+    ].join("\n\n");
+  }
+  return [
+    "Classify the delivery path AGDF would select for this task. Do not modify files or invoke tools.",
+    "Return only JSON matching the supplied schema. Do not reveal hidden reasoning.",
+    `Allowed paths: ${DELIVERY_PATHS.join(", ")}.`,
+    "Use null plus ambiguous=true when the evidence does not support one path.",
+    "compact_delivery requires decision_grounds that visibly reference approved UR, completed Brownfield analysis, and stored quick_task context.",
+    `Case ID: ${testCase.case_id}`,
+    `Task: ${testCase.task_summary}`,
+    `Repository context: ${testCase.repository_context}`,
+    `Control-state context: ${testCase.control_state_context}`,
+    "Current canonical routing sources follow:",
+    behaviorSources,
+  ].join("\n\n");
+}