create-agdf 0.20.1 → 0.30.0

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

@@ -1,11 +1,13 @@
+import { boundStdioOutput } from './stdio-output.js';
 import { McpServer, ProtocolError, ProtocolErrorCode, fromJsonSchema } from "@modelcontextprotocol/server";
-import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { serveStdio, StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { AjvJsonSchemaValidator } from '@modelcontextprotocol/server/validators/ajv';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
-import { DispatchExecutionError, createWorkerDispatchExecutor } from "./worker.js";
+import { DispatchExecutionError } from "./worker.js";
 import { loadCockpitResource } from './cockpit-resource.js';
-import { requestDeclaresMcpAppUi, requestMcpClientInfo, requestMcpClientCapabilities } from "./ui-capability.js";
+import { requestDeclaresMcpAppUi, requestMcpClientInfo, requestMcpClientCapabilities, requiresMcpAppUi,
+  missingMcpAppUi, capabilityTransport, modernToolUiDenial } from "./ui-capability.js";
 
 export const SERVER_NAME = "agdf-mcp";
 
@@ -38,7 +40,7 @@ function toolResult(runtime, name, input, result, serialize = runtime.serialize,
   return response;
 }
 
-export function buildAgdfServer({ runtime, executor } = {}) {
+export function buildAgdfServer({ runtime, executor, era } = {}) {
   if (!runtime?.definition || typeof runtime.serialize !== "function") {
     throw new TypeError("AGDF MCP runtime is required");
   }
@@ -57,7 +59,14 @@ export function buildAgdfServer({ runtime, executor } = {}) {
     },
     close: async () => runtime.close?.(),
   };
-  const server = new McpServer(
+  const registrations = new Map();
+  class AgdfServer extends McpServer {
+    async connect(transport) {
+      return super.connect(capabilityTransport(transport, message => modernToolUiDenial(message,
+        { era: era ?? (this.server.getNegotiatedProtocolVersion() === '2026-07-28' ? 'modern' : 'legacy'), runtime, registrations })));
+    }
+  }
+  const server = new AgdfServer(
     { name: SERVER_NAME, version: runtime.trustedContext.expectedVersion },
     { capabilities: { tools: {}, ...(runtime.ui ? { resources: {} } : {}) } },
   );
@@ -87,16 +96,26 @@ export function buildAgdfServer({ runtime, executor } = {}) {
   } };
   for (const tool of tools) {
     const { name, definition, serialize } = tool;
-    server.registerTool(
+    const schema = fromJsonSchema(definition.inputSchema, { getValidator(inputSchema) {
+      const validate = deferredSchemas.getValidator(inputSchema);
+      return input => {
+        const checked = validate(input);
+        if (checked.valid) return checked;
+        const hint = runtime.inputValidationHint?.(name, input);
+        return hint ? { ...checked, errorMessage: `${hint} Schema: ${checked.errorMessage}` } : checked;
+      };
+    } });
+    const registered = server.registerTool(
       name,
       {
         description: definition.description,
         annotations: definition.annotations,
-        inputSchema: fromJsonSchema(definition.inputSchema, deferredSchemas),
+        inputSchema: schema,
         ...(definition.outputSchema ? { outputSchema: fromJsonSchema(definition.outputSchema, deferredSchemas) } : {}),
         ...(definition._meta ? { _meta: definition._meta } : {}),
       },
       async (argumentsValue, context) => {
+        const started = performance.now();
         const denied = !uiAllowed(context) ? runtime.unsupportedUiCode ?? 'resource_denied'
           : tool.requiresUi && !supportsUi(context) ? 'host_ui_unsupported' : null;
         if (denied) {
@@ -104,20 +123,25 @@ export function buildAgdfServer({ runtime, executor } = {}) {
           const failure = runtime.projectToolResult(name, argumentsValue, runtime.failure(denied, name, argumentsValue, facts), facts);
           return respond(name, argumentsValue, failure, serialize ?? runtime.serialize, context, facts);
         }
-        let phase = tool.parentOwned ? 'parse' : 'execute';
+        const parentOwned = typeof tool.parentOwned === 'function' ? tool.parentOwned(argumentsValue) : tool.parentOwned;
+        let phase = parentOwned ? 'parse' : 'execute';
         try {
+          phase = 'parse';
+          argumentsValue = runtime.prepareInput?.(name, argumentsValue) ?? argumentsValue;
+          phase = parentOwned ? 'parse' : 'execute';
           let result;
-          if (tool.parentOwned) {
+          if (parentOwned) {
             const parsed = tool.parse(argumentsValue); phase = 'execute';
             result = await tool.execute(parsed, context.signal,
               { client: requestMcpClientInfo(server.server, context), uiSupported: supportsUi(context) });
-          } else result = await dispatchExecutor.execute(argumentsValue, { signal: context.signal, toolName: name });
+          } else result = await dispatchExecutor.execute(argumentsValue, { signal: context.signal, toolName: name,
+            trusted: runtime.prepareDispatch?.(name, argumentsValue) });
           if (runtime.postprocessToolResult) result = await runtime.postprocessToolResult(name, argumentsValue, result,
             { uiSupported: supportsUi(context), client: requestMcpClientInfo(server.server, context) });
           return respond(name, argumentsValue, result, serialize ?? runtime.serialize, context);
         } catch (error) {
           const facts = runtime.normalizeFailure(error, { phase });
-          const failure = runtime.failure(facts.code, name, argumentsValue, facts);
+          const failure = runtime.failure(facts.code, name, argumentsValue, { ...facts, elapsed_ms: performance.now() - started });
           // A local execution/delivery failure is owned here, including malformed
           // producer output. It never causes re-execution or a second write.
           const projected = runtime.projectToolResult(name, argumentsValue, failure, facts);
@@ -125,12 +149,16 @@ export function buildAgdfServer({ runtime, executor } = {}) {
         }
       },
     );
+    registrations.set(name, { tool, schema, registered });
   }
   if (runtime.ui) {
     const resource = loadCockpitResource(runtime.ui);
     server.registerResource(runtime.mode === 'decision' ? 'AGDF Gate Decision' : runtime.ui.label ?? 'AGDF Cockpit', resource.uri, { mimeType: resource.mimeType, _meta: resource._meta },
       async (_uri, context) => {
-        if (!uiAllowed(context) || runtime.mode === 'decision' && !supportsUi(context)) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "resource_denied");
+        if (requiresMcpAppUi(runtime, { requiresUi: runtime.mode === 'decision' }) && !supportsUi(context)) {
+          if ((era ?? (server.server.getNegotiatedProtocolVersion() === '2026-07-28' ? 'modern' : 'legacy')) === 'modern') throw missingMcpAppUi(runtime.ui.mimeType);
+          throw new ProtocolError(ProtocolErrorCode.InvalidParams, "resource_denied");
+        }
         return { contents: [resource] };
       });
     if (gated || runtime.mode === 'decision') {
@@ -155,12 +183,13 @@ export function buildAgdfServer({ runtime, executor } = {}) {
 
 export function serveAgdfStdio({ runtime, executor, onerror } = {}) {
   const instances = new Set();
-  const handle = serveStdio(() => {
-    const server = buildAgdfServer({ runtime, executor });
+  const handle = serveStdio(({ era }) => {
+    const server = buildAgdfServer({ runtime, executor, era });
     instances.add(server);
     return server;
   }, {
     legacy: "serve",
+    transport: boundStdioOutput(new StdioServerTransport()),
     onerror: () => onerror?.("AGDF_MCP_TRANSPORT_ERROR"),
   });
   return Object.freeze({
@@ -177,11 +206,4 @@ export function serveAgdfStdio({ runtime, executor, onerror } = {}) {
   });
 }
 
-export function createAgdfWorkerExecutor(runtime, options = {}) {
-  return createWorkerDispatchExecutor({
-    surface: runtime.trustedContext.surface,
-    expectedVersion: runtime.trustedContext.expectedVersion,
-    commandGroups: runtime.trustedContext.commandGroups,
-    ...options,
-  });
-}
+export { createAgdfWorkerExecutor } from './worker.js';

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/ui-capability.js

@@ -1,7 +1,55 @@
-import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, MissingRequiredClientCapabilityError, classifyInboundRequest } from "@modelcontextprotocol/server";
 
 // Extension id under which MCP Apps hosts declare UI support (@modelcontextprotocol/ext-apps EXTENSION_ID).
 export const MCP_APP_UI_EXTENSION = "io.modelcontextprotocol/ui";
+export const requiresMcpAppUi = (runtime, tool) => runtime.mode === 'cockpit' && runtime.uiCapabilityRequired === true || tool?.requiresUi === true;
+export const missingMcpAppUi = mimeType => new MissingRequiredClientCapabilityError({
+  requiredCapabilities: { extensions: { [MCP_APP_UI_EXTENSION]: { mimeTypes: [mimeType] } } },
+}, 'resource_denied');
+
+// One narrow Transport decorator; framing, request dispatch, validation and
+// pending-id/drain accounting remain with the original SDK connection.
+export function capabilityTransport(transport, denial) {
+  const wrapped = {
+    onmessage: transport.onmessage,
+    onerror: transport.onerror,
+    onclose: transport.onclose,
+    start: () => transport.start(),
+    send: (message, options) => transport.send(message, options),
+    close: () => transport.close(),
+    get sessionId() { return transport.sessionId; },
+    set sessionId(value) { transport.sessionId = value; },
+    get hasPerRequestStream() { return transport.hasPerRequestStream; },
+  };
+  for (const method of ['setProtocolVersion', 'setSupportedProtocolVersions']) {
+    if (transport[method]) wrapped[method] = (...args) => transport[method](...args);
+  }
+  transport.onerror = error => wrapped.onerror?.(error);
+  transport.onclose = () => wrapped.onclose?.();
+  transport.onmessage = (message, extra) => {
+    const error = denial(message);
+    if (!error) { wrapped.onmessage?.(message, extra); return; }
+    // Sending through the original channel settles its pending request id.
+    Promise.resolve().then(() => transport.send({ jsonrpc: '2.0', id: message.id,
+      error: { code: error.code, message: error.message, data: error.data } }))
+      .catch(cause => wrapped.onerror?.(cause));
+  };
+  return wrapped;
+}
+
+export function modernToolUiDenial(message, { era, runtime, registrations }) {
+  if (era !== 'modern' || message?.method !== 'tools/call') return null;
+  const classified = classifyInboundRequest({ httpMethod: 'POST', body: message });
+  if (classified.kind !== 'modern' || classified.messageKind !== 'request') return null;
+  const entry = registrations.get(message.params?.name);
+  if (!entry?.registered.enabled || !requiresMcpAppUi(runtime, entry.tool)
+      || declaresMcpAppUi(message.params?._meta?.[CLIENT_CAPABILITIES_META_KEY], runtime.ui.mimeType)) return null;
+  const checked = entry.schema['~standard'].validate(message.params.arguments ?? {});
+  // The pinned fromJsonSchema provider is synchronous. Never treat an unknown
+  // asynchronous provider as proof that arguments passed validation.
+  if (checked?.then || checked.issues?.length) return null;
+  return missingMcpAppUi(runtime.ui.mimeType);
+}
 export const requestMcpClientInfo = (server, context) => context?.mcpReq?.envelope?.[CLIENT_INFO_META_KEY] ?? server.getClientVersion();
 export const requestMcpClientCapabilities = (server, context) => context?.mcpReq?.envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? server.getClientCapabilities();
 

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.1",
+  "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
@@ -465,7 +470,8 @@
       "slug": "sd-definition",
       "runtimeContractModules": [
         "sd-definition",
-        "gate-artifact-preparation"
+        "gate-artifact-preparation",
+        "quality"
       ],
       "discovery": "automatic",
       "useFor": "bound SD content",
@@ -479,7 +485,8 @@
       "slug": "tp-definition",
       "runtimeContractModules": [
         "tp-definition",
-        "gate-artifact-preparation"
+        "gate-artifact-preparation",
+        "quality"
       ],
       "discovery": "automatic",
       "useFor": "bound TP content",

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

@@ -141,6 +141,20 @@
       "profile_id": "runtime-plugin",
       "entry_digest": "ac320d0a30e2cf4cfe31c89cbf63c00350c42b50f84f62aa0ad1d366ca90e35d",
       "status": "supported"
+    },
+    "0.20.2": {
+      "contract_id": "five-profile-v1",
+      "provenance_schema_version": 1,
+      "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.1",
+  "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"] }
+      }
+    }
+  }
+}