create-agdf 0.31.0 → 0.32.0

package/generated/plugins/copilot/agdf/mcp/server/src/generation-runtime.js

@@ -15,7 +15,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
   // Companion events (SD SDD-006): this generation executed the call, so it journals the final result
   // once, before the result leaves; a failing journal never changes or delays the result.
   function journal(name, args, projected) {
-    try { runtime.observeOutcome?.(name, args, projected); } catch { /* notification only */ }
+    try { return runtime.observeOutcome?.(name, args, projected) === true; } catch { return false; /* notification only */ }
   }
   function send(input, kind, payload) {
     const reply = generationMessage(epoch, generation, kind, payload, {}, input.original_operation_id, input.request_id);
@@ -41,6 +41,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
           runtime = await createMcpDecisionRuntime({ runtime, ui });
         }
         if (runtime.ui) uiDigest = loadCockpitResource(runtime.ui).digest;
+        if (runtime.mode === 'cockpit' && uiDigest) runtime.bindResourceIdentity({ digest: uiDigest, version: inspected.expectedVersion });
         // Inspect reports package-owned immutable identities, not caller evidence.
         sdkDigest = inspected.generationIdentity.sdk_digest; serverDigest = inspected.generationIdentity.server_digest;
         executor = runtime.mode === 'cockpit' ? null : createAgdfWorkerExecutor(runtime, { releaseOwnedLock: releaseAbandonedOwnedLock });
@@ -68,7 +69,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
         ++inflight;
         const parentOwned = typeof tool.parentOwned === 'function' ? tool.parentOwned(args) : tool.parentOwned;
         const started = performance.now();
-        let result, phase = parentOwned || !executor ? 'parse' : 'execute';
+        let result, journaled = false, phase = parentOwned || !executor ? 'parse' : 'execute';
         try {
           phase = 'parse';
           args = runtime.prepareInput?.(name, args) ?? args;
@@ -82,13 +83,14 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
           if (name === 'agdf_inspect' && args.operation === 'operation-status' && result.report?.status === 'recorded'
             && (result.report.receipt?.operation_id ?? result.report.receipt?.operation?.operation_id) === args.module.split('/').at(-1)) unknown.delete(args.module.split('/').at(-1));
           const projected = runtime.projectToolResult(name, args, result);
-          journal(name, args, projected);
+          journaled = journal(name, args, projected);
           send(input, 'result', projected);
         } catch (error) {
           const facts = runtime.normalizeFailure(error, { phase });
           if (input.original_operation_id && facts.dispatch !== 'not_dispatched') unknown.add(input.original_operation_id);
           const projected = runtime.projectToolResult(name, args, runtime.failure(facts.code, name, args, { ...facts, elapsed_ms: performance.now() - started }), facts);
-          journal(name, args, projected);
+          // One call leaves at most one event: a failure after its result left an event adds none.
+          if (!journaled) journal(name, args, projected);
           send(input, 'result', projected);
         } finally { --inflight; }
       }

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

@@ -211,8 +211,9 @@ export async function createOwnedGenerationFacade({ runtime, publisher, createCo
       operations.set(key, row);
     }
     ++row.inflight; event(row, 'invoke', name);
+    let replied;
     try {
-      const result = (await request(row, 'invoke', { name, arguments: args }, actualContext, canonical ? args.operation_id : null, invokeMs)).payload;
+      const result = replied = (await request(row, 'invoke', { name, arguments: args }, actualContext, canonical ? args.operation_id : null, invokeMs)).payload;
       if (canonical && result.outcome === 'effect_unknown') row.unknown.add(key);
       if (name === 'agdf_inspect' && args.operation === 'operation-status' && result.report?.status === 'recorded'
         && (result.report.receipt?.operation_id ?? result.report.receipt?.operation?.operation_id) === id) row.unknown.delete(key);
@@ -228,7 +229,12 @@ export async function createOwnedGenerationFacade({ runtime, publisher, createCo
         }
       }
       return result;
-    } catch (error) { if (canonical && error.dispatch !== 'not_dispatched') row.unknown.add(key); throw error; }
+    } catch (error) {
+      // The generation journaled the reply it sent; a failure raised here afterwards carries it, so the
+      // server adds no second companion event for the same call.
+      if (replied && error && typeof error === 'object') error.generationResult = replied;
+      if (canonical && error.dispatch !== 'not_dispatched') row.unknown.add(key); throw error;
+    }
     finally { --row.inflight; if (closed && !row.inflight && !row.unknown.size) void retire(row, true); }
   }
   current = await reserve(publisher.initial, {}); current.state = 'current'; event(current, 'admitted');

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

@@ -41,7 +41,10 @@ export async function runMcpServer({ surface, cockpitDir, cockpitMode, runtime,
     runtime = thin ? await dispatcherRuntime.createMcpDecisionTransportRuntime({ runtime, ui })
       : await dispatcherRuntime.createMcpDecisionRuntime({ runtime, ui });
   }
-  if (runtime.mode === 'cockpit') loadCockpitResource(runtime.ui);
+  if (runtime.mode === 'cockpit') {
+    const resource = loadCockpitResource(runtime.ui);
+    runtime.bindResourceIdentity?.({ digest: resource.digest, version: serverVersion });
+  }
   let transport;
   if (ownedPublication) {
     const { createOwnedGenerationFacade } = await import('./generation.js');

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

@@ -156,7 +156,12 @@ export function buildAgdfServer({ runtime, executor, era, preparedCallStore } =
   const journaling = () => !runtime.requiresProjectedResult && typeof runtime.observeOutcome === 'function';
   const journalingFailures = () => typeof runtime.observeOutcome === 'function';
   const journal = (name, input, projected) => {
-    try { runtime.observeOutcome(name, input, projected); } catch { /* notification only */ }
+    try { return runtime.observeOutcome(name, input, projected) === true; } catch { return false; /* notification only */ }
+  };
+  // Whether a result the generation returned left an event there (it journals what it produces).
+  const generationJournaled = (name, input, result) => {
+    if (!runtime.requiresProjectedResult || !result) return false;
+    try { return runtime.observesOutcome?.(name, input, result) === true; } catch { return false; }
   };
   const uiAllowed = (context) => !gated || requestDeclaresMcpAppUi(server.server, context, runtime.ui.mimeType);
   const supportsUi = context => !!runtime.ui && requestDeclaresMcpAppUi(server.server, context, runtime.ui.mimeType);
@@ -217,6 +222,8 @@ export function buildAgdfServer({ runtime, executor, era, preparedCallStore } =
         }
         let parentOwned;
         let phase = 'parse';
+        // Whether this call's result already left a companion event (written here or by its generation).
+        let journaled = false;
         try {
           phase = 'parse';
           argumentsValue = preparedCalls.resolve(name, argumentsValue);
@@ -228,8 +235,12 @@ export function buildAgdfServer({ runtime, executor, era, preparedCallStore } =
             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,
-            trusted: runtime.prepareDispatch?.(name, argumentsValue) });
+          } else {
+            result = await dispatchExecutor.execute(argumentsValue, { signal: context.signal, toolName: name,
+              trusted: runtime.prepareDispatch?.(name, argumentsValue) });
+          }
+          // Behind the facade the generation journaled the result it returned.
+          journaled = generationJournaled(name, argumentsValue, result);
           if (runtime.postprocessToolResult) result = await runtime.postprocessToolResult(name, argumentsValue, result,
             { uiSupported: supportsUi(context), client: requestMcpClientInfo(server.server, context) });
           // Validate the producer and its canonical domain before consuming any
@@ -237,10 +248,12 @@ export function buildAgdfServer({ runtime, executor, era, preparedCallStore } =
           const checked = Object.hasOwn(result._meta ?? {}, 'agdf/tool-result') || runtime.requiresProjectedResult ? result
             : runtime.projectToolResult(name, argumentsValue, result);
           const { domain } = consume(name, checked);
-          if (journaling()) journal(name, argumentsValue, checked);
+          if (journaling()) journaled = journal(name, argumentsValue, checked);
           const continued = await nextRead(domain, context);
           return respond(name, argumentsValue, checked, serialize ?? runtime.serialize, context, undefined, continued.next_read);
         } catch (error) {
+          // A facade failure raised after its generation had replied carries that reply.
+          journaled ||= generationJournaled(name, argumentsValue, error?.generationResult);
           const facts = runtime.normalizeFailure(error, { phase });
           const help = phase === 'parse' ? preparedCalls.validationHint(name, argumentsValue) : '';
           const failure = { ...runtime.failure(facts.code, name, argumentsValue, { ...facts, elapsed_ms: performance.now() - started }),
@@ -248,7 +261,8 @@ export function buildAgdfServer({ runtime, executor, era, preparedCallStore } =
           // 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);
-          if (journalingFailures()) journal(name, argumentsValue, projected);
+          // One call leaves at most one event: a failure after its result left an event adds none.
+          if (journalingFailures() && !journaled) journal(name, argumentsValue, projected);
           return respond(name, argumentsValue, projected, serialize ?? runtime.serialize, context, facts);
         }
       },

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "planning": {
     "schema": "planned-ur-v1",
     "protocol_version": 1,

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

@@ -162,6 +162,13 @@
       "profile_id": "runtime-plugin",
       "entry_digest": "d3a3b0a1fc9e3312cb8a9437a4acf8ba99a563b2dab665b38feec8e2257e4f23",
       "status": "supported"
+    },
+    "0.32.0": {
+      "contract_id": "five-profile-v1",
+      "provenance_schema_version": 1,
+      "profile_id": "runtime-plugin",
+      "entry_digest": "de32d75f665191ff8aebe1a4186f6e156164a3394c968640f109a6c5d58b0cb7",
+      "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.31.0",
+  "version": "0.32.0",
   "description": "Control layer for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

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

@@ -1379,7 +1379,12 @@
           "moreRuns": "+ {count} more",
           "position": "{position} of {count} open runs",
           "events": "Events",
-          "material": "Material"
+          "material": "Material",
+          "newRun": "New run",
+          "gatePurpose": "What this gate decides",
+          "checkedFolder": "Checked project folder",
+          "finding": "Finding",
+          "step": "Step {position} of {count}"
         },
         "actions": {
           "retry": "Read again",
@@ -1391,6 +1396,8 @@
           "soundOff": "Sound off",
           "expand": "More",
           "collapse": "Less",
+          "infoShow": "ⓘ Details",
+          "infoHide": "ⓘ Hide details",
           "previous": "Previous run",
           "next": "Next run",
           "about": "About",
@@ -1426,6 +1433,7 @@
           "blockiert": "blocked",
           "fertig": "done",
           "bereit": "idle",
+          "notSetUp": "not set up",
           "unreadable": "unreadable"
         },
         "reasons": {
@@ -1438,8 +1446,67 @@
           "building": "In progress: {gate}",
           "ended": "Run ended",
           "idle": "No run shown",
+          "completionUnconfirmed": "Completion not confirmed",
           "unreadable": "Run not readable: {reason}"
         },
+        "routes": {
+          "quick_task": "Compact Delivery",
+          "verified_change": "Verified Change",
+          "structured": "Structured delivery",
+          "undecided": "Delivery path open"
+        },
+        "activity": {
+          "draft": {
+            "working": "drafting the {gate}",
+            "idle": "{gate} draft is next"
+          },
+          "analysis": {
+            "working": "analysing the existing system",
+            "idle": "System analysis is next"
+          },
+          "route": {
+            "working": "choosing the delivery path",
+            "idle": "Delivery path is next"
+          },
+          "build": {
+            "working": "building and testing",
+            "idle": "Implementation is next"
+          },
+          "review": {
+            "working": "reviewing the code",
+            "idle": "Code review is next"
+          },
+          "quality": {
+            "working": "checking the quality",
+            "idle": "Quality check is next"
+          },
+          "acceptance": {
+            "working": "preparing the acceptance",
+            "idle": "Acceptance is next"
+          },
+          "closeout": {
+            "working": "closing out",
+            "idle": "Closeout is next"
+          },
+          "other": {
+            "working": "working on: {step}",
+            "idle": "{step} is next"
+          }
+        },
+        "turn": {
+          "you": "Your turn",
+          "claude": "Claude is working",
+          "blocked": "Blocked",
+          "approve": "Approve {gate}",
+          "decide": "Decide: {gate}",
+          "inChat": "In the chat with “{approval}”",
+          "moment": "One moment",
+          "next": "Up next",
+          "drafting": "I'm preparing a draft for you: {step}",
+          "workingOn": "I'm working on it: {step}",
+          "draft": "Draft: {step}",
+          "resume": "Tell me in the chat when I should carry on."
+        },
         "unreadable": {
           "missing": "run state file missing or not readable",
           "too_large": "run state file too large",
@@ -1459,8 +1526,13 @@
         "messages": {
           "reading": "Reading run state …",
           "noControl": "No AGDF control folder in “{folder}”.",
-          "noControlHint": "Checked project folder: {path}",
+          "notSetUp": "AGDF isn't set up in this project yet.",
+          "notSetUpHint": "Tell me in the chat if you'd like to use AGDF here – I'll set it up with you.",
           "noOpenRuns": "No open runs in this project.",
+          "allRunsDone": "All runs across the line. 🏁",
+          "allRunsDoneHint": "What's next? Just tell me in the chat.",
+          "noRunsYet": "Starting grid empty.",
+          "noRunsYetHint": "Tell me in the chat what you have in mind – I'll get the first run ready.",
           "noRunAssigned": "No run assigned",
           "noRunAssignedHint": "No run changed in this session. Choose an open run to show it here.",
           "unreadable": "Run state not readable: {reason}",
@@ -2858,7 +2930,12 @@
           "moreRuns": "+ {count} weitere",
           "position": "{position} von {count} offenen Runs",
           "events": "Ereignisse",
-          "material": "Material"
+          "material": "Material",
+          "newRun": "Neues Vorhaben",
+          "gatePurpose": "Wozu dieses Gate da ist",
+          "checkedFolder": "Geprüfter Projektordner",
+          "finding": "Befund",
+          "step": "Schritt {position} von {count}"
         },
         "actions": {
           "retry": "Neu lesen",
@@ -2870,6 +2947,8 @@
           "soundOff": "Ton aus",
           "expand": "Mehr",
           "collapse": "Weniger",
+          "infoShow": "ⓘ Details",
+          "infoHide": "ⓘ Details ausblenden",
           "previous": "Vorheriger Run",
           "next": "Nächster Run",
           "about": "About",
@@ -2905,6 +2984,7 @@
           "blockiert": "blockiert",
           "fertig": "fertig",
           "bereit": "bereit",
+          "notSetUp": "nicht eingerichtet",
           "unreadable": "nicht lesbar"
         },
         "reasons": {
@@ -2917,8 +2997,67 @@
           "building": "In Arbeit: {gate}",
           "ended": "Run beendet",
           "idle": "Kein Run angezeigt",
+          "completionUnconfirmed": "Abschluss nicht bestätigt",
           "unreadable": "Run nicht lesbar: {reason}"
         },
+        "routes": {
+          "quick_task": "Compact Delivery",
+          "verified_change": "Verified Change",
+          "structured": "Strukturierte Lieferung",
+          "undecided": "Lieferweg noch offen"
+        },
+        "activity": {
+          "draft": {
+            "working": "schreibt am {gate}-Entwurf",
+            "idle": "{gate}-Entwurf steht an"
+          },
+          "analysis": {
+            "working": "analysiert den Bestand",
+            "idle": "Bestandsanalyse steht an"
+          },
+          "route": {
+            "working": "wählt den Lieferweg",
+            "idle": "Lieferweg steht an"
+          },
+          "build": {
+            "working": "baut und testet",
+            "idle": "Umsetzung steht an"
+          },
+          "review": {
+            "working": "prüft den Code",
+            "idle": "Code-Prüfung steht an"
+          },
+          "quality": {
+            "working": "prüft die Qualität",
+            "idle": "Qualitätsprüfung steht an"
+          },
+          "acceptance": {
+            "working": "bereitet die Abnahme vor",
+            "idle": "Abnahme steht an"
+          },
+          "closeout": {
+            "working": "schließt ab",
+            "idle": "Abschluss steht an"
+          },
+          "other": {
+            "working": "arbeitet an: {step}",
+            "idle": "{step} steht an"
+          }
+        },
+        "turn": {
+          "you": "Du bist dran",
+          "claude": "Claude arbeitet",
+          "blocked": "Blockiert",
+          "approve": "{gate} freigeben",
+          "decide": "Entscheidung treffen: {gate}",
+          "inChat": "Im Chat mit „{approval}“",
+          "moment": "Einen Augenblick",
+          "next": "Als Nächstes",
+          "drafting": "Ich bereite einen Entwurf für dich vor: {step}",
+          "workingOn": "Ich arbeite gerade daran: {step}",
+          "draft": "Entwurf: {step}",
+          "resume": "Sag mir im Chat, wenn ich weitermachen soll."
+        },
         "unreadable": {
           "missing": "Run-Datei fehlt oder ist nicht lesbar",
           "too_large": "Run-Datei ist zu groß",
@@ -2938,8 +3077,13 @@
         "messages": {
           "reading": "Run-Status wird gelesen …",
           "noControl": "Kein AGDF-Kontrollordner in „{folder}“.",
-          "noControlHint": "Geprüfter Projektordner: {path}",
+          "notSetUp": "AGDF ist in diesem Projekt noch nicht eingerichtet.",
+          "notSetUpHint": "Sag mir im Chat, wenn du AGDF hier nutzen möchtest – ich richte es mit dir ein.",
           "noOpenRuns": "Keine offenen Runs in diesem Projekt.",
+          "allRunsDone": "Alle Runs im Ziel. 🏁",
+          "allRunsDoneHint": "Was steht als Nächstes an? Sag's mir im Chat.",
+          "noRunsYet": "Startaufstellung leer.",
+          "noRunsYetHint": "Erzähl mir im Chat, was du vorhast – ich mach den ersten Run startklar.",
           "noRunAssigned": "Kein Run zugeordnet",
           "noRunAssignedHint": "In dieser Sitzung hat sich kein Run geändert. Wähle einen offenen Run, um ihn hier zu zeigen.",
           "unreadable": "Run-Status nicht lesbar: {reason}",

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "planning": {
     "schema": "planned-ur-v1",
     "protocol_version": 1,

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/mcp-dispatch-runtime.js

@@ -44,7 +44,7 @@ export async function createMcpCockpitRuntime({ surface, cockpitDir, cockpitMode
     import("#agdf-core/control-inspect/cockpit-session.js"),
     import("#agdf-core/control-read/snapshot.js"),
   ]);
-  const session = createCockpitSessionService(root, { pluginMode });
+  const session = createCockpitSessionService(root, { pluginMode, integrationSurface: surface });
   const renderDefinition = pluginMode ? COCKPIT_PLUGIN_RENDER_DEFINITION : COCKPIT_RENDER_DEFINITION;
   const tools = [
     { name: renderDefinition.name, definition: renderDefinition,
@@ -54,6 +54,7 @@ export async function createMcpCockpitRuntime({ surface, cockpitDir, cockpitMode
   ];
   // Claude Code renders no MCP app UI today; its cockpit stays hidden until a client declares support.
   return Object.freeze({ ...errorSupport(true), mode: 'cockpit', definition: renderDefinition, tools,
+    bindResourceIdentity: identity => session.bindResourceIdentity(identity),
     producerIdentity: inspected.generationIdentity ?? null,
     uiCapabilityRequired: pluginMode || surface === 'claude', responseLimit: READ_LIMITS.response,
     ...(pluginMode ? { unsupportedUiCode: 'host_ui_unsupported' } : {}),
@@ -106,6 +107,7 @@ export function createMcpDispatchRuntime({ surface, inspected = inspectMcpDispat
     readBudget,
     delivery,
     observeOutcome: (name, input, result) => journal.observe(name, input, result),
+    observesOutcome: (name, input, result) => journal.observes(name, input, result),
     async postprocessToolResult(name, input, result) {
       const configuration = protocol.configurationProjection(input);
       if (configuration && name === 'agdf_inspect' && result.report) result = { ...result, report: { ...result.report, effective_configuration: configuration } };
@@ -142,6 +144,7 @@ export async function createMcpDecisionRuntime({ runtime, ui, appOnlyMediationQu
     action: (input, host) => session.action(input, host), close: () => session.close() });
   return Object.freeze({ ...protocol,
     observeOutcome: (name, input, result) => runtime.observeOutcome?.(name, input, result) ?? false,
+    observesOutcome: (name, input, result) => runtime.observesOutcome?.(name, input, result) ?? false,
     async postprocessToolResult(name, input, result, { uiSupported, client } = {}) {
       if (name === 'agdf_inspect' && input.operation === 'native-qualification' && result.report?.available) {
         return { ...result, report: { ...result.report, ui_rendering_support: uiSupported ? 'supported' : 'unsupported',