@agent-link/agent 0.1.334 → 0.1.336

package/dist/copilot.js

@@ -10,18 +10,16 @@
  */
 import { spawn } from 'child_process';
 import { createInterface } from 'readline';
-import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdirSync } from 'fs';
+import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdirSync, statSync } from 'fs';
 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();
@@ -29,24 +27,6 @@ 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',
@@ -80,107 +60,6 @@ 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;
@@ -254,18 +133,10 @@ 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({
@@ -334,10 +205,6 @@ 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;
         }
     }
@@ -362,13 +229,6 @@ 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) {
@@ -383,7 +243,7 @@ export function restartCopilotConversation(conversationId, opts) {
         child: null,
         abortController: null,
         copilotSessionId: null,
-        lastCopilotSessionId: opts?.preserveSession === false ? null : copilotSessionId,
+        lastCopilotSessionId: copilotSessionId,
         workDir: state?.workDir || process.cwd(),
         turnActive: false,
         providerId: opts?.providerId || state?.providerId || 'copilot',
@@ -394,13 +254,6 @@ 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 };
 }
@@ -414,459 +267,6 @@ 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)
@@ -943,30 +343,26 @@ 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;
-    const providerChanged = !!options?.providerId && state.providerId !== options.providerId;
-    if (options?.providerId)
-        detachCopilotProviderSession(state, options.providerId);
+    if (options?.providerId) {
+        state.providerId = options.providerId;
+    }
     // Determine session to resume
-    const resumeId = providerChanged
-        ? null
-        : options?.resumeSessionId
-            || state.copilotSessionId
-            || state.lastCopilotSessionId;
+    const resumeId = 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);
@@ -978,19 +374,6 @@ 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);
@@ -1111,20 +494,7 @@ 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}`;
@@ -1202,44 +572,6 @@ 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) {
@@ -1330,15 +662,8 @@ function handleCopilotEvent(state, event) {
                 state.copilotSessionId = sessionId;
                 state.lastCopilotSessionId = sessionId;
             }
-            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);
+            const usage = buildCopilotUsage(state, event.usage);
             // Emit backend_event turn_completed
             sendFn({
                 type: 'backend_event',
@@ -1366,23 +691,10 @@ 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);
@@ -1411,7 +723,7 @@ function cleanupCopilotConversation(conversationId) {
     const state = conversations.get(conversationId);
     if (!state)
         return;
-    if (state.child || state.commandRuntime) {
+    if (state.child) {
         cancelCopilotExecution(conversationId);
     }
     if (state.heartbeatTimer) {
@@ -1553,8 +865,8 @@ const copilotWorkspaceCache = new FileCache({
     ttlMs: 0,
     debug: false,
 });
-function listCopilotWorkspaceFiles() {
-    if (!existsSync(COPILOT_SESSION_DIR))
+function listCopilotWorkspaceFiles(strictReadErrors = false) {
+    if (!strictReadErrors && !existsSync(COPILOT_SESSION_DIR))
         return [];
     try {
         const dirs = readdirSync(COPILOT_SESSION_DIR, { withFileTypes: true });
@@ -1563,24 +875,42 @@ function listCopilotWorkspaceFiles() {
             if (!dir.isDirectory())
                 continue;
             const wsPath = join(COPILOT_SESSION_DIR, dir.name, 'workspace.yaml');
-            if (existsSync(wsPath))
+            if (strictReadErrors) {
+                try {
+                    statSync(wsPath);
+                    files.push(wsPath);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+            else if (existsSync(wsPath)) {
                 files.push(wsPath);
+            }
         }
         return files;
     }
-    catch {
+    catch (error) {
+        if (strictReadErrors && error.code !== 'ENOENT')
+            throw error;
         return [];
     }
 }
-function getCopilotSessionEntries(workDir) {
+function getCopilotSessionEntries(workDir, strictReadErrors = false) {
     const normalizedWorkDir = workDir ? normalizeCursorPath(workDir) : '';
     const entries = [];
-    for (const wsPath of listCopilotWorkspaceFiles()) {
+    for (const wsPath of listCopilotWorkspaceFiles(strictReadErrors)) {
         const parsed = copilotWorkspaceCache.get(wsPath);
+        if (!parsed && strictReadErrors)
+            throw new Error('Unable to read Copilot session workspace metadata');
         if (!parsed)
             continue;
-        if (normalizedWorkDir && normalizeCursorPath(parsed.projectPath) !== normalizedWorkDir)
+        if (workDir !== undefined && (!parsed.projectPath || normalizeCursorPath(parsed.projectPath) !== normalizedWorkDir))
             continue;
+        if (strictReadErrors && parsed.sessionId !== basename(dirname(wsPath))) {
+            throw new Error('Copilot session ID does not match its workspace directory');
+        }
         entries.push({
             session: parsed,
             sortKey: {
@@ -1593,11 +923,11 @@ function getCopilotSessionEntries(workDir) {
     entries.sort((a, b) => compareCursorSortKeys(a.sortKey, b.sortKey));
     return entries;
 }
-export function listCopilotSessions(workDir) {
-    return listCopilotSessionsPage(workDir, { limit: Number.POSITIVE_INFINITY }).sessions;
+export function listCopilotSessions(workDir, options = {}) {
+    return listCopilotSessionsPage(workDir, { ...options, limit: Number.POSITIVE_INFINITY }).sessions;
 }
 export function listCopilotSessionsPage(workDir, options = {}) {
-    const entries = getCopilotSessionEntries(workDir);
+    const entries = getCopilotSessionEntries(workDir, options.strictReadErrors);
     const limit = normalizeSessionLimit(options.limit);
     let startIndex = 0;
     if (options.cursor) {
@@ -1623,9 +953,9 @@ export function listCopilotSessionsPage(workDir, options = {}) {
     };
 }
 // ── Session history ────────────────────────────────────────────────────────
-export function readCopilotSessionMessages(_workDir, sessionId) {
+export function readCopilotSessionMessages(_workDir, sessionId, options = {}) {
     const eventsPath = join(COPILOT_SESSION_DIR, sessionId, 'events.jsonl');
-    if (!existsSync(eventsPath))
+    if (!options.strictReadErrors && !existsSync(eventsPath))
         return [];
     const messages = [];
     try {
@@ -1717,42 +1047,13 @@ export function readCopilotSessionMessages(_workDir, sessionId) {
             }
         }
     }
-    catch {
-        // File not readable
+    catch (error) {
+        if (options.strictReadErrors)
+            throw error;
+        // Legacy history reads tolerate unreadable files.
     }
     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);