@agent-link/agent 0.1.333 → 0.1.334

package/dist/copilot.js

@@ -14,12 +14,14 @@ import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdirSync
 import { basename, dirname, extname, join, resolve } from 'path';
 import { homedir, platform } from 'os';
 import { randomUUID } from 'crypto';
+import * as acp from '@agentclientprotocol/sdk';
 import { processUserMessage } from './history-message-transform.js';
 import { copilotCapabilities } from './backends/types.js';
 import { CONFIG_DIR } from './config.js';
 import { getCleanEnv, resolveExecutablePath } from './sdk.js';
 import { getProvider, resolveProviderCommand } from './providers.js';
 import { FileCache } from './file-cache.js';
+import { CopilotCommandRuntime, } from './copilot-command-bridge.js';
 // ── Module state ───────────────────────────────────────────────────────────
 const conversations = new Map();
 const sendFns = new Set();
@@ -27,6 +29,24 @@ let globalModel = null;
 const MODEL_PATTERN = /^[a-zA-Z0-9._-]+$/;
 const CONTEXT_TIERS = new Set(['default', 'long_context']);
 const REASONING_EFFORTS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
+const COPILOT_PLAN_INPUT_TIMEOUT_MS = 10 * 60_000;
+const COPILOT_CONTINUE_PLAN_ANSWER = 'Continue developing the plan. In your final response, ask me to confirm the plan or describe any changes.';
+const pendingCopilotDecisions = new Map();
+class CopilotDecisionCancelledError extends Error {
+    constructor() {
+        super('Copilot decision request was cancelled');
+    }
+}
+function setCopilotModeState(state, mode) {
+    state.copilotMode = mode;
+    state.planMode = mode === 'plan';
+    sendFn({
+        type: 'plan_mode_changed',
+        enabled: state.planMode,
+        mode,
+        conversationId: state.conversationId,
+    });
+}
 const COPILOT_NATIVE_ATTACHMENT_MIME_TYPES = new Set([
     'application/pdf',
     'image/gif',
@@ -60,6 +80,107 @@ export function addCopilotSendFn(fn) {
     sendFns.add(fn);
     return () => { sendFns.delete(fn); };
 }
+function emitCopilotDecisionRequest(pending) {
+    sendFn({
+        type: 'backend_event',
+        conversationId: pending.conversationId,
+        providerId: pending.providerId,
+        claudeSessionId: pending.sessionId,
+        event: {
+            type: 'user_input_requested',
+            session: sessionRef(pending.sessionId),
+            requestId: pending.requestId,
+            request: pending.request,
+        },
+    });
+}
+function settleCopilotDecision(pending, answer) {
+    if (pendingCopilotDecisions.get(pending.requestId) !== pending)
+        return false;
+    pendingCopilotDecisions.delete(pending.requestId);
+    if (pending.timer)
+        clearTimeout(pending.timer);
+    pending.timer = null;
+    sendFn({
+        type: 'backend_event',
+        conversationId: pending.conversationId,
+        providerId: pending.providerId,
+        claudeSessionId: pending.sessionId,
+        event: {
+            type: 'user_input_resolved',
+            session: sessionRef(pending.sessionId),
+            requestId: pending.requestId,
+            resolution: answer.action === 'cancel' ? 'cancelled' : 'answered',
+        },
+    });
+    pending.resolve(answer);
+    return true;
+}
+function waitForCopilotDecision(state, sessionId, request, choices = []) {
+    const requestId = randomUUID();
+    return new Promise(resolvePromise => {
+        const pending = {
+            requestId,
+            conversationId: state.conversationId,
+            providerId: state.providerId,
+            sessionId,
+            request,
+            choices,
+            resolve: resolvePromise,
+            timer: null,
+        };
+        pendingCopilotDecisions.set(requestId, pending);
+        if (request.expiresAt) {
+            pending.timer = setTimeout(() => {
+                if (choices.length > 0) {
+                    settleCopilotDecision(pending, { action: 'answer', answer: choices[0] });
+                }
+                else {
+                    settleCopilotDecision(pending, {
+                        action: 'answer',
+                        answer: COPILOT_CONTINUE_PLAN_ANSWER,
+                    });
+                }
+            }, Math.max(0, request.expiresAt - Date.now()));
+        }
+        emitCopilotDecisionRequest(pending);
+    });
+}
+function cancelPendingCopilotDecisions(conversationId) {
+    for (const pending of [...pendingCopilotDecisions.values()]) {
+        if (pending.conversationId === conversationId) {
+            settleCopilotDecision(pending, { action: 'cancel' });
+        }
+    }
+}
+export function getPendingCopilotDecisions(conversationId) {
+    return [...pendingCopilotDecisions.values()]
+        .filter(pending => pending.conversationId === conversationId)
+        .map(pending => ({
+        requestId: pending.requestId,
+        conversationId: pending.conversationId,
+        providerId: pending.providerId,
+        sessionId: pending.sessionId,
+        request: pending.request,
+    }));
+}
+export function handleCopilotUserAnswer(requestId, answers, scope = {}) {
+    const pending = pendingCopilotDecisions.get(requestId);
+    if (!pending)
+        return false;
+    if (scope.conversationId && pending.conversationId !== scope.conversationId)
+        return false;
+    if (scope.providerId && pending.providerId !== scope.providerId)
+        return false;
+    const action = typeof answers.__action === 'string' ? answers.__action : undefined;
+    const feedback = typeof answers.__feedback === 'string' ? answers.__feedback.trim() : undefined;
+    const firstAnswer = Object.entries(answers)
+        .find(([key, value]) => !key.startsWith('__') && typeof value === 'string')?.[1];
+    const answer = action || (typeof firstAnswer === 'string' ? firstAnswer : '');
+    if (!answer)
+        return false;
+    return settleCopilotDecision(pending, { action: 'answer', answer, feedback });
+}
 function resolveDirectExecution(cmdPath) {
     if (platform() !== 'win32')
         return null;
@@ -133,10 +254,18 @@ function finishCopilotTurn(state) {
         state.heartbeatTimer = null;
     }
 }
+function ensureCopilotCommandTurnActive(state, turnId) {
+    if (!state.turnActive || state.turnId !== turnId) {
+        throw new CopilotDecisionCancelledError();
+    }
+}
 function emitCopilotCancelled(conversationId, state) {
     sendFn({
         type: 'backend_event',
         conversationId,
+        claudeSessionId: state?.copilotSessionId || null,
+        turnId: state?.turnId || null,
+        stateVersion: state?.stateVersion || 0,
         event: { type: 'turn_cancelled', session: sessionRef(state?.copilotSessionId || '') },
     });
     sendFn({
@@ -205,6 +334,10 @@ export function rebindCopilotConversation(copilotSessionId, newConvId) {
             conversations.delete(oldConvId);
             state.conversationId = newConvId;
             conversations.set(newConvId, state);
+            for (const pending of pendingCopilotDecisions.values()) {
+                if (pending.conversationId === oldConvId)
+                    pending.conversationId = newConvId;
+            }
             return true;
         }
     }
@@ -229,6 +362,13 @@ export function createCopilotPlaceholder(conversationId, opts) {
         stateVersion: 0,
         heartbeatTimer: null,
         sessionNotified: false,
+        copilotMode: 'interactive',
+        planMode: false,
+        planModePending: false,
+        isCompacting: false,
+        commandRuntime: null,
+        commandSessionId: null,
+        deferredCommandUsage: null,
     });
 }
 export function restartCopilotConversation(conversationId, opts) {
@@ -243,7 +383,7 @@ export function restartCopilotConversation(conversationId, opts) {
         child: null,
         abortController: null,
         copilotSessionId: null,
-        lastCopilotSessionId: copilotSessionId,
+        lastCopilotSessionId: opts?.preserveSession === false ? null : copilotSessionId,
         workDir: state?.workDir || process.cwd(),
         turnActive: false,
         providerId: opts?.providerId || state?.providerId || 'copilot',
@@ -254,6 +394,13 @@ export function restartCopilotConversation(conversationId, opts) {
         stateVersion: (state?.stateVersion || 0) + 1,
         heartbeatTimer: null,
         sessionNotified: false,
+        copilotMode: state?.copilotMode || (state?.planMode ? 'plan' : 'interactive'),
+        planMode: state?.planMode || false,
+        planModePending: state?.planModePending || false,
+        isCompacting: false,
+        commandRuntime: null,
+        commandSessionId: null,
+        deferredCommandUsage: null,
     });
     return { wasTurnActive, copilotSessionId };
 }
@@ -267,6 +414,459 @@ export function setModel(conversationId, model) {
         globalModel = model;
     }
 }
+function detachCopilotProviderSession(state, providerId) {
+    if (state.providerId === providerId)
+        return;
+    state.providerId = providerId;
+    state.copilotSessionId = null;
+    state.lastCopilotSessionId = null;
+    state.sessionNotified = false;
+}
+function isMissingCopilotSessionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /(?:session|resource).*not found|not found.*(?:session|resource)|no (?:session|task|name).*matched/i.test(message);
+}
+function emitCopilotCompactionStarted(state) {
+    if (state.isCompacting)
+        return false;
+    state.isCompacting = true;
+    const session = sessionRef(state.copilotSessionId || state.commandSessionId || 'pending');
+    sendFn({
+        type: 'context_compaction',
+        conversationId: state.conversationId,
+        turnId: state.turnId,
+        status: 'started',
+    });
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        turnId: state.turnId,
+        event: { type: 'compact_started', session },
+    });
+    return true;
+}
+function emitCopilotCompactionCompleted(state) {
+    if (!state.isCompacting)
+        return false;
+    state.isCompacting = false;
+    const session = sessionRef(state.copilotSessionId || state.commandSessionId || '');
+    sendFn({
+        type: 'context_compaction',
+        conversationId: state.conversationId,
+        turnId: state.turnId,
+        status: 'completed',
+    });
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        turnId: state.turnId,
+        event: { type: 'compact_completed', session },
+    });
+    return true;
+}
+function emitCopilotCommandOutput(state, content) {
+    if (!content.trim())
+        return;
+    sendFn({
+        type: 'command_output',
+        conversationId: state.conversationId,
+        content,
+    });
+}
+function emitCopilotCommandCompleted(state) {
+    if (!state.turnActive)
+        return;
+    finishCopilotTurn(state);
+    const session = sessionRef(state.copilotSessionId || '');
+    const usage = state.deferredCommandUsage || undefined;
+    state.deferredCommandUsage = null;
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: { type: 'turn_completed', session, ...(usage ? { usage } : {}) },
+    });
+    sendFn({
+        type: 'turn_completed',
+        conversationId: state.conversationId,
+        workDir: state.workDir,
+        claudeSessionId: state.copilotSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+        ...(usage ? { usage } : {}),
+    });
+}
+function commandInputForDisplay(command, input) {
+    return input.trim() ? `/${command} ${input}` : `/${command}`;
+}
+async function applyCopilotCommandResult(state, runtime, sessionId, command, input, result) {
+    switch (result.kind) {
+        case 'text':
+            emitCopilotCommandOutput(state, result.text);
+            return;
+        case 'completed':
+            if (result.message)
+                emitCopilotCommandOutput(state, result.message);
+            return;
+        case 'select-subcommand':
+            throw new Error(`${result.title}: ${result.options.map(option => option.name).join(', ')}`);
+        case 'agent-prompt':
+            if (result.notice)
+                emitCopilotCommandOutput(state, result.notice);
+            if (result.mode) {
+                await runtime.setMode(sessionId, result.mode);
+                setCopilotModeState(state, result.mode);
+            }
+            await runtime.send(sessionId, result.prompt, result.displayPrompt || commandInputForDisplay(command, input));
+    }
+}
+async function requestCopilotPlanInput(state, sessionId, request) {
+    const choices = request.choices || [];
+    const expiresAt = Date.now() + COPILOT_PLAN_INPUT_TIMEOUT_MS;
+    const decision = await waitForCopilotDecision(state, sessionId, {
+        questions: [{
+                question: request.question,
+                header: 'Plan question',
+                options: choices.map(choice => ({ label: choice, value: choice })),
+            }],
+        source: 'tool_request_user_input',
+        presentation: 'inline',
+        kind: 'plan_input',
+        allowFreeform: request.allowFreeform !== false,
+        expiresAt,
+        timeoutAction: choices.length > 0 ? 'first_option' : 'continue_plan',
+    }, choices);
+    if (decision.action === 'cancel')
+        throw new CopilotDecisionCancelledError();
+    const answer = decision.answer || '';
+    return {
+        answer,
+        wasFreeform: !choices.includes(answer),
+    };
+}
+async function requestCopilotAcpElicitation(state, request) {
+    if (!acp.CreateElicitationRequest.isForm(request) || !('sessionId' in request)) {
+        return { action: 'cancel' };
+    }
+    const properties = Object.entries(request.requestedSchema.properties || {});
+    const [fieldName, field] = properties[0] || [];
+    if (!fieldName || !field)
+        return { action: 'decline' };
+    let choices = [];
+    let multiSelect = false;
+    if (acp.ElicitationPropertySchema.isString(field)) {
+        choices = field.oneOf?.map(option => option.const) || field.enum || [];
+    }
+    else if (acp.ElicitationPropertySchema.isArray(field)) {
+        multiSelect = true;
+        choices = acp.MultiSelectItems.isTitled(field.items)
+            ? field.items.anyOf.map(option => option.const)
+            : (acp.MultiSelectItems.isString(field.items) ? field.items.enum : []);
+    }
+    else if (acp.ElicitationPropertySchema.isBoolean(field)) {
+        choices = ['true', 'false'];
+    }
+    const fieldRecord = field;
+    const fieldDescription = typeof fieldRecord.description === 'string'
+        ? fieldRecord.description
+        : request.message;
+    const fieldTitle = typeof fieldRecord.title === 'string'
+        ? fieldRecord.title
+        : 'Plan question';
+    const expiresAt = Date.now() + COPILOT_PLAN_INPUT_TIMEOUT_MS;
+    const decision = await waitForCopilotDecision(state, request.sessionId, {
+        questions: [{
+                question: fieldDescription,
+                header: fieldTitle,
+                options: choices.map(choice => ({ label: choice, value: choice })),
+                multiSelect,
+            }],
+        source: 'tool_request_user_input',
+        presentation: 'inline',
+        kind: 'plan_input',
+        allowFreeform: choices.length === 0,
+        expiresAt,
+        timeoutAction: choices.length > 0 ? 'first_option' : 'continue_plan',
+    }, choices);
+    if (decision.action === 'cancel')
+        return { action: 'cancel' };
+    const raw = decision.answer || '';
+    let value = raw;
+    if (acp.ElicitationPropertySchema.isArray(field))
+        value = raw ? raw.split(/,\s*/) : [];
+    else if (acp.ElicitationPropertySchema.isBoolean(field))
+        value = raw === 'true';
+    else if (acp.ElicitationPropertySchema.isNumber(field)
+        || acp.ElicitationPropertySchema.isInteger(field))
+        value = Number(raw);
+    return { action: 'accept', content: { [fieldName]: value } };
+}
+function copilotPlanConfirmationPrompt(content) {
+    return /[\u3400-\u9fff]/.test(content)
+        ? '请确认以上计划，或直接回复需要修改的内容。'
+        : 'Please confirm the Plan above, or reply with any changes you want.';
+}
+function emitCopilotPlanReview(state, sessionId, content, languageHint = content || '') {
+    const plan = content?.trim() || '';
+    const prompt = copilotPlanConfirmationPrompt(languageHint);
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        providerId: state.providerId,
+        claudeSessionId: sessionId,
+        event: {
+            type: 'text_delta',
+            session: sessionRef(sessionId),
+            text: `${plan ? `\n\n${plan}\n\n` : '\n\n'}> ${prompt}`,
+        },
+    });
+}
+async function acceptCopilotPlanExitWithoutBlocking(state, request) {
+    const selectedAction = request.actions.includes('exit_only')
+        ? 'exit_only'
+        : request.actions.includes('interactive')
+            ? 'interactive'
+            : null;
+    if (!selectedAction) {
+        return {
+            approved: false,
+            feedback: COPILOT_CONTINUE_PLAN_ANSWER,
+        };
+    }
+    state.planModePending = false;
+    return { approved: true, selectedAction };
+}
+export async function executeCopilotCommand(conversationId, command, input, workDir, options) {
+    let state = conversations.get(conversationId);
+    if (!state) {
+        createCopilotPlaceholder(conversationId, { providerId: options?.providerId });
+        state = conversations.get(conversationId);
+    }
+    if (state.turnActive || state.commandRuntime) {
+        sendFn({
+            type: 'backend_event',
+            conversationId,
+            event: { type: 'error', message: 'Copilot is already processing this conversation' },
+        });
+        return;
+    }
+    state.workDir = workDir;
+    const providerChanged = !!options?.providerId && state.providerId !== options.providerId;
+    if (options?.providerId)
+        detachCopilotProviderSession(state, options.providerId);
+    const resumeSessionId = providerChanged
+        ? undefined
+        : options?.resumeSessionId
+            || state.copilotSessionId
+            || state.lastCopilotSessionId
+            || undefined;
+    const normalized = normalizeCopilotRunOptions(options?.copilotOptions);
+    if (normalized.error) {
+        sendCopilotSetupError(state, normalized.error);
+        return;
+    }
+    if (normalized.options.model)
+        state.model = normalized.options.model;
+    if (normalized.options.context)
+        state.contextTier = normalized.options.context;
+    if (normalized.options.effort)
+        state.reasoningEffort = normalized.options.effort;
+    state.deferredCommandUsage = null;
+    let pendingPlanReview = null;
+    const runtime = new CopilotCommandRuntime({
+        providerId: state.providerId,
+        workDir,
+        onSessionEvent: (eventSessionId, event) => {
+            if (eventSessionId === state.commandSessionId)
+                handleCopilotEvent(state, event);
+        },
+        onUserInputRequest: command === 'plan'
+            ? (eventSessionId, request) => requestCopilotPlanInput(state, eventSessionId, request)
+            : undefined,
+        onExitPlanModeRequest: command === 'plan'
+            ? (eventSessionId, request) => {
+                pendingPlanReview = {
+                    sessionId: eventSessionId,
+                    content: request.planContent || request.summary,
+                    languageHint: `${request.summary}\n${request.planContent || ''}`,
+                };
+                return acceptCopilotPlanExitWithoutBlocking(state, request);
+            }
+            : undefined,
+        onAcpElicitationRequest: command === 'plan'
+            ? request => requestCopilotAcpElicitation(state, request)
+            : undefined,
+    });
+    state.commandRuntime = runtime;
+    const previousMode = state.copilotMode;
+    startCopilotTurn(state);
+    const commandTurnId = state.turnId;
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: {
+            type: 'turn_started',
+            session: sessionRef(resumeSessionId || 'pending'),
+        },
+    });
+    if (command === 'compact')
+        emitCopilotCompactionStarted(state);
+    let sessionId = null;
+    try {
+        await runtime.start();
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        const sessionOptions = {
+            model: state.model || globalModel || undefined,
+            contextTier: state.contextTier || undefined,
+            reasoningEffort: state.reasoningEffort || undefined,
+        };
+        try {
+            sessionId = await runtime.openSession(resumeSessionId, sessionOptions);
+            ensureCopilotCommandTurnActive(state, commandTurnId);
+        }
+        catch (error) {
+            if (!resumeSessionId || !isMissingCopilotSessionError(error))
+                throw error;
+            state.copilotSessionId = null;
+            state.lastCopilotSessionId = null;
+            state.sessionNotified = false;
+            sessionId = await runtime.openSession(undefined, sessionOptions);
+            ensureCopilotCommandTurnActive(state, commandTurnId);
+        }
+        state.commandSessionId = sessionId;
+        state.copilotSessionId = sessionId;
+        state.lastCopilotSessionId = sessionId;
+        await runtime.enableAllowAll(sessionId);
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        if (!state.sessionNotified) {
+            state.sessionNotified = true;
+            sendFn({
+                type: 'backend_event',
+                conversationId,
+                event: { type: 'session_started', session: sessionRef(sessionId) },
+            });
+        }
+        const commands = await runtime.listSessionCommands(sessionId);
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        if (!commands.some(value => value.name === command)) {
+            throw new Error(`Copilot provider ${state.providerId} does not expose /${command}`);
+        }
+        if (command === 'plan')
+            state.planModePending = true;
+        if (command === 'goal')
+            state.planModePending = false;
+        const result = await runtime.invokeCommand(sessionId, command, input);
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        await applyCopilotCommandResult(state, runtime, sessionId, command, input, result);
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        if (command === 'compact')
+            emitCopilotCompactionCompleted(state);
+        const reportedMode = await runtime.getMode(sessionId);
+        ensureCopilotCommandTurnActive(state, commandTurnId);
+        const mode = command === 'plan'
+            ? (state.planModePending ? 'plan' : reportedMode)
+            : command === 'goal'
+                ? 'autopilot'
+                : reportedMode;
+        state.planModePending = mode === 'plan';
+        setCopilotModeState(state, mode);
+        if (command === 'plan') {
+            const review = pendingPlanReview || {
+                sessionId,
+                languageHint: input,
+            };
+            emitCopilotPlanReview(state, review.sessionId, review.content, review.languageHint);
+            pendingPlanReview = null;
+        }
+    }
+    catch (error) {
+        pendingPlanReview = null;
+        if (command === 'compact')
+            state.isCompacting = false;
+        if (!resumeSessionId && sessionId && state.copilotSessionId === sessionId) {
+            state.copilotSessionId = null;
+            state.lastCopilotSessionId = null;
+            state.sessionNotified = false;
+        }
+        if (command === 'plan') {
+            state.planModePending = true;
+            setCopilotModeState(state, 'plan');
+        }
+        else if (command === 'goal') {
+            setCopilotModeState(state, previousMode);
+        }
+        if (!(error instanceof CopilotDecisionCancelledError) && state.turnActive) {
+            sendFn({
+                type: 'backend_event',
+                conversationId,
+                event: {
+                    type: 'error',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    finally {
+        if (sessionId)
+            await runtime.destroySession(sessionId);
+        await runtime.stop();
+        state.commandRuntime = null;
+        state.commandSessionId = null;
+        state.isCompacting = false;
+        emitCopilotCommandCompleted(state);
+    }
+}
+export async function setCopilotPlanMode(conversationId, enabled, workDir, providerId = 'copilot') {
+    let state = conversations.get(conversationId);
+    if (!state) {
+        createCopilotPlaceholder(conversationId, { providerId });
+        state = conversations.get(conversationId);
+    }
+    if (state.turnActive || state.commandRuntime) {
+        throw new Error('Copilot is already processing this conversation');
+    }
+    state.workDir = workDir;
+    detachCopilotProviderSession(state, providerId);
+    if (enabled) {
+        state.planModePending = true;
+        setCopilotModeState(state, 'plan');
+        return;
+    }
+    state.planModePending = false;
+    const sessionId = state.copilotSessionId || state.lastCopilotSessionId;
+    if (!sessionId) {
+        setCopilotModeState(state, 'interactive');
+        return;
+    }
+    const runtime = new CopilotCommandRuntime({ providerId, workDir });
+    state.commandRuntime = runtime;
+    state.commandSessionId = sessionId;
+    let activeSessionId = sessionId;
+    try {
+        await runtime.start();
+        try {
+            await runtime.openSession(sessionId);
+        }
+        catch (error) {
+            if (!isMissingCopilotSessionError(error))
+                throw error;
+            state.copilotSessionId = null;
+            state.lastCopilotSessionId = null;
+            state.sessionNotified = false;
+            activeSessionId = await runtime.openSession();
+            state.copilotSessionId = activeSessionId;
+            state.lastCopilotSessionId = activeSessionId;
+            state.commandSessionId = activeSessionId;
+        }
+        await runtime.setMode(activeSessionId, 'interactive');
+        setCopilotModeState(state, await runtime.getMode(activeSessionId));
+    }
+    finally {
+        await runtime.destroySession(activeSessionId);
+        await runtime.stop();
+        state.commandRuntime = null;
+        state.commandSessionId = null;
+    }
+}
 export function normalizeCopilotRunOptions(input) {
     const options = {};
     if (!input)
@@ -343,26 +943,30 @@ export function handleCopilotChat(conversationId, text, workDir, options, files)
             stateVersion: 0,
             heartbeatTimer: null,
             sessionNotified: false,
+            copilotMode: 'interactive',
+            planMode: false,
+            planModePending: false,
+            isCompacting: false,
+            commandRuntime: null,
+            commandSessionId: null,
+            deferredCommandUsage: null,
         };
         conversations.set(conversationId, state);
     }
     state.workDir = workDir;
-    if (options?.providerId) {
-        state.providerId = options.providerId;
-    }
+    const providerChanged = !!options?.providerId && state.providerId !== options.providerId;
+    if (options?.providerId)
+        detachCopilotProviderSession(state, options.providerId);
     // Determine session to resume
-    const resumeId = options?.resumeSessionId
-        || state.copilotSessionId
-        || state.lastCopilotSessionId;
+    const resumeId = providerChanged
+        ? null
+        : options?.resumeSessionId
+            || state.copilotSessionId
+            || state.lastCopilotSessionId;
     if (resumeId) {
         state.copilotSessionId = resumeId;
         state.lastCopilotSessionId = resumeId;
     }
-    // For new sessions, pre-assign a sessionId via --session-id so we know it
-    // immediately (don't have to wait for the `result` event).
-    if (!resumeId) {
-        state.copilotSessionId = randomUUID();
-    }
     const normalized = normalizeCopilotRunOptions(options?.copilotOptions);
     if (normalized.error) {
         sendCopilotSetupError(state, normalized.error);
@@ -374,6 +978,19 @@ export function handleCopilotChat(conversationId, text, workDir, options, files)
         state.contextTier = normalized.options.context;
     if (normalized.options.effort)
         state.reasoningEffort = normalized.options.effort;
+    if (state.planModePending) {
+        void executeCopilotCommand(conversationId, 'plan', text, workDir, {
+            resumeSessionId: resumeId || undefined,
+            providerId: state.providerId,
+            copilotOptions: options?.copilotOptions,
+        });
+        return;
+    }
+    // For new one-shot sessions, pre-assign a sessionId via --session-id so we
+    // know it immediately (the SDK command path creates its own persisted ID).
+    if (!resumeId) {
+        state.copilotSessionId = randomUUID();
+    }
     let processedFiles;
     try {
         processedFiles = processFilesForCopilot(files);
@@ -494,7 +1111,20 @@ export function handleCopilotChat(conversationId, text, workDir, options, files)
         state.child = null;
         state.abortController = null;
         if (state.turnActive) {
+            const missingResumeSession = !!resumeId
+                && code !== 0
+                && isMissingCopilotSessionError(stderrBuf);
             finishCopilotTurn(state);
+            if (missingResumeSession) {
+                state.copilotSessionId = null;
+                state.lastCopilotSessionId = null;
+                state.sessionNotified = false;
+                handleCopilotChat(conversationId, text, workDir, {
+                    providerId: state.providerId,
+                    copilotOptions: options?.copilotOptions,
+                }, files);
+                return;
+            }
             // If turn wasn't completed by a result event, emit error or cancellation
             if (code !== 0 && code !== null) {
                 const errMsg = stderrBuf.trim() || `Copilot process exited with code ${code}`;
@@ -572,6 +1202,44 @@ function handleCopilotEvent(state, event) {
     }
     const session = sessionRef(state.copilotSessionId || 'pending');
     switch (event.type) {
+        case 'session.mode_changed': {
+            const data = event.data;
+            if (data?.newMode) {
+                const mode = data.newMode;
+                if (state.planModePending && mode === 'interactive')
+                    break;
+                setCopilotModeState(state, mode);
+            }
+            break;
+        }
+        case 'session.compaction_start': {
+            emitCopilotCompactionStarted(state);
+            break;
+        }
+        case 'session.compaction_complete': {
+            // Native providers can report a compaction boundary before the command
+            // request itself settles. Keep the synthesized row pending until
+            // invokeCommand succeeds so a later rejection cannot leave a false
+            // completed checkmark behind.
+            if (state.commandRuntime && state.isCompacting)
+                break;
+            emitCopilotCompactionCompleted(state);
+            break;
+        }
+        case 'session.compaction_failed': {
+            state.isCompacting = false;
+            const data = event.data;
+            sendFn({
+                type: 'backend_event',
+                conversationId: convId,
+                turnId: state.turnId,
+                event: {
+                    type: 'error',
+                    message: data?.error || 'Context compaction failed',
+                },
+            });
+            break;
+        }
         case 'assistant.message_delta': {
             const data = event.data;
             if (data?.deltaContent) {
@@ -662,8 +1330,15 @@ function handleCopilotEvent(state, event) {
                 state.copilotSessionId = sessionId;
                 state.lastCopilotSessionId = sessionId;
             }
-            finishCopilotTurn(state);
             const usage = buildCopilotUsage(state, event.usage);
+            // Native command turns can remain open after Copilot finishes generating
+            // while AgentLink waits for a required final Plan decision. Their outer
+            // command lifecycle emits the authoritative terminal event.
+            if (state.commandRuntime) {
+                state.deferredCommandUsage = usage;
+                break;
+            }
+            finishCopilotTurn(state);
             // Emit backend_event turn_completed
             sendFn({
                 type: 'backend_event',
@@ -691,10 +1366,23 @@ function handleCopilotEvent(state, event) {
 // ── Cancel ──────────────────────────────────────────────────────────────────
 export function cancelCopilotExecution(conversationId) {
     const state = conversations.get(conversationId);
+    cancelPendingCopilotDecisions(conversationId);
     if (!state) {
         emitCopilotCancelled(conversationId);
         return;
     }
+    state.deferredCommandUsage = null;
+    if (state.commandRuntime && state.commandSessionId) {
+        const cancellation = state.isCompacting
+            ? state.commandRuntime.abortManualCompaction(state.commandSessionId)
+            : state.commandRuntime.abort(state.commandSessionId);
+        state.isCompacting = false;
+        void cancellation.catch(() => { });
+        if (state.turnActive)
+            finishCopilotTurn(state);
+        emitCopilotCancelled(conversationId, state);
+        return;
+    }
     if (!state.child) {
         if (state.turnActive) {
             finishCopilotTurn(state);
@@ -723,7 +1411,7 @@ function cleanupCopilotConversation(conversationId) {
     const state = conversations.get(conversationId);
     if (!state)
         return;
-    if (state.child) {
+    if (state.child || state.commandRuntime) {
         cancelCopilotExecution(conversationId);
     }
     if (state.heartbeatTimer) {
@@ -1034,6 +1722,37 @@ export function readCopilotSessionMessages(_workDir, sessionId) {
     }
     return messages;
 }
+export function readCopilotSessionMode(sessionId) {
+    const sessionRoot = resolve(COPILOT_SESSION_DIR);
+    const sessionDir = resolve(COPILOT_SESSION_DIR, sessionId);
+    if (sessionDir === sessionRoot || !sessionDir.startsWith(`${sessionRoot}${process.platform === 'win32' ? '\\' : '/'}`)) {
+        return 'interactive';
+    }
+    const eventsPath = join(sessionDir, 'events.jsonl');
+    if (!existsSync(eventsPath))
+        return 'interactive';
+    let mode = 'interactive';
+    try {
+        for (const line of readFileSync(eventsPath, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                const nextMode = event.type === 'session.mode_changed' ? event.data?.newMode : undefined;
+                if (nextMode === 'interactive' || nextMode === 'plan' || nextMode === 'autopilot') {
+                    mode = nextMode;
+                }
+            }
+            catch {
+                // Ignore partial or malformed history lines.
+            }
+        }
+    }
+    catch {
+        return 'interactive';
+    }
+    return mode;
+}
 export function getCopilotSessionWorkDir(sessionId) {
     const sessionRoot = resolve(COPILOT_SESSION_DIR);
     const sessionDir = resolve(COPILOT_SESSION_DIR, sessionId);