@agent-link/agent 0.1.337 → 0.1.339

package/dist/copilot-command-bridge.js

@@ -0,0 +1,1800 @@
+import { execFile, spawn } from 'child_process';
+import { COPILOT_COMPACTION_POLICY } from './copilot-compaction-policy.js';
+import { createHash, randomUUID } from 'crypto';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'path';
+import { homedir, platform } from 'os';
+import { Readable, Writable } from 'stream';
+import * as acp from '@agentclientprotocol/sdk';
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from 'vscode-jsonrpc/node.js';
+import { getProvider, resolveProviderCommand } from './providers.js';
+import { getCleanEnv, resolveExecutablePath } from './sdk.js';
+import { CopilotTurnJournal } from './copilot-turn-journal.js';
+import { CopilotCompactionLifecycle } from './copilot-compaction-lifecycle.js';
+import { copilotChildScope, isCopilotChildEvent } from './copilot-event-scope.js';
+import { applyModelCatalog, configurationIssue, confirmConfiguration, createCopilotConfiguration, finishConfiguration, observeConfigurationEvent, readConfigurationEvents, resetCopilotConfigurationObservation } from './copilot-configuration.js';
+import { beginCopilotPlanState, copilotPlanControlPrompt, readCopilotPlanState, sealCopilotPlanState, stripCopilotPlanControl } from './copilot-plan-state.js';
+import { assertCopilotCapabilities, hasCopilotOfflineModel, mergeCopilotCapabilities } from './copilot-capabilities.js';
+const SDK_START_TIMEOUT_MS = 30_000;
+const AGENCY_ACP_START_TIMEOUT_MS = 5 * 60_000;
+const SDK_REQUEST_TIMEOUT_MS = 30_000;
+const DIRECT_COPILOT_COMPACTION_TIMEOUT_MS = 10 * 60_000;
+const COPILOT_COMPACTION_RETRIES = 3;
+const SDK_STOP_TIMEOUT_MS = 5_000;
+const SESSION_LOCK_TIMEOUT_MS = 30_000;
+const ACP_SESSION_OPEN_TIMEOUT_MS = 10 * 60_000;
+const DIRECT_COPILOT_BACKGROUND_COMPACTION_THRESHOLD = COPILOT_COMPACTION_POLICY.background;
+const DIRECT_COPILOT_BUFFER_EXHAUSTION_THRESHOLD = COPILOT_COMPACTION_POLICY.bufferExhaustion;
+const COPILOT_BACKGROUND_COMPACTION_THRESHOLD = String(COPILOT_COMPACTION_POLICY.background);
+const SUPPORTED_COMMANDS = ['compact', 'plan', 'goal'];
+function compactionHasNothingToCompact(failure) {
+    const error = failure?.data?.error;
+    const message = typeof error === 'string' ? error : error?.message;
+    return typeof message === 'string' && /^\s*Nothing to compact\.?\s*$/i.test(message);
+}
+const sessionLocks = new Map();
+const AGENCY_PLAN_INTERACTION_MARKER = 'AgentLink Plan interaction requirement:';
+const LEGACY_NATIVE_AGENCY_PLAN_INTERACTION_GUIDANCE = [
+    AGENCY_PLAN_INTERACTION_MARKER,
+    'Before writing or finalizing plan.md, if any user decision is needed, use ACP form elicitation so AgentLink receives a user_input_requested interaction.',
+    'Ask one decision at a time, wait for the user answer, and continue this same Plan session only after the answer is returned.',
+    'Do not put unresolved questions in plan.md, do not assume answers, and do not start implementation.',
+    'Write the final plan.md only after all required decisions have been resolved.',
+].join(' ');
+const ASK_USER_ONLY_AGENCY_PLAN_INTERACTION_GUIDANCE = [
+    AGENCY_PLAN_INTERACTION_MARKER,
+    'Before writing or finalizing plan.md, if any user decision is needed, call the built-in ask_user tool; it is transported as ACP form elicitation so AgentLink receives a user_input_requested interaction.',
+    'Ask exactly one decision at a time, wait for the user answer, and continue this same Plan session only after the answer is returned.',
+    'Do not print unresolved questions in the response or put them in plan.md, do not assume answers, and do not start implementation.',
+    'Write the final plan.md only after all required decisions have been resolved.',
+].join(' ');
+const AGENCY_PLAN_ARTIFACT_INTERACTION_GUIDANCE = [
+    AGENCY_PLAN_INTERACTION_MARKER,
+    'If the plan needs user decisions, record every unresolved question in plan.md under a dedicated confirmation section.',
+    'Use the exact heading "## Decisions needed" for that section.',
+    'Write each question as a numbered item and put any selectable choices in indented bullet items below that question.',
+    'Do not assume answers or start implementation. AgentLink will collect the answers and return them in this Plan session.',
+    'Answering one batch does not finish the Plan: reassess the requirements and add any newly required decisions in the next revision.',
+].join(' ');
+const LEGACY_LONG_ARTIFACT_AGENCY_PLAN_INTERACTION_GUIDANCE = [
+    AGENCY_PLAN_INTERACTION_MARKER,
+    'If the plan needs user decisions, record every unresolved question in plan.md under a dedicated confirmation section.',
+    'Write each question as a numbered item and put any selectable choices in indented bullet items below that question.',
+    'Do not assume answers or start implementation. AgentLink will collect the answers and return them in this Plan session.',
+].join(' ');
+const LEGACY_SHORT_ARTIFACT_AGENCY_PLAN_INTERACTION_GUIDANCE = [
+    AGENCY_PLAN_INTERACTION_MARKER,
+    'If the plan needs user decisions, record the unresolved questions in plan.md under a dedicated confirmation section.',
+    'Do not assume answers or start implementation. AgentLink will collect the answers and return them in this Plan session.',
+].join(' ');
+export function stripAgencyPlanInteractionGuidance(text) {
+    const trimmed = stripCopilotPlanControl(text).trimEnd();
+    const knownGuidance = [
+        LEGACY_NATIVE_AGENCY_PLAN_INTERACTION_GUIDANCE,
+        ASK_USER_ONLY_AGENCY_PLAN_INTERACTION_GUIDANCE,
+        AGENCY_PLAN_ARTIFACT_INTERACTION_GUIDANCE,
+        LEGACY_LONG_ARTIFACT_AGENCY_PLAN_INTERACTION_GUIDANCE,
+        LEGACY_SHORT_ARTIFACT_AGENCY_PLAN_INTERACTION_GUIDANCE,
+    ];
+    for (const guidance of knownGuidance) {
+        if (trimmed.endsWith(guidance)) {
+            return trimmed.slice(0, -guidance.length).trimEnd();
+        }
+    }
+    const markerIndex = trimmed.lastIndexOf(AGENCY_PLAN_INTERACTION_MARKER);
+    if (markerIndex >= 0) {
+        const possibleTruncatedGuidance = trimmed
+            .slice(markerIndex)
+            .replace(/(?:\.{3}|…)\s*$/, '')
+            .trimEnd();
+        if (knownGuidance.some(guidance => guidance.startsWith(possibleTruncatedGuidance))) {
+            return trimmed.slice(0, markerIndex).trimEnd();
+        }
+    }
+    return stripCopilotPlanControl(text);
+}
+export function copilotBootstrapCommands() {
+    return [
+        {
+            id: 'command:compact',
+            name: 'compact',
+            invocation: '/compact',
+            description: 'Summarize conversation history to reduce context window usage. Optionally provide focus instructions.',
+            kind: 'command',
+        },
+        {
+            id: 'command:plan',
+            name: 'plan',
+            invocation: '/plan',
+            description: 'Enter plan mode.',
+            kind: 'command',
+        },
+        {
+            id: 'command:goal',
+            name: 'goal',
+            invocation: '/goal',
+            description: 'Toggle autopilot mode, or set an autopilot objective with an optional AI-credit limit (--max-ai-credits)',
+            kind: 'command',
+        },
+    ];
+}
+function withTimeout(promise, timeoutMs, label) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const timer = setTimeout(() => rejectPromise(new Error(`${label} timed out`)), timeoutMs);
+        promise.then(value => {
+            clearTimeout(timer);
+            resolvePromise(value);
+        }, error => {
+            clearTimeout(timer);
+            rejectPromise(error);
+        });
+    });
+}
+function resolveDirectExecution(command) {
+    if (platform() !== 'win32' || !command.toLowerCase().endsWith('.cmd'))
+        return null;
+    const baseDir = dirname(command);
+    const loader = join(baseDir, 'node_modules', '@github', 'copilot', 'npm-loader.js');
+    if (existsSync(loader))
+        return { command: process.execPath, prefixArgs: [loader] };
+    try {
+        const match = readFileSync(command, 'utf8').match(/"%~dp0\\([^"\r\n]+\.js)"/);
+        if (match) {
+            const script = join(baseDir, match[1]);
+            if (existsSync(script))
+                return { command: process.execPath, prefixArgs: [script] };
+        }
+    }
+    catch {
+        // Fall through to cmd.exe below.
+    }
+    return null;
+}
+export function copilotMetadataScopeKey(scope) {
+    const spec = resolveCopilotCommandSpawn(scope.providerId, scope.workDir, {}, 'sdk');
+    const stamp = [spec.command, ...spec.args, resolveExecutablePath('copilot')].filter(Boolean).map(candidate => {
+        try {
+            const stat = statSync(candidate);
+            return `${candidate}:${stat.size}:${stat.mtimeMs}`;
+        }
+        catch {
+            return '';
+        }
+    });
+    return createHash('sha256').update(JSON.stringify([scope.providerId, spec.command, spec.args,
+        spec.options?.cwd, spec.options?.env, stamp])).digest('hex');
+}
+function validateCopilotSpawn(spec, providerId) {
+    const cwd = spec.options?.cwd;
+    if (typeof cwd !== 'string' || !cwd.trim())
+        throw new Error(`${providerId}: a working directory is required.`);
+    try {
+        if (!statSync(cwd).isDirectory())
+            throw new Error('Not a directory');
+    }
+    catch (error) {
+        const code = error.code || error.message;
+        throw new Error(`${providerId}: working directory is unavailable: ${cwd} (${code}). Please select an existing directory.`);
+    }
+    // Bare commands are resolved through PATH by spawn; do not guess another CLI
+    // or silently fall back to another working directory.
+    if (isAbsolute(spec.command) || /[\\/]/.test(spec.command)) {
+        const executable = isAbsolute(spec.command) ? spec.command : resolve(cwd, spec.command);
+        try {
+            if (!statSync(executable).isFile())
+                throw new Error('Not a file');
+        }
+        catch (error) {
+            const code = error.code || error.message;
+            throw new Error(`${providerId}: executable is unavailable: ${executable} (${code}). Check the backend installation/path.`);
+        }
+    }
+}
+function copilotSpawnError(spec, providerId, error) {
+    const cause = error;
+    return new Error(`${providerId}: runtime process failed${cause.code ? ` (${cause.code})` : ''}. `
+        + `Executable: ${spec.command}; working directory: ${String(spec.options?.cwd)}. ${cause.message || String(error)}`);
+}
+export function resolveCopilotCommandSpawn(providerId, workDir, sessionOptions = {}, transport = 'sdk') {
+    const provider = getProvider(providerId);
+    const isDefaultCopilot = providerId === 'copilot'
+        && provider.command === 'copilot'
+        && !provider.args?.length
+        && !provider.shell;
+    const resolved = isDefaultCopilot
+        ? { command: resolveExecutablePath('copilot') || 'copilot', prefixArgs: [], spawnOpts: {} }
+        : resolveProviderCommand(provider);
+    const runtimeArgs = [
+        ...resolved.prefixArgs,
+        ...(providerId === 'agency-copilot' && sessionOptions.contextTier
+            ? ['--context', sessionOptions.contextTier] : []),
+        ...(providerId === 'agency-copilot' && transport === 'acp'
+            ? ['--acp'] : [providerId === 'agency-copilot' ? '--server' : '--headless', '--no-auto-update', '--stdio']),
+    ];
+    const direct = resolveDirectExecution(resolved.command);
+    const runtimeEnv = {
+        ...getCleanEnv(),
+        ...(provider.env || {}),
+        ...((providerId === 'copilot' || providerId === 'agency-copilot')
+            ? { COPILOT_BACKGROUND_COMPACTION_THRESHOLD }
+            : {}),
+    };
+    if (direct) {
+        return {
+            command: direct.command,
+            args: [...direct.prefixArgs, ...runtimeArgs],
+            options: {
+                cwd: provider.cwd || workDir,
+                env: runtimeEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            },
+        };
+    }
+    if (platform() === 'win32' && resolved.command.toLowerCase().endsWith('.cmd')) {
+        return {
+            command: process.env.COMSPEC || 'cmd.exe',
+            args: ['/d', '/s', '/c', resolved.command, ...runtimeArgs],
+            options: {
+                cwd: provider.cwd || workDir,
+                env: runtimeEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            },
+        };
+    }
+    return {
+        command: resolved.command,
+        args: runtimeArgs,
+        options: {
+            cwd: provider.cwd || workDir,
+            env: runtimeEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            ...resolved.spawnOpts,
+        },
+    };
+}
+export class CopilotCommandRuntime {
+    options;
+    cancelledCompactions = new Set();
+    compactionAttempts = new Map();
+    liveCompactions = new Map();
+    compactionLifecycle = new CopilotCompactionLifecycle();
+    goalSessions = new Set();
+    planRevisions = new Map();
+    preparePlanReview(sessionId) {
+        const revision = beginCopilotPlanState(this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId);
+        this.planRevisions.set(sessionId, revision);
+        return revision;
+    }
+    planControlPrompt(sessionId, revision, deferred = []) {
+        return copilotPlanControlPrompt(this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId, revision, deferred, !this.usesAgencyAcp() && !!this.options.onUserInputRequest);
+    }
+    readPlanReadiness(sessionId, revision) {
+        return readCopilotPlanState(this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId, revision);
+    }
+    sealPlanReadiness(sessionId, revision, content) {
+        sealCopilotPlanState(this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId, revision, content);
+    }
+    child = null;
+    connection = null;
+    acpConnection = null;
+    acpSessions = new Map();
+    acpCommandWaiters = new Map();
+    acpToolNames = new Map();
+    promptWaiters = new Map();
+    stderr = '';
+    releaseSessionLock = null;
+    cancelSessionLockWait = null;
+    stopPromise = null;
+    startPromise = null;
+    rejectStartup = null;
+    configuration = null;
+    configurationSince = 0;
+    configurationSessionId = '';
+    capabilityCheckedAt = 0;
+    capabilityDirty = false;
+    metadataScopeKey = '';
+    async configurationNeedsRefresh() {
+        if (!this.configuration || !this.options.verifyConfiguration)
+            return false;
+        if (this.options.strictCapabilities && !hasCopilotOfflineModel(this.options.providerId, this.configuration.requested.model))
+            return false;
+        if (this.capabilityDirty)
+            return true;
+        if (this.usesAgencyAcp() || Date.now() - this.capabilityCheckedAt < 300_000)
+            return false;
+        this.capabilityCheckedAt = Date.now();
+        try {
+            const candidate = createCopilotConfiguration(this.options.providerId, this.transport, this.configuration.requested);
+            applyModelCatalog(candidate, await this.request('models.list'), this.configuration);
+            this.capabilityDirty = !!candidate.capabilityFingerprint && candidate.capabilityFingerprint !== this.configuration.capabilityFingerprint;
+            return this.capabilityDirty;
+        }
+        catch (error) {
+            if (/model .* unavailable/i.test(String(error)))
+                throw error;
+            return false; // Existing confirmed configuration remains usable.
+        }
+    }
+    getConfiguration() {
+        return this.configuration ? structuredClone(this.configuration) : null;
+    }
+    beginConfiguration(sessionId, options) {
+        if (!this.options.verifyConfiguration)
+            return;
+        this.configurationSessionId = sessionId;
+        this.configurationSince = Date.now();
+        this.configuration = createCopilotConfiguration(this.options.providerId, this.transport, {
+            model: options.model, context: options.contextTier || 'default', effort: options.reasoningEffort,
+        });
+        this.configuration.sessionId = sessionId;
+        const previous = this.options.previousConfiguration;
+        if (previous?.effective.model === options.model)
+            this.configuration.observedDefaultWindow = previous?.observedDefaultWindow;
+        if (previous?.sessionId === sessionId && previous.providerId === this.options.providerId
+            && previous.windowEvidenceVersion === 1
+            && previous.effective.model === options.model
+            && previous.effective.context === (options.contextTier || 'default')
+            && ['provider_config', 'provider_event'].includes(previous.sources.contextWindow || '')) {
+            // Effort changes reasoning, not the selected model/context tier's input
+            // limit. Keep this observed window until fresh Provider evidence replaces it.
+            confirmConfiguration(this.configuration, 'contextWindow', previous.effective.contextWindow, previous.sources.contextWindow, previous.evidenceTimes?.contextWindow);
+        }
+    }
+    publishConfiguration() {
+        if (!this.configuration)
+            return;
+        this.configuration.runtime = { pid: this.child?.pid, phase: 'runtime' };
+        finishConfiguration(this.configuration);
+        this.options.onConfiguration?.(this.configurationSessionId, structuredClone(this.configuration));
+    }
+    observeConfiguration(sessionId, event) {
+        if (!this.configuration || sessionId !== this.configurationSessionId)
+            return;
+        const timestamp = typeof event.timestamp === 'string' ? Date.parse(event.timestamp) : NaN;
+        if (Number.isFinite(timestamp) && timestamp < this.configurationSince)
+            return;
+        const before = JSON.stringify(this.configuration.effective);
+        observeConfigurationEvent(this.configuration, event);
+        if (JSON.stringify(this.configuration.effective) !== before)
+            this.publishConfiguration();
+    }
+    async refreshConfiguration(sessionId) {
+        if (!this.configuration || sessionId !== this.configurationSessionId)
+            return;
+        if (!this.usesAgencyAcp()) {
+            try {
+                const current = await this.request('session.model.getCurrent', { sessionId }, 5000);
+                confirmConfiguration(this.configuration, 'model', current.modelId ?? current.model, 'provider_config');
+                confirmConfiguration(this.configuration, 'effort', current.reasoningEffort, 'provider_config');
+                confirmConfiguration(this.configuration, 'context', current.contextTier, 'provider_config');
+                confirmConfiguration(this.configuration, 'contextWindow', current.contextWindow, 'provider_config');
+            }
+            catch { /* Older Providers leave unreported fields explicitly unverified. */ }
+        }
+        readConfigurationEvents(this.configuration, this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId, this.configurationSince);
+        this.publishConfiguration();
+        if (this.configuration.status === 'failed')
+            throw new Error(this.configuration.issues.at(-1)?.message || 'Provider configuration failed');
+    }
+    /** Query an already-open Session only; never start a Runtime or send a prompt. */
+    async readContextSnapshot(sessionId) {
+        if (this.usesAgencyAcp())
+            return null;
+        const configuration = this.configuration;
+        const expectedModel = configuration?.effective.model;
+        const confirmedWindow = configuration?.effective.contextWindow;
+        if (!expectedModel || !confirmedWindow
+            || !['provider_config', 'provider_event'].includes(configuration?.sources.contextWindow || ''))
+            return null;
+        let response;
+        try {
+            // CLI 1.0.85 attribution reports the 128K default even for an observed
+            // 272K model. Never promote that diagnostic default (or a catalog/UI
+            // guess) to window evidence. Count against the already observed limit.
+            response = await this.request('session.metadata.contextInfo', {
+                sessionId, selectedModel: expectedModel, promptTokenLimit: confirmedWindow, outputTokenLimit: 0,
+            }, 5000);
+        }
+        catch (error) {
+            if (error?.code === -32601)
+                return null; // Older CLI.
+            throw error;
+        }
+        if (this.stopping || configuration !== this.configuration || configuration?.effective.model !== expectedModel
+            || configuration?.effective.contextWindow !== confirmedWindow)
+            throw new Error('Copilot context query was cancelled');
+        const value = response?.contextInfo;
+        if (!value)
+            return null; // A brand-new Session has no initialized context yet.
+        if (typeof value.modelName !== 'string' || value.modelName.toLowerCase() !== expectedModel.toLowerCase()) {
+            throw new Error('Copilot returned context usage for a different model');
+        }
+        const validTokens = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+        if (!validTokens(value.totalTokens) || value.promptTokenLimit !== confirmedWindow) {
+            throw new Error('Copilot returned invalid context usage');
+        }
+        const snapshot = {
+            model: expectedModel,
+            contextTokens: value.totalTokens,
+            contextWindow: value.promptTokenLimit,
+            // Both SDK paths expose tools. Cold CLI 1.0.85 reports zero tool
+            // definitions until they are restored; a valid total alone is not proof
+            // of full context. MCP/custom-instruction counts are subsets, not extras.
+            contextComplete: validTokens(value.systemTokens) && value.systemTokens > 0
+                && validTokens(value.conversationTokens)
+                && validTokens(value.toolDefinitionsTokens) && value.toolDefinitionsTokens > 0
+                && value.systemTokens + value.conversationTokens + value.toolDefinitionsTokens === value.totalTokens,
+            ...(validTokens(value.compactionThreshold) ? { backgroundThreshold: value.compactionThreshold } : {}),
+            ...(validTokens(value.limit) && validTokens(value.bufferTokens) && value.limit >= value.bufferTokens
+                ? { blockingThreshold: value.limit - value.bufferTokens } : {}),
+        };
+        // The supplied limit is not new window evidence; do not publish it as such.
+        return snapshot;
+    }
+    stopping = false;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.startPromise)
+            return this.startPromise;
+        const starting = this.startRuntime().finally(() => {
+            if (this.startPromise === starting)
+                this.startPromise = null;
+        });
+        this.startPromise = starting;
+        return starting;
+    }
+    async startRuntime() {
+        if (this.stopPromise)
+            await this.stopPromise;
+        if (this.connection || this.acpConnection)
+            return;
+        const spec = resolveCopilotCommandSpawn(this.options.providerId, this.options.workDir, this.options.sessionOptions, this.transport);
+        validateCopilotSpawn(spec, this.options.providerId);
+        if (this.options.verifyConfiguration) {
+            this.beginConfiguration(this.options.initialSessionId || 'pending', this.options.sessionOptions || {});
+            this.options.onConfiguration?.(this.configurationSessionId, structuredClone(this.configuration));
+        }
+        this.stopping = false;
+        this.stderr = '';
+        this.metadataScopeKey = copilotMetadataScopeKey(this.options);
+        let child;
+        try {
+            child = spawn(spec.command, spec.args, spec.options);
+        }
+        catch (error) {
+            throw copilotSpawnError(spec, this.options.providerId, error);
+        }
+        this.child = child;
+        let starting = true;
+        let failureHandled = false;
+        let rejectStartup;
+        const startupFailure = new Promise((_, reject) => { rejectStartup = reject; });
+        // A child may fail before a protocol handshake or even stdio setup exists.
+        void startupFailure.catch(() => { });
+        this.rejectStartup = rejectStartup;
+        const fail = (error, exited = false) => {
+            if (this.child !== child || failureHandled)
+                return;
+            failureHandled = true;
+            rejectStartup(error);
+            if (exited)
+                this.child = null;
+            this.connection?.dispose();
+            this.connection = null;
+            this.acpConnection?.close();
+            this.acpConnection = null;
+            this.acpSessions.clear();
+            this.acpCommandWaiters.clear();
+            this.acpToolNames.clear();
+            this.goalSessions.clear();
+            for (const [id, attempt] of this.compactionAttempts) {
+                attempt.cancelled = true;
+                this.cancelledCompactions.add(id);
+            }
+            this.compactionAttempts.clear();
+            this.failPromptWaiters(error);
+            this.cancelSessionLockWait?.(error);
+            if (exited)
+                this.releaseSessionLock?.();
+            // During startup the rejecting start() owns reporting/cleanup. Calling
+            // onRuntimeExit here would make its caller mistake failure for cancellation.
+            const notifyExit = !starting && !this.stopping;
+            if (!starting && !exited) {
+                // Retain caller ownership until disposal finishes. A concurrent retry
+                // then sees this Runtime and joins stop(), rather than racing its lock.
+                const notify = () => { if (notifyExit)
+                    this.options.onRuntimeExit?.(error); };
+                void this.stop().then(notify, notify);
+            }
+            else if (notifyExit)
+                this.options.onRuntimeExit?.(error);
+        };
+        // Keep the listener for the child's entire lifetime, including after stop:
+        // a late error on an old child must not crash Agent or poison its successor.
+        child.on('error', error => fail(copilotSpawnError(spec, this.options.providerId, error)));
+        child.stderr?.on('data', chunk => {
+            if (this.stderr.length < 16_384)
+                this.stderr += String(chunk);
+        });
+        child.once('exit', code => {
+            fail(copilotSpawnError(spec, this.options.providerId, new Error(`Process exited${code == null ? '' : ` with code ${code}`}`)), true);
+        });
+        let resolveSpawn;
+        const spawned = new Promise(resolve => { resolveSpawn = resolve; child.once('spawn', resolveSpawn); });
+        try {
+            // Never write connect/initialize to a failed spawn's pipes (in addition
+            // to ENOENT, that can trigger vscode-jsonrpc's unhandled write rejection).
+            await withTimeout(Promise.race([spawned, startupFailure]), SDK_START_TIMEOUT_MS, 'Copilot process startup');
+            if (this.stopping || this.child !== child)
+                throw new Error('Copilot runtime startup cancelled');
+            if (this.configuration) {
+                this.configuration.runtime = { pid: child.pid, phase: 'runtime' };
+                this.options.onConfiguration?.(this.configurationSessionId, structuredClone(this.configuration));
+            }
+            await this.initializeConnection(child, startupFailure, error => {
+                if (!this.stopping)
+                    fail(error);
+            });
+            if (this.stopping || this.child !== child)
+                throw new Error('Copilot runtime startup cancelled');
+        }
+        catch (error) {
+            const detail = this.stderr.trim().split(/\r?\n/).slice(-4).join('\n');
+            await this.stop();
+            throw new Error(`${error.message}${detail ? `\n${detail}` : ''}`);
+        }
+        finally {
+            starting = false;
+            child.removeListener('spawn', resolveSpawn);
+            if (this.rejectStartup === rejectStartup)
+                this.rejectStartup = null;
+        }
+    }
+    async initializeConnection(child, startupFailure, onFailure) {
+        if (!child.stdout || !child.stdin) {
+            throw new Error('Copilot SDK runtime did not expose stdio pipes');
+        }
+        if (this.usesAgencyAcp()) {
+            const client = acp.client({ name: 'agentlink' })
+                .onNotification(acp.methods.client.session.update, ({ params }) => {
+                this.handleAcpSessionUpdate(params);
+            })
+                .onRequest(acp.methods.client.session.requestPermission, ({ params }) => {
+                const selected = params.options.find(option => option.kind === 'allow_always')
+                    || params.options.find(option => option.kind === 'allow_once');
+                return selected
+                    ? { outcome: { outcome: 'selected', optionId: selected.optionId } }
+                    : { outcome: { outcome: 'cancelled' } };
+            })
+                .onRequest(acp.methods.client.elicitation.create, ({ params }) => {
+                if (!this.options.onAcpElicitationRequest) {
+                    return { action: 'cancel' };
+                }
+                const requestId = `acp-elicitation:${randomUUID()}`;
+                const sessionId = 'sessionId' in params && typeof params.sessionId === 'string'
+                    ? params.sessionId
+                    : '';
+                if (sessionId)
+                    this.pausePromptWaiter(sessionId, requestId);
+                return this.options.onAcpElicitationRequest(params).finally(() => {
+                    if (sessionId)
+                        this.resumePromptWaiter(sessionId, requestId);
+                });
+            });
+            const stream = acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+            const connection = client.connect(stream);
+            this.acpConnection = connection;
+            void connection.closed.then(() => onFailure(new Error('Agency Copilot ACP connection closed')), error => onFailure(error instanceof Error ? error : new Error(String(error))));
+            await withTimeout(Promise.race([
+                connection.agent.request(acp.methods.agent.initialize, {
+                    protocolVersion: acp.PROTOCOL_VERSION,
+                    clientCapabilities: {
+                        session: { compaction: {}, configOptions: {} },
+                        ...(this.options.onAcpElicitationRequest
+                            ? { elicitation: { form: {} } }
+                            : {}),
+                    },
+                    clientInfo: { name: 'agentlink', version: '1' },
+                }), startupFailure,
+            ]), AGENCY_ACP_START_TIMEOUT_MS, 'Agency Copilot ACP startup');
+            return;
+        }
+        const connection = createMessageConnection(new StreamMessageReader(child.stdout), new StreamMessageWriter(child.stdin));
+        this.connection = connection;
+        connection.onClose(() => onFailure(new Error('Copilot SDK connection closed')));
+        connection.onError(([error]) => onFailure(error));
+        connection.onNotification('session.event', notification => {
+            if (!notification || typeof notification !== 'object')
+                return;
+            const value = notification;
+            if (typeof value.sessionId === 'string'
+                && value.event
+                && typeof value.event === 'object') {
+                this.handleDirectSessionEvent(value.sessionId, value.event);
+            }
+        });
+        connection.onRequest('userInput.request', async (params) => {
+            if (!this.options.onUserInputRequest || !isRecord(params)) {
+                throw new Error('Copilot user input handler is unavailable');
+            }
+            const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+            const question = typeof params.question === 'string' ? params.question : '';
+            if (!sessionId || !question)
+                throw new Error('Invalid Copilot user input request');
+            const requestId = typeof params.requestId === 'string'
+                ? params.requestId
+                : `legacy:${question}`;
+            this.pausePromptWaiter(sessionId, requestId);
+            try {
+                return await this.options.onUserInputRequest(sessionId, {
+                    question,
+                    choices: Array.isArray(params.choices)
+                        ? params.choices.filter((value) => typeof value === 'string')
+                        : undefined,
+                    allowFreeform: typeof params.allowFreeform === 'boolean'
+                        ? params.allowFreeform
+                        : undefined,
+                });
+            }
+            finally {
+                this.resumePromptWaiter(sessionId, requestId);
+            }
+        });
+        connection.onRequest('exitPlanMode.request', async (params) => {
+            if (!this.options.onExitPlanModeRequest || !isRecord(params)) {
+                throw new Error('Copilot Plan decision handler is unavailable');
+            }
+            const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+            const summary = typeof params.summary === 'string' ? params.summary : '';
+            const actions = Array.isArray(params.actions)
+                ? params.actions.filter((value) => typeof value === 'string')
+                : [];
+            const recommendedAction = typeof params.recommendedAction === 'string'
+                ? params.recommendedAction
+                : actions[0] || '';
+            if (!sessionId || !summary)
+                throw new Error('Invalid Copilot Plan decision request');
+            return this.options.onExitPlanModeRequest(sessionId, {
+                summary,
+                planContent: typeof params.planContent === 'string' ? params.planContent : undefined,
+                actions,
+                recommendedAction,
+            });
+        });
+        connection.listen();
+        await withTimeout(Promise.race([connection.sendRequest('connect', {}), startupFailure]), this.options.providerId === 'agency-copilot' ? AGENCY_ACP_START_TIMEOUT_MS : SDK_START_TIMEOUT_MS, 'Copilot SDK startup');
+    }
+    async request(method, params = {}, timeoutMs = SDK_REQUEST_TIMEOUT_MS) {
+        if (!this.connection)
+            throw new Error('Copilot SDK runtime is not started');
+        if (timeoutMs == null)
+            return this.connection.sendRequest(method, params);
+        return withTimeout(this.connection.sendRequest(method, params), timeoutMs, method);
+    }
+    async openSession(sessionId, options = {}) {
+        if (this.usesAgencyAcp()) {
+            return this.openAcpSession(sessionId, options);
+        }
+        const activeSessionId = sessionId || randomUUID();
+        await this.acquireSessionLock(activeSessionId);
+        this.beginConfiguration(activeSessionId, options);
+        const method = sessionId ? 'session.resume' : 'session.create';
+        let response;
+        try {
+            let effort = options.reasoningEffort;
+            if (this.configuration) {
+                let catalog;
+                try {
+                    catalog = await this.request('models.list');
+                }
+                catch {
+                    configurationIssue(this.configuration, 'effort', 'unconfirmed', 'Provider model capability catalog is unavailable.');
+                }
+                if (this.options.strictCapabilities) {
+                    const status = await this.request('status.get').catch(() => undefined);
+                    assertCopilotCapabilities(mergeCopilotCapabilities(this.options.providerId, catalog, status?.version), {
+                        model: options.model, context: options.contextTier, effort: options.reasoningEffort,
+                    });
+                }
+                const catalogModels = catalog?.models;
+                if (!this.options.strictCapabilities || (hasCopilotOfflineModel(this.options.providerId, options.model)
+                    && (!Array.isArray(catalogModels) || catalogModels.some(m => m.id === options.model)))) {
+                    effort = applyModelCatalog(this.configuration, catalog, this.options.previousConfiguration).effort;
+                }
+                this.capabilityCheckedAt = Date.now();
+            }
+            const params = {
+                sessionId: activeSessionId,
+                clientName: 'agentlink',
+                workingDirectory: this.options.workDir,
+                model: options.model,
+                contextTier: options.contextTier,
+                reasoningEffort: effort,
+                streaming: true,
+                includeSubAgentStreamingEvents: true,
+                requestUserInput: !!this.options.onUserInputRequest,
+                requestExitPlanMode: !!this.options.onExitPlanModeRequest,
+                toolFilterPrecedence: 'excluded',
+                envValueMode: 'direct',
+                // AgentLink handles the pre-request tier between turns; native tiers
+                // use the shared local policy. CLI acceptance alone is not
+                // proof it honors this policy; the publication barrier is separate.
+                infiniteSessions: {
+                    enabled: true,
+                    backgroundCompactionThreshold: DIRECT_COPILOT_BACKGROUND_COMPACTION_THRESHOLD,
+                    bufferExhaustionThreshold: DIRECT_COPILOT_BUFFER_EXHAUSTION_THRESHOLD,
+                },
+                ...(sessionId ? { disableResume: true, continuePendingWork: false } : {}),
+            };
+            const timeout = this.options.providerId === 'agency-copilot' ? ACP_SESSION_OPEN_TIMEOUT_MS : SDK_REQUEST_TIMEOUT_MS;
+            for (let attempt = 0;; attempt++) {
+                try {
+                    response = await this.request(method, params, timeout);
+                    break;
+                }
+                catch (error) {
+                    if (this.options.strictCapabilities)
+                        throw error;
+                    if (!this.configuration || attempt >= 2)
+                        throw error;
+                    const message = String(error);
+                    if (params.contextTier === 'long_context' && /(?:context.*(?:unsupported|not supported|invalid)|unsupported.*context)/i.test(message)) {
+                        configurationIssue(this.configuration, 'context', 'unsupported', message);
+                        params.contextTier = 'default';
+                    }
+                    else if (params.reasoningEffort && /(?:effort.*(?:unsupported|not supported|invalid)|(?:unsupported|invalid).*effort)/i.test(message)) {
+                        configurationIssue(this.configuration, 'effort', 'unsupported', message);
+                        delete params.reasoningEffort;
+                    }
+                    else
+                        throw error;
+                }
+            }
+        }
+        catch (error) {
+            if (this.configuration) {
+                this.configuration.status = 'failed';
+                configurationIssue(this.configuration, 'model', 'rejected', String(error));
+                this.publishConfiguration();
+            }
+            this.releaseSessionLock?.();
+            throw error;
+        }
+        const returnedSessionId = response.sessionId || activeSessionId;
+        if (returnedSessionId !== activeSessionId) {
+            this.releaseSessionLock?.();
+            throw new Error(`Copilot SDK returned unexpected session ID ${returnedSessionId}`);
+        }
+        await this.refreshConfiguration(returnedSessionId);
+        if (this.options.strictCapabilities && this.configuration) {
+            for (const field of ['model', 'context', 'effort']) {
+                if (field !== 'model' && !hasCopilotOfflineModel(this.options.providerId, options.model))
+                    continue;
+                const requested = this.configuration.requested[field];
+                const actual = this.configuration.effective[field];
+                if (requested && actual && requested !== actual && this.configuration.sources[field] === 'provider_config') {
+                    this.releaseSessionLock?.();
+                    throw new Error(`Copilot did not apply the selected ${field}. Please choose another value in Options.`);
+                }
+            }
+        }
+        try {
+            await this.getMode(returnedSessionId);
+        }
+        catch { /* Older runtimes rely on subsequent mode events. */ }
+        return returnedSessionId;
+    }
+    async acquireSessionLock(sessionId) {
+        if (this.stopping)
+            throw new Error('Copilot runtime is stopped');
+        if (this.releaseSessionLock || this.cancelSessionLockWait) {
+            throw new Error('Copilot SDK runtime already owns a session lock');
+        }
+        const previous = sessionLocks.get(sessionId) || Promise.resolve();
+        let releaseCurrent;
+        const current = new Promise(resolvePromise => {
+            releaseCurrent = resolvePromise;
+        });
+        const tail = previous.then(() => current, () => current);
+        sessionLocks.set(sessionId, tail);
+        let cancelWait;
+        const cancelled = new Promise((_resolve, reject) => { cancelWait = reject; });
+        this.cancelSessionLockWait = cancelWait;
+        const timer = setTimeout(() => cancelWait(new Error(`Copilot Session ${sessionId} is still owned by another Runtime (lock wait timed out after 30 seconds). Stop the other request and retry.`)), SESSION_LOCK_TIMEOUT_MS);
+        try {
+            await Promise.race([previous.catch(() => { }), cancelled]);
+            if (this.stopping)
+                throw new Error('Copilot runtime stopped while waiting for its Session lock');
+            this.releaseSessionLock = () => {
+                releaseCurrent();
+                if (sessionLocks.get(sessionId) === tail)
+                    sessionLocks.delete(sessionId);
+                this.releaseSessionLock = null;
+            };
+        }
+        catch (error) {
+            releaseCurrent();
+            // Keep the predecessor in the queue: a cancelled waiter must not let a
+            // later Runtime bypass an owner that still has the Session open.
+            void tail.then(() => {
+                if (sessionLocks.get(sessionId) === tail)
+                    sessionLocks.delete(sessionId);
+            });
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            if (this.cancelSessionLockWait === cancelWait)
+                this.cancelSessionLockWait = null;
+        }
+    }
+    async listSessionCommands(sessionId) {
+        if (this.usesAgencyAcp()) {
+            const current = this.acpSessions.get(sessionId)?.commands;
+            if (current)
+                return current;
+            return withTimeout(new Promise(resolvePromise => {
+                const waiters = this.acpCommandWaiters.get(sessionId) || new Set();
+                waiters.add(resolvePromise);
+                this.acpCommandWaiters.set(sessionId, waiters);
+            }), SDK_REQUEST_TIMEOUT_MS, 'Agency Copilot command catalog');
+        }
+        return normalizeCopilotCommands(await this.request('session.commands.list', {
+            sessionId,
+            includeBuiltins: true,
+            includeSkills: true,
+            includeClientCommands: true,
+        }));
+    }
+    async invokeCommand(sessionId, name, input) {
+        this.cancelledCompactions.delete(sessionId);
+        if (name === 'compact' && !this.usesAgencyAcp()) {
+            return this.compactWithRetries(sessionId, input);
+        }
+        return this.invokeCommandOnce(sessionId, name, input);
+    }
+    /** Retry only a settled native failure, never a possibly still-running RPC. */
+    compactWithRetries(sessionId, input, initialFailure) {
+        const existing = this.compactionAttempts.get(sessionId);
+        if (existing?.promise)
+            return existing.promise;
+        const attempt = { cancelled: false };
+        this.compactionAttempts.set(sessionId, attempt);
+        let succeeded = false;
+        const checkActive = () => {
+            if (this.stopping)
+                throw new Error('Copilot runtime is stopped');
+            if (attempt.cancelled || this.compactionAttempts.get(sessionId) !== attempt) {
+                throw new Error('Copilot compaction cancelled');
+            }
+        };
+        // Defer one microtask so the operation owns the Session before any callback.
+        attempt.promise = Promise.resolve().then(async () => {
+            checkActive();
+            if (compactionHasNothingToCompact(initialFailure)) {
+                throw new Error('Context compaction failed: Nothing to compact.');
+            }
+            let lastFailure = initialFailure;
+            for (let retry = initialFailure ? 1 : 0; retry <= COPILOT_COMPACTION_RETRIES; retry++) {
+                checkActive();
+                if (retry)
+                    console.info(`[Copilot] Retrying settled compaction: session=${sessionId} retry=${retry}/${COPILOT_COMPACTION_RETRIES}`);
+                attempt.failure = undefined;
+                attempt.completion = undefined;
+                let result;
+                let requestError;
+                try {
+                    result = await this.invokeCommandOnce(sessionId, 'compact', input);
+                }
+                catch (error) {
+                    requestError = error;
+                }
+                checkActive();
+                // Re-read callback-owned fields after await (they may have changed).
+                const { failure, completion } = this.compactionAttempts.get(sessionId);
+                if (failure) {
+                    lastFailure = failure;
+                    // A client deadline does not prove the native request has unwound,
+                    // even if an earlier failed event was seen. Do not overlap attempts.
+                    if (requestError && /timed out|disconnected|closed|stopped|cancelled/i.test(String(requestError)))
+                        throw requestError;
+                    if (compactionHasNothingToCompact(failure)) {
+                        throw new Error('Context compaction failed: Nothing to compact.');
+                    }
+                    continue;
+                }
+                if (requestError)
+                    throw requestError;
+                if (!result || result.kind === 'agent-prompt' || result.kind === 'select-subcommand') {
+                    throw new Error('Provider did not complete context compaction; no chat message was resent.');
+                }
+                if (retry && completion?.data?.success !== true) {
+                    throw new Error('Provider did not confirm that retried context compaction succeeded.');
+                }
+                // Publish the native completion only after its RPC has settled. This
+                // keeps the original output barrier and turn alive across all retries.
+                if (completion)
+                    this.options.onSessionEvent?.(sessionId, completion);
+                succeeded = true;
+                return result;
+            }
+            const reason = lastFailure?.data?.error;
+            throw new Error(`Context compaction failed after ${COPILOT_COMPACTION_RETRIES} retries: ${typeof reason === 'string' ? reason : reason?.message || 'Provider reported unsuccessful compaction'}`);
+        }).finally(() => {
+            if (this.compactionAttempts.get(sessionId) !== attempt)
+                return;
+            this.compactionAttempts.delete(sessionId);
+            this.liveCompactions.get(sessionId)?.delete('main');
+            if (succeeded)
+                queueMicrotask(() => this.promptWaiters.get(sessionId)?.reconcile());
+        });
+        return attempt.promise;
+    }
+    async invokeCommandOnce(sessionId, name, input) {
+        const revision = name === 'plan' ? this.planRevisions.get(sessionId) : undefined;
+        const control = revision ? `\n\n${this.planControlPrompt(sessionId, revision)}` : '';
+        if (this.usesAgencyAcp()) {
+            const commandText = input.trim() ? `/${name} ${input}` : `/${name}`;
+            await this.waitForPrompt(sessionId, () => this.requestAcp(acp.methods.agent.session.prompt, {
+                sessionId,
+                prompt: [{
+                        type: 'text',
+                        text: name === 'plan'
+                            ? `${commandText}\n\n${AGENCY_PLAN_ARTIFACT_INTERACTION_GUIDANCE}${control}`
+                            : commandText,
+                    }],
+            }, name === 'compact' ? DIRECT_COPILOT_COMPACTION_TIMEOUT_MS : null));
+            await this.refreshConfiguration(sessionId);
+            return { kind: 'completed' };
+        }
+        // Native maintenance must not replace the chat configuration with the
+        // compactor's/default model. Use an authoritative snapshot, never a guess
+        // from the selected UI options or the compaction token limit.
+        const beforeCompaction = name === 'compact' && this.options.verifyConfiguration
+            ? await this.request('session.model.getCurrent', { sessionId })
+            : undefined;
+        if (beforeCompaction) {
+            // A cold resume can invalidate the native model catalog after the earlier
+            // capability check. models.list is process/account metadata; only
+            // session.model.list populates this Session's native catalog using its
+            // own auth/integration. No probe chat or replacement Session is involved.
+            const catalog = await this.request('session.model.list', { sessionId });
+            const model = catalog.list?.find(item => item.id === beforeCompaction.modelId);
+            if (!model || model.policy?.state === 'disabled')
+                throw new Error('Cannot compact: the current model capability catalog is unavailable. Retry after the Provider is ready.');
+            if (this.stopping)
+                throw new Error('Copilot runtime is stopped');
+        }
+        try {
+            const result = await this.request('session.commands.invoke', { sessionId, name, input }, name === 'compact' ? DIRECT_COPILOT_COMPACTION_TIMEOUT_MS : SDK_REQUEST_TIMEOUT_MS);
+            if (beforeCompaction && !this.stopping) {
+                const after = await this.request('session.model.getCurrent', { sessionId });
+                const keys = ['modelId', 'contextTier', 'reasoningEffort'];
+                const changed = keys.some(key => typeof beforeCompaction[key] === 'string'
+                    && beforeCompaction[key] !== after[key]);
+                if (changed) {
+                    if (typeof beforeCompaction.modelId !== 'string' || !beforeCompaction.modelId) {
+                        throw new Error('Context was compacted, but the original chat model could not be confirmed.');
+                    }
+                    await this.request('session.model.switchTo', {
+                        sessionId, modelId: beforeCompaction.modelId,
+                        ...(typeof beforeCompaction.contextTier === 'string' ? { contextTier: beforeCompaction.contextTier } : {}),
+                        ...(typeof beforeCompaction.reasoningEffort === 'string' ? { reasoningEffort: beforeCompaction.reasoningEffort } : {}),
+                    });
+                    const restored = await this.request('session.model.getCurrent', { sessionId });
+                    if (keys.some(key => typeof beforeCompaction[key] === 'string' && beforeCompaction[key] !== restored[key])) {
+                        throw new Error('Context was compacted, but the Provider did not restore the original chat configuration.');
+                    }
+                }
+            }
+            return control && result.kind === 'agent-prompt'
+                ? { ...result, prompt: `${result.prompt}${control}` }
+                : result;
+        }
+        finally {
+            if (name === 'compact' && this.configuration)
+                resetCopilotConfigurationObservation(this.configuration);
+        }
+    }
+    async setMode(sessionId, mode) {
+        if (this.usesAgencyAcp()) {
+            const state = this.acpSessions.get(sessionId);
+            const modeId = state?.modes?.availableModes.find(value => normalizeAcpMode(value.id) === mode)?.id
+                || mode;
+            await this.requestAcp(acp.methods.agent.session.setMode, { sessionId, modeId });
+            if (state?.modes)
+                state.modes.currentModeId = modeId;
+            return;
+        }
+        await this.request('session.mode.set', { sessionId, mode });
+        if (mode === 'autopilot')
+            this.goalSessions.add(sessionId);
+        else
+            this.goalSessions.delete(sessionId);
+    }
+    async getMode(sessionId) {
+        if (this.usesAgencyAcp()) {
+            return normalizeAcpMode(this.acpSessions.get(sessionId)?.modes?.currentModeId);
+        }
+        const mode = await this.request('session.mode.get', { sessionId });
+        if (mode === 'autopilot')
+            this.goalSessions.add(sessionId);
+        else if (mode === 'interactive' || mode === 'plan')
+            this.goalSessions.delete(sessionId);
+        return mode;
+    }
+    async enableAllowAll(sessionId) {
+        if (this.usesAgencyAcp())
+            return;
+        await this.request('session.permissions.setMode', {
+            sessionId,
+            mode: 'allow-all',
+            source: 'rpc',
+        });
+    }
+    async send(sessionId, prompt, displayPrompt, attachments) {
+        this.cancelledCompactions.delete(sessionId);
+        if (this.usesAgencyAcp()) {
+            await this.waitForPrompt(sessionId, () => this.requestAcp(acp.methods.agent.session.prompt, { sessionId, prompt: [{ type: 'text', text: prompt || displayPrompt }] }, null));
+            // ACP does not expose context tier in configOptions on all versions.
+            // Re-read this configuration generation's native journal after the real
+            // prompt, when session/model evidence has been flushed by the Provider.
+            await this.refreshConfiguration(sessionId);
+            return;
+        }
+        await this.waitForPrompt(sessionId, () => this.request('session.send', {
+            sessionId,
+            prompt,
+            displayPrompt,
+            wait: true,
+            ...(attachments?.length ? { attachments } : {}),
+        }, null));
+        await this.refreshConfiguration(sessionId);
+    }
+    readPlanContent(sessionId, sessionRoot = join(homedir(), '.copilot', 'session-state')) {
+        const root = resolve(sessionRoot);
+        const sessionDir = resolve(root, sessionId);
+        if (sessionDir === root || !sessionDir.startsWith(`${root}${sep}`))
+            return null;
+        const planPath = join(sessionDir, 'plan.md');
+        try {
+            const content = readFileSync(planPath, 'utf8').trim();
+            return content || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async abort(sessionId) {
+        this.cancelledCompactions.add(sessionId);
+        const attempt = this.compactionAttempts.get(sessionId);
+        if (attempt)
+            attempt.cancelled = true;
+        this.compactionAttempts.delete(sessionId);
+        this.liveCompactions.delete(sessionId);
+        try {
+            this.resumeAllPromptWaiters(sessionId);
+            if (this.usesAgencyAcp()) {
+                await this.notifyAcp(acp.methods.agent.session.cancel, { sessionId });
+            }
+            else {
+                try {
+                    if (this.goalSessions.has(sessionId)) {
+                        await this.request('session.mode.set', { sessionId, mode: 'interactive' }, SDK_STOP_TIMEOUT_MS);
+                        this.goalSessions.delete(sessionId);
+                    }
+                }
+                finally {
+                    await this.request('session.abort', { sessionId }, SDK_STOP_TIMEOUT_MS);
+                }
+            }
+        }
+        finally {
+            this.promptWaiters.get(sessionId)?.fail(new Error('Copilot request cancelled'));
+        }
+    }
+    async respondToUserInput(sessionId, requestId, response) {
+        if (this.usesAgencyAcp())
+            return false;
+        const result = await this.request('session.ui.handlePendingUserInput', {
+            sessionId,
+            requestId,
+            response,
+        });
+        if (result.success === true)
+            this.resumePromptWaiter(sessionId, requestId);
+        return result.success === true;
+    }
+    async abortManualCompaction(sessionId) {
+        this.cancelledCompactions.add(sessionId);
+        const attempt = this.compactionAttempts.get(sessionId);
+        if (attempt)
+            attempt.cancelled = true;
+        this.compactionAttempts.delete(sessionId);
+        if (this.usesAgencyAcp()) {
+            await this.abort(sessionId);
+            return;
+        }
+        await this.request('session.history.abortManualCompaction', { sessionId });
+    }
+    async destroySession(sessionId) {
+        if (this.usesAgencyAcp()) {
+            try {
+                await this.requestAcp(acp.methods.agent.session.close, { sessionId }, SDK_STOP_TIMEOUT_MS);
+            }
+            catch {
+                // ACP connection shutdown below releases any remaining session resources.
+            }
+            this.acpSessions.delete(sessionId);
+            return;
+        }
+        try {
+            await this.request('session.destroy', { sessionId });
+        }
+        catch {
+            // Runtime shutdown below also releases any remaining session handles.
+        }
+    }
+    async deleteSession(sessionId) {
+        if (this.options.providerId === 'agency-copilot')
+            return;
+        await this.request('session.delete', { sessionId });
+    }
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        this.stopping = true;
+        for (const attempt of this.compactionAttempts.values())
+            attempt.cancelled = true;
+        this.compactionAttempts.clear();
+        this.liveCompactions.clear();
+        this.compactionLifecycle = new CopilotCompactionLifecycle();
+        this.rejectStartup?.(new Error('Copilot runtime startup cancelled'));
+        this.cancelSessionLockWait?.(new Error('Copilot runtime stopped while waiting for its Session lock'));
+        const stopped = this.stopRuntime().finally(() => {
+            if (this.stopPromise === stopped)
+                this.stopPromise = null;
+        });
+        this.stopPromise = stopped;
+        return stopped;
+    }
+    async stopRuntime() {
+        const connection = this.connection;
+        const acpConnection = this.acpConnection;
+        const child = this.child;
+        let onClose;
+        const closed = child?.pid && child.exitCode === null && child.signalCode === null && typeof child.once === 'function'
+            ? new Promise(resolveClosed => { onClose = resolveClosed; child.once('close', onClose); })
+            : Promise.resolve();
+        this.connection = null;
+        this.acpConnection = null;
+        this.child = null;
+        // Agency can still be fetching remote configuration before ACP initialize.
+        // On Windows killing only agency.exe leaves its Git/credential helpers
+        // alive. Terminate this owned tree before closing stdio (which can make
+        // the parent exit before taskkill has enumerated its descendants).
+        const forceAgencyTree = this.options.providerId === 'agency-copilot' && platform() === 'win32' && child?.pid
+            && child.exitCode === null && child.signalCode === null;
+        if (forceAgencyTree) {
+            // Do not send runtime.shutdown into a pipe we are about to terminate.
+            // vscode-jsonrpc's failed write can also escape as an unhandled rejection.
+            connection?.dispose();
+            await new Promise(resolve => {
+                try {
+                    execFile('taskkill.exe', ['/pid', String(child.pid), '/t', '/f'], { timeout: SDK_STOP_TIMEOUT_MS, windowsHide: true }, () => resolve());
+                }
+                catch {
+                    resolve(); // The direct kill below is the bounded fallback.
+                }
+            });
+        }
+        if (acpConnection)
+            acpConnection.close();
+        if (connection && !forceAgencyTree) {
+            try {
+                await withTimeout(connection.sendRequest('runtime.shutdown', {}), SDK_STOP_TIMEOUT_MS, 'Copilot SDK shutdown');
+            }
+            catch {
+                // Force termination below is the bounded fallback.
+            }
+            connection.dispose();
+        }
+        if (child && !child.killed)
+            child.kill();
+        // On Windows a successful kill/absent PID can precede close of stdio/cwd
+        // handles. Do not let a retry outlive cleanup of its predecessor.
+        try {
+            await withTimeout(closed, SDK_STOP_TIMEOUT_MS, 'Copilot process shutdown');
+        }
+        finally {
+            if (onClose)
+                child?.removeListener('close', onClose);
+            this.failPromptWaiters(new Error('Copilot runtime stopped'));
+        }
+        this.acpSessions.clear();
+        this.goalSessions.clear();
+        this.acpCommandWaiters.clear();
+        this.acpToolNames.clear();
+        this.releaseSessionLock?.();
+    }
+    isRunning() {
+        return !!this.child && (!!this.connection || !!this.acpConnection);
+    }
+    get transport() {
+        return this.options.providerId === 'agency-copilot' ? this.options.transport || 'sdk' : 'sdk';
+    }
+    usesAgencyAcp() {
+        return this.transport === 'acp';
+    }
+    handleDirectSessionEvent(sessionId, event) {
+        if (!this.observeCompactionLifecycle(sessionId, event))
+            return;
+        this.observeGoalLifecycle(sessionId, event);
+        this.observeConfiguration(sessionId, event);
+        const type = typeof event.type === 'string' ? event.type : '';
+        const data = isRecord(event.data) ? event.data : undefined;
+        const requestId = typeof data?.requestId === 'string' ? data.requestId : undefined;
+        if (type === 'user_input.requested' && requestId) {
+            this.pausePromptWaiter(sessionId, requestId);
+        }
+        else if (type === 'user_input.completed' && requestId) {
+            this.resumePromptWaiter(sessionId, requestId);
+        }
+        this.options.onSessionEvent?.(sessionId, event);
+    }
+    observeGoalLifecycle(sessionId, event) {
+        if (isCopilotChildEvent(event))
+            return;
+        if (event.type === 'session.mode_changed') {
+            if (event.data?.newMode === 'autopilot')
+                this.goalSessions.add(sessionId);
+            else if (event.data?.newMode === 'interactive' || event.data?.newMode === 'plan')
+                this.goalSessions.delete(sessionId);
+        }
+        if (event.type === 'session.task_complete')
+            this.goalSessions.delete(sessionId);
+    }
+    observeCompactionLifecycle(sessionId, event) {
+        if (!event.type?.startsWith('session.compaction_'))
+            return true;
+        if (this.stopping || this.cancelledCompactions.has(sessionId))
+            return false;
+        const scope = copilotChildScope(event) || 'main';
+        const observed = this.compactionLifecycle.accept(sessionId, event);
+        console.debug(`[CopilotCompactionBridge] ${JSON.stringify({ sessionId, scope, type: event.type,
+            eventId: event.id, accepted: !!observed, late: observed?.late === true })}`);
+        if (!observed)
+            return false;
+        event.agentlinkCompaction = observed.record;
+        event.agentlinkCompactionLate = observed.late;
+        if (observed.late)
+            return true;
+        const scopes = this.liveCompactions.get(sessionId) || new Set();
+        const failed = event.type === 'session.compaction_failed' || event.data?.success === false;
+        const attempt = scope === 'main' ? this.compactionAttempts.get(sessionId) : undefined;
+        if (attempt && event.type !== 'session.compaction_start') {
+            attempt.failure = failed ? event : undefined;
+            attempt.completion = failed ? undefined : event;
+            return false;
+        }
+        if (failed && scope === 'main' && !this.usesAgencyAcp() && !this.stopping
+            && (scopes.has('main') || this.promptWaiters.has(sessionId))) {
+            scopes.add('main');
+            this.liveCompactions.set(sessionId, scopes);
+            void this.compactWithRetries(sessionId, '', event).catch(error => {
+                if (this.stopping || /compaction cancelled/.test(String(error)))
+                    return;
+                this.options.onSessionEvent?.(sessionId, {
+                    type: 'session.compaction_failed',
+                    data: { error: error instanceof Error ? error.message : String(error) },
+                });
+                this.promptWaiters.get(sessionId)?.fail(error instanceof Error ? error : new Error(String(error)));
+                void this.abort(sessionId).catch(() => { });
+            });
+            return false;
+        }
+        if (event.type === 'session.compaction_start')
+            scopes.add(scope);
+        else
+            scopes.delete(scope);
+        this.liveCompactions.set(sessionId, scopes);
+        if (failed) {
+            this.promptWaiters.get(sessionId)?.fail(new Error('Copilot native compaction failed'));
+            void this.abort(sessionId).catch(() => { });
+        }
+        else if (!scopes.size) {
+            queueMicrotask(() => this.promptWaiters.get(sessionId)?.reconcile());
+        }
+        return true;
+    }
+    waitForPrompt(sessionId, requestFactory) {
+        if (this.promptWaiters.has(sessionId)) {
+            return Promise.reject(new Error(`A Copilot prompt is already active for ${sessionId}`));
+        }
+        return new Promise((resolvePromise, rejectPromise) => {
+            const waiter = {
+                pendingUserInputIds: new Set(),
+                settled: false,
+                reconcile: () => { },
+                reject: rejectPromise,
+                fail: error => {
+                    if (waiter.settled)
+                        return;
+                    waiter.settled = true;
+                    this.clearPromptWaiter(sessionId, waiter);
+                    waiter.reject(error);
+                },
+            };
+            this.promptWaiters.set(sessionId, waiter);
+            let requestReturned = false;
+            let requestValue;
+            const journalPath = join(this.options.sessionRoot || join(homedir(), '.copilot', 'session-state'), sessionId, 'events.jsonl');
+            if (this.usesAgencyAcp() && /^[\w-]+$/.test(sessionId) && existsSync(journalPath)) {
+                const state = this.acpSessions.get(sessionId) || {};
+                state.journalCompaction = true;
+                this.acpSessions.set(sessionId, state);
+            }
+            const journal = /^[\w-]+$/.test(sessionId) ? new CopilotTurnJournal(journalPath, event => {
+                this.observeGoalLifecycle(sessionId, event);
+                const data = event.data || {};
+                if (isCopilotChildEvent(event))
+                    return;
+                if (event.type === 'user_input.requested' && data.requestId)
+                    this.pausePromptWaiter(sessionId, data.requestId);
+                if (event.type === 'user_input.completed' && data.requestId)
+                    this.resumePromptWaiter(sessionId, data.requestId);
+                // A persisted Goal summary must reach the same live reply path even
+                // if its SDK notification was lost after an early send response.
+                // The conversation handler already deduplicates task_complete text.
+                if (event.type === 'session.task_complete') {
+                    this.options.onSessionEvent?.(sessionId, event);
+                }
+                // SDK notifications can be lost across a long background compaction.
+                // Replay only its native lifecycle evidence; the driver deduplicates
+                // event IDs/timestamps against the live stream, for both SDK backends.
+                if (!this.usesAgencyAcp() && event.type?.startsWith('session.compaction_')) {
+                    this.handleDirectSessionEvent(sessionId, event);
+                }
+                if (!this.usesAgencyAcp())
+                    return;
+                if (event.type === 'session.usage_checkpoint' || event.type?.startsWith('session.compaction_')) {
+                    const state = this.acpSessions.get(sessionId) || {};
+                    state.journalUsage = true;
+                    state.journalCompaction = true;
+                    this.acpSessions.set(sessionId, state);
+                    this.emitAcpEvent(sessionId, { ...event, journal: true });
+                }
+                else if (event.type === 'assistant.message' && data.phase === 'final_answer' && data.content) {
+                    this.emitAcpEvent(sessionId, { type: 'agentlink.journal_final', id: event.id, timestamp: event.timestamp, data });
+                }
+            }) : undefined;
+            const settle = () => {
+                if (waiter.settled || waiter.pendingUserInputIds.size > 0 || this.goalSessions.has(sessionId)
+                    || this.liveCompactions.get(sessionId)?.size || this.compactionAttempts.has(sessionId))
+                    return;
+                // A background admission ACK is not completion. Conversely, a persisted
+                // main final answer/Goal success + turn end + checkpoint can repair a
+                // stuck RPC without mistaking a child completion for the whole turn.
+                if ((requestReturned && !journal?.pending) || journal?.complete) {
+                    waiter.settled = true;
+                    this.clearPromptWaiter(sessionId, waiter);
+                    resolvePromise(requestValue);
+                }
+            };
+            if (journal) {
+                waiter.journalTimer = setInterval(() => { journal.read(); settle(); }, 1000);
+                waiter.journalTimer.unref?.();
+            }
+            waiter.reconcile = () => { journal?.read(); settle(); };
+            let request;
+            try {
+                request = requestFactory();
+            }
+            catch (error) {
+                waiter.fail(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            request.then(value => {
+                if (waiter.settled)
+                    return;
+                requestValue = value;
+                requestReturned = true;
+                journal?.read();
+                settle();
+            }, error => {
+                if (waiter.settled)
+                    return;
+                const compaction = this.compactionAttempts.get(sessionId)?.promise;
+                if (compaction) {
+                    // A failed send is not replayable. Finish maintenance first, then
+                    // report the original failure instead of resending the user turn.
+                    void compaction.then(() => waiter.fail(error), failure => waiter.fail(failure));
+                    return;
+                }
+                waiter.settled = true;
+                this.clearPromptWaiter(sessionId, waiter);
+                rejectPromise(error);
+            });
+        });
+    }
+    pausePromptWaiter(sessionId, requestId) {
+        const waiter = this.promptWaiters.get(sessionId);
+        if (!waiter || waiter.settled)
+            return;
+        waiter.pendingUserInputIds.add(requestId);
+    }
+    resumePromptWaiter(sessionId, requestId) {
+        const waiter = this.promptWaiters.get(sessionId);
+        if (!waiter || waiter.settled)
+            return;
+        waiter.pendingUserInputIds.delete(requestId);
+        queueMicrotask(() => { if (!waiter.settled)
+            waiter.reconcile(); });
+    }
+    resumeAllPromptWaiters(sessionId) {
+        const waiter = this.promptWaiters.get(sessionId);
+        if (!waiter || waiter.settled)
+            return;
+        waiter.pendingUserInputIds.clear();
+    }
+    clearPromptWaiter(sessionId, waiter) {
+        if (waiter.journalTimer)
+            clearInterval(waiter.journalTimer);
+        waiter.pendingUserInputIds.clear();
+        if (this.promptWaiters.get(sessionId) === waiter) {
+            this.promptWaiters.delete(sessionId);
+        }
+    }
+    failPromptWaiters(error) {
+        for (const waiter of [...this.promptWaiters.values()])
+            waiter.fail(error);
+    }
+    async openAcpSession(sessionId, options = {}) {
+        const lockId = sessionId || randomUUID();
+        await this.acquireSessionLock(lockId);
+        this.beginConfiguration(lockId, options);
+        let activeSessionId;
+        try {
+            if (sessionId) {
+                const state = this.acpSessions.get(sessionId) || {};
+                state.suppressEvents = true;
+                this.acpSessions.set(sessionId, state);
+            }
+            const response = sessionId
+                ? await this.requestAcp(acp.methods.agent.session.load, { sessionId, cwd: this.options.workDir, mcpServers: [] }, ACP_SESSION_OPEN_TIMEOUT_MS)
+                : await this.requestAcp(acp.methods.agent.session.new, { cwd: this.options.workDir, mcpServers: [] }, ACP_SESSION_OPEN_TIMEOUT_MS);
+            activeSessionId = sessionId || response.sessionId;
+            if (!activeSessionId)
+                throw new Error('Agency Copilot ACP did not return a session ID');
+            this.configurationSessionId = activeSessionId;
+            if (this.configuration)
+                this.configuration.sessionId = activeSessionId;
+            const state = this.acpSessions.get(activeSessionId) || {};
+            if (response && 'modes' in response)
+                state.modes = response.modes;
+            if (response && 'configOptions' in response)
+                state.configOptions = response.configOptions;
+            this.acpSessions.set(activeSessionId, state);
+            await this.applyAcpSessionOptions(activeSessionId, state, options);
+            state.suppressEvents = false;
+            await this.refreshConfiguration(activeSessionId);
+            return activeSessionId;
+        }
+        catch (error) {
+            if (activeSessionId)
+                this.acpSessions.delete(activeSessionId);
+            else if (sessionId)
+                this.acpSessions.delete(sessionId);
+            if (this.configuration) {
+                this.configuration.status = 'failed';
+                configurationIssue(this.configuration, 'model', 'rejected', String(error));
+                this.publishConfiguration();
+            }
+            this.releaseSessionLock?.();
+            throw error;
+        }
+    }
+    async applyAcpSessionOptions(sessionId, state, options) {
+        const requested = [
+            {
+                label: 'model',
+                value: options.model,
+                categories: ['model'],
+                namePattern: /model/i,
+            },
+            {
+                label: 'context tier',
+                value: options.contextTier,
+                categories: ['model_config'],
+                namePattern: /context/i,
+                startupFallback: true,
+            },
+            {
+                label: 'reasoning effort',
+                value: options.reasoningEffort,
+                categories: ['thought_level'],
+                namePattern: /reason|thought|effort/i,
+            },
+        ];
+        for (const target of requested) {
+            if (!target.value)
+                continue;
+            const field = target.label === 'model' ? 'model' : target.label === 'context tier' ? 'context' : 'effort';
+            const config = this.findAcpSelectConfig(state.configOptions, this.options.verifyConfiguration ? undefined : target.value, target.categories, target.namePattern);
+            if (!config) {
+                if (this.configuration)
+                    configurationIssue(this.configuration, field, 'unconfirmed', `Agency ACP does not report a ${target.label} configuration field.`);
+                if (!target.startupFallback) {
+                    console.warn(`[Copilot] Agency ACP did not expose a compatible ${target.label} option for ${target.value}`);
+                }
+                continue;
+            }
+            const values = config.options.flatMap(entry => 'options' in entry ? entry.options : [entry]).map(entry => entry.value);
+            if (this.configuration && field === 'effort')
+                this.configuration.supportedEfforts = values;
+            if (!values.includes(target.value)) {
+                if (field === 'model')
+                    throw new Error(`Agency Copilot model ${target.value} is unavailable.`);
+                const fallback = field === 'context' && values.includes('default') ? 'default'
+                    : values.includes(config.currentValue) ? config.currentValue : undefined;
+                if (fallback && fallback !== config.currentValue) {
+                    const response = await this.requestAcp(acp.methods.agent.session.setConfigOption, { sessionId, configId: config.id, value: fallback });
+                    state.configOptions = response.configOptions;
+                }
+                if (this.configuration) {
+                    configurationIssue(this.configuration, field, 'unsupported', `Requested ${target.label} ${target.value} is unsupported.`);
+                    const actual = state.configOptions?.find(option => option.id === config.id);
+                    if (fallback && actual?.type === 'select')
+                        confirmConfiguration(this.configuration, field, actual.currentValue, 'provider_config');
+                }
+                continue;
+            }
+            if (config.currentValue !== target.value) {
+                try {
+                    const response = await this.requestAcp(acp.methods.agent.session.setConfigOption, { sessionId, configId: config.id, value: target.value });
+                    state.configOptions = response.configOptions;
+                }
+                catch (error) {
+                    if (!this.configuration || field === 'model' || !/unsupported|not supported|invalid.*(?:effort|context)/i.test(String(error)))
+                        throw error;
+                    configurationIssue(this.configuration, field, 'unsupported', String(error));
+                }
+            }
+            const actual = state.configOptions?.find(option => option.id === config.id);
+            if (this.configuration && actual?.type === 'select') {
+                confirmConfiguration(this.configuration, field, actual.currentValue, 'provider_config');
+            }
+        }
+    }
+    findAcpSelectConfig(options, requestedValue, categories, namePattern) {
+        let best;
+        let bestScore = 0;
+        for (const option of options || []) {
+            if (option.type !== 'select')
+                continue;
+            const values = option.options.flatMap(entry => ('options' in entry ? entry.options : [entry])).map(entry => entry.value);
+            if (requestedValue !== undefined && !values.includes(requestedValue))
+                continue;
+            const identity = `${option.id} ${option.name}`;
+            const score = (namePattern.test(identity) ? 2 : 0)
+                + (option.category && categories.includes(option.category) ? 1 : 0);
+            if (score > bestScore) {
+                best = option;
+                bestScore = score;
+            }
+        }
+        return best;
+    }
+    async requestAcp(method, params, timeoutMs = SDK_REQUEST_TIMEOUT_MS) {
+        if (!this.acpConnection)
+            throw new Error('Agency Copilot ACP runtime is not started');
+        if (timeoutMs == null) {
+            return this.acpConnection.agent.request(method, params);
+        }
+        return withTimeout(this.acpConnection.agent.request(method, params), timeoutMs, method);
+    }
+    async notifyAcp(method, params) {
+        if (!this.acpConnection)
+            throw new Error('Agency Copilot ACP runtime is not started');
+        await this.acpConnection.agent.notify(method, params);
+    }
+    handleAcpSessionUpdate(notification) {
+        const { sessionId, update } = notification;
+        const state = this.acpSessions.get(sessionId) || {};
+        this.acpSessions.set(sessionId, state);
+        switch (update.sessionUpdate) {
+            case 'available_commands_update': {
+                const commands = normalizeAcpCommands(update.availableCommands);
+                state.commands = commands;
+                const waiters = this.acpCommandWaiters.get(sessionId);
+                if (waiters) {
+                    this.acpCommandWaiters.delete(sessionId);
+                    for (const resolvePromise of waiters)
+                        resolvePromise(commands);
+                }
+                break;
+            }
+            case 'current_mode_update':
+                if (state.modes)
+                    state.modes.currentModeId = update.currentModeId;
+                else
+                    state.modes = { currentModeId: update.currentModeId, availableModes: [] };
+                this.emitAcpEvent(sessionId, {
+                    type: 'session.mode_changed',
+                    data: { newMode: normalizeAcpMode(update.currentModeId) },
+                });
+                break;
+            case 'config_option_update':
+                if (this.configuration && !state.suppressEvents) {
+                    const shape = (options) => JSON.stringify(options?.map(option => [option.id,
+                        option.type === 'select' ? option.options.flatMap(entry => 'options' in entry ? entry.options : [entry]).map(entry => entry.value).sort() : [],
+                    ]).sort((a, b) => String(a[0]).localeCompare(String(b[0]))));
+                    const previous = shape(state.configOptions);
+                    const next = shape(update.configOptions);
+                    if (previous !== next)
+                        this.capabilityDirty = true;
+                }
+                state.configOptions = update.configOptions;
+                break;
+            case 'compaction_update': {
+                if (state.journalCompaction)
+                    break;
+                const type = update.status === 'in_progress'
+                    ? 'session.compaction_start'
+                    : update.status === 'completed'
+                        ? 'session.compaction_complete'
+                        : 'session.compaction_failed';
+                this.emitAcpEvent(sessionId, {
+                    type,
+                    data: { status: update.status, error: update.error },
+                });
+                break;
+            }
+            case 'usage_update':
+                // Journal checkpoints own token counts, but ACP still supplies the
+                // actual Session window. Do not discard that independent evidence.
+                if (!state.suppressEvents && this.promptWaiters.has(sessionId)) {
+                    this.observeConfiguration(sessionId, { type: 'session.usage_update', data: { size: update.size } });
+                }
+                if (state.journalUsage)
+                    break;
+                this.emitAcpEvent(sessionId, {
+                    type: 'session.usage_update',
+                    data: {
+                        used: update.used,
+                        size: update.size,
+                        cost: update.cost,
+                    },
+                });
+                break;
+            case 'agent_message_chunk':
+            case 'agent_thought_chunk':
+                if (update.content.type === 'text') {
+                    this.emitAcpEvent(sessionId, {
+                        type: update.sessionUpdate === 'agent_message_chunk'
+                            ? 'assistant.message_delta'
+                            : 'assistant.reasoning_delta',
+                        data: { deltaContent: update.content.text },
+                    });
+                }
+                break;
+            case 'tool_call': {
+                const name = update.name || update.title;
+                this.acpToolNames.set(update.toolCallId, name);
+                this.emitAcpEvent(sessionId, {
+                    type: 'assistant.message',
+                    data: {
+                        toolRequests: [{
+                                toolCallId: update.toolCallId,
+                                name,
+                                arguments: update.rawInput,
+                                intentionSummary: update.title,
+                            }],
+                    },
+                });
+                break;
+            }
+            case 'tool_call_update':
+                if (update.status === 'completed' || update.status === 'failed') {
+                    this.emitAcpEvent(sessionId, {
+                        type: 'tool.execution_complete',
+                        data: {
+                            toolCallId: update.toolCallId,
+                            toolName: update.name || this.acpToolNames.get(update.toolCallId),
+                            success: update.status === 'completed',
+                            result: { content: stringifyAcpToolOutput(update.rawOutput) },
+                            error: update.status === 'failed'
+                                ? { message: stringifyAcpToolOutput(update.rawOutput) || 'Tool execution failed' }
+                                : undefined,
+                        },
+                    });
+                }
+                break;
+        }
+    }
+    emitAcpEvent(sessionId, event) {
+        if (this.acpSessions.get(sessionId)?.suppressEvents)
+            return;
+        if (!this.observeCompactionLifecycle(sessionId, event))
+            return;
+        this.observeConfiguration(sessionId, event);
+        this.options.onSessionEvent?.(sessionId, event);
+    }
+}
+function normalizeAcpMode(modeId) {
+    const normalized = modeId?.toLowerCase().split(/[#/]/).filter(Boolean).at(-1);
+    if (normalized === 'plan')
+        return 'plan';
+    if (normalized === 'autopilot')
+        return 'autopilot';
+    return 'interactive';
+}
+function stringifyAcpToolOutput(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function normalizeAcpCommands(values) {
+    if (!Array.isArray(values))
+        return [];
+    const normalized = [];
+    for (const supported of SUPPORTED_COMMANDS) {
+        const source = values.find(command => {
+            const name = command?.name?.toLowerCase();
+            return name === supported || (supported === 'goal' && name === 'autopilot');
+        });
+        if (!source)
+            continue;
+        normalized.push({
+            id: `command:${supported}`,
+            name: supported,
+            invocation: `/${supported}`,
+            description: source.description || '',
+            kind: 'command',
+        });
+    }
+    return normalized;
+}
+export function normalizeCopilotCommands(input) {
+    const values = input?.commands;
+    if (!Array.isArray(values))
+        return [];
+    const normalized = [];
+    for (const supported of SUPPORTED_COMMANDS) {
+        const source = values.find(command => {
+            if (!command || typeof command.name !== 'string')
+                return false;
+            const names = [command.name, ...(Array.isArray(command.aliases) ? command.aliases : [])];
+            return names.some(name => name.toLowerCase() === supported);
+        });
+        if (!source)
+            continue;
+        normalized.push({
+            id: `command:${supported}`,
+            name: supported,
+            invocation: `/${supported}`,
+            description: typeof source.description === 'string' ? source.description : '',
+            kind: 'command',
+        });
+    }
+    return normalized;
+}
+export async function discoverCopilotCommands(_scope) {
+    return { commands: copilotBootstrapCommands() };
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object';
+}
+//# sourceMappingURL=copilot-command-bridge.js.map