@aiwg/cockpit 2026.8.17 → 2026.8.19

package/README.md

@@ -2,6 +2,11 @@
 
 # AIWG Cockpit
 
+Cockpit's agentic-sandbox management API version, upstream A2A protocol
+version, and extension `/v1` URI suffixes are independent. See
+[A2A protocol compatibility](../../docs/a2a-protocol-compatibility.md) for the
+0.3/1.0 selection and qualification contract.
+
 **Local control plane for AIWG and multi-stack agentic sessions**
 
 Observe live agent work, attach to sessions, handle approvals, launch runtime

package/bridge/src/server.mjs

@@ -33,6 +33,8 @@ const EXECUTOR_TOKEN_FILE = process.env.AIWG_COCKPIT_EXECUTOR_TOKEN_FILE ?? '';
 const MCP_TOKEN_FILE = process.env.AIWG_COCKPIT_MCP_TOKEN_FILE ?? '';
 const LOCAL_DOCKER_FALLBACK = process.env.AIWG_COCKPIT_LOCAL_DOCKER_FALLBACK === '1';
 const REQUIRE_SANDBOX_MTLS = process.env.AIWG_COCKPIT_REQUIRE_SANDBOX_MTLS === '1';
+const COCKPIT_A2A_PROTOCOL_POLICY = process.env.AIWG_COCKPIT_A2A_PROTOCOL_POLICY ?? '0.3';
+const COCKPIT_A2A_PROTOCOL_FALLBACK = process.env.AIWG_COCKPIT_A2A_PROTOCOL_FALLBACK === '1';
 export function localLibvirtFallbackAllowed(platform = process.platform, envValue = process.env.AIWG_COCKPIT_LOCAL_LIBVIRT_FALLBACK) {
   return platform === 'linux' || envValue === '1';
 }
@@ -1532,6 +1534,7 @@ function normalizeInstance(executorUrl, i) {
     state: i.state ?? i.status ?? 'unknown',
     tenant: i.tenant_id ?? i.tenant ?? i.tenantId ?? 'default',
     card_url: i.card_url ?? i.cardUrl ?? `${executorUrl}/agents/${encodeURIComponent(id)}/.well-known/agent-card.json`,
+    a2a_protocol: i.a2a_protocol ?? i.a2aProtocol,
     runtime_posture: runtimePosture,
     host_daemon: normalizeHostDaemon(i.host_daemon ?? i.hostDaemon, runtimePosture.kind),
     transport: normalizeTransport(
@@ -1761,6 +1764,113 @@ function runtimeExtensionFromCard(card) {
   return ext?.params && typeof ext.params === 'object' ? ext.params : null;
 }
 
+function cockpitA2ASettings() {
+  const context = executorRequestContext.getStore();
+  return {
+    policy: context?.a2aProtocolPolicy ?? COCKPIT_A2A_PROTOCOL_POLICY,
+    allowFallback: context?.allowA2AProtocolFallback ?? COCKPIT_A2A_PROTOCOL_FALLBACK,
+  };
+}
+
+/** Normalize and select the ordered AgentCard interface Cockpit will use. */
+export function selectCockpitA2AInterface(card, policy = '0.3') {
+  if (!['0.3', '1.0', 'auto'].includes(policy)) {
+    throw new Error(`invalid Cockpit A2A protocol policy: ${policy}`);
+  }
+  const normalizeVersion = (value) => {
+    const match = /^(0\.3|1\.0)(?:\.\d+)?$/.exec(String(value ?? '').trim());
+    return match?.[1] ?? null;
+  };
+  const topVersion = normalizeVersion(card?.protocolVersion);
+  const interfaces = [];
+  for (const [preference, entry] of (Array.isArray(card?.supportedInterfaces) ? card.supportedInterfaces : []).entries()) {
+    const version = normalizeVersion(entry?.protocolVersion) ?? topVersion;
+    const binding = entry?.protocolBinding ?? entry?.transport;
+    if (!version || !binding || typeof entry?.url !== 'string') continue;
+    interfaces.push({
+      url: entry.url.replace(/\/+$/, ''),
+      protocol_version: version,
+      protocol_binding: String(binding),
+      preference,
+    });
+  }
+  if (topVersion === '0.3' && typeof card?.url === 'string' && !interfaces.some((entry) => entry.protocol_version === '0.3')) {
+    interfaces.push({
+      url: card.url.replace(/\/+$/, ''),
+      protocol_version: '0.3',
+      protocol_binding: String(card.preferredTransport ?? 'REST'),
+      preference: interfaces.length,
+    });
+  }
+  const versions = policy === 'auto' ? ['1.0', '0.3'] : [policy];
+  for (const version of versions) {
+    const selected = interfaces
+      .filter((entry) => entry.protocol_version === version)
+      .sort((a, b) => a.preference - b.preference)[0];
+    if (selected) return { policy, ...selected };
+  }
+  throw new Error(`AgentCard has no interface compatible with Cockpit A2A policy ${policy}`);
+}
+
+async function discoverCockpitA2AInterface(executorUrl, instanceId) {
+  const { body: card } = await fetchJsonFirst([
+    `${executorUrl}/agents/${encodeURIComponent(instanceId)}/.well-known/agent-card.json`,
+  ]);
+  return { card, selected: selectCockpitA2AInterface(card, cockpitA2ASettings().policy) };
+}
+
+function cockpitA2AHeaders(version, mutating = false) {
+  const mediaType = version === '1.0' ? 'application/a2a+json' : 'application/json';
+  return {
+    accept: mediaType,
+    ...(mutating ? { 'content-type': mediaType } : {}),
+    ...(version === '1.0' ? { 'a2a-version': '1.0' } : {}),
+  };
+}
+
+function isA2AVersionNotSupported(status, body) {
+  const type = String(body?.type ?? '').toLowerCase();
+  const code = String(body?.code ?? body?.error?.code ?? '').toLowerCase();
+  return status === 400 && (
+    type.includes('version-not-supported') ||
+    ['versionnotsupportederror', 'version_not_supported', 'a2a.version_not_supported', '-32009'].includes(code)
+  );
+}
+
+async function negotiatedCockpitA2ARequest(executorUrl, instanceId, candidatesFor) {
+  const settings = cockpitA2ASettings();
+  let card;
+  let selected;
+  try {
+    ({ card, selected } = await discoverCockpitA2AInterface(executorUrl, instanceId));
+  } catch (error) {
+    // Pre-AgentCard executors remain supported only under the explicit legacy
+    // policy. Auto and 1.0 must negotiate from advertised interfaces.
+    if (settings.policy !== '0.3') throw error;
+    selected = {
+      policy: '0.3',
+      url: `${executorUrl}/agents/${encodeURIComponent(instanceId)}`,
+      protocol_version: '0.3',
+      protocol_binding: 'REST',
+      preference: 0,
+    };
+  }
+  let result = await fetchJsonFirst(candidatesFor(selected));
+  let active = selected;
+  let fallbackReason;
+  if (
+    selected.protocol_version === '1.0' &&
+    settings.policy === 'auto' &&
+    settings.allowFallback &&
+    isA2AVersionNotSupported(result.status, result.body)
+  ) {
+    active = selectCockpitA2AInterface(card, '0.3');
+    fallbackReason = `${result.body?.type ?? result.body?.code ?? 'VersionNotSupportedError'}`;
+    result = await fetchJsonFirst(candidatesFor(active));
+  }
+  return { ...result, selected: active, fallbackReason };
+}
+
 async function enrichInstanceFromAgentCard(executorUrl, instance) {
   const id = instance.instance_id ?? instance.instanceId ?? instance.id;
   if (!id) return instance;
@@ -1769,12 +1879,20 @@ async function enrichInstanceFromAgentCard(executorUrl, instance) {
       `${executorUrl}/agents/${encodeURIComponent(id)}/.well-known/agent-card.json`,
     ]);
     const runtimeExtension = runtimeExtensionFromCard(body);
-    if (!runtimeExtension) return instance;
+    const selected = selectCockpitA2AInterface(body, cockpitA2ASettings().policy);
     return {
       ...instance,
-      runtime_extension: runtimeExtension,
-      loadout: instance.loadout ?? runtimeExtension.loadout,
-      image_ref: instance.image_ref ?? runtimeExtension.image_ref,
+      a2a_protocol: {
+        policy: selected.policy,
+        selected_version: selected.protocol_version,
+        protocol_binding: selected.protocol_binding,
+        interface_url: selected.url,
+      },
+      ...(runtimeExtension ? {
+        runtime_extension: runtimeExtension,
+        loadout: instance.loadout ?? runtimeExtension.loadout,
+        image_ref: instance.image_ref ?? runtimeExtension.image_ref,
+      } : {}),
     };
   } catch (err) {
     rethrowExecutorSecurityError(err);
@@ -1901,20 +2019,59 @@ async function getInventory(executorUrl, { requireSandboxMtls = false } = {}) {
 // /admin/running. A2A task lifecycle states: submitted/working/input-required are
 // active; completed/canceled/failed/rejected are terminal.
 const ACTIVE_TASK_STATES = new Set(['submitted', 'working', 'input-required', 'in_progress', 'running']);
-const taskState = (t) => t.status?.state ?? t.state ?? (typeof t.status === 'string' ? t.status : 'unknown');
+const V1_TASK_STATES = {
+  TASK_STATE_SUBMITTED: 'submitted',
+  TASK_STATE_WORKING: 'working',
+  TASK_STATE_COMPLETED: 'completed',
+  TASK_STATE_FAILED: 'failed',
+  TASK_STATE_CANCELED: 'canceled',
+  TASK_STATE_INPUT_REQUIRED: 'input-required',
+  TASK_STATE_REJECTED: 'rejected',
+  TASK_STATE_AUTH_REQUIRED: 'auth-required',
+};
+const normalizeTaskState = (value) => V1_TASK_STATES[value] ?? value ?? 'unknown';
+const taskState = (t) => normalizeTaskState(t.status?.state ?? t.state ?? (typeof t.status === 'string' ? t.status : 'unknown'));
 const taskIdOf = (t) => t.id ?? t.task_id ?? t.taskId;
 const taskTenantOf = (t) => t.metadata?.tenant_id ?? t.metadata?.tenantId ?? t.tenant ?? t.tenant_id ?? t.tenantId ?? 'default';
 
+function normalizeCockpitA2ATask(task) {
+  if (!task || typeof task !== 'object' || !task.id || !task.status || typeof task.status !== 'object') return task;
+  return { ...task, status: { ...task.status, state: normalizeTaskState(task.status.state) } };
+}
+
+function normalizeCockpitA2ATaskResponse(body) {
+  const candidate = body?.task && typeof body.task === 'object' ? body.task : body;
+  return normalizeCockpitA2ATask(candidate);
+}
+
 /** Active tasks for one instance via the A2A task surface (#1639). The session
  *  agent id (not the instance id) keys the agent routes on real executors. */
 async function listInstanceTasks(executorUrl, instanceId) {
   const agentId = await resolveSessionAgentId(executorUrl, instanceId);
-  const candidates = unique([instanceId, agentId]).flatMap((id) => [
-    `${executorUrl}/agents/${encodeURIComponent(id)}/tasks`,
-    `${executorUrl}/api/v1/agents/${encodeURIComponent(id)}/tasks`,
-  ]);
-  const { body } = await fetchJsonFirst(candidates);
-  return asArrayFromEnvelope(body, ['tasks', 'items', 'data']);
+  const settings = cockpitA2ASettings();
+  try {
+    const result = await negotiatedCockpitA2ARequest(executorUrl, agentId, (selected) => {
+      const headers = cockpitA2AHeaders(selected.protocol_version);
+      return selected.protocol_version === '1.0'
+        ? [{ target: `${selected.url}/tasks`, headers }]
+        : [
+            { target: `${selected.url}/v1/tasks`, headers },
+            { target: `${selected.url}/tasks`, headers },
+          ];
+    });
+    if (result.status >= 400) {
+      throw new Error(`A2A ${result.selected.protocol_version} task list failed with HTTP ${result.status}`);
+    }
+    return asArrayFromEnvelope(result.body, ['tasks', 'items', 'data']).map(normalizeCockpitA2ATask);
+  } catch (error) {
+    if (settings.policy !== '0.3') throw error;
+    const candidates = unique([instanceId, agentId]).flatMap((id) => [
+      `${executorUrl}/agents/${encodeURIComponent(id)}/tasks`,
+      `${executorUrl}/api/v1/agents/${encodeURIComponent(id)}/tasks`,
+    ]);
+    const { body } = await fetchJsonFirst(candidates);
+    return asArrayFromEnvelope(body, ['tasks', 'items', 'data']).map(normalizeCockpitA2ATask);
+  }
 }
 
 /** Running board derived from active A2A tasks across running instances (#1639).
@@ -2078,6 +2235,41 @@ function missionSummary(mission) {
     completed_at: mission.completedAt ?? mission.completed_at,
     error: mission.error,
     terminal: TERMINAL_MISSION_STATES.has(status),
+    ...(graphMissionProjection(mission) ?? {}),
+  };
+}
+
+function graphMissionProjection(mission) {
+  const graph = mission.graph ?? mission.graph_metadata;
+  if (!graph || typeof graph !== 'object' || !graph.graphId || !graph.runId) return null;
+  const nodes = Array.isArray(mission.graphNodes ?? mission.graph_nodes)
+    ? (mission.graphNodes ?? mission.graph_nodes).map((node) => ({
+      node_id: node.nodeId ?? node.node_id,
+      node_run_id: node.nodeRunId ?? node.node_run_id,
+      state: node.state ?? node.nodeState ?? 'unknown',
+      runtime_binding: node.runtimeBinding ?? node.runtime_binding ?? 'unknown',
+      route_reason: node.routeReason ?? node.route_reason,
+      evidence_summary: node.evidenceSummary ?? node.evidence_summary,
+      hitl_status: node.hitlStatus ?? node.hitl_status,
+      cost_usd: Number(node.costUsd ?? node.cost_usd ?? 0),
+      tokens: Number(node.tokens ?? 0),
+      duration_ms: Number(node.durationMs ?? node.duration_ms ?? 0),
+      retry_count: Number(node.retryCount ?? node.retry_count ?? 0),
+      budget_remaining: node.budgetRemaining ?? node.budget_remaining,
+      checkpoint_id: node.checkpointId ?? node.checkpoint_id,
+      replay_of_node_run_id: node.replayOfNodeRunId ?? node.replay_of_node_run_id,
+      artifacts: Array.isArray(node.artifacts) ? node.artifacts : [],
+    })) : [];
+  return {
+    graph: {
+      schema_version: graph.schemaVersion ?? graph.schema_version ?? 'graph.flow.aiwg.io/v1',
+      graph_id: graph.graphId,
+      graph_version: graph.graphVersion,
+      run_id: graph.runId,
+      replay_of_run_id: graph.replayOfRunId ?? graph.replay_of_run_id,
+      checkpoint_id: graph.checkpointId ?? graph.checkpoint_id,
+    },
+    graph_nodes: nodes,
   };
 }
 
@@ -2226,6 +2418,10 @@ function fleetMissionProjection(record, sessionId) {
     exit_classification: status.exit_classification,
     error: status.error_code,
     schedule: record.spec?.schedule,
+    ...(graphMissionProjection({
+      graph_metadata: record.lineage?.graph_metadata ?? record.metadata?.['aiwg.flow.graph'],
+      graph_nodes: record.status?.graph_nodes,
+    }) ?? {}),
   };
 }
 
@@ -2336,46 +2532,55 @@ async function respondApproval(executorUrl, approvalId, decision) {
   const [instanceId, taskId] = String(approvalId).split('::');
   if (!instanceId || !taskId) return { status: 400, body: { error: 'invalid_approval_id' } };
   const agentId = await resolveSessionAgentId(executorUrl, instanceId);
-  const message = {
-    message: {
-      messageId: `cockpit-hitl-${Date.now()}`,
-      role: 'user',
-      taskId,
-      contextId: taskId,
-      parts: [{ kind: 'text', text: decision }],
-      metadata: { hitl_response: { decision }, approval_decision: decision },
-    },
-  };
-  const response = JSON.stringify({ decision, response: message.message });
-  const candidates = unique([agentId, instanceId]).flatMap((id) => [
-    {
-      target: `${executorUrl}/api/v1/agents/${encodeURIComponent(id)}/tasks/${encodeURIComponent(taskId)}:respond`,
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: response,
-    },
-    {
-      target: `${executorUrl}/agents/${encodeURIComponent(id)}/tasks/${encodeURIComponent(taskId)}:respond`,
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: response,
-    },
-    {
-      target: `${executorUrl}/api/v1/agents/${encodeURIComponent(id)}/messages:send`,
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(message),
-    },
-    {
-      target: `${executorUrl}/agents/${encodeURIComponent(id)}/messages:send`,
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(message),
-    },
-  ]);
   try {
-    const { status, body } = await fetchJsonFirst(candidates);
-    return { status, body };
+    const result = await negotiatedCockpitA2ARequest(executorUrl, agentId, (selected) => {
+      const message = {
+        messageId: `cockpit-hitl-${Date.now()}`,
+        role: selected.protocol_version === '1.0' ? 'ROLE_USER' : 'user',
+        taskId,
+        contextId: taskId,
+        parts: [selected.protocol_version === '1.0'
+          ? { text: decision }
+          : { kind: 'text', text: decision }],
+        metadata: { hitl_response: { decision }, approval_decision: decision },
+      };
+      if (selected.protocol_version === '1.0') {
+        return [{
+          target: `${selected.url}/message:send`,
+          method: 'POST',
+          headers: cockpitA2AHeaders('1.0', true),
+          body: JSON.stringify({ message }),
+        }];
+      }
+      const response = JSON.stringify({ decision, response: message });
+      return [
+        {
+          target: `${selected.url}/v1/tasks/${encodeURIComponent(taskId)}:respond`,
+          method: 'POST',
+          headers: cockpitA2AHeaders('0.3', true),
+          body: response,
+        },
+        {
+          target: `${selected.url}/tasks/${encodeURIComponent(taskId)}:respond`,
+          method: 'POST',
+          headers: cockpitA2AHeaders('0.3', true),
+          body: response,
+        },
+        {
+          target: `${executorUrl}/api/v1/agents/${encodeURIComponent(agentId)}/tasks/${encodeURIComponent(taskId)}:respond`,
+          method: 'POST',
+          headers: cockpitA2AHeaders('0.3', true),
+          body: response,
+        },
+        {
+          target: `${selected.url}/v1/messages:send`,
+          method: 'POST',
+          headers: cockpitA2AHeaders('0.3', true),
+          body: JSON.stringify({ message }),
+        },
+      ];
+    });
+    return { status: result.status, body: normalizeCockpitA2ATaskResponse(result.body) };
   } catch (e) {
     rethrowExecutorSecurityError(e);
     return { status: 409, body: { error: 'approval_response_failed', detail: String(e?.message ?? e) } };
@@ -2661,7 +2866,12 @@ export function createBridge({
   requireSandboxMtls = REQUIRE_SANDBOX_MTLS,
   bootstrapTtlMs = 60_000,
   sessionTtlMs = 12 * 60 * 60 * 1000,
+  a2aProtocolPolicy = COCKPIT_A2A_PROTOCOL_POLICY,
+  allowA2AProtocolFallback = COCKPIT_A2A_PROTOCOL_FALLBACK,
 } = {}) {
+  if (!['0.3', '1.0', 'auto'].includes(a2aProtocolPolicy)) {
+    throw new Error(`AIWG_COCKPIT_A2A_PROTOCOL_POLICY must be 0.3, 1.0, or auto (received '${a2aProtocolPolicy}')`);
+  }
   const upstreamUrl = executorUrl;
   const TOKEN = token ?? randomBytes(24).toString('hex');
   const bootstrapNonces = new Map();
@@ -3195,8 +3405,33 @@ export function createBridge({
         return json(res, 200, { ...result, projection: await getMissions(upstreamUrl) });
       }
       if ((m = url.pathname.match(/^\/api\/tasks\/([^/]+)\/([^/]+)\/cancel$/)) && req.method === 'POST') {
-        await appendAudit('task.cancel.requested', { instance_id: decodeURIComponent(m[1]), task_id: decodeURIComponent(m[2]) });
-        return proxy(res, 'POST', `${upstreamUrl}/agents/${encodeURIComponent(m[1])}/tasks/${encodeURIComponent(m[2])}:cancel`);
+        const instanceId = decodeURIComponent(m[1]);
+        const taskId = decodeURIComponent(m[2]);
+        await appendAudit('task.cancel.requested', { instance_id: instanceId, task_id: taskId });
+        const agentId = await resolveSessionAgentId(upstreamUrl, instanceId);
+        const result = await negotiatedCockpitA2ARequest(upstreamUrl, agentId, (selected) => {
+          const request = (target) => ({
+            target,
+            method: 'POST',
+            headers: cockpitA2AHeaders(selected.protocol_version, true),
+            body: '{}',
+          });
+          return selected.protocol_version === '1.0'
+            ? [request(`${selected.url}/tasks/${encodeURIComponent(taskId)}:cancel`)]
+            : [
+                request(`${selected.url}/v1/tasks/${encodeURIComponent(taskId)}/cancel`),
+                request(`${selected.url}/tasks/${encodeURIComponent(taskId)}/cancel`),
+                request(`${upstreamUrl}/api/v1/agents/${encodeURIComponent(agentId)}/tasks/${encodeURIComponent(taskId)}/cancel`),
+              ];
+        });
+        await appendAudit('task.cancel.protocol', {
+          instance_id: instanceId,
+          task_id: taskId,
+          selected_version: result.selected.protocol_version,
+          protocol_binding: result.selected.protocol_binding,
+          ...(result.fallbackReason ? { fallback_reason: result.fallbackReason } : {}),
+        });
+        return json(res, result.status, normalizeCockpitA2ATaskResponse(result.body));
       }
 
       // --- approval inbox (UC-009) + cost (UC-010) ---
@@ -3217,6 +3452,10 @@ export function createBridge({
         executor_url: upstreamUrl,
         mock_executor_allowed: allowMockExecutor,
         executor_auth_configured: Boolean(executorTokenFile),
+        a2a_protocol: {
+          policy: a2aProtocolPolicy,
+          fallback_enabled: Boolean(allowA2AProtocolFallback),
+        },
         executor: await getExecutorCapabilities(upstreamUrl),
       });
       if (url.pathname === '/' || url.pathname === '/index.html') {
@@ -3246,11 +3485,11 @@ export function createBridge({
     }
   };
   const server = http.createServer((req, res) => executorRequestContext.run(
-    { executorOrigin, executorTokenFile },
+    { executorOrigin, executorTokenFile, a2aProtocolPolicy, allowA2AProtocolFallback },
     () => handleRequest(req, res),
   ));
   server.on('upgrade', (req, socket, head) => executorRequestContext.run(
-    { executorOrigin, executorTokenFile },
+    { executorOrigin, executorTokenFile, a2aProtocolPolicy, allowA2AProtocolFallback },
     async () => {
       try {
         const url = new URL(req.url, `http://${req.headers.host ?? 'localhost'}`);

package/bridge/src/smoke.mjs

@@ -3,7 +3,12 @@
 import assert from 'node:assert/strict';
 import { fileURLToPath } from 'node:url';
 import { createExecutor, DEFAULT_INSTANCE } from '../../mock-executor/src/server.mjs';
-import { createBridge, localLibvirtFallbackAllowed, normalizeSessionRows } from './server.mjs';
+import {
+  createBridge,
+  localLibvirtFallbackAllowed,
+  normalizeSessionRows,
+  selectCockpitA2AInterface,
+} from './server.mjs';
 
 const mock = createExecutor();
 await new Promise((r) => mock.listen(0, '127.0.0.1', r));
@@ -37,6 +42,17 @@ try {
   assert.equal(i0.storage?.persistent, true, 'storage persistence surfaced');
   assert.equal(i0.storage?.delete_on_destroy, true, 'storage delete-on-destroy surfaced');
   assert.ok(['vm', 'container', 'host', 'wasm-edge'].includes(i0.runtime), 'runtime kind');
+  assert.equal(i0.a2a_protocol?.selected_version, '0.3', 'inventory exposes the selected A2A protocol');
+  assert.equal(selectCockpitA2AInterface({
+    name: 'dual',
+    version: '1',
+    protocolVersion: '0.3.0',
+    url: 'https://legacy.test/agent',
+    supportedInterfaces: [
+      { url: 'https://v1.test/agent', protocolBinding: 'HTTP+JSON', protocolVersion: '1.0' },
+      { url: 'https://legacy.test/agent', transport: 'REST', protocolVersion: '0.3' },
+    ],
+  }, 'auto').protocol_version, '1.0', 'Cockpit auto selects the preferred 1.0 interface');
 
   // A transient executor outage must not poison Bridge state or require a
   // Bridge restart. Every poll is a fresh upstream request, so the same Bridge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cockpit",
-  "version": "2026.8.17",
+  "version": "2026.8.19",
   "description": "AIWG Cockpit — UX-first control plane over AIWG + multi-stack agentic sessions. Opt-in, separately published; NOT shipped in the base aiwg npm package (guarded by test/smoke/cockpit-base-footprint.test.js).",
   "type": "module",
   "license": "MIT",