create-agdf 0.20.2 → 0.30.0

package/generated/plugins/copilot/agdf/mcp/server/src/stdio-output.js

@@ -0,0 +1,42 @@
+import { OWNER_LIMITS } from './generation-protocol.js';
+
+// One entry-owned SDK wire, one active write. Concurrent SDK responses must not
+// attach one drain/error listener per result to a blocked native Worker stream.
+// Capture exact JSON at admission. Existing result/resource owners bound the
+// one active message; the additional queue has its own strict byte/frame cap.
+// A legal large UI response must still work without lowering its resource cap.
+export function boundStdioOutput(transport) {
+  const originalSend = transport.send.bind(transport), originalClose = transport.close.bind(transport);
+  const queue = [];
+  let active, queuedBytes = 0, closed = false, closing;
+  const capacityError = () => Error('AGDF_MCP_STDIO_CAPACITY');
+  function pump() {
+    if (active || closed || !queue.length) return;
+    const entry = active = queue.shift(); queuedBytes -= entry.bytes;
+    Promise.resolve().then(() => originalSend(entry.message)).then(entry.resolve, entry.reject).finally(() => {
+      active = undefined; pump();
+    });
+  }
+  transport.send = message => {
+    if (closed) return Promise.reject(Error('AGDF_MCP_STDIO_CLOSED'));
+    let snapshot, size;
+    try {
+      const json = JSON.stringify(message); size = Buffer.byteLength(json) + 1;
+      if (queue.length + (active ? 1 : 0) >= OWNER_LIMITS.frames || active && queuedBytes + size > OWNER_LIMITS.bytes) return Promise.reject(capacityError());
+      snapshot = JSON.parse(json); // Preserve SDK JSON semantics and call-time bytes.
+    } catch (error) { return Promise.reject(error); }
+    return new Promise((resolve, reject) => {
+      queuedBytes += size; queue.push({ message: snapshot, bytes: size, resolve, reject }); pump();
+    });
+  };
+  transport.close = () => {
+    if (closing) return closing;
+    closed = true;
+    for (const entry of queue.splice(0)) { queuedBytes -= entry.bytes; entry.reject(Error('AGDF_MCP_STDIO_CLOSED')); }
+    // Close does not prove that an active write drained. Its SDK promise stays
+    // observed; genuine Worker exit is still required by the lifecycle owner.
+    active?.reject(Error('AGDF_MCP_STDIO_CLOSED'));
+    closing = Promise.resolve().then(originalClose); return closing;
+  };
+  return transport;
+}

package/generated/plugins/copilot/agdf/mcp/server/src/worker-entry.js

@@ -1,6 +1,6 @@
 import { subscribe } from "node:diagnostics_channel";
 import { parentPort, workerData } from "node:worker_threads";
-import { OWNED_LOCK_CHANNEL, createMcpDispatchRuntime } from "create-agdf/mcp-dispatch-runtime";
+import { OWNED_LOCK_CHANNEL, createMcpDispatchRuntime } from "#agdf-dispatch-worker";
 import { ownedLockForwarder } from "./worker.js";
 
 function send(message) {
@@ -14,7 +14,7 @@ subscribe(OWNED_LOCK_CHANNEL, ownedLockForwarder(send));
 let runtime, phase = 'setup';
 try {
   send({ type: 'phase', phase: 'runtime_provenance' });
-  runtime = createMcpDispatchRuntime({ surface: workerData.surface, ...(workerData.commandGroups !== undefined ? { commandGroups: workerData.commandGroups } : {}) });
+  runtime = createMcpDispatchRuntime({ surface: workerData.surface, materialGrants: workerData.materialGrants, inputContext: workerData.inputContext, ...(workerData.commandGroups !== undefined ? { commandGroups: workerData.commandGroups } : {}) });
   if (runtime.trustedContext.provenanceStatus !== "matched") {
     send({ type: "failure", code: "runtime_provenance_invalid", dispatch: "not_dispatched" });
   } else if (runtime.trustedContext.expectedVersion !== workerData.expectedVersion) {

package/generated/plugins/copilot/agdf/mcp/server/src/worker.js

@@ -30,21 +30,30 @@ export function createWorkerDispatchExecutor({
   // Reserve up to one second instead of beginning shutdown at the deadline.
   const terminationReserveMs = Math.min(1_000, Math.max(1, Math.floor(timeoutMs / 4)));
   let active = null;
+  let closed = false;
+  const waiting = [];
+  const rejectWaiting = error => { for (const job of waiting.splice(0)) { job.cleanup(); job.reject(error); } };
+  const drain = () => {
+    if (active || closed || !waiting.length) return;
+    const job = waiting.shift(); job.cleanup();
+    execute(job.argumentsValue, { ...job.options, deadline: job.deadline }).then(job.resolve, job.reject).finally(drain);
+  };
   const event = (phase, started) => {
     try { onEvent({ phase, elapsed_ms: performance.now() - started }); } catch {}
   };
-  return Object.freeze({
-    async execute(argumentsValue, { signal, toolName } = {}) {
+  const execute = async (argumentsValue, { signal, toolName, trusted, deadline: queuedDeadline } = {}) => {
       if (active) throw new DispatchExecutionError("dispatch_busy", 'not_dispatched');
       if (signal?.aborted) throw new DispatchExecutionError("dispatch_cancelled", 'not_dispatched');
       return new Promise((resolve, reject) => {
         let settled = false, exited = false, completion, workerPhase = 'worker_start';
         let confirmExit;
         const actualExit = new Promise(resolve => { confirmExit = resolve; });
-        const started = performance.now(), deadline = started + timeoutMs;
+        const started = performance.now(), deadline = queuedDeadline ?? started + timeoutMs;
+        const budget = deadline - started;
+        if (budget <= 0) { reject(new DispatchExecutionError('dispatch_timeout', 'not_dispatched')); return; }
         let worker;
         try { worker = new WorkerClass(WORKER_URL, {
-          workerData: { surface, expectedVersion, commandGroups, argumentsValue, toolName: toolName ?? null },
+          workerData: { surface, expectedVersion, commandGroups, argumentsValue, toolName: toolName ?? null, materialGrants: trusted?.materialGrants, inputContext: trusted?.inputContext },
         }); } catch { reject(new DispatchExecutionError('dispatch_worker_failed', 'not_dispatched')); return; }
         event('worker_start', started);
         const current = { worker, timer: null, cleanupSignal: null, cancel: () => finish(reject, new DispatchExecutionError("dispatch_cancelled")) };
@@ -62,7 +71,7 @@ export function createWorkerDispatchExecutor({
           try { onEvent({ phase: 'locks_released', elapsed_ms: performance.now() - started, count: released }); } catch {}
         };
         // Called only after actual exit or confirmed termination: the thread no longer runs.
-        const release = () => { releaseHeldLocks(); if (active === current) active = null; };
+        const release = () => { releaseHeldLocks(); if (active === current) { active = null; queueMicrotask(drain); } };
         const finish = (callback, value) => {
           if (settled) return completion;
           settled = true;
@@ -87,6 +96,8 @@ export function createWorkerDispatchExecutor({
             } else {
               // A late actual exit may release capacity; rejection alone never proves termination.
               event('termination_unconfirmed', started);
+              current.unconfirmed = true;
+              rejectWaiting(new DispatchExecutionError('dispatch_busy', 'not_dispatched'));
               reject(new DispatchExecutionError('dispatch_worker_termination_unconfirmed', 'unknown', undefined, {
                 ...(callback === reject && value instanceof DispatchExecutionError ? { cause_code: value.code } : {}),
                 worker_phase: workerPhase,
@@ -100,7 +111,8 @@ export function createWorkerDispatchExecutor({
           current.cleanupSignal = () => signal.removeEventListener("abort", cancel);
           signal.addEventListener("abort", cancel, { once: true });
         }
-        current.timer = setTimeout(() => finish(reject, new DispatchExecutionError("dispatch_timeout")), timeoutMs - terminationReserveMs);
+        current.timer = setTimeout(() => finish(reject, new DispatchExecutionError("dispatch_timeout")),
+          budget - Math.min(terminationReserveMs, Math.max(1, Math.floor(budget / 4))));
         worker.on("message", message => {
           // Lock messages also arrive after settlement while the worker drains.
           if (message?.type === 'lock') {
@@ -127,8 +139,42 @@ export function createWorkerDispatchExecutor({
         // Cover an abort racing listener installation.
         if (signal?.aborted) cancel();
       });
+    };
+  return Object.freeze({
+    execute(argumentsValue, options = {}) {
+      if (closed) return Promise.reject(new DispatchExecutionError(active ? 'dispatch_busy' : 'dispatch_cancelled', 'not_dispatched'));
+      if (options.signal?.aborted) return Promise.reject(new DispatchExecutionError('dispatch_cancelled', 'not_dispatched'));
+      const deadline = performance.now() + timeoutMs;
+      if (!active && !waiting.length) return execute(argumentsValue, { ...options, deadline });
+      // Only immutable Inspect requests wait. Commands still report contention;
+      // no write is replayed, parallelized or admitted after unknown termination.
+      if (options.toolName !== 'agdf_inspect' || active?.unconfirmed)
+        return Promise.reject(new DispatchExecutionError('dispatch_busy', 'not_dispatched'));
+      if (waiting.length >= 8) return Promise.reject(new DispatchExecutionError('resource_limit', 'not_dispatched'));
+      return new Promise((resolve, reject) => {
+        const job = { argumentsValue, options, deadline, resolve, reject };
+        const remove = error => {
+          const index = waiting.indexOf(job);
+          if (index < 0) return;
+          waiting.splice(index, 1); job.cleanup(); reject(error);
+        };
+        const abort = () => remove(new DispatchExecutionError('dispatch_cancelled', 'not_dispatched'));
+        const timer = setTimeout(() => remove(new DispatchExecutionError('dispatch_timeout', 'not_dispatched')), timeoutMs);
+        job.cleanup = () => { clearTimeout(timer); options.signal?.removeEventListener('abort', abort); };
+        waiting.push(job); options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted) abort();
+      });
     },
-    async close() { await active?.cancel(); },
+    async close() { closed = true; rejectWaiting(new DispatchExecutionError('dispatch_cancelled', 'not_dispatched')); await active?.cancel(); },
     get active() { return Boolean(active); },
   });
 }
+
+export function createAgdfWorkerExecutor(runtime, options = {}) {
+  return createWorkerDispatchExecutor({
+    surface: runtime.trustedContext.surface,
+    expectedVersion: runtime.trustedContext.expectedVersion,
+    commandGroups: runtime.trustedContext.commandGroups,
+    ...options,
+  });
+}

package/generated/plugins/copilot/agdf/meta/agdf-agent-router.md

@@ -109,7 +109,7 @@ Structured Delivery Mode must respect gates, reviews and closeout discipline.
 | `clean-implementation-review` | evidence dimension: inspect whether the solution is structurally clean | supports Quality Readiness; not a TP or QA substitute |
 | `code-review` | evidence dimension: review the actual diff for defects, regression and security findings | supports Quality Readiness; does not replace QA |
 | `delivery-closeout` | commit/PR-near handoff after QA/OR/UAT | never performs VCS actions automatically |
-| `ur-definition` | bound UR drafting, clarification or revision | content only; preserves approved intent |
+| `ur-definition` | UR drafting in planning scope or a bound Run | content only; no start or approval authority |
 | `prd-definition` | bound PRD drafting, clarification or revision | content only; preserves approved intent |
 | `sd-definition` | bound SD content | content only; preserves approved intent |
 | `tp-definition` | bound TP content | content only; preserves approved sources |
@@ -120,7 +120,7 @@ Structured Delivery Mode must respect gates, reviews and closeout discipline.
 <!-- AGDF-SKILL-ROUTING:END -->
 
 For named operations, use the catalog owner in `contracts/request-activation.md`; active-run
-inventory uses `control.doctor` with all-active inspection.
+inventory uses `control.inventory`.
 For skill or delivery routes, select exactly one primary skill first.
 Add more only when they cover a distinct concrete risk dimension.
 Do not choose `brownfield-analysis` as the first primary skill for a fresh "I want to build/change X" prompt unless `gate-check` or existing live AGDF control state already makes implementation preparation the next allowed action.
@@ -148,7 +148,7 @@ When the target repository uses the AGDF control scaffold, keep live control fil
 Use templates as starting points only.
 
 Do not let chat history become the source of truth for gate state, approvals, evidence, backlog status or durable Brownfield knowledge.
-After editing a run or its listed artefacts, record the revision with the dispatch validator's `run-update` before `gate-check`; record an exact gate reply only with `run-approve`, never by editing Approvals.
+Stage current reviewed material and record it through the inspected typed owner; never edit a bound document or Run and reseal it. Current control, approvals and document references derive from canonical typed records. Only a fresh deliberate reply to the frozen presentation records an approval.
 
 AGDF is agent-native first and CLI-verifiable by design: read the live control state, apply the active skill and make the next allowed step explicit.
 Use `init` only when durable control state is explicitly requested, the repository already uses `.agdf/control/` as its live AGDF working state, or a deterministic CLI/CI setup path is being executed.

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

@@ -1,7 +1,12 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.20.2",
+  "version": "0.30.0",
+  "planning": {
+    "schema": "planned-ur-v1",
+    "protocol_version": 1,
+    "authoring_owner": "ur-definition"
+  },
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",
@@ -440,8 +445,8 @@
         "ur-definition"
       ],
       "discovery": "automatic",
-      "useFor": "bound UR drafting, clarification or revision",
-      "boundary": "content only; preserves approved intent",
+      "useFor": "UR drafting in planning scope or a bound Run",
+      "boundary": "content only; no start or approval authority",
       "dispatch": {
         "mode": "judgement_required",
         "requiresControlSnapshot": true

package/generated/plugins/copilot/agdf/meta/distribution-profile-history.json

@@ -148,6 +148,13 @@
       "profile_id": "runtime-plugin",
       "entry_digest": "1b194df6abf5de884b4d69ab38cde567b5c28674f392ef853678800e05de7e65",
       "status": "supported"
+    },
+    "0.30.0": {
+      "contract_id": "five-profile-v1",
+      "provenance_schema_version": 1,
+      "profile_id": "runtime-plugin",
+      "entry_digest": "05a4645b92ab7f33c40ae676f7e92c95f618b86e3fc031684cfbac8bf6b21ce6",
+      "status": "supported"
     }
   }
 }

package/generated/plugins/copilot/agdf/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "agdf",
-  "version": "0.20.2",
+  "version": "0.30.0",
   "description": "Control layer for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/plugins/copilot/agdf/runtime/agdf-session-check.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // Generated by scripts/sync-plugin-runtime.js; do not edit.
-import { spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
@@ -93,26 +93,18 @@ if (process.argv.length !== 2) {
   let repositoryControl;
   const deadline = Date.now() + 10000;
   if (repositoryRoot) {
-    const child = spawnSync(process.execPath, [validator, "doctor", "--all-active", "--json", "--dir", repositoryRoot], {
-      cwd: repositoryRoot,
-      env: { ...process.env, AGDF_SURFACE: process.env.AGDF_SURFACE || "plugin" },
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 10000,
-      maxBuffer: 1024 * 1024,
+    const runtimeEnv = { ...process.env, AGDF_SURFACE: process.env.AGDF_SURFACE || "plugin" };
+    // Doctor runs beside the compatibility inspection: run first, it can exhaust the shared deadline alone.
+    const doctorOutput = new Promise((resolveDoctor) => {
+      const child = execFile(process.execPath, [validator, "doctor", "--all-active", "--json", "--dir", repositoryRoot], {
+        cwd: repositoryRoot,
+        env: runtimeEnv,
+        encoding: "utf8",
+        timeout: 10000,
+        maxBuffer: 1024 * 1024,
+      }, (_error, stdout) => resolveDoctor(stdout));
+      child.stdin?.end();
     });
-    try {
-      const report = JSON.parse(child.stdout || "{}");
-      const supportedStatuses = new Set(["pass", "warn", "revise", "block"]);
-      const rawStatus = typeof report.status === "string" ? report.status : "unknown";
-      const rawFindings = report.summary?.findings ?? report.reports?.reduce((sum, item) => sum + (item.summary?.findings ?? 0), 0) ?? 0;
-      check = {
-        status: supportedStatuses.has(rawStatus) ? rawStatus : "unknown",
-        findings: Number.isSafeInteger(rawFindings) && rawFindings >= 0 ? Math.min(rawFindings, 999999) : 0,
-      };
-    } catch {
-      check = { status: "unavailable", findings: 0 };
-    }
     const configPath = join(repositoryRoot, ".agdf", "control", "config.json");
     configState = "missing";
     if (existsSync(configPath)) {
@@ -138,13 +130,25 @@ if (process.argv.length !== 2) {
       }
     }
     repositoryControl = inspectStartupCompatibility({ target: repositoryRoot, executable: process.execPath,
-      validator, env: { ...process.env, AGDF_SURFACE: process.env.AGDF_SURFACE || "plugin" }, deadline });
+      validator, env: runtimeEnv, deadline });
     const invocation = startupMaintenanceInvocation(repositoryControl, { executable: process.execPath,
       validator, language: languages?.chat || "en" });
     if (invocation) {
       repositoryControl.invocation = invocation;
       repositoryControl.notice = renderStartupControlNotice(repositoryControl, { language: languages?.chat || "en" });
     }
+    try {
+      const report = JSON.parse((await doctorOutput) || "{}");
+      const supportedStatuses = new Set(["pass", "warn", "revise", "block"]);
+      const rawStatus = typeof report.status === "string" ? report.status : "unknown";
+      const rawFindings = report.summary?.findings ?? report.reports?.reduce((sum, item) => sum + (item.summary?.findings ?? 0), 0) ?? 0;
+      check = {
+        status: supportedStatuses.has(rawStatus) ? rawStatus : "unknown",
+        findings: Number.isSafeInteger(rawFindings) && rawFindings >= 0 ? Math.min(rawFindings, 999999) : 0,
+      };
+    } catch {
+      check = { status: "unavailable", findings: 0 };
+    }
   }
   const facts = {
     context_state: hostContext.context_state,

package/generated/plugins/copilot/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-defaults.json

@@ -0,0 +1,9 @@
+{
+  "schema_version": 1,
+  "preferences": {
+    "chat_language": "en",
+    "artifact_language": "en",
+    "presentation_route": "markdown",
+    "gate_check_variant": null
+  }
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-defaults.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "preferences"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "preferences": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["chat_language", "artifact_language", "presentation_route", "gate_check_variant"],
+      "properties": {
+        "chat_language": { "type": "string", "maxLength": 64, "pattern": "^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$" },
+        "artifact_language": { "type": "string", "maxLength": 64, "pattern": "^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$" },
+        "presentation_route": { "enum": ["markdown", "automatic", "fallback"] },
+        "gate_check_variant": { "enum": [null, "status-card", "approval-envelope"] }
+      }
+    }
+  }
+}