@aiwg/cockpit 2026.7.11 → 2026.7.13

package/shell-core/keychain.mjs

@@ -37,6 +37,38 @@ async function canRun(cmd) {
   }
 }
 
+async function windowsPowerShell() {
+  if (await canRun('powershell')) return 'powershell';
+  if (await canRun('pwsh')) return 'pwsh';
+  throw new Error('no supported Windows PowerShell command found');
+}
+
+async function storeWindowsCredential(token, account) {
+  const ps = await windowsPowerShell();
+  const script = [
+    '[void][Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]',
+    '$vault = New-Object Windows.Security.Credentials.PasswordVault',
+    'try { $vault.Remove($vault.Retrieve($args[0], $args[1])) } catch {}',
+    '$password = [Console]::In.ReadToEnd()',
+    '$credential = New-Object Windows.Security.Credentials.PasswordCredential -ArgumentList $args[0], $args[1], $password',
+    '$vault.Add($credential)',
+  ].join('; ');
+  await collect(ps, ['-NoProfile', '-NonInteractive', '-Command', script, SERVICE, account], token);
+  return { backend: 'windows-credential-manager', service: SERVICE, account, target: `${SERVICE}:${account}` };
+}
+
+async function readWindowsCredential(ref) {
+  const ps = await windowsPowerShell();
+  const script = [
+    '[void][Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]',
+    '$vault = New-Object Windows.Security.Credentials.PasswordVault',
+    '$credential = $vault.Retrieve($args[0], $args[1])',
+    '$credential.RetrievePassword()',
+    '[Console]::Out.Write($credential.Password)',
+  ].join('; ');
+  return (await collect(ps, ['-NoProfile', '-NonInteractive', '-Command', script, ref.service || SERVICE, ref.account])).trim();
+}
+
 export async function storeCockpitToken(token, account = `bridge-${process.pid}`) {
   if (process.env.AIWG_COCKPIT_KEYCHAIN_DISABLED === '1') {
     throw new Error('OS keychain disabled by AIWG_COCKPIT_KEYCHAIN_DISABLED');
@@ -46,10 +78,8 @@ export async function storeCockpitToken(token, account = `bridge-${process.pid}`
     await collect('security', ['add-generic-password', '-a', account, '-s', SERVICE, '-w', token, '-U']);
     return { backend: 'macos-keychain', service: SERVICE, account };
   }
-  if (os === 'win32' && await canRun('cmdkey')) {
-    const target = `${SERVICE}:${account}`;
-    await collect('cmdkey', [`/generic:${target}`, `/user:${account}`, `/pass:${token}`]);
-    return { backend: 'windows-credential-manager', service: SERVICE, account, target };
+  if (os === 'win32') {
+    return storeWindowsCredential(token, account);
   }
   if (await canRun('secret-tool')) {
     await collect('secret-tool', ['store', '--label', 'AIWG Cockpit Bridge', 'service', SERVICE, 'account', account], token);
@@ -68,7 +98,7 @@ export async function readCockpitToken(ref) {
     return (await collect('security', ['find-generic-password', '-a', ref.account, '-s', ref.service || SERVICE, '-w'])).trim();
   }
   if (ref.backend === 'windows-credential-manager') {
-    throw new Error('Windows Credential Manager read requires the shell-provided runtime token until native shell integration lands');
+    return readWindowsCredential(ref);
   }
   if (ref.backend === 'libsecret') {
     return (await collect('secret-tool', ['lookup', 'service', ref.service || SERVICE, 'account', ref.account])).trim();

package/vscode/extension.js

@@ -4,43 +4,28 @@
 // Bridge — it reads the per-launch token the Bridge wrote and loads its UI.
 // CommonJS so it runs with no build step.
 const vscode = require('vscode');
-const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const cp = require('child_process');
+const { pathToFileURL } = require('url');
 
 function runtimeFile() {
   const override = vscode.workspace.getConfiguration('aiwg-cockpit').get('bridgeRuntimeFile');
   return override && override.length ? override : path.join(os.homedir(), '.aiwg', 'cockpit', 'runtime', 'bridge.json');
 }
 
-function readTokenRef(ref) {
-  if (!ref || !ref.backend) return '';
-  if (ref.backend === 'macos-keychain') {
-    return cp.execFileSync('security', ['find-generic-password', '-a', ref.account, '-s', ref.service || 'aiwg-cockpit-bridge', '-w'], { encoding: 'utf8' }).trim();
-  }
-  if (ref.backend === 'libsecret') {
-    return cp.execFileSync('secret-tool', ['lookup', 'service', ref.service || 'aiwg-cockpit-bridge', 'account', ref.account], { encoding: 'utf8' }).trim();
-  }
-  if (ref.backend === 'kwallet') {
-    return cp.execFileSync('kwallet-query', ['-f', ref.folder || 'AIWG Cockpit', '-r', ref.account, ref.wallet || 'kdewallet'], { encoding: 'utf8' }).trim();
-  }
-  throw new Error(`Unsupported Cockpit keychain backend: ${ref.backend}`);
+async function shellCore() {
+  const runtimeModule = path.join(__dirname, '..', 'shell-core', 'runtime.mjs');
+  return import(pathToFileURL(runtimeModule).href);
 }
 
 /** Read the Bridge connection + confirm liveness; throws with a friendly hint if down. */
 async function ensureRuntime() {
-  let rt;
   try {
-    const r = JSON.parse(fs.readFileSync(runtimeFile(), 'utf8'));
-    const token = r.token || readTokenRef(r.token_ref);
-    rt = { ...r, token, url: `http://127.0.0.1:${r.port}` };
-  } catch {
-    throw new Error('AIWG Cockpit Bridge not found. Start it with `aiwg cockpit` (or `node apps/cockpit/bridge/src/server.mjs`) and retry.');
+    const { connect } = await shellCore();
+    return await connect({ file: runtimeFile(), timeoutMs: 2500 });
+  } catch (e) {
+    throw new Error(`AIWG Cockpit Bridge not reachable. Start it with \`aiwg cockpit\` (or \`node apps/cockpit/bridge/src/server.mjs\`) and retry. ${(e && e.message) || ''}`.trim());
   }
-  try { if (!(await fetch(`${rt.url}/healthz`)).ok) throw new Error(); }
-  catch { throw new Error(`AIWG Cockpit Bridge not reachable at ${rt.url}. Is it still running?`); }
-  return rt;
 }
 
 function activate(context) {
@@ -49,7 +34,8 @@ function activate(context) {
       let rt;
       try { rt = await ensureRuntime(); } catch (e) { return vscode.window.showWarningMessage(e.message); }
       const panel = vscode.window.createWebviewPanel('aiwgCockpit', 'AIWG Cockpit', vscode.ViewColumn.One, { enableScripts: true, retainContextWhenHidden: true });
-      const u = `${rt.url}/?token=${encodeURIComponent(rt.token)}`;
+      const { webviewUrl } = await shellCore();
+      const u = webviewUrl(rt);
       panel.webview.html = `<!doctype html><html><head><meta charset="utf-8" />
         <meta http-equiv="Content-Security-Policy" content="default-src 'none'; frame-src http://127.0.0.1:* http://localhost:*; style-src 'unsafe-inline';" />
         <style>html,body,iframe{margin:0;height:100vh;width:100%;border:0}</style></head>
@@ -58,11 +44,12 @@ function activate(context) {
     vscode.commands.registerCommand('aiwg-cockpit.auditIssues', async () => {
       let rt;
       try { rt = await ensureRuntime(); } catch (e) { return vscode.window.showWarningMessage(e.message); }
-      vscode.env.openExternal(vscode.Uri.parse(`${rt.url}/?token=${encodeURIComponent(rt.token)}#actions`));
+      const { webviewUrl } = await shellCore();
+      vscode.env.openExternal(vscode.Uri.parse(`${webviewUrl(rt)}#actions`));
     }),
   );
 }
 
 function deactivate() {}
 
-module.exports = { activate, deactivate };
+module.exports = { activate, deactivate, _private: { ensureRuntime, runtimeFile, shellCore } };

package/vscode/smoke.mjs

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import Module from 'node:module';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+
+const runtimeDir = await mkdtemp(join(tmpdir(), 'cockpit-vscode-smoke-'));
+const runtimePath = join(runtimeDir, 'bridge.json');
+await writeFile(runtimePath, JSON.stringify({ token: 'vscode-shell-core-token-1234567890', port: 8159 }), { mode: 0o600 });
+
+const requests = [];
+globalThis.fetch = async (input, init = {}) => {
+  requests.push({ url: String(input), init });
+  return new Response(JSON.stringify({ ok: true }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+};
+
+const originalLoad = Module._load;
+Module._load = function patchedLoad(request, parent, isMain) {
+  if (request === 'vscode') {
+    return {
+      workspace: { getConfiguration: () => ({ get: () => runtimePath }) },
+      window: { showWarningMessage: () => undefined, createWebviewPanel: () => ({ webview: { html: '' } }) },
+      commands: { registerCommand: () => ({ dispose: () => undefined }) },
+      env: { openExternal: () => undefined },
+      Uri: { parse: (value) => ({ value }) },
+      ViewColumn: { One: 1 },
+    };
+  }
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+try {
+  const require = createRequire(import.meta.url);
+  const extension = require('./extension.js');
+  const rt = await extension._private.ensureRuntime();
+  assert.equal(rt.port, 8159, 'VS Code shell uses shell-core runtime connection');
+  assert.equal(rt.token, 'vscode-shell-core-token-1234567890', 'VS Code shell receives the resolved runtime token');
+  assert.ok(
+    requests.some((r) => r.url.endsWith('/api/health') && r.init.headers?.authorization === `Bearer ${rt.token}`),
+    'shell-core performs the authenticated Bridge health check',
+  );
+  console.log('SMOKE OK - VS Code shell delegates runtime resolution to shell-core');
+} finally {
+  Module._load = originalLoad;
+  await rm(runtimeDir, { recursive: true, force: true });
+}

package/web/src/App.test.tsx

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render, screen, cleanup, waitFor, fireEvent } from '@testing-library/react';
-import { App } from './App';
+import { App, waitForSessionReady } from './App';
 
 // Rendered-DOM coverage (the a11y assertions deferred from T2, and a guard against the
 // "blank render" class of bug). The Welcome tab fetches inventory/running/approvals on
@@ -45,6 +45,44 @@ describe('App shell (rendered DOM)', () => {
     expect(screen.getByText(/start a session automatically/i)).toBeTruthy();
   });
 
+  it('counts qemu and kvm instances as VM runtime coverage in the header (#1782)', async () => {
+    for (const kind of ['qemu', 'kvm']) {
+      cleanup();
+      globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+        const url = String(input);
+        if (url.includes('/api/health')) return jsonResponse({ executor_url: 'http://127.0.0.1:8122' });
+        if (url.includes('/api/inventory')) return jsonResponse({ instances: [instance(`${kind}-1`, kind, 'full-suite')] });
+        if (url.includes('/api/running')) return jsonResponse({ count: 0, running: [] });
+        if (url.includes('/api/approvals')) return jsonResponse({ approvals: [] });
+        if (url.includes('/api/cost')) return jsonResponse({ total: { input_tokens: 0, output_tokens: 0, usd: 0 }, per_instance: [] });
+        return jsonResponse({});
+      }) as typeof fetch;
+
+      render(<App />);
+      expect((await screen.findByTitle('Runtime target coverage')).textContent).toContain('vm ✓');
+    }
+  });
+
+  it('does not bind launch session creation to the first unrelated running instance (#1743)', async () => {
+    vi.useFakeTimers();
+    try {
+      globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+        const url = String(input);
+        if (url.includes('/api/operations/op-1')) return jsonResponse({ id: 'op-1', state: 'running', result: { runtime: 'docker' } });
+        if (url.includes('/api/inventory')) return jsonResponse({ instances: [instance('busy-existing', 'container', 'Existing stack')] });
+        return jsonResponse({});
+      }) as typeof fetch;
+
+      const ready = waitForSessionReady(undefined, 'op-1');
+      const rejection = expect(ready).rejects.toThrow(/waiting for launch operation to report instance id/i);
+      for (let i = 0; i < 151; i += 1) await vi.advanceTimersByTimeAsync(1_000);
+      await rejection;
+      expect(globalThis.fetch).not.toHaveBeenCalledWith(expect.stringContaining('/api/instances/busy-existing/sessions'), expect.anything());
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('renders durable Missions projection from aiwg mc state and live executor work', async () => {
     globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
       const url = String(input);
@@ -384,6 +422,86 @@ describe('App shell (rendered DOM)', () => {
     expect((destroy as HTMLButtonElement).disabled).toBe(false);
   });
 
+  it('offers Reconnect for a running Docker row whose agent is not registered', async () => {
+    const stale = {
+      ...instance('stale-dkr-2', 'docker', 'full-suite'),
+      agent_ready: false,
+      session_backends: [{
+        mode: 'managed',
+        backend: 'tmux',
+        available: false,
+        observe: true,
+        drive: true,
+        reason: 'container is running but the agent has not registered; PTY sessions are not ready',
+      }],
+    };
+    const inventory = { instances: [stale], count: 1, fetched_at: new Date().toISOString() };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      if (url.includes('/api/health')) return jsonResponse({ executor_url: 'http://127.0.0.1:8122' });
+      if (url.includes('/api/inventory')) return jsonResponse(inventory);
+      if (url.includes('/api/running')) return jsonResponse({ count: 0, running: [] });
+      if (url.includes('/api/approvals')) return jsonResponse({ approvals: [] });
+      if (url.includes('/api/cost')) return jsonResponse({ total: { input_tokens: 0, output_tokens: 0, usd: 0 }, per_instance: [] });
+      if (url.includes('/api/instances/stale-dkr-2/reconnect') && init?.method === 'POST') {
+        return jsonResponse({ state: 'reconnecting', message: 'Reconnect requested for stale-dkr-2; inventory will refresh as the agent re-registers.' });
+      }
+      return jsonResponse({});
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<App />);
+    fireEvent.click(screen.getByRole('tab', { name: 'Inventory' }));
+    expect(await screen.findByText('agent unreachable')).toBeTruthy();
+    fireEvent.click(await screen.findByRole('button', { name: /reconnect agent for stale-dkr-2/i }));
+
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining('/api/instances/stale-dkr-2/reconnect'),
+      expect.objectContaining({ method: 'POST' }),
+    ));
+    expect((await screen.findByRole('status')).textContent).toMatch(/reconnect requested/i);
+  });
+
+  it('offers Reconnect for a running VM row whose agent is not registered (#1778)', async () => {
+    const staleVm = {
+      ...instance('stale-vm-1', 'vm', 'full-suite'),
+      agent_ready: false,
+      session_backends: [{
+        mode: 'managed',
+        backend: 'tmux',
+        available: false,
+        observe: true,
+        drive: true,
+        reason: 'VM is running but the agent has not registered; PTY sessions are not ready',
+      }],
+    };
+    const inventory = { instances: [staleVm], count: 1, fetched_at: new Date().toISOString() };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      if (url.includes('/api/health')) return jsonResponse({ executor_url: 'http://127.0.0.1:8122' });
+      if (url.includes('/api/inventory')) return jsonResponse(inventory);
+      if (url.includes('/api/running')) return jsonResponse({ count: 0, running: [] });
+      if (url.includes('/api/approvals')) return jsonResponse({ approvals: [] });
+      if (url.includes('/api/cost')) return jsonResponse({ total: { input_tokens: 0, output_tokens: 0, usd: 0 }, per_instance: [] });
+      if (url.includes('/api/instances/stale-vm-1/reconnect') && init?.method === 'POST') {
+        return jsonResponse({ state: 'reconnecting', message: 'Reconnect requested for VM stale-vm-1; inventory will refresh as the agent re-registers.' });
+      }
+      return jsonResponse({});
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<App />);
+    fireEvent.click(screen.getByRole('tab', { name: 'Inventory' }));
+    expect(await screen.findByText('agent unreachable')).toBeTruthy();
+    fireEvent.click(await screen.findByRole('button', { name: /reconnect agent for stale-vm-1/i }));
+
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining('/api/instances/stale-vm-1/reconnect'),
+      expect.objectContaining({ method: 'POST' }),
+    ));
+    expect((await screen.findByRole('status')).textContent).toMatch(/reconnect requested/i);
+  });
+
   it('each tab has a matching labelled tabpanel (controls/labelledby pairing)', () => {
     render(<App />);
     for (const tab of screen.getAllByRole('tab')) {

package/web/src/App.tsx

@@ -2,6 +2,7 @@ import { useEffect, useState, type ReactNode } from 'react';
 import { useSession } from './useSession';
 import { api, TOKEN } from './api';
 import type { Approval, Instance, ResponseNeeded } from './types';
+import { runtimeFamily } from './util';
 import { Welcome } from './components/Welcome';
 import { Inventory } from './components/Inventory';
 import { Running } from './components/Running';
@@ -15,6 +16,7 @@ import { Telemetry } from './components/Telemetry';
 import { Memory } from './components/Memory';
 import { StartSessionModal } from './components/StartSessionModal';
 import { LaunchInstanceModal } from './components/LaunchInstanceModal';
+import { registryResponseNeededItems, useSessionRegistry } from './sessionRegistry';
 
 const TABS = [
   { id: 'welcome', label: 'Home' },
@@ -48,6 +50,8 @@ export function App() {
     return TABS.some((t) => t.id === hash) ? hash as TabId : 'welcome';
   });
   const session = useSession();
+  const sessionRegistry = useSessionRegistry();
+  const registryResponses = registryResponseNeededItems(sessionRegistry).filter((response) => response.id !== `pty:${sessionRegistry.activeKey}`);
   const [composer, setComposer] = useState('');
   const [chrome, setChrome] = useState<ChromeStatus | null>(null);
   const [startOpen, setStartOpen] = useState(false);
@@ -72,15 +76,16 @@ export function App() {
           api<{ approvals: Approval[] }>('/api/approvals?status=pending').catch(() => ({ approvals: [] as Approval[] })),
         ]);
         if (cancelled) return;
-        const kinds = inv.instances.map((i) => i.runtime_posture.kind);
+        const families = inv.instances.map((i) => runtimeFamily(i.runtime_posture?.kind ?? i.runtime));
+        const attachedResponseCount = session.responseNeeded.needed ? 1 : 0;
         setChrome({
           executor: health.executor_url,
           instances: inv.instances.length,
           running: run.count,
-          responses: apr.approvals.length + (session.responseNeeded.needed ? 1 : 0),
-          host: kinds.includes('host'),
-          container: kinds.includes('container') || kinds.includes('docker'),
-          vm: kinds.includes('vm'),
+          responses: apr.approvals.length + registryResponses.length + attachedResponseCount,
+          host: families.includes('host'),
+          container: families.includes('container'),
+          vm: families.includes('vm'),
         });
       } catch {
         if (!cancelled) setChrome(null);
@@ -89,7 +94,7 @@ export function App() {
     load();
     const timer = window.setInterval(load, 15_000);
     return () => { cancelled = true; window.clearInterval(timer); };
-  }, [session.responseNeeded.needed, refreshTick]);
+  }, [session.responseNeeded.needed, refreshTick, registryResponses.length]);
 
   useEffect(() => {
     if (typeof EventSource === 'undefined' || !TOKEN) return;
@@ -115,22 +120,36 @@ export function App() {
   const requestStart = (instanceId?: string) => { setStartInst(instanceId); setStartOpen(true); };
   const handleLaunched = async (instanceId?: string, openSession?: boolean, operationId?: string) => {
     setRefreshTick((t) => t + 1);
-    if (openSession) {
-      const inst = await waitForSessionReady(instanceId, operationId);
-      const backend = inst.session_backends.find((b) => b.available !== false && b.drive !== false)
-        ?? inst.session_backends.find((b) => b.available !== false)
-        ?? inst.session_backends[0];
-      if (!backend || backend.available === false) throw new Error(backend?.reason ?? 'No available session backend for the new instance.');
-      const qs = new URLSearchParams({ mode: backend.mode, backend: backend.backend });
-      const s = await api<{ id: string; attach_url: string }>(
-        `/api/instances/${encodeURIComponent(inst.id)}/sessions?${qs}`, { method: 'POST' },
-      );
-      session.attach(s.attach_url, false, backend.drive === false ? 'observer' : 'controller');
-      setTab('sessions');
-    } else {
+    if (!openSession) {
       setTab('inventory');
+      setRefreshTick((t) => t + 1);
+      return;
     }
-    setRefreshTick((t) => t + 1);
+    // Readiness can take minutes for heavy loadouts (e.g. full-suite) or stall if the
+    // executor is degraded. Never block the launch modal on it: switch to the Sessions
+    // workspace now and run the wait+attach in the background. If it doesn't complete,
+    // the instance is still visible under Inventory to start a session from manually.
+    setTab('sessions');
+    void (async () => {
+      try {
+        const inst = await waitForSessionReady(instanceId, operationId);
+        const backend = inst.session_backends.find((b) => b.available !== false && b.drive !== false)
+          ?? inst.session_backends.find((b) => b.available !== false)
+          ?? inst.session_backends[0];
+        if (!backend || backend.available === false) throw new Error(backend?.reason ?? 'No available session backend for the new instance.');
+        const qs = new URLSearchParams({ mode: backend.mode, backend: backend.backend });
+        const s = await api<{ id: string; attach_url: string }>(
+          `/api/instances/${encodeURIComponent(inst.id)}/sessions?${qs}`, { method: 'POST' },
+        );
+        session.attach(s.attach_url, false, backend.drive === false ? 'observer' : 'controller', { instanceId: inst.id, sessionId: s.id });
+      } catch (e) {
+        // Non-blocking: surface via console; the instance remains in Inventory.
+        console.warn('auto-session after launch did not complete:', (e as Error).message);
+      } finally {
+        setRefreshTick((t) => t + 1);
+      }
+    })();
+    return;
   };
   const copyLaunchCommand = async () => {
     await navigator.clipboard?.writeText('aiwg cockpit');
@@ -169,14 +188,14 @@ export function App() {
       </div>
       <main>
         <Panel id="welcome" tab={tab}><Welcome onStartSession={() => requestStart()} onLaunchInstance={() => setLaunchOpen(true)} goTo={(t) => setTab(t as TabId)} /></Panel>
-        <Panel id="inventory" tab={tab}><Inventory onStartSession={requestStart} onLaunchInstance={() => setLaunchOpen(true)} /></Panel>
+        <Panel id="inventory" tab={tab}><Inventory onStartSession={requestStart} onLaunchInstance={() => setLaunchOpen(true)} refreshTick={refreshTick} /></Panel>
         <Panel id="running" tab={tab}><Running refreshTick={refreshTick} /></Panel>
         <Panel id="missions" tab={tab}><Missions refreshTick={refreshTick} /></Panel>
         {/* Sessions stays mounted so the WebSocket survives tab switches */}
         <section id="panel-sessions" role="tabpanel" aria-labelledby="tab-sessions" hidden={tab !== 'sessions'}>
           <Sessions session={session} composer={composer} setComposer={setComposer} onRequestStart={requestStart} />
         </section>
-        <Panel id="approvals" tab={tab}><Approvals refreshTick={refreshTick} responses={session.responseNeeded.needed ? [sessionResponse(session)] : []} goSessions={() => setTab('sessions')} /></Panel>
+        <Panel id="approvals" tab={tab}><Approvals refreshTick={refreshTick} responses={[...registryResponses, ...(session.responseNeeded.needed ? [sessionResponse(session)] : [])]} goSessions={() => setTab('sessions')} /></Panel>
         <Panel id="explore" tab={tab}><Explore /></Panel>
         <Panel id="library" tab={tab}>
           <Library session={session} setComposer={setComposer} goSessions={() => setTab('sessions')} />
@@ -222,7 +241,7 @@ const SESSION_READY_TIMEOUT_S = (() => {
   return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 150;
 })();
 
-async function waitForSessionReady(instanceId?: string, operationId?: string) {
+export async function waitForSessionReady(instanceId?: string, operationId?: string) {
   let last = '';
   let operationDetail = '';
   for (let i = 0; i < SESSION_READY_TIMEOUT_S; i += 1) {
@@ -238,10 +257,22 @@ async function waitForSessionReady(instanceId?: string, operationId?: string) {
       }
     }
     const inv = await api<{ instances: Instance[] }>('/api/inventory');
+    // Fast-fail: if the instance is visible but has settled into a terminal,
+    // non-running state (e.g. a container whose agent never enrolled → 'stopped'),
+    // its session will never come up. Abort instead of blocking the launch modal
+    // for the full readiness window. A short grace (>3s) avoids tripping on the
+    // transient 'provisioning'/'created' states a healthy instance passes through.
+    const TERMINAL = new Set(['stopped', 'failed', 'error', 'terminated', 'destroyed', 'exited', 'dead']);
+    const present = instanceId ? inv.instances.find((inst) => inst.id === instanceId) : null;
+    if (present && i > 3 && TERMINAL.has(String(present.state).toLowerCase())) {
+      throw new Error(
+        `Instance ${present.id} did not come online — it settled to '${present.state}' instead of running`
+        + (operationDetail ? ` (${operationDetail})` : '')
+        + '. Its agent likely failed to register; check the runtime and try again.',
+      );
+    }
     const candidates = inv.instances.filter((inst) => String(inst.state).toLowerCase() === 'running');
-    const selected = instanceId
-      ? candidates.find((inst) => inst.id === instanceId)
-      : candidates[0];
+    const selected = instanceId ? candidates.find((inst) => inst.id === instanceId) : null;
     if (selected) {
       const backend = selected.session_backends.find((b) => b.available !== false) ?? selected.session_backends[0];
       if (backend && backend.available !== false) return selected;
@@ -249,7 +280,7 @@ async function waitForSessionReady(instanceId?: string, operationId?: string) {
     } else {
       last = [
         operationDetail,
-        instanceId ? `instance ${instanceId} not visible in inventory yet` : 'no running instance visible in inventory yet',
+        instanceId ? `instance ${instanceId} not visible in inventory yet` : 'waiting for launch operation to report instance id',
       ].filter(Boolean).join('; ');
     }
     await sleep(1_000);

package/web/src/components/Actions.tsx

@@ -40,7 +40,7 @@ export function Actions({ refreshTick = 0, session, setComposer, goSessions }: {
         },
       }),
     }).catch(() => undefined);
-    if (session.isController && session.sendInput(command)) {
+    if (session.isController && session.state.target && session.sendInput(command, session.state.target)) {
       setNote(`Injected "${command}" into the attached session — the agent runs it.`);
     } else {
       setComposer(command); // prefill the session composer; attach (drive) or start one, then Send

package/web/src/components/Inventory.tsx

@@ -5,7 +5,7 @@ import type { Instance } from '../types';
 
 interface Inv { count: number; fetched_at: string; instances: Instance[] }
 
-export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession?: (instanceId?: string) => void; onLaunchInstance?: () => void }) {
+export function Inventory({ onStartSession, onLaunchInstance, refreshTick = 0, refreshMs = 5_000 }: { onStartSession?: (instanceId?: string) => void; onLaunchInstance?: () => void; refreshTick?: number; refreshMs?: number }) {
   const [data, setData] = useState<Inv | null>(null);
   const [err, setErr] = useState('');
   const [actionErr, setActionErr] = useState('');
@@ -14,13 +14,19 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
   const load = useCallback(() => {
     api<Inv>('/api/inventory').then((d) => { setData(d); setErr(''); }).catch((e) => setErr((e as Error).message));
   }, []);
-  useEffect(() => { load(); }, [load]);
+  // Poll (and react to the app-wide refreshTick) so instances launched after this
+  // tab first mounted appear without a manual reload — matches the other data tabs.
+  useEffect(() => {
+    load();
+    const timer = window.setInterval(load, refreshMs);
+    return () => window.clearInterval(timer);
+  }, [load, refreshMs, refreshTick]);
 
-  const control = (path: string, method: string) =>
+  const control = (path: string, method: string, fallbackMessage = '') =>
     api<{ already_gone?: boolean; message?: string }>(path, { method })
       .then((result) => {
         setActionErr('');
-        setActionMsg(result.already_gone ? (result.message ?? 'Instance already removed; inventory refreshed.') : '');
+        setActionMsg(result.message ?? (result.already_gone ? 'Instance already removed; inventory refreshed.' : fallbackMessage));
         load();
       })
       .catch((e) => {
@@ -45,13 +51,13 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
       <div className="section-toolbar">
         <div>
           <h2>Agent instances</h2>
-          <p className="hint">{data.count} target(s) · {new Date(data.fetched_at).toLocaleTimeString()}</p>
+          <p className="hint">{data.count} {data.count === 1 ? 'target' : 'targets'} · {new Date(data.fetched_at).toLocaleTimeString()}</p>
         </div>
-        {onLaunchInstance && <button className="cta" onClick={onLaunchInstance}>＋ New instance + session</button>}
+        {onLaunchInstance && <button className="cta" onClick={onLaunchInstance}>New instance</button>}
       </div>
       {actionErr && <p className="err">Action failed: {actionErr}</p>}
       {actionMsg && <p className="hint" role="status">{actionMsg}</p>}
-      <table>
+      <table className="inventory-table">
         <caption>Available instance deployments</caption>
         <thead>
           <tr>
@@ -69,13 +75,15 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
               {(() => {
                 const sessionReady = i.session_backends?.some((b) => b.available);
                 const unavailableReason = i.session_backends?.find((b) => !b.available)?.reason;
+                const reconnectable = isReconnectable(i);
+                const health = instanceHealth(i);
                 return (
             <>
-              <td>
+              <td className="instance-cell">
                 <code title={i.id}>{i.launch_context?.name ?? fmtId(i.id)}</code>
                 {i.launch_context?.name && <div className="cell-note">{fmtId(i.id)}</div>}
               </td>
-              <td>
+              <td className="runtime-cell">
                 <span className={`badge isolation-${i.runtime_posture.isolation}`} title={i.runtime_posture.warning || i.runtime_posture.label}>
                   {i.runtime_posture.label}
                 </span>
@@ -92,12 +100,17 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
                 </span>
                 <div className="cell-note">{i.transport.mode}{i.transport.stale ? ' · stale' : ''}</div>
               </td>
-              <td>
+              <td className="daemon-cell">
                 <span className={`badge daemon-${i.host_daemon.status}`}>{i.host_daemon.status.replace('_', ' ')}</span>
                 {i.host_daemon.detail && <div className="cell-note">{i.host_daemon.detail}</div>}
                 {i.host_daemon.operator_command && <code title="Operator start command">{i.host_daemon.operator_command}</code>}
               </td>
-              <td><span className={`state ${i.state}`}><span className="dot" aria-hidden="true" />{i.state}</span></td>
+              <td>
+                <span className={`state ${health.kind === 'stale-agent' ? 'degraded' : i.state}`} title={health.detail}>
+                  <span className="dot" aria-hidden="true" />{health.label}
+                </span>
+                {health.detail && health.kind !== 'healthy' && <div className="cell-note">{health.detail}</div>}
+              </td>
               <td>{i.tenant}</td>
               <td className="manage-actions">
                 {i.state === 'running' && onStartSession && (
@@ -108,12 +121,21 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
                     title={!sessionReady ? unavailableReason : undefined}
                     onClick={() => onStartSession(i.id)}
                   >
-                    New Session
+                    Session
+                  </button>
+                )}{' '}
+                {reconnectable && (
+                  <button
+                    aria-label={`Reconnect agent for ${fmtId(i.id)}`}
+                    title={unavailableReason ?? 'Ask the running agent to re-register without restarting the instance.'}
+                    onClick={() => control(`/api/instances/${encodeURIComponent(i.id)}/reconnect`, 'POST', 'Reconnect requested; inventory will refresh shortly.')}
+                  >
+                    Reconnect
                   </button>
                 )}{' '}
                 {i.state === 'running'
-                  ? <button aria-label={`Stop instance ${fmtId(i.id)}`} onClick={() => control(`/api/instances/${encodeURIComponent(i.id)}/stop`, 'POST')}>Stop Instance</button>
-                  : <button aria-label={`Start instance ${fmtId(i.id)}`} onClick={() => control(`/api/instances/${encodeURIComponent(i.id)}/start`, 'POST')}>Start Instance</button>}{' '}
+                  ? <button aria-label={`Stop instance ${fmtId(i.id)}`} onClick={() => control(`/api/instances/${encodeURIComponent(i.id)}/stop`, 'POST')}>Stop</button>
+                  : <button aria-label={`Start instance ${fmtId(i.id)}`} onClick={() => control(`/api/instances/${encodeURIComponent(i.id)}/start`, 'POST')}>Start</button>}{' '}
                 <button
                   aria-label={`Destroy instance ${fmtId(i.id)}`}
                   title={i.state !== 'running' && i.runtime === 'docker' ? 'Stopped Docker row — Destroy removes the container directly (admin-v2 has no instance record).' : undefined}
@@ -132,3 +154,28 @@ export function Inventory({ onStartSession, onLaunchInstance }: { onStartSession
     </>
   );
 }
+
+// VM runtimes included per #1778 — the bridge signals the in-guest agent via
+// qemu-guest-agent, the container/docker path via docker exec.
+const RECONNECTABLE_RUNTIMES = ['docker', 'container', 'vm', 'qemu', 'kvm'];
+
+function isReconnectable(i: Instance): boolean {
+  const runtime = String(i.runtime_posture?.kind ?? i.runtime).toLowerCase();
+  const running = String(i.state).toLowerCase() === 'running';
+  const agentMissing = i.agent_ready === false || i.session_backends?.some((b) => b.available === false);
+  return running && RECONNECTABLE_RUNTIMES.includes(runtime) && Boolean(agentMissing);
+}
+
+function instanceHealth(i: Instance): { kind: 'healthy' | 'stale-agent'; label: string; detail?: string } {
+  const running = String(i.state).toLowerCase() === 'running';
+  const unavailableReason = i.session_backends?.find((b) => b.available === false)?.reason;
+  const agentMissing = i.agent_ready === false || Boolean(unavailableReason);
+  if (running && agentMissing) {
+    return {
+      kind: 'stale-agent',
+      label: 'agent unreachable',
+      detail: unavailableReason ?? 'Runtime is still running, but the agent is not registered.',
+    };
+  }
+  return { kind: 'healthy', label: i.state };
+}