fraim-framework 2.0.161 → 2.0.163

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

@@ -8,18 +8,23 @@ exports.parseSeekMentoringSignal = parseSeekMentoringSignal;
 exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.detectEmployees = detectEmployees;
+exports.prepareCodexBrowserHome = prepareCodexBrowserHome;
+exports.sharedBrowserHostConfig = sharedBrowserHostConfig;
 exports.buildStartPlan = buildStartPlan;
 exports.buildContinuePlan = buildContinuePlan;
 exports.supportsDirectPath = supportsDirectPath;
 exports.buildDirectStartPlan = buildDirectStartPlan;
 exports.buildDirectContinuePlan = buildDirectContinuePlan;
 exports.parseHostLine = parseHostLine;
+exports.findGeminiSessionIdForPrompt = findGeminiSessionIdForPrompt;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const managed_agent_paths_1 = require("../cli/utils/managed-agent-paths");
+const mcp_config_generator_1 = require("../cli/setup/mcp-config-generator");
+const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
 // Parse a single line of host stdout looking for a seekMentoring tool-use
 // signal. Returns null if the line does not contain one. Supports both
 // hosts FRAIM ships against today:
@@ -89,8 +94,9 @@ function parseSeekMentoringSignal(line) {
 // Issue #347 — extract per-turn usage from the host's JSON stream.
 // Codex: `{"type":"turn.completed","usage":{input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens}}`.
 // Claude Code: `{"type":"result", ..., "usage":{input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens}, "total_cost_usd": ...}`.
+// Gemini CLI: `{"stats":{"models":{"model-id":{"tokens":{input,prompt,cached,candidates,thoughts,tool}}}}}`.
 function parseUsageSignal(line) {
-    if (!line.includes('usage'))
+    if (!line.includes('usage') && !line.includes('"stats"'))
         return null;
     let parsed;
     try {
@@ -138,6 +144,62 @@ function parseUsageSignal(line) {
             costUsd: costUsd ?? undefined,
         };
     }
+    // Gemini CLI JSON output reports per-model stats. Its `input` bucket is
+    // fresh prompt input, `cached` is prompt-cache reads, and `thoughts` are
+    // billable output/reasoning tokens.
+    if (typeof obj.stats === 'object' && obj.stats !== null) {
+        const stats = obj.stats;
+        const models = stats.models;
+        if (models && typeof models === 'object') {
+            let sawTokens = false;
+            let nonCachedInputTokens = 0;
+            let cachedInputTokens = 0;
+            let outputTokens = 0;
+            let reasoningTokens = 0;
+            let costUsd = 0;
+            let hasCompletePricing = true;
+            for (const [modelId, modelStats] of Object.entries(models)) {
+                if (typeof modelStats !== 'object' || modelStats === null)
+                    continue;
+                const tokens = modelStats.tokens;
+                if (!tokens || typeof tokens !== 'object')
+                    continue;
+                const freshInput = numberOrNull(tokens.input) ?? 0;
+                const cachedInput = numberOrNull(tokens.cached) ?? 0;
+                const candidates = numberOrNull(tokens.candidates) ?? 0;
+                const thoughts = numberOrNull(tokens.thoughts) ?? 0;
+                const toolTokens = numberOrNull(tokens.tool) ?? 0;
+                const modelOutput = candidates + thoughts + toolTokens;
+                if (freshInput === 0 && cachedInput === 0 && modelOutput === 0)
+                    continue;
+                sawTokens = true;
+                nonCachedInputTokens += freshInput;
+                cachedInputTokens += cachedInput;
+                outputTokens += modelOutput;
+                reasoningTokens += thoughts;
+                const price = (0, agent_token_prices_1.lookupPrice)('gemini', modelId.toLowerCase());
+                if (price) {
+                    costUsd +=
+                        (freshInput / 1_000_000) * price.inputPerMTok +
+                            (cachedInput / 1_000_000) * price.cacheReadPerMTok +
+                            (modelOutput / 1_000_000) * price.outputPerMTok;
+                }
+                else {
+                    hasCompletePricing = false;
+                }
+            }
+            if (!sawTokens)
+                return null;
+            return {
+                nonCachedInputTokens,
+                cachedInputTokens,
+                cacheCreationTokens: 0,
+                outputTokens,
+                reasoningTokens: reasoningTokens || undefined,
+                costUsd: hasCompletePricing ? costUsd : undefined,
+            };
+        }
+    }
     return null;
 }
 // Issue #347 — extract agent identity from the fraim_connect tool call.
@@ -212,13 +274,58 @@ function extractSignalFromArgs(args) {
     const discriminant = typeof args.runDiscriminant === 'string' ? args.runDiscriminant : undefined;
     const jobName = typeof args.jobName === 'string' ? args.jobName : undefined;
     const jobId = typeof args.jobId === 'string' ? args.jobId : undefined;
-    return { phaseId, phaseStatus, findingsText, discriminant, jobName, jobId };
+    const reviewHandoff = extractReviewHandoffFromArgs(args);
+    return { phaseId, phaseStatus, findingsText, discriminant, jobName, jobId, ...(reviewHandoff ? { reviewHandoff } : {}) };
+}
+function extractReviewHandoffFromArgs(args) {
+    const direct = readReviewHandoffCandidate(args.reviewHandoff);
+    if (direct)
+        return direct;
+    const evidence = args.evidence;
+    if (evidence && typeof evidence === 'object') {
+        return readReviewHandoffCandidate(evidence.reviewHandoff);
+    }
+    return null;
+}
+function readReviewHandoffCandidate(value) {
+    let candidate = value;
+    if (typeof candidate === 'string') {
+        try {
+            candidate = JSON.parse(candidate);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
+        return null;
+    const obj = candidate;
+    if (typeof obj.reviewRequired !== 'boolean')
+        return null;
+    const artifacts = Array.isArray(obj.artifacts)
+        ? obj.artifacts.filter((artifact) => artifact && typeof artifact === 'object')
+        : [];
+    return {
+        reviewRequired: obj.reviewRequired,
+        reviewTarget: obj.reviewTarget && typeof obj.reviewTarget === 'object'
+            ? obj.reviewTarget
+            : null,
+        artifacts,
+        ...(typeof obj.summary === 'string' ? { summary: obj.summary } : {}),
+        ...(typeof obj.feedbackMode === 'string' ? { feedbackMode: obj.feedbackMode } : {}),
+    };
 }
 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) {
@@ -247,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],
@@ -302,8 +415,40 @@ function transformHeadlessFraimMessage(message, kind) {
     if (parsed.remainder) {
         parts.push(`\n\nManager instructions: ${parsed.remainder}`);
     }
+    const storageGuard = machineLevelStorageGuard(parsed.jobId);
+    if (storageGuard) {
+        parts.push(`\n\n${storageGuard}`);
+    }
     return parts.join('');
 }
+function machineLevelStorageGuard(jobId) {
+    const normalized = jobId.toLowerCase();
+    const userFraim = path_1.default.join(os_1.default.homedir(), '.fraim');
+    if (normalized === 'manager-agreements') {
+        const managerContext = path_1.default.join(userFraim, 'personalized-employee', 'context', 'manager_context.md');
+        const managerRules = path_1.default.join(userFraim, 'personalized-employee', 'rules', 'manager_rules.md');
+        return [
+            'Storage scope guardrail:',
+            '- Manager agreements artifacts are machine-level, not repo-level.',
+            `- Required write targets: ${managerContext} and ${managerRules}.`,
+            '- Keep the split crisp: manager_context.md is what is true about the manager; manager_rules.md is how employees must behave because of those truths.',
+            '- Do not write, validate, call canonical, commit, or open a PR for repo-local fraim/personalized-employee/context/manager_context.md or fraim/personalized-employee/rules/manager_rules.md as substitutes.',
+            '- If the exact machine-level paths cannot be written, fail the phase and report the concrete filesystem error.',
+        ].join('\n');
+    }
+    if (normalized === 'organization-onboarding') {
+        const orgContext = path_1.default.join(userFraim, 'personalized-employee', 'context', 'org_context.md');
+        const orgRules = path_1.default.join(userFraim, 'personalized-employee', 'rules', 'org_rules.md');
+        return [
+            'Storage scope guardrail:',
+            '- Organization onboarding artifacts are machine-level, not repo-level.',
+            `- Required write targets: ${orgContext} and ${orgRules}.`,
+            '- Do not write, validate, call canonical, commit, or open a PR for repo-local fraim/personalized-employee/context/org_context.md or fraim/personalized-employee/rules/org_rules.md as substitutes.',
+            '- If the exact machine-level paths cannot be written, fail the phase and report the concrete filesystem error.',
+        ].join('\n');
+    }
+    return null;
+}
 // If ~/.gemini/settings.json has a wrong/test FRAIM_API_KEY, patch it with the
 // real key from ~/.fraim/config.json so the FRAIM MCP server can authenticate.
 // This self-heals when a test run accidentally writes a test key to global config.
@@ -329,49 +474,201 @@ function ensureGeminiApiKey() {
     }
     catch { /* best-effort: never crash the Hub over a config patch */ }
 }
-function buildStartPlan(hostId, message) {
+// Build (idempotently) a Hub-managed CODEX_HOME so `codex exec` drives the shared
+// browser. config.toml = user's real config + a playwright→cdp override; auth is
+// copied; the sessions dir is junctioned to the real one so resume + new sessions
+// keep working. The user's real ~/.codex is never modified. Returns the temp home
+// path, or null on any failure (caller then leaves Codex on its own browser).
+function prepareCodexBrowserHome(cdp, env = process.env) {
+    try {
+        const real = env['CODEX_HOME'] || path_1.default.join(os_1.default.homedir(), '.codex');
+        // Derive the temp-home path from the real home so different real homes (e.g.
+        // a test's fake home vs the user's ~/.codex) never share — and pollute — one
+        // temp home (a stale sessions junction breaks resume).
+        const homeKey = (0, crypto_1.createHash)('sha1').update(real).digest('hex').slice(0, 12);
+        const home = path_1.default.join(os_1.default.tmpdir(), 'fraim-codex-home-' + homeKey);
+        fs_1.default.mkdirSync(home, { recursive: true });
+        // config.toml = real config with the playwright server redirected to the CDP endpoint.
+        const realConfig = path_1.default.join(real, 'config.toml');
+        const existing = fs_1.default.existsSync(realConfig) ? fs_1.default.readFileSync(realConfig, 'utf8') : '';
+        const pwBlock = `[mcp_servers.playwright]\ncommand = "npx"\nargs = ["-y", "@playwright/mcp@latest", "--cdp-endpoint", "${cdp}"]\n`;
+        const merged = (0, mcp_config_generator_1.mergeTomlMCPServers)(existing, pwBlock, ['playwright']).content;
+        fs_1.default.writeFileSync(path_1.default.join(home, 'config.toml'), merged, 'utf8');
+        // Auth + the session index (so resume can find existing rollouts by thread id).
+        for (const f of ['auth.json', 'session_index.jsonl', 'history.jsonl']) {
+            const src = path_1.default.join(real, f);
+            if (fs_1.default.existsSync(src)) {
+                try {
+                    fs_1.default.copyFileSync(src, path_1.default.join(home, f));
+                }
+                catch { /* best effort */ }
+            }
+        }
+        // Sessions: junction temp/sessions -> real/sessions so resume (existing sessions)
+        // works and new sessions persist alongside the user's. Re-point if the existing
+        // junction targets the wrong dir.
+        const realSessions = path_1.default.join(real, 'sessions');
+        fs_1.default.mkdirSync(realSessions, { recursive: true });
+        const tmpSessions = path_1.default.join(home, 'sessions');
+        try {
+            let ok = false;
+            if (fs_1.default.existsSync(tmpSessions)) {
+                const st = fs_1.default.lstatSync(tmpSessions);
+                if (st.isSymbolicLink()) {
+                    ok = path_1.default.resolve(fs_1.default.readlinkSync(tmpSessions)) === path_1.default.resolve(realSessions);
+                    if (!ok)
+                        fs_1.default.unlinkSync(tmpSessions); // wrong target → drop the junction (not the target)
+                }
+            }
+            if (!ok && !fs_1.default.existsSync(tmpSessions))
+                fs_1.default.symlinkSync(realSessions, tmpSessions, 'junction');
+        }
+        catch { /* junction best-effort; new runs still work without resuming old sessions */ }
+        return home;
+    }
+    catch {
+        return null;
+    }
+}
+function sharedBrowserHostConfig(hostId, env = process.env) {
+    const cdp = env['FRAIM_BROWSER_CDP_ENDPOINT'];
+    if (!cdp)
+        return { args: [] };
+    const pwArgs = ['-y', '@playwright/mcp@latest', '--cdp-endpoint', cdp];
+    const mcpServers = { playwright: { command: 'npx', args: pwArgs } };
+    if (hostId === 'claude') {
+        // Claude Code's --mcp-config takes a FILE path (inline JSON is rejected by the
+        // CLI's schema). Write the ephemeral config to a temp file and pass its path —
+        // per-invocation; never touches the user's persisted ~/.claude.json.
+        const file = path_1.default.join(os_1.default.tmpdir(), 'fraim-shared-browser-mcp.json');
+        try {
+            fs_1.default.writeFileSync(file, JSON.stringify({ mcpServers }), 'utf8');
+        }
+        catch {
+            return { args: [] };
+        }
+        return { args: ['--mcp-config', file] };
+    }
     if (hostId === 'codex') {
+        // Codex `exec` ignores -c overrides of mcp_servers, so we point CODEX_HOME at a
+        // Hub-managed temp dir whose config.toml merges the user's real config with a
+        // playwright→cdp override. Auth is copied and the sessions dir is junctioned to
+        // ~/.codex/sessions, so resume (incl. existing sessions) still works and new
+        // sessions persist there. The user's real ~/.codex/config.toml is never touched.
+        const home = prepareCodexBrowserHome(cdp, env);
+        return home ? { args: [], env: { CODEX_HOME: home } } : { args: [] };
+    }
+    if (hostId === 'gemini') {
+        // Gemini CLI has no per-invocation MCP flag, but it loads a SYSTEM settings
+        // file from GEMINI_CLI_SYSTEM_SETTINGS_PATH which overrides the same-named
+        // server. Point it at an ephemeral temp file — per-invocation via env; the
+        // user's ~/.gemini/settings.json is untouched.
+        const file = path_1.default.join(os_1.default.tmpdir(), 'fraim-gemini-browser-settings.json');
+        try {
+            fs_1.default.writeFileSync(file, JSON.stringify({ mcpServers }), 'utf8');
+        }
+        catch {
+            return { args: [] };
+        }
+        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) {
+    if (hostId === 'codex') {
+        const browser = sharedBrowserHostConfig('codex');
         return {
             command: executableName('codex'),
-            args: ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox'],
+            args: ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', ...browser.args],
             stdin: transformHeadlessFraimMessage(message, 'start'),
+            env: browser.env,
         };
     }
     if (hostId === 'gemini') {
         ensureGeminiApiKey();
+        const prompt = transformHeadlessFraimMessage(message, 'start');
+        const browser = sharedBrowserHostConfig('gemini');
         return {
             command: executableName('gemini'),
-            args: ['--yolo', '--skip-trust'],
+            // Gemini CLI creates the durable session id itself. Hub captures
+            // that real id from Gemini's chat log after start; pre-seeded UUIDs
+            // are not reliably accepted by `gemini --resume`.
+            args: ['--yolo', '--skip-trust', '-p', ' ', ...browser.args],
+            stdin: prompt,
+            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'),
-        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'],
+        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions', ...browser.args],
         stdin: transformHeadlessFraimMessage(message, 'start'),
+        env: browser.env,
     };
 }
 function buildContinuePlan(hostId, sessionId, message) {
     if (hostId === 'codex') {
+        const browser = sharedBrowserHostConfig('codex');
         return {
             command: executableName('codex'),
-            args: ['exec', 'resume', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', sessionId],
+            args: ['exec', 'resume', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', sessionId, ...browser.args],
             stdin: transformHeadlessFraimMessage(message, 'continue'),
+            env: browser.env,
         };
     }
     if (hostId === 'gemini') {
-        // Gemini CLI does not have a native session-resume flag; each message
-        // is sent as a fresh invocation. The Hub still tracks state client-side.
+        ensureGeminiApiKey();
+        const prompt = transformHeadlessFraimMessage(message, 'continue');
+        const browser = sharedBrowserHostConfig('gemini');
         return {
             command: executableName('gemini'),
-            args: ['--yolo', '--skip-trust'],
+            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', ' ', ...browser.args],
+            stdin: prompt,
+            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'),
-        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions', '-r', sessionId],
+        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions', '-r', sessionId, ...browser.args],
         stdin: transformHeadlessFraimMessage(message, 'continue'),
+        env: browser.env,
     };
 }
 // Issue #442: all agents support a direct-path invocation (no FRAIM, no
@@ -401,7 +698,7 @@ const DIRECT_PREAMBLE = 'DO NOT USE FRAIM FOR THIS SESSION. No phases, no seekMe
 // Issue #442: builds a CLI plan for the Direct (B) side of an A/B run.
 // All agents supported: Codex and Gemini run raw (no FRAIM preamble);
 // Claude uses --strict-mcp-config + --append-system-prompt for full isolation.
-function buildDirectStartPlan(hostId, message) {
+function buildDirectStartPlan(hostId, message, sessionId) {
     if (hostId === 'codex') {
         return {
             command: executableName('codex'),
@@ -413,7 +710,15 @@ function buildDirectStartPlan(hostId, message) {
         ensureGeminiApiKey();
         return {
             command: executableName('gemini'),
-            args: ['--yolo', '--skip-trust'],
+            args: ['--yolo', '--skip-trust', '-p', ' '],
+            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,
         };
     }
@@ -443,7 +748,15 @@ function buildDirectContinuePlan(hostId, sessionId, message) {
         ensureGeminiApiKey();
         return {
             command: executableName('gemini'),
-            args: ['--yolo', '--skip-trust'],
+            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', ' '],
+            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,
         };
     }
@@ -502,10 +815,42 @@ function parseHostLine(hostId, line) {
     // message so it still surfaces in the Hub timeline.
     if (hostId === 'gemini') {
         try {
-            JSON.parse(trimmed); // validate JSON — if this throws, fall through to plain text
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.session_id === 'string' && parsed.session_id.trim().length > 0) {
+                return withSignal({ sessionId: parsed.session_id.trim(), raw: trimmed });
+            }
+            return withSignal({ raw: trimmed });
+        }
+        catch {
+            if (isGeminiCliNotice(trimmed)) {
+                return withSignal({ raw: trimmed });
+            }
+            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 });
         }
     }
@@ -531,6 +876,10 @@ function parseHostLine(hostId, line) {
         return withSignal({ raw: trimmed });
     }
 }
+function isGeminiCliNotice(line) {
+    return line === 'YOLO mode is enabled. All tool calls will be automatically approved.' ||
+        line === 'Ripgrep is not available. Falling back to GrepTool.';
+}
 function wireHostProcess(hostId, child, handlers) {
     const wire = (buffer, channel) => {
         let pending = '';
@@ -561,6 +910,7 @@ function wireHostProcess(hostId, child, handlers) {
 }
 function spawnHostProcess(hostId, plan, projectPath, handlers) {
     const invocation = resolveHostInvocation(plan);
+    const startedAtMs = Date.now();
     const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
         cwd: projectPath,
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -570,20 +920,114 @@ function spawnHostProcess(hostId, plan, projectPath, handlers) {
         child.stdin.write(plan.stdin);
     }
     child.stdin.end();
+    if (typeof plan.stdin === 'string' && !plan.args.includes('--resume')) {
+        child.once('close', () => {
+            const sessionId = discoverSessionIdAfterStart(hostId, projectPath, plan.stdin || '', startedAtMs);
+            if (sessionId) {
+                handlers.onEvent({ sessionId, raw: `${hostId}-session:${sessionId}` }, 'system');
+            }
+        });
+    }
     return wireHostProcess(hostId, child, handlers);
 }
+function discoverSessionIdAfterStart(hostId, projectPath, prompt, startedAtMs) {
+    if (hostId !== 'gemini')
+        return null;
+    return findGeminiSessionIdForPrompt(projectPath, prompt, startedAtMs);
+}
+function findGeminiSessionIdForPrompt(_projectPath, prompt, startedAtMs) {
+    const promptNeedle = normalizeGeminiPromptForMatch(prompt).slice(0, 160);
+    const records = readGeminiSessionRecords();
+    const recent = records
+        .filter((record) => record.updatedAtMs >= startedAtMs - 10_000)
+        .filter((record) => {
+        if (!promptNeedle)
+            return true;
+        const userText = normalizeGeminiPromptForMatch(record.userText);
+        return userText.includes(promptNeedle) || promptNeedle.includes(userText.slice(0, 80));
+    })
+        .sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+    if (recent[0])
+        return recent[0].sessionId;
+    const fallback = records
+        .filter((record) => record.updatedAtMs >= startedAtMs - 10_000)
+        .sort((a, b) => b.updatedAtMs - a.updatedAtMs)[0];
+    return fallback?.sessionId || null;
+}
+function readGeminiSessionRecords() {
+    const root = path_1.default.join(os_1.default.homedir(), '.gemini', 'tmp');
+    if (!fs_1.default.existsSync(root))
+        return [];
+    const records = [];
+    for (const filePath of collectGeminiSessionFiles(root)) {
+        try {
+            const stat = fs_1.default.statSync(filePath);
+            const lines = fs_1.default.readFileSync(filePath, 'utf8').split(/\r?\n/).filter(Boolean);
+            const metadata = JSON.parse(lines[0] || '{}');
+            const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+            if (!sessionId)
+                continue;
+            const userText = lines
+                .slice(1, 8)
+                .map((line) => {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.type !== 'user' || !Array.isArray(entry.content))
+                        return '';
+                    return entry.content.map((part) => typeof part.text === 'string' ? part.text : '').join('\n');
+                }
+                catch {
+                    return '';
+                }
+            })
+                .filter(Boolean)
+                .join('\n');
+            records.push({ sessionId, filePath, updatedAtMs: stat.mtimeMs, userText });
+        }
+        catch {
+            // Ignore malformed or concurrently-written session files.
+        }
+    }
+    return records;
+}
+function collectGeminiSessionFiles(root) {
+    const files = [];
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(fullPath);
+            }
+            else if (/^session-.*\.jsonl$/i.test(entry.name)) {
+                files.push(fullPath);
+            }
+        }
+    };
+    visit(root);
+    return files;
+}
+function normalizeGeminiPromptForMatch(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
 class CliHostRuntime {
     detectEmployees() {
         return detectEmployees();
     }
-    startRun(hostId, projectPath, message, handlers) {
-        return spawnHostProcess(hostId, buildStartPlan(hostId, message), projectPath, handlers);
+    startRun(hostId, projectPath, message, handlers, sessionId) {
+        return spawnHostProcess(hostId, buildStartPlan(hostId, message, sessionId), projectPath, handlers);
     }
     continueRun(hostId, projectPath, sessionId, message, handlers) {
         return spawnHostProcess(hostId, buildContinuePlan(hostId, sessionId, message), projectPath, handlers);
     }
-    startDirectRun(hostId, message, projectPath, handlers) {
-        return spawnHostProcess(hostId, buildDirectStartPlan(hostId, message), projectPath, handlers);
+    startDirectRun(hostId, message, projectPath, handlers, sessionId) {
+        return spawnHostProcess(hostId, buildDirectStartPlan(hostId, message, sessionId), projectPath, handlers);
     }
     continueDirectRun(hostId, sessionId, message, projectPath, handlers) {
         return spawnHostProcess(hostId, buildDirectContinuePlan(hostId, sessionId, message), projectPath, handlers);
@@ -596,18 +1040,21 @@ 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() {
         return this.employees;
     }
-    startRun(hostId, _projectPath, message, handlers) {
+    startRun(hostId, _projectPath, message, handlers, _sessionId) {
+        this.lastStartMessage = message;
         return this.fakeProcess(hostId, this.fakeEmployeeReply('start', message), handlers);
     }
     continueRun(hostId, _projectPath, sessionId, message, handlers) {
+        this.lastContinueMessage = message;
         return this.fakeProcess(hostId, this.fakeEmployeeReply('continue', message), handlers);
     }
-    startDirectRun(hostId, _message, _projectPath, handlers) {
+    startDirectRun(hostId, _message, _projectPath, handlers, _sessionId) {
         return this.fakeProcess(hostId, 'Understood. Working directly on that now.', handlers);
     }
     continueDirectRun(hostId, _sessionId, _message, _projectPath, handlers) {
@@ -676,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
@@ -688,8 +1136,8 @@ class ScriptedHostRuntime {
     detectEmployees() {
         return this.employees;
     }
-    startRun(_hostId, _projectPath, _message, handlers) {
-        const sessionId = (0, crypto_1.randomUUID)();
+    startRun(_hostId, _projectPath, _message, handlers, requestedSessionId) {
+        const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
         handlers.onEvent({ sessionId, raw: 'scripted-session-start' }, 'system');
         this.handlersBySession.set(sessionId, handlers);
         return this.spawnDouble();
@@ -699,8 +1147,8 @@ class ScriptedHostRuntime {
         handlers.onEvent({ sessionId, raw: 'scripted-session-resume' }, 'system');
         return this.spawnDouble();
     }
-    startDirectRun(_hostId, _message, _projectPath, handlers) {
-        const sessionId = (0, crypto_1.randomUUID)();
+    startDirectRun(_hostId, _message, _projectPath, handlers, requestedSessionId) {
+        const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
         handlers.onEvent({ sessionId, raw: 'scripted-direct-session-start' }, 'system');
         return this.spawnDouble();
     }