fraim-framework 2.0.162 → 2.0.163

package/dist/src/ai-hub/hosts.js

@@ -319,7 +319,13 @@ const EMPLOYEE_LABELS = {
     codex: 'Codex',
     claude: 'Claude Code',
     gemini: 'Gemini CLI',
+    copilot: 'GitHub Copilot CLI',
 };
+// GitHub Copilot CLI binary name after `npm install -g @github/copilot`.
+// The @github/copilot package installs a binary named `copilot` on PATH.
+// Note: the package name is @github/copilot (NOT @github/copilot-cli which
+// does not exist on npm). The binary is `copilot` (NOT `github-copilot-cli`).
+const COPILOT_BINARY = 'copilot';
 const executableName = (command) => command;
 function quoteWindowsArg(value) {
     if (value.length === 0) {
@@ -348,9 +354,15 @@ const availableByVersionProbe = (command) => {
     });
     return result.status === 0;
 };
+// Resolve the binary name for each agent tool.
+function agentBinaryName(id) {
+    if (id === 'copilot')
+        return COPILOT_BINARY;
+    return executableName(id);
+}
 function detectEmployees() {
     return Object.keys(EMPLOYEE_LABELS).map((id) => {
-        const available = availableByVersionProbe(executableName(id));
+        const available = availableByVersionProbe(agentBinaryName(id));
         return {
             id,
             label: EMPLOYEE_LABELS[id],
@@ -560,6 +572,15 @@ function sharedBrowserHostConfig(hostId, env = process.env) {
         }
         return { args: [], env: { GEMINI_CLI_SYSTEM_SETTINGS_PATH: file } };
     }
+    if (hostId === 'copilot') {
+        // GitHub Copilot CLI does not yet publish a documented per-invocation
+        // settings-file env var analogous to GEMINI_CLI_SYSTEM_SETTINGS_PATH.
+        // If one is discovered in a future release, write the ephemeral file here
+        // and return { args: [], env: { <COPILOT_SETTINGS_ENV_VAR>: file } }.
+        // Until then, return the Option-B no-op per spec R5.2 — the Hub's
+        // start-payload builder will inject a browser-guidance note instead.
+        return { args: [] };
+    }
     return { args: [] };
 }
 function buildStartPlan(hostId, message, sessionId) {
@@ -586,6 +607,22 @@ function buildStartPlan(hostId, message, sessionId) {
             env: browser.env,
         };
     }
+    if (hostId === 'copilot') {
+        // GitHub Copilot CLI headless invocation.
+        // --yolo auto-approves all tool permissions (analogous to
+        // --dangerously-skip-permissions for Claude Code). The task is provided
+        // via stdin; -p/--prompt requires inline text which is cumbersome for
+        // multi-line FRAIM instructions. The session id is self-assigned by the
+        // binary on first run; Hub captures it from the stream output
+        // (parseHostLine 'copilot' branch).
+        const browser = sharedBrowserHostConfig('copilot');
+        return {
+            command: COPILOT_BINARY,
+            args: ['--yolo', ...browser.args],
+            stdin: transformHeadlessFraimMessage(message, 'start'),
+            env: browser.env,
+        };
+    }
     const browser = sharedBrowserHostConfig('claude');
     return {
         command: executableName('claude'),
@@ -615,6 +652,17 @@ function buildContinuePlan(hostId, sessionId, message) {
             env: browser.env,
         };
     }
+    if (hostId === 'copilot') {
+        // Resume an existing GitHub Copilot CLI session.
+        // --resume <sessionId> accepts the session id returned on the first run.
+        const browser = sharedBrowserHostConfig('copilot');
+        return {
+            command: COPILOT_BINARY,
+            args: ['--yolo', '--resume', sessionId, ...browser.args],
+            stdin: transformHeadlessFraimMessage(message, 'continue'),
+            env: browser.env,
+        };
+    }
     const browser = sharedBrowserHostConfig('claude');
     return {
         command: executableName('claude'),
@@ -666,6 +714,14 @@ function buildDirectStartPlan(hostId, message, sessionId) {
             stdin: DIRECT_PREAMBLE + message,
         };
     }
+    if (hostId === 'copilot') {
+        // Direct (A/B) mode for Copilot: headless, no FRAIM MCP wiring.
+        return {
+            command: COPILOT_BINARY,
+            args: ['--yolo'],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
     return {
         command: executableName('claude'),
         args: [
@@ -696,6 +752,14 @@ function buildDirectContinuePlan(hostId, sessionId, message) {
             stdin: DIRECT_PREAMBLE + message,
         };
     }
+    if (hostId === 'copilot') {
+        // Direct continue mode for Copilot: resume session, no FRAIM MCP wiring.
+        return {
+            command: COPILOT_BINARY,
+            args: ['--yolo', '--resume', sessionId],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
     return {
         command: executableName('claude'),
         args: [
@@ -764,6 +828,32 @@ function parseHostLine(hostId, line) {
             return withSignal({ message: trimmed, raw: trimmed });
         }
     }
+    // GitHub Copilot CLI output: JSON stream where each event carries a `type`
+    // field. Known event shapes (from the agentic CLI stream):
+    //   { "type": "session.started", "session_id": "..." }  — session id
+    //   { "type": "message", "role": "assistant", "content": "..." }  — reply text
+    //   { "type": "turn.completed", "usage": { ... } }  — token usage (same shape as Codex)
+    // For any JSON event not matching the above, signal scanning (seekMentoring,
+    // agent identity) still runs because withSignal is applied to every parsed result.
+    // Non-JSON lines from Copilot are treated as plain-text employee messages.
+    if (hostId === 'copilot') {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === 'session.started' && typeof parsed.session_id === 'string' && parsed.session_id.length > 0) {
+                return withSignal({ sessionId: parsed.session_id, raw: trimmed });
+            }
+            if (parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string') {
+                return withSignal({ message: parsed.content, raw: trimmed });
+            }
+            // All other JSON events: apply signal scanning and surface as raw.
+            return withSignal({ raw: trimmed });
+        }
+        catch {
+            // Non-JSON line from Copilot: treat as a plain-text employee message,
+            // same pattern as Gemini CLI's non-JSON output.
+            return withSignal({ message: trimmed, raw: trimmed });
+        }
+    }
     try {
         const parsed = JSON.parse(trimmed);
         if (parsed.type === 'system' && parsed.session_id) {
@@ -950,6 +1040,7 @@ class FakeHostRuntime {
             { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.', supportsRaw: true },
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.', supportsRaw: true },
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.', supportsRaw: true },
+            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Test double agent tool.', supportsRaw: true },
         ];
     }
     detectEmployees() {
@@ -1032,6 +1123,7 @@ class ScriptedHostRuntime {
             { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
+            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
         ];
         // Track each active run so the test can emit signals at it. Key is the
         // sessionId we hand back on startRun; mapping sessionId → handlers

package/dist/src/ai-hub/preferences.js

@@ -29,7 +29,7 @@ class AiHubPreferencesStore {
             const raw = JSON.parse(fs_1.default.readFileSync(this.stateFilePath, 'utf8'));
             return {
                 projectPath: raw.projectPath || projectPath,
-                employeeId: (raw.employeeId === 'claude' || raw.employeeId === 'codex') ? raw.employeeId : DEFAULT_EMPLOYEE,
+                employeeId: (raw.employeeId === 'claude' || raw.employeeId === 'codex' || raw.employeeId === 'gemini' || raw.employeeId === 'copilot') ? raw.employeeId : DEFAULT_EMPLOYEE,
                 categoryId: typeof raw.categoryId === 'string' && raw.categoryId.length > 0 ? raw.categoryId : DEFAULT_CATEGORY,
                 recentJobIds: Array.isArray(raw.recentJobIds) ? raw.recentJobIds.filter((value) => typeof value === 'string') : [],
                 recentJobInstructions: (typeof raw.recentJobInstructions === 'object' && raw.recentJobInstructions !== null && !Array.isArray(raw.recentJobInstructions))

package/dist/src/ai-hub/server.js

@@ -516,6 +516,7 @@ const HUB_TO_FIRST_RUN_ID = {
     claude: 'claude-code',
     codex: 'codex',
     gemini: 'gemini-cli',
+    copilot: 'copilot-cli',
 };
 function hubAgentOption(hubId) {
     const frId = HUB_TO_FIRST_RUN_ID[hubId];

package/dist/src/cli/doctor/check-runner.js

@@ -7,7 +7,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runChecks = runChecks;
 const CHECK_TIMEOUT = 2000; // 2 seconds per check
-const MCP_CHECK_TIMEOUT = 10000; // 10 seconds for MCP connectivity checks
+// Issue #532: stdio MCP servers need up to 15s for handshake + npm version resolution
+// on first call via fraim-mcp-latest-launcher; 20s gives a 5s buffer.
+const MCP_CHECK_TIMEOUT = 20000; // 20 seconds for MCP connectivity checks
 const TOTAL_TIMEOUT = 30000; // 30 seconds total
 // Simple logger for doctor command (optional, falls back to no-op)
 const logger = {

package/dist/src/cli/doctor/checks/mcp-connectivity-checks.js

@@ -3,6 +3,7 @@
  * MCP connectivity checks for FRAIM doctor command
  * Tests FRAIM server connectivity and validates IDE MCP configurations
  * Issue #144: Enhanced doctor command
+ * Issue #532: Stdio MCP runtime connectivity check
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -43,6 +44,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNpmMajorVersion = getNpmMajorVersion;
 exports.diagnoseFraimMcpLaunchPlan = diagnoseFraimMcpLaunchPlan;
+exports.spawnAndHandshake = spawnAndHandshake;
+exports.getStdioMCPRuntimeChecks = getStdioMCPRuntimeChecks;
 exports.getMCPConnectivityChecks = getMCPConnectivityChecks;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -52,7 +55,16 @@ const axios_1 = __importDefault(require("axios"));
 const toml = __importStar(require("toml"));
 const ide_detector_1 = require("../../setup/ide-detector");
 const fraim_mcp_latest_launcher_1 = require("../../mcp/fraim-mcp-latest-launcher");
+const command_resolution_1 = require("../../mcp/command-resolution");
+// Cache the npm major version so execFileSync is called at most once per process.
+// Without caching, each IDE config check calls diagnoseFraimMcpLaunchPlan which calls
+// getNpmMajorVersion, and execFileSync blocks the event loop for ~2s on Windows.
+// With 8+ IDE checks running via Promise.all the blocking stacks sequentially.
+let _npmMajorVersionCache = undefined;
 function getNpmMajorVersion() {
+    if (_npmMajorVersionCache !== undefined) {
+        return _npmMajorVersionCache;
+    }
     try {
         const command = process.platform === 'win32' ? (process.env.ComSpec || 'cmd.exe') : 'npm';
         const args = process.platform === 'win32' ? ['/d', '/s', '/c', 'npm --version'] : ['--version'];
@@ -61,11 +73,12 @@ function getNpmMajorVersion() {
             stdio: ['ignore', 'pipe', 'ignore']
         });
         const major = Number.parseInt(output.trim().split('.')[0], 10);
-        return Number.isFinite(major) ? major : null;
+        _npmMajorVersionCache = Number.isFinite(major) ? major : null;
     }
     catch {
-        return null;
+        _npmMajorVersionCache = null;
     }
+    return _npmMajorVersionCache;
 }
 function diagnoseFraimMcpLaunchPlan(fraimServer, platform = process.platform, npmMajorVersion = getNpmMajorVersion()) {
     const command = String(fraimServer?.command || '');
@@ -419,6 +432,248 @@ async function validateIDEMCPConfig(ide) {
         };
     }
 }
+// ============================================================
+// Issue #532: Stdio MCP Runtime Connectivity Check
+// ============================================================
+const STDIO_HANDSHAKE_TIMEOUT_MS = 15000;
+/**
+ * Spawn a stdio MCP server, perform a two-phase JSON-RPC handshake
+ * (initialize then tools/list), and return a structured result.
+ *
+ * On Windows, wraps the command in cmd.exe /d /s /c so that .cmd wrappers
+ * resolve correctly. The same pattern is used by resolveManagedCommand and
+ * fraim-mcp-latest-launcher.
+ */
+async function spawnAndHandshake(command, args, timeoutMs = STDIO_HANDSHAKE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        let spawnCommand;
+        let spawnArgs;
+        // spawnOptions is typed loosely so we can set windowsVerbatimArguments below.
+        let spawnOptions = {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: process.env
+        };
+        if (process.platform === 'win32') {
+            // On Windows, wrap in cmd.exe so .cmd wrappers are resolved.
+            // cmd.exe /d /s /c requires special handling when the command path contains spaces:
+            //   cmd /c ""path with spaces" arg1 arg2"
+            // The outer pair of double-quotes is mandatory when the first token is quoted.
+            // We must also pass windowsVerbatimArguments: true so Node's CreateProcess call
+            // does not re-escape our already-quoted command string.
+            const comSpec = process.env.ComSpec || 'cmd.exe';
+            const quotedTokens = [command, ...args].map((a) => {
+                const v = String(a);
+                return /[\s"&|<>^]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
+            });
+            const innerCmd = quotedTokens.join(' ');
+            // Wrap in outer quotes only when the command contains spaces (i.e. was itself quoted).
+            const needsOuterQuote = /[\s"&|<>^]/.test(String(command));
+            const cmdString = needsOuterQuote ? `"${innerCmd}"` : innerCmd;
+            spawnCommand = comSpec;
+            spawnArgs = ['/d', '/s', '/c', cmdString];
+            spawnOptions = { ...spawnOptions, windowsVerbatimArguments: true };
+        }
+        else {
+            spawnCommand = command;
+            spawnArgs = args;
+        }
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(spawnCommand, spawnArgs, spawnOptions);
+        }
+        catch (spawnErr) {
+            resolve({
+                status: 'error',
+                phase: 'spawn',
+                message: `Failed to spawn MCP server: ${spawnErr.message}`,
+                suggestion: 'Verify that npx is installed and accessible on PATH.',
+                details: { command, args, error: spawnErr.message }
+            });
+            return;
+        }
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* best effort */ }
+            resolve({
+                status: 'error',
+                phase: 'initialize',
+                message: `MCP server did not respond within ${timeoutMs}ms`,
+                suggestion: 'The server may be slow to start. Check that the package is installed and npx cache is warm.',
+                details: { command, args, timeoutMs, elapsed: Date.now() - startTime }
+            });
+        }, timeoutMs);
+        let stderrBuffer = '';
+        let stdoutBuffer = '';
+        let spawnError = null;
+        child.stderr?.on('data', (d) => {
+            stderrBuffer += d.toString();
+        });
+        child.on('error', (err) => {
+            spawnError = err;
+        });
+        child.stdout?.on('data', (d) => {
+            stdoutBuffer += d.toString();
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (spawnError) {
+                const msg = spawnError.message || '';
+                const isEnoent = msg.includes('ENOENT') || msg.includes('not found');
+                resolve({
+                    status: 'error',
+                    phase: 'spawn',
+                    message: `Failed to start MCP server: ${msg}`,
+                    suggestion: isEnoent
+                        ? 'Verify that npx is installed. Run: npm install -g npm to update npm/npx.'
+                        : 'Check that the required package can be installed via npx.',
+                    details: { command, args, error: msg }
+                });
+                return;
+            }
+            if (code !== 0 && stdoutBuffer.trim() === '') {
+                resolve({
+                    status: 'error',
+                    phase: 'spawn',
+                    message: `MCP server exited with code ${code} before responding`,
+                    suggestion: 'Run: npx -y <package> manually to check for installation errors.',
+                    details: { command, args, exitCode: code, stderr: stderrBuffer.slice(0, 500) }
+                });
+                return;
+            }
+            // Parse all JSON-RPC messages received from stdout
+            const lines = stdoutBuffer.split('\n').map((l) => l.trim()).filter(Boolean);
+            let initializeResponse = null;
+            let toolsListResponse = null;
+            for (const line of lines) {
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg?.id === 1 && msg?.result !== undefined) {
+                        initializeResponse = msg;
+                    }
+                    if (msg?.id === 2 && msg?.result !== undefined) {
+                        toolsListResponse = msg;
+                    }
+                }
+                catch {
+                    // Ignore non-JSON lines (e.g., startup log output)
+                }
+            }
+            if (!initializeResponse) {
+                resolve({
+                    status: 'error',
+                    phase: 'initialize',
+                    message: 'MCP server did not return a valid initialize response',
+                    suggestion: 'The server may have crashed during startup. Check stderr for error details.',
+                    details: { command, args, exitCode: code, stderr: stderrBuffer.slice(0, 500) }
+                });
+                return;
+            }
+            if (!toolsListResponse) {
+                resolve({
+                    status: 'error',
+                    phase: 'tools-list',
+                    message: 'MCP server did not respond to tools/list',
+                    suggestion: 'The server initialized but did not expose any tools. Check the package documentation.',
+                    details: { command, args, exitCode: code }
+                });
+                return;
+            }
+            const toolCount = Array.isArray(toolsListResponse.result?.tools)
+                ? toolsListResponse.result.tools.length
+                : 0;
+            const elapsed = Date.now() - startTime;
+            resolve({
+                status: 'passed',
+                message: `MCP server responded with ${toolCount} tool(s) in ${elapsed}ms`,
+                details: { command, args, toolCount, elapsed }
+            });
+        });
+        // Send two-phase JSON-RPC handshake
+        try {
+            const initMsg = JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: { name: 'fraim-doctor', version: '1.0' }
+                }
+            }) + '\n';
+            child.stdin?.write(initMsg);
+            const toolsMsg = JSON.stringify({
+                jsonrpc: '2.0',
+                id: 2,
+                method: 'tools/list',
+                params: {}
+            }) + '\n';
+            child.stdin?.write(toolsMsg);
+            child.stdin?.end();
+        }
+        catch {
+            // stdin may not be writable if the process exited immediately
+        }
+    });
+}
+/**
+ * Run a connectivity check for a single named stdio MCP server.
+ */
+async function testStdioMCPServer(serverName, command, args) {
+    if (process.env.NODE_ENV === 'test') {
+        return {
+            status: 'warning',
+            message: `Stdio MCP runtime check for "${serverName}" skipped (test mode)`,
+            details: { testMode: true, skipped: true, serverName }
+        };
+    }
+    const result = await spawnAndHandshake(command, args, STDIO_HANDSHAKE_TIMEOUT_MS);
+    if (result.status === 'passed') {
+        return {
+            status: 'passed',
+            message: `${serverName} stdio MCP: ${result.message}`,
+            details: result.details
+        };
+    }
+    return {
+        status: 'error',
+        message: `${serverName} stdio MCP connectivity failed (phase: ${result.phase}): ${result.message}`,
+        suggestion: result.suggestion,
+        details: { ...result.details, phase: result.phase }
+    };
+}
+/**
+ * Build the 3 stdio MCP runtime checks (git, playwright, fraim).
+ * Exported separately so callers can obtain just the runtime checks if needed.
+ */
+function getStdioMCPRuntimeChecks() {
+    const npx = (0, command_resolution_1.resolveManagedCommand)('npx');
+    // For the fraim MCP server we use the latest launcher so the test
+    // exercises the same path that IDE configs use.
+    const fraimLauncherPath = (0, fraim_mcp_latest_launcher_1.getFraimMcpLatestLauncherPath)();
+    return [
+        {
+            name: 'git stdio runtime check',
+            category: 'mcpConnectivity',
+            critical: false,
+            run: () => testStdioMCPServer('git', npx, ['-y', '@cyanheads/git-mcp-server'])
+        },
+        {
+            name: 'playwright stdio runtime check',
+            category: 'mcpConnectivity',
+            critical: false,
+            run: () => testStdioMCPServer('playwright', npx, ['-y', '@playwright/mcp'])
+        },
+        {
+            name: 'fraim stdio runtime check',
+            category: 'mcpConnectivity',
+            critical: false,
+            run: () => testStdioMCPServer('fraim', process.execPath, [fraimLauncherPath])
+        }
+    ];
+}
 /**
  * Get all MCP connectivity checks
  */
@@ -441,5 +696,9 @@ function getMCPConnectivityChecks() {
             run: async () => validateIDEMCPConfig(ide)
         });
     }
+    // Check 3 (Issue #532): Confirm stdio MCP servers respond at runtime.
+    // "Disconnected" in mcp list is expected on-demand-spawn behavior. These checks
+    // verify that each server can actually start and complete a JSON-RPC handshake.
+    checks.push(...getStdioMCPRuntimeChecks());
     return checks;
 }

package/dist/src/first-run/types.js

@@ -50,6 +50,14 @@ exports.FIRST_RUN_AGENT_OPTIONS = [
         launchCommand: 'gemini',
         installPackage: '@google/gemini-cli',
     },
+    {
+        id: 'copilot-cli',
+        label: 'GitHub Copilot',
+        detectAliases: ['copilot'],
+        loginCommand: 'copilot login',
+        launchCommand: 'copilot',
+        installPackage: '@github/copilot',
+    },
 ];
 /**
  * The canonical row set, in display order. Each row starts in `pending`;

package/dist/src/local-mcp-server/agent-token-prices.js

@@ -109,6 +109,36 @@ exports.AGENT_TOKEN_PRICES = [
         source: 'https://ai.google.dev/gemini-api/docs/pricing',
         verifiedOn: '2026-06-02',
     },
+    // GitHub Copilot CLI. The CLI's agentic mode uses GPT-4.1 (also branded
+    // "gpt-4.1" in the Copilot API stream). GitHub charges for Copilot via
+    // premium-request quota rather than per-token billing on most plans; the
+    // per-token rates below apply to the Copilot API / enterprise API billing
+    // path (pay-per-token, not included-requests) as published at
+    // https://docs.github.com/en/copilot/about-github-copilot/plans-for-github-copilot
+    // and the underlying OpenAI model pricing for gpt-4.1 at openai.com/api/pricing/.
+    // Coverage is 'partial' for Copilot runs where the CLI does not emit a cost
+    // field — the table backstops cost computation when a token count is present
+    // but no direct costUsd is in the stream.
+    {
+        agent: 'copilot',
+        model: 'gpt-4.1',
+        inputPerMTok: 2.00,
+        outputPerMTok: 8.00,
+        cacheReadPerMTok: 0.50,
+        cacheCreationPerMTok: 0,
+        source: 'https://openai.com/api/pricing/ (gpt-4.1 row; GitHub Copilot CLI agentic mode)',
+        verifiedOn: '2026-06-09',
+    },
+    {
+        agent: 'copilot',
+        model: 'gpt-4o',
+        inputPerMTok: 2.50,
+        outputPerMTok: 10.00,
+        cacheReadPerMTok: 1.25,
+        cacheCreationPerMTok: 0,
+        source: 'https://openai.com/api/pricing/ (gpt-4o row; GitHub Copilot CLI fallback model)',
+        verifiedOn: '2026-06-09',
+    },
 ];
 /**
  * Look up the price entry for an agent + model. Agent is matched

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.162",
+  "version": "2.0.163",
   "description": "FRAIM: AI Workforce Infrastructure — the organizational capability that turns AI agents into an accountable workforce, their operators into capable AI managers, and executives into leaders with clear optics on AI proficiency.",
   "main": "index.js",
   "bin": {
@@ -15,7 +15,7 @@
     "build:fraim-brain": "node scripts/generate-fraim-brain.js",
     "test-all": "npm run test && npm run test:isolated tests/isolated/test-*.ts && npm run test:ui",
     "test": "node scripts/test-with-server.js",
-    "test:isolated": "npx tsx --test --test-concurrency=1 --test-reporter=spec ",
+    "test:isolated": "node scripts/test-isolated.js",
     "test:smoke": "node scripts/test-with-server.js --tags=smoke",
     "test:coverage": "node scripts/test-with-server.js --tags=smoke --coverage",
     "test:stripe": "node scripts/test-with-server.js tests/test-stripe-payment-complete.ts",

package/public/ai-hub/index.html

@@ -329,7 +329,7 @@
                 </span>
                 <span class="active-employee-row" onclick="event.stopPropagation()">
                   <span class="active-employee-label">Maestro</span>
-                  <select id="active-employee-select" class="employee-select inline" aria-label="Employee"></select>
+                  <select id="active-employee-select" class="employee-select inline" aria-label="Agent Tool"></select>
                 </span>
               </summary>
               <div class="panel-body">
@@ -476,8 +476,8 @@
             <div class="word-ctx-card-body" id="word-ctx-card-body" hidden></div>
           </div>
           <div class="employee-line">
-            <span class="employee-label">Employee:</span>
-            <select id="employee-select" class="employee-select"></select>
+            <span class="employee-label">Agent Tool:</span>
+            <select id="employee-select" class="employee-select" aria-label="Agent Tool"></select>
           </div>
           <div id="agent-install-panel"></div>
           <div id="ab-toggle-wrap" hidden>

package/public/ai-hub/script.js

@@ -9,8 +9,6 @@
 // conversation maps to one job and (when active) one backend run id. The
 // existing single-active-run backend stays untouched per spec R15.
 
-const STORAGE_KEY_CONVERSATIONS = 'fraim.aiHub.conversations.v1';
-const STORAGE_KEY_ACTIVE = 'fraim.aiHub.activeConversation.v1';
 const STORAGE_KEY_TREE_WIDTH = 'fraim.aiHub.treeSidebarWidth.v1';
 const STORAGE_KEY_TREE_COLLAPSED = 'fraim.aiHub.treeSidebarCollapsed.v1';
 const TREE_WIDTH_MIN = 176;
@@ -386,35 +384,6 @@ function normalizeGeminiConversationMessages(conv) {
   return changed;
 }
 
-function loadConversationsFromStorage() {
-  try {
-    const raw = window.localStorage.getItem(STORAGE_KEY_CONVERSATIONS);
-    state.conversations = raw ? JSON.parse(raw) : {};
-  } catch {
-    state.conversations = {};
-  }
-  try {
-    state.activeId = window.localStorage.getItem(STORAGE_KEY_ACTIVE) || null;
-  } catch {
-    state.activeId = null;
-  }
-  // Retroactively fix titles that were saved as the generic "New job" fallback
-  // by re-deriving from the first manager message.
-  let normalizedLegacyConversations = false;
-  for (const convList of Object.values(state.conversations)) {
-    for (const conv of convList) {
-      normalizedLegacyConversations = normalizeGeminiConversationMessages(conv) || normalizedLegacyConversations;
-      if (conv.title === 'New job') {
-        const firstMsg = (conv.messages || []).find((m) => m.role === 'manager');
-        if (!firstMsg) continue;
-        const rederived = deriveTitle(conv.jobTitle || '', firstMsg.text || '');
-        if (rederived !== 'New job') conv.title = rederived;
-      }
-    }
-  }
-  if (normalizedLegacyConversations) persistConversations();
-}
-
 function projectConversationPayload() {
   return {
     projectPath: state.projectPath || '',
@@ -423,19 +392,6 @@ function projectConversationPayload() {
   };
 }
 
-function persistConversationsToCache() {
-  try {
-    window.localStorage.setItem(STORAGE_KEY_CONVERSATIONS, JSON.stringify(state.conversations));
-    if (state.activeId) {
-      window.localStorage.setItem(STORAGE_KEY_ACTIVE, state.activeId);
-    } else {
-      window.localStorage.removeItem(STORAGE_KEY_ACTIVE);
-    }
-  } catch (error) {
-    console.warn('Could not persist conversations:', error);
-  }
-}
-
 function scheduleConversationDiskPersist() {
   if (!state.projectPath) return;
   if (state.conversationPersistTimer) window.clearTimeout(state.conversationPersistTimer);
@@ -457,7 +413,6 @@ function scheduleConversationDiskPersist() {
 
 function persistConversations(options) {
   const opts = options || {};
-  persistConversationsToCache();
   if (opts.disk !== false) scheduleConversationDiskPersist();
 }
 
@@ -465,33 +420,17 @@ async function hydrateConversationsFromServer() {
   if (!state.projectPath) return;
   try {
     const payload = await requestJson(`/api/ai-hub/conversations?projectPath=${encodeURIComponent(state.projectPath)}`);
-    const serverConversations = Array.isArray(payload.conversations) ? payload.conversations : [];
-    const localConversations = projectConversations();
-    const mergedById = new Map();
-    for (const conv of serverConversations) mergedById.set(conv.id, conv);
-    for (const conv of localConversations) {
-      const existing = mergedById.get(conv.id);
-      if (!existing || conversationTimestamp(conv) > conversationTimestamp(existing)) {
-        mergedById.set(conv.id, conv);
-      }
-    }
-    const conversations = Array.from(mergedById.values())
-      .sort((a, b) => conversationTimestamp(b) - conversationTimestamp(a));
-    // #534: apply the same Gemini stdout/stderr normalization as the localStorage
-    // path so server-hydrated conversations render identically (the localStorage
-    // path normalizes in loadConversationsFromStorage; without this, a hydrate-vs-
-    // load race can surface uncoalesced/stale rows).
+    const conversations = Array.isArray(payload.conversations) ? payload.conversations : [];
     for (const conv of conversations) normalizeGeminiConversationMessages(conv);
     state.conversations[state.projectPath] = conversations;
     const activeCandidates = [state.activeId, payload.activeId].filter(Boolean);
     state.activeId = activeCandidates.find((id) => conversations.some((conv) => conv.id === id)) || (conversations[0] ? conversations[0].id : null);
     state.conversationDiskAvailable = true;
-    persistConversations({ disk: false });
     renderRail();
     renderActive();
   } catch (error) {
     state.conversationDiskAvailable = false;
-    console.warn('Could not hydrate conversations from local disk:', error);
+    console.warn('Could not hydrate conversations from server:', error);
   }
 }
 
@@ -767,14 +706,72 @@ function renderRail() {
     !(inWorkspace && projectUpdateJobs.has(conv.jobId))
   );
 
+  // Issue #550: Two-path routing for ad-hoc (freeform) conversations.
+  // Path A: jobId === '__freeform__' AND conv.personaKey resolves to a FRAIM
+  //         employee the user has access to -> groups with that employee's
+  //         accordion, identical to a structured catalog run.
+  // Path B: jobId === '__freeform__' AND no personaKey (no FRAIM employee
+  //         identity was resolved) -> deferred to a single "Watercooler
+  //         Conversations" group rendered after all employee groups (R3).
+  //         The agentName (host CLI) is NOT a FRAIM employee and does not
+  //         qualify an ad-hoc run for Path A — only personaKey does.
+  const watercoolerConvs = [];
   const groups = new Map();
   for (const conv of list) {
+    const isFreeform = conv.jobId === '__freeform__';
+    if (isFreeform && !conv.personaKey) {
+      // Path B: unmatched ad-hoc — collect for the Watercooler group.
+      watercoolerConvs.push(conv);
+      continue;
+    }
+    // Path A (matched ad-hoc with personaKey) or structured run:
+    // group by employee key as before.
     const key = conv.personaKey || conversationAgentName(conv) || 'free';
     const label = getConversationEmployeeLabel(conv);
     if (!groups.has(key)) groups.set(key, { key, label, detail: getConversationEmployeeDetail(conv), sample: conv, conversations: [] });
     groups.get(key).conversations.push(conv);
   }
 
+  // Helper: build the run-item buttons shared by employee groups and Watercooler.
+  function buildGroupList(conversations) {
+    const groupList = document.createElement('div');
+    groupList.className = 'conv-employee-list';
+    for (const conv of conversations) {
+      const btn = document.createElement('button');
+      btn.type = 'button';
+      btn.className = 'conv-item' + (state.activeId === conv.id ? ' active' : '');
+      btn.dataset.conv = conv.id;
+      const bodyDiv = document.createElement('span');
+      bodyDiv.className = 'conv-body';
+      const titleSpan = document.createElement('span');
+      titleSpan.className = 'conv-title';
+      titleSpan.textContent = conv.title || '';
+      bodyDiv.appendChild(titleSpan);
+      btn.appendChild(bodyDiv);
+      const dotClass = conversationStateDotClass(conv);
+      const statusDot = document.createElement('span');
+      statusDot.className = 'state-dot conv-state-dot dot-' + dotClass;
+      statusDot.title = tfDotTitle(dotClass);
+      btn.appendChild(statusDot);
+      const statusSpan = document.createElement('span');
+      statusSpan.className = 'conv-status';
+      statusSpan.textContent = conversationStateLabel(conv);
+      statusSpan.classList.add(conversationUiState(conv));
+      btn.appendChild(statusSpan);
+      // Issue #442: A/B badge on rail entry.
+      if (conv.compareMode === 'ab') {
+        const badge = document.createElement('span');
+        badge.className = 'ab-badge';
+        badge.textContent = 'A/B';
+        btn.appendChild(badge);
+      }
+      tfAttachRunDelete(btn, conv, { tree: false }); // #533 R6: delete a run
+      btn.addEventListener('click', () => switchToConversation(conv.id));
+      groupList.appendChild(btn);
+    }
+    return groupList;
+  }
+
   for (const group of groups.values()) {
     const details = document.createElement('details');
     details.className = 'conv-employee-group';
@@ -812,48 +809,46 @@ function renderRail() {
     summary.appendChild(addBtn);
     summary.appendChild(count);
     details.appendChild(summary);
-
-    const groupList = document.createElement('div');
-    groupList.className = 'conv-employee-list';
-
-    for (const conv of group.conversations) {
-      const btn = document.createElement('button');
-      btn.type = 'button';
-      btn.className = 'conv-item' + (state.activeId === conv.id ? ' active' : '');
-      btn.dataset.conv = conv.id;
-      const bodyDiv = document.createElement('span');
-      bodyDiv.className = 'conv-body';
-      const titleSpan = document.createElement('span');
-      titleSpan.className = 'conv-title';
-      titleSpan.textContent = conv.title || '';
-      bodyDiv.appendChild(titleSpan);
-      btn.appendChild(bodyDiv);
-      const dotClass = conversationStateDotClass(conv);
-      const statusDot = document.createElement('span');
-      statusDot.className = 'state-dot conv-state-dot dot-' + dotClass;
-      statusDot.title = tfDotTitle(dotClass);
-      btn.appendChild(statusDot);
-      const statusSpan = document.createElement('span');
-      statusSpan.className = 'conv-status';
-      statusSpan.textContent = conversationStateLabel(conv);
-      statusSpan.classList.add(conversationUiState(conv));
-      btn.appendChild(statusSpan);
-      // Issue #442: A/B badge on rail entry.
-      if (conv.compareMode === 'ab') {
-        const badge = document.createElement('span');
-        badge.className = 'ab-badge';
-        badge.textContent = 'A/B';
-        btn.appendChild(badge);
-      }
-      tfAttachRunDelete(btn, conv, { tree: false }); // #533 R6: delete a run
-      btn.addEventListener('click', () => switchToConversation(conv.id));
-      groupList.appendChild(btn);
-    }
-
-    details.appendChild(groupList);
+    details.appendChild(buildGroupList(group.conversations));
     els['conv-list'].appendChild(details);
   }
 
+  // Issue #550 R2/R3: Render the Watercooler Conversations group after all
+  // employee groups, only when at least one unmatched ad-hoc conv exists.
+  // R9: the persona filter excludes unmatched ad-hoc convs entirely (they carry
+  // no personaKey so they never satisfy the filter), meaning watercoolerConvs is
+  // already empty when a persona filter is active.
+  if (watercoolerConvs.length > 0) {
+    const wcDetails = document.createElement('details');
+    wcDetails.className = 'conv-employee-group conv-employee-group--adhoc';
+    wcDetails.open = true;
+    const wcSummary = document.createElement('summary');
+    wcSummary.className = 'conv-employee-tab';
+    // R4: dashed-border avatar placeholder — no image or initials.
+    const wcAvatar = document.createElement('span');
+    wcAvatar.className = 'conv-employee-avatar conv-employee-avatar--adhoc';
+    const wcCopy = document.createElement('span');
+    wcCopy.className = 'conv-employee-tab-copy';
+    const wcLabel = document.createElement('strong');
+    wcLabel.className = 'conv-employee-tab-label';
+    wcLabel.textContent = 'Watercooler Conversations'; // R5
+    const wcDetail = document.createElement('small');
+    wcDetail.className = 'conv-employee-tab-detail';
+    wcDetail.textContent = 'Unmatched ad-hoc tasks'; // R5
+    wcCopy.appendChild(wcLabel);
+    wcCopy.appendChild(wcDetail);
+    const wcCount = document.createElement('span');
+    wcCount.className = 'conv-employee-tab-count';
+    wcCount.textContent = String(watercoolerConvs.length);
+    // R6: NO "+ assign" button in Watercooler summary.
+    wcSummary.appendChild(wcAvatar);
+    wcSummary.appendChild(wcCopy);
+    wcSummary.appendChild(wcCount);
+    wcDetails.appendChild(wcSummary);
+    wcDetails.appendChild(buildGroupList(watercoolerConvs));
+    els['conv-list'].appendChild(wcDetails);
+  }
+
   // #521: hide the "Runs" section header when there's nothing in it — in the
   // workspace, project-update jobs are deduped out, so a project that has only
   // run onboarding would otherwise show a dangling empty "Runs" label.
@@ -870,6 +865,11 @@ function statusLabel(s) {
 function conversationUiState(conv) {
   if (!conv) return 'idle';
   if (conv.status === 'running') return 'working';
+  // #549: conv.stopped is set by tfStopRun after a manager-initiated stop.
+  // A stopped run is an intentional pause — visually distinct from an error-failed run.
+  // Guard on status==='failed' only: a completed run should resolve to complete/waiting,
+  // not stay stuck as stopped even if the stopped flag was not cleared.
+  if (conv.stopped && conv.status === 'failed') return 'stopped';
   if (conv.status === 'failed') return 'waiting';
   if (conv.status === 'completed' && conv.reviewApproved) return 'complete';
   if (conv.status === 'completed') return 'waiting';
@@ -881,6 +881,8 @@ function conversationStateDotClass(conv) {
   if (uiState === 'working') return 'amber';
   if (uiState === 'waiting') return 'red';
   if (uiState === 'complete') return 'green';
+  // #549: stopped runs use a non-pulsing amber dot (intentional pause, not error).
+  if (uiState === 'stopped') return 'amber-static';
   return 'grey';
 }
 
@@ -889,6 +891,8 @@ function conversationStateLabel(conv) {
   if (uiState === 'working') return 'Working';
   if (uiState === 'waiting') return 'Waiting on you';
   if (uiState === 'complete') return 'Done';
+  // #549: manager-stopped run gets a distinct "Stopped" label in the rail.
+  if (uiState === 'stopped') return 'Stopped';
   return 'Idle';
 }
 
@@ -1301,6 +1305,7 @@ function renderActive() {
   }
   els['empty'].hidden = true;
   els['active-conv'].hidden = false;
+  els['active-conv'].dataset.runId = conv.runId || '';
   els['active-title'].textContent = conversationTitle(conv);
   renderConversationIdentity(conv);
   renderRunStatePill(conv);
@@ -1516,6 +1521,8 @@ function renderRunStatePill(conv) {
     pill.textContent = 'DONE';
     pill.className = 'run-state-pill complete';
   } else {
+    // #549 R3: conversationUiState now returns 'stopped' for manager-stopped runs.
+    // conversationStateLabel returns 'Stopped' for that state; toUpperCase() => 'STOPPED'.
     pill.textContent = conversationStateLabel(conv).toUpperCase();
     pill.className = `run-state-pill ${conversationUiState(conv)}`;
   }
@@ -1523,16 +1530,33 @@ function renderRunStatePill(conv) {
   const stopBtn = els['run-stop-btn'];
   if (stopBtn) {
     const canStop = conv.status === 'running' && !!conv.runId && !conv._stopping;
-    stopBtn.hidden = !canStop;
+    // #549 R1/AC1.3: While in-flight (_stopping===true), keep the button VISIBLE but disabled
+    // so the manager retains the affordance showing "Stopping…". Hide only when the run is
+    // not active at all (canStop===false AND not in-flight).
+    stopBtn.hidden = !canStop && !conv._stopping;
     stopBtn.disabled = !!conv._stopping;
+    if (conv._stopping) {
+      stopBtn.textContent = '⏹ Stopping…';
+      stopBtn.setAttribute('aria-label', 'Stopping the employee, please wait');
+    } else {
+      stopBtn.textContent = '⏹ Stop';
+      stopBtn.setAttribute('aria-label', 'Ask the employee to stop and wait for you');
+    }
   }
 }
 
 // #521: ask the agent to stop and park the run in "waiting on you" mode.
 async function tfStopRun(conv) {
-  if (!conv || !conv.runId || conv.status !== 'running') return;
+  // #549 B2: Guard against _stopping so a rapid double-click (or force-click
+  // that bypasses the disabled button) cannot fire a second stop request while
+  // the first is still in-flight. The button is set disabled in renderRunStatePill
+  // but DOM state is not a reliable guard for programmatic re-entry.
+  if (!conv || !conv.runId || conv.status !== 'running' || conv._stopping) return;
   conv._stopping = true;
   if (typeof renderRunStatePill === 'function') renderRunStatePill(conv);
+  // #549 R1: Update the thread indicator immediately to show the in-flight dash
+  // so the manager sees "stopping in progress" rather than "still working".
+  if (typeof syncWorkingIndicator === 'function') syncWorkingIndicator(conv);
   try {
     const run = await requestJson('/api/ai-hub/runs/' + encodeURIComponent(conv.runId) + '/stop', {
       method: 'POST',
@@ -1553,6 +1577,11 @@ async function tfStopRun(conv) {
   } catch (e) {
     conv._stopping = false;
     if (typeof renderRunStatePill === 'function') renderRunStatePill(conv);
+    // #549 B1: Restore the three typing-dots when the stop POST fails.
+    // Without this call, syncWorkingIndicator was never called after the catch
+    // cleared _stopping, leaving the stopping-dash in #employee-working-indicator
+    // permanently even though the employee is still running.
+    if (typeof syncWorkingIndicator === 'function') syncWorkingIndicator(conv);
     if (typeof showStatus === 'function') showStatus((e && e.message) || 'Could not stop the run.', true);
   }
 }
@@ -1571,23 +1600,58 @@ function syncThreadUiState(conv) {
 function syncWorkingIndicator(conv) {
   const host = els['messages'];
   if (!host) return;
-  const shouldShow = conversationUiState(conv) === 'working';
+  const uiState = conversationUiState(conv);
+  const isStopping = conv && conv._stopping;
+  const shouldShowWorking = uiState === 'working';
+  const shouldShowStopped = uiState === 'stopped';
+
+  // ── #549 R2: Remove stopped indicator when state is no longer stopped. ──
+  let stoppedIndicator = host.querySelector('#employee-stopped-indicator');
+  if (!shouldShowStopped && stoppedIndicator) {
+    stoppedIndicator.remove();
+    stoppedIndicator = null;
+  }
+
+  // ── Working indicator (three-dot bounce or in-flight dash). ──
   let indicator = host.querySelector('#employee-working-indicator');
-  if (!shouldShow) {
+  if (!shouldShowWorking && !isStopping) {
     if (indicator) indicator.remove();
-    return;
+  } else {
+    // Create the bubble if it doesn't exist yet.
+    if (!indicator) {
+      indicator = document.createElement('article');
+      indicator.id = 'employee-working-indicator';
+      indicator.className = 'message typing-indicator';
+      indicator.setAttribute('aria-label', 'Employee is working');
+      const bubble = document.createElement('div');
+      bubble.className = 'bubble';
+      bubble.innerHTML = '<span class="typing-dot"></span><span class="typing-dot"></span><span class="typing-dot"></span>';
+      indicator.appendChild(bubble);
+    }
+    // #549 R1: While stop is in-flight, replace the three-dot animation with
+    // a single static dash so the manager sees "stopping" rather than "still working".
+    const bubble = indicator.querySelector('.bubble');
+    if (isStopping) {
+      bubble.innerHTML = '<span class="stopping-dash">–</span>';
+    } else if (!bubble.querySelector('.typing-dot')) {
+      // Restore three dots if _stopping cleared (e.g. stop failed).
+      bubble.innerHTML = '<span class="typing-dot"></span><span class="typing-dot"></span><span class="typing-dot"></span>';
+    }
+    host.appendChild(indicator);
   }
-  if (!indicator) {
-    indicator = document.createElement('article');
-    indicator.id = 'employee-working-indicator';
-    indicator.className = 'message typing-indicator';
-    indicator.setAttribute('aria-label', 'Employee is working');
+
+  // ── #549 R2: Show stopped-state system message after stop completes. ──
+  if (shouldShowStopped && !stoppedIndicator) {
+    const article = document.createElement('article');
+    article.id = 'employee-stopped-indicator';
+    article.className = 'message system';
+    article.setAttribute('aria-label', 'Employee stopped');
     const bubble = document.createElement('div');
     bubble.className = 'bubble';
-    bubble.innerHTML = '<span class="typing-dot"></span><span class="typing-dot"></span><span class="typing-dot"></span>';
-    indicator.appendChild(bubble);
+    bubble.textContent = '⏸ Employee stopped. Send your next instruction to continue.';
+    article.appendChild(bubble);
+    host.appendChild(article);
   }
-  host.appendChild(indicator);
 }
 
 function buildConversationSummary(conv) {
@@ -3837,6 +3901,9 @@ async function continueRun(text) {
   const coachingJobId = state.pendingCoachingJobId || undefined;
   clearPendingCoachingJob();
   conv.reviewApproved = false;
+  // #549 R6/AC6.1: Clear the stopped flag before starting the new run so
+  // stopped-state indicators are removed on the next render tick.
+  conv.stopped = false;
   conv.status = 'running';
   upsertConversation(conv);
   refreshStatusSurfaces(); // #533 R5: also recolor the tree/area dots back to working
@@ -4651,7 +4718,8 @@ function wireEvents() {
   // This is a belt-and-suspenders fallback in case the inline script was skipped.
 
   gatherElements();
-  loadConversationsFromStorage();
+  state.conversations = {};
+  state.activeId = null;
   wirePopovers();
   wireEvents();
 
@@ -4707,7 +4775,6 @@ function wireEvents() {
     if (convNeedsPolling(conv)) startPolling();
   } else {
     state.activeId = null;
-    persistConversations();
     renderActive();
   }
 })();

package/public/ai-hub/styles.css

@@ -495,6 +495,19 @@ img.conv-employee-avatar {
   background: var(--accent-soft);
   border-color: rgba(0,113,227,.28);
 }
+/* Issue #550: Watercooler Conversations group modifier */
+/* R4: dashed avatar placeholder — no image or persona initials */
+.conv-employee-avatar--adhoc {
+  border-style: dashed;
+  border-color: var(--muted);
+  background: transparent;
+  color: transparent;
+}
+/* R5: muted label color for the Watercooler group header */
+.conv-employee-group--adhoc .conv-employee-tab-label {
+  color: var(--muted);
+  font-weight: 600;
+}
 .conv-employee-list {
   display: grid;
   gap: 8px;
@@ -588,6 +601,8 @@ img.conv-employee-avatar {
 .conv-status.working { color: var(--state-working); }
 .conv-status.waiting { color: var(--state-waiting); }
 .conv-status.complete { color: var(--state-complete); }
+/* #549 R4: Amber label for manager-stopped runs in the conversation rail. */
+.conv-status.stopped { color: var(--warn); }
 .state-dot {
   display: inline-block;
   width: 8px;
@@ -765,6 +780,11 @@ img.conv-employee-avatar {
   background: color-mix(in srgb, var(--done) 14%, transparent);
   color: var(--done);
 }
+/* #549 R3: Amber STOPPED pill — intentional pause, distinct from red WAITING ON YOU. */
+.run-state-pill.stopped {
+  background: color-mix(in srgb, var(--warn) 15%, transparent);
+  color: var(--warn);
+}
 .run-state-pill.approved {
   background: color-mix(in srgb, #2e7d32 18%, transparent);
   color: #2e7d32;
@@ -1170,6 +1190,16 @@ img.coach-employee-avatar { object-fit: cover; border-radius: 4px; }
 }
 .typing-dot:nth-child(2) { animation-delay: 120ms; }
 .typing-dot:nth-child(3) { animation-delay: 240ms; }
+/* #549 R1: Static dash shown in the working-indicator bubble while stop is in-flight.
+   Replaces the animated typing-dots to signal "stopping in progress, please wait". */
+.stopping-dash {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 14px;
+  color: var(--muted);
+  line-height: 1;
+}
 @keyframes typing-bounce {
   0%, 80%, 100% { opacity: 0.35; transform: translateY(0); }
   40% { opacity: 0.9; transform: translateY(-3px); }
@@ -2582,6 +2612,9 @@ body.hub-shell { display: flex; flex-direction: column; height: 100vh; overflow:
 .dot-amber { background: var(--state-working) !important; }
 .dot-green { background: var(--state-complete) !important; }
 .dot-grey  { background: var(--line) !important; }
+/* #549 R4: amber-static — same amber colour as dot-amber but no pulse animation.
+   Used for manager-stopped runs to distinguish intentional pause from active work. */
+.dot-amber-static { background: var(--warn) !important; }
 
 /* Workspace conversation pane */
 .workspace-conv { flex: 1; display: flex; flex-direction: column; overflow: hidden; background: var(--bg); }