cli-copilot-worker 0.1.0

package/dist/src/daemon/service.js

@@ -0,0 +1,800 @@
+import { unlink, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { approveAll } from '@github/copilot-sdk';
+import { buildAuthenticatedClient } from '../core/copilot.js';
+import { classifyCopilotStartupFailure, classifySessionErrorEvent } from '../core/failure-classifier.js';
+import { ensureStateRoot } from '../core/paths.js';
+import { ProfileFaultPlanner } from '../core/profile-faults.js';
+import { ProfileManager } from '../core/profile-manager.js';
+import { QuestionRegistry } from '../core/question-registry.js';
+import { PersistentStore } from '../core/store.js';
+const DEFAULT_MODEL = 'gpt-5.4';
+const DEFAULT_TIMEOUT_MS = 300_000;
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function applyDetail(entry, detail) {
+    if (detail === 'full') {
+        return entry;
+    }
+    if (detail === 'meta') {
+        return { ...entry, content: '' };
+    }
+    const limit = detail === 'verbose' ? 2000 : 500;
+    return {
+        ...entry,
+        content: entry.content.length > limit
+            ? `${entry.content.slice(0, limit)}...`
+            : entry.content,
+    };
+}
+export class CliCopilotWorkerService {
+    store = new PersistentStore();
+    activeExecutions = new Map();
+    clients = new Map();
+    profileManager;
+    faultPlanner;
+    createAuthenticatedClient = buildAuthenticatedClient;
+    questionRegistry = new QuestionRegistry(this.store, (conversationId, event, data) => {
+        const execution = this.activeExecutions.get(conversationId);
+        execution?.writer?.event(event, data);
+        if (event === 'question') {
+            execution?.signalWaitingAnswer?.();
+            execution?.resolveDone({
+                status: 'waiting_answer',
+                job: this.store.getJob(execution.jobId),
+                conversation: this.store.getConversation(conversationId),
+            });
+        }
+    });
+    async initialize() {
+        await this.store.load();
+        this.profileManager = ProfileManager.fromEnvironment(this.store.getProfiles());
+        this.faultPlanner = ProfileFaultPlanner.fromEnvironment();
+        this.store.setProfiles(this.profileManager.toPersistedState());
+        await this.store.persist();
+    }
+    async ping() {
+        return {
+            status: 'ok',
+            conversations: this.store.listConversations().length,
+            jobs: this.store.listJobs().length,
+        };
+    }
+    async daemonStatus() {
+        const { daemonMetaPath, socketPath } = ensureStateRoot();
+        return {
+            status: 'running',
+            socketPath,
+            daemonMetaPath,
+            profiles: this.profileManager.getProfiles(),
+            conversations: this.store.listConversations().length,
+            running: this.store.listJobs().filter((job) => job.status === 'running' || job.status === 'waiting_answer').length,
+        };
+    }
+    async shutdown() {
+        for (const execution of this.activeExecutions.values()) {
+            await execution.session.abort().catch(() => { });
+            await execution.session.disconnect().catch(() => { });
+            await execution.client.stop().catch(async () => {
+                await execution.client.forceStop().catch(() => { });
+            });
+        }
+        this.activeExecutions.clear();
+        for (const client of this.clients.values()) {
+            await client.stop().catch(async () => {
+                await client.forceStop().catch(() => { });
+            });
+        }
+        this.clients.clear();
+        const { daemonMetaPath, socketPath } = ensureStateRoot();
+        if (existsSync(daemonMetaPath)) {
+            await unlink(daemonMetaPath).catch(() => { });
+        }
+        if (existsSync(socketPath)) {
+            await unlink(socketPath).catch(() => { });
+        }
+        return { status: 'stopped' };
+    }
+    async run(args, writer) {
+        const conversation = this.store.createConversation({
+            cwd: args.cwd,
+            model: args.model ?? DEFAULT_MODEL,
+        });
+        const job = this.store.createJob({
+            conversationId: conversation.id,
+            kind: 'run',
+            inputFilePath: args.inputFilePath,
+        });
+        await this.persistState();
+        return await this.executeJob({
+            conversation,
+            job,
+            content: args.content,
+            async: args.async ?? false,
+            timeoutMs: args.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            writer,
+        });
+    }
+    async send(args, writer) {
+        const conversation = this.store.resolveConversation(args.conversationId);
+        if (!conversation) {
+            throw new Error(`Conversation not found: ${args.conversationId}`);
+        }
+        if (conversation.status === 'running' || conversation.status === 'waiting_answer') {
+            throw new Error(`Conversation ${conversation.id} is busy`);
+        }
+        const job = this.store.createJob({
+            conversationId: conversation.id,
+            kind: 'send',
+            inputFilePath: args.inputFilePath,
+        });
+        await this.persistState();
+        return await this.executeJob({
+            conversation,
+            job,
+            content: args.content,
+            async: args.async ?? false,
+            timeoutMs: args.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            writer,
+        });
+    }
+    async answer(args) {
+        const conversation = this.store.resolveConversation(args.conversationId);
+        if (!conversation) {
+            throw new Error(`Conversation not found: ${args.conversationId}`);
+        }
+        const result = this.questionRegistry.submitAnswer(conversation.id, args.content);
+        if (!result.success) {
+            throw new Error(result.error);
+        }
+        await this.persistState();
+        return {
+            conversationId: conversation.id,
+            answer: result.resolvedAnswer,
+            status: 'submitted',
+        };
+    }
+    async read(args) {
+        const conversation = this.store.resolveConversation(args.conversationId);
+        if (!conversation) {
+            throw new Error(`Conversation not found: ${args.conversationId}`);
+        }
+        const lastJob = conversation.lastJobId ? this.store.getJob(conversation.lastJobId) : undefined;
+        const transcript = await this.store.readTranscript(conversation.id);
+        const detail = args.detail ?? 'standard';
+        let entries = transcript;
+        if (args.after !== undefined) {
+            entries = entries.filter((entry) => entry.index > args.after);
+        }
+        if (args.before !== undefined) {
+            entries = entries.filter((entry) => entry.index < args.before);
+        }
+        const start = args.from ?? (entries[0]?.index ?? 1);
+        const end = args.to ?? (entries[entries.length - 1]?.index ?? start);
+        entries = entries.filter((entry) => entry.index >= start && entry.index <= end);
+        const budget = args.tokens ?? 4000;
+        let spent = 0;
+        const sliced = [];
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = applyDetail(entries[index], detail);
+            const cost = estimateTokens(entry.content || JSON.stringify(entry.data ?? {})) + 4;
+            if (sliced.length > 0 && spent + cost > budget) {
+                break;
+            }
+            sliced.unshift(entry);
+            spent += cost;
+        }
+        return {
+            conversation: {
+                id: conversation.id,
+                status: conversation.status,
+                cwd: conversation.cwd,
+                model: conversation.model,
+                pendingQuestion: conversation.pendingQuestion,
+                lastJobId: conversation.lastJobId,
+            },
+            meta: {
+                totalEntries: transcript.length,
+                returnedEntries: sliced.length,
+                tokenBudget: budget,
+                approxTokens: spent,
+                nextActions: {
+                    send: `cli-copilot-worker send ${conversation.id} prompt.md`,
+                    answer: conversation.pendingQuestion ? `cli-copilot-worker answer ${conversation.id} answer.md` : null,
+                },
+            },
+            attempts: lastJob?.attempts ?? [],
+            entries: sliced,
+        };
+    }
+    async list() {
+        return {
+            conversations: this.store.listConversations().map((conversation) => ({
+                id: conversation.id,
+                status: conversation.status,
+                cwd: conversation.cwd,
+                model: conversation.model,
+                updatedAt: conversation.updatedAt,
+                pendingQuestion: conversation.pendingQuestion?.question,
+            })),
+        };
+    }
+    async info(conversationId) {
+        const conversation = this.store.resolveConversation(conversationId);
+        if (!conversation) {
+            throw new Error(`Conversation not found: ${conversationId}`);
+        }
+        const jobs = this.store.jobsForConversation(conversation.id);
+        return {
+            conversation,
+            jobs,
+        };
+    }
+    async jobList() {
+        return {
+            jobs: this.store.listJobs(),
+        };
+    }
+    async jobStatus(jobId) {
+        const job = this.store.getJob(jobId);
+        if (!job) {
+            throw new Error(`Job not found: ${jobId}`);
+        }
+        const conversation = this.store.getConversation(job.conversationId);
+        return {
+            job,
+            attempts: job.attempts,
+            activeProfileId: conversation?.profileId,
+            activeProfileConfigDir: conversation?.profileConfigDir,
+            actions: this.buildJobActions(job),
+        };
+    }
+    async jobRead(jobId) {
+        const job = this.store.getJob(jobId);
+        if (!job) {
+            throw new Error(`Job not found: ${jobId}`);
+        }
+        const conversation = this.store.getConversation(job.conversationId);
+        if (!conversation) {
+            throw new Error(`Conversation not found: ${job.conversationId}`);
+        }
+        const transcript = await this.store.readTranscript(conversation.id);
+        const entries = transcript.filter((entry) => {
+            if (entry.index < job.startEntryIndex) {
+                return false;
+            }
+            if (job.endEntryIndex !== undefined && entry.index > job.endEntryIndex) {
+                return false;
+            }
+            return true;
+        });
+        return {
+            job,
+            attempts: job.attempts,
+            activeProfileId: conversation.profileId,
+            activeProfileConfigDir: conversation.profileConfigDir,
+            entries,
+        };
+    }
+    async jobWait(args) {
+        const timeoutMs = (args.timeoutSeconds ?? 300) * 1000;
+        const intervalMs = (args.intervalSeconds ?? 2) * 1000;
+        const started = Date.now();
+        while (true) {
+            const job = this.store.getJob(args.jobId);
+            if (!job) {
+                throw new Error(`Job not found: ${args.jobId}`);
+            }
+            if (job.status !== 'running') {
+                return {
+                    job,
+                    actions: this.buildJobActions(job),
+                };
+            }
+            if (Date.now() - started > timeoutMs) {
+                throw new Error(`Job ${args.jobId} did not complete within ${args.timeoutSeconds ?? 300}s`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    async jobCancel(jobId) {
+        const job = this.store.getJob(jobId);
+        if (!job) {
+            throw new Error(`Job not found: ${jobId}`);
+        }
+        const execution = this.activeExecutions.get(job.conversationId);
+        if (execution) {
+            if (execution.attempt.outcome === 'running') {
+                this.store.finalizeJobAttempt(execution.attempt, {
+                    outcome: 'failed',
+                    endedAt: new Date().toISOString(),
+                    failureMessage: 'Job cancelled.',
+                });
+            }
+            await execution.session.abort().catch(() => { });
+            await execution.session.disconnect().catch(() => { });
+            await execution.client.stop().catch(async () => {
+                await execution.client.forceStop().catch(() => { });
+            });
+            this.activeExecutions.delete(job.conversationId);
+        }
+        this.store.finalizeJob(job.id, 'cancelled');
+        this.store.updateConversation(job.conversationId, {
+            status: 'cancelled',
+        });
+        await this.store.appendTranscript({
+            conversationId: job.conversationId,
+            jobId: job.id,
+            role: 'status',
+            content: 'Job cancelled.',
+        });
+        await this.persistState();
+        return {
+            job: this.store.getJob(job.id),
+        };
+    }
+    async executeJob(input) {
+        const completion = this.startExecution(input);
+        if (input.async) {
+            return {
+                conversationId: input.conversation.id,
+                jobId: input.job.id,
+                status: 'running',
+                attempts: input.job.attempts,
+                activeProfileId: input.conversation.profileId,
+                activeProfileConfigDir: input.conversation.profileConfigDir,
+                actions: this.buildJobActions(input.job),
+            };
+        }
+        const result = await completion;
+        return {
+            conversationId: result.conversation.id,
+            jobId: result.job.id,
+            status: result.status,
+            attempts: result.job.attempts,
+            activeProfileId: result.conversation.profileId,
+            activeProfileConfigDir: result.conversation.profileConfigDir,
+            pendingQuestion: result.conversation.pendingQuestion,
+            actions: this.buildConversationActions(result.conversation),
+        };
+    }
+    startExecution(input) {
+        const done = new Promise((resolve, reject) => {
+            void this.executeInBackground(input, resolve, reject);
+        });
+        return done;
+    }
+    async executeInBackground(input, resolveDone, rejectDone) {
+        const conversation = this.store.getConversation(input.conversation.id);
+        const job = this.store.getJob(input.job.id);
+        await this.store.appendTranscript({
+            conversationId: conversation.id,
+            jobId: job.id,
+            role: 'user',
+            content: input.content,
+            data: {
+                inputFilePath: job.inputFilePath,
+                kind: job.kind,
+            },
+        });
+        input.writer?.event('status', {
+            message: `Running ${job.kind} on ${conversation.id}`,
+        });
+        const profiles = this.planProfiles(conversation);
+        if (profiles.length === 0) {
+            const failure = classifyCopilotStartupFailure(new Error('No eligible Copilot profiles are available. All configured profiles are cooling down or unavailable.'));
+            await this.finalizeJobFailure(job.id, conversation.id, failure.message);
+            rejectDone(new Error(failure.message));
+            return;
+        }
+        for (let index = 0; index < profiles.length; index += 1) {
+            const profile = profiles[index];
+            const attempt = this.store.createJobAttempt(job.id, profile);
+            const attemptLabel = `profile ${profile.id} (${profile.configDir})`;
+            this.store.updateConversation(conversation.id, {
+                status: 'running',
+                profileId: profile.id,
+                profileConfigDir: profile.configDir,
+            });
+            await this.store.appendTranscript({
+                conversationId: conversation.id,
+                jobId: job.id,
+                role: 'status',
+                content: index === 0
+                    ? `Using ${attemptLabel}.`
+                    : `Switching to ${attemptLabel}.`,
+            });
+            input.writer?.event('status', {
+                message: index === 0
+                    ? `Using ${attemptLabel}`
+                    : `Switching to ${attemptLabel}`,
+            });
+            await this.persistState();
+            const outcome = await this.startProfileAttempt({
+                conversation,
+                job,
+                attempt,
+                profile,
+                content: input.content,
+                timeoutMs: input.timeoutMs,
+                writer: input.writer,
+                resolveDone,
+                rejectDone,
+            });
+            if (outcome.kind === 'completed' || outcome.kind === 'waiting_answer') {
+                return;
+            }
+            this.profileManager.markFailure(profile.id, outcome.failure.category, outcome.failure.message);
+            await this.persistState();
+            const nextProfile = profiles[index + 1];
+            if (outcome.failure.retryable && nextProfile) {
+                const switchMessage = `Profile ${profile.id} failed with ${outcome.failure.category}; switching to ${nextProfile.id}.`;
+                await this.store.appendTranscript({
+                    conversationId: conversation.id,
+                    jobId: job.id,
+                    role: 'status',
+                    content: switchMessage,
+                });
+                input.writer?.event('status', { message: switchMessage });
+                await this.persistState();
+                continue;
+            }
+            await this.finalizeJobFailure(job.id, conversation.id, outcome.failure.message);
+            rejectDone(new Error(outcome.failure.message));
+            return;
+        }
+    }
+    async startProfileAttempt(input) {
+        const injectedFault = this.faultPlanner.takeFault(input.profile);
+        if (injectedFault) {
+            const failure = classifySessionErrorEvent({
+                errorType: injectedFault.errorType,
+                message: injectedFault.message ?? `Injected ${injectedFault.category} failure`,
+                statusCode: injectedFault.statusCode,
+            });
+            await this.recordAttemptFailure({
+                conversationId: input.conversation.id,
+                jobId: input.job.id,
+                attempt: input.attempt,
+                failure,
+            });
+            input.writer?.event('error', { message: failure.message });
+            return { kind: 'failed', failure };
+        }
+        let client;
+        let clientKey;
+        try {
+            const clientResult = await this.getOrCreateClient(input.conversation.cwd, input.profile);
+            client = clientResult.client;
+            clientKey = clientResult.clientKey;
+            const session = input.conversation.hasStarted
+                ? await client.resumeSession(input.conversation.sessionId, {
+                    onPermissionRequest: approveAll,
+                    onUserInputRequest: (request, invocation) => this.questionRegistry.register({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        sessionId: invocation.sessionId,
+                        question: request.question,
+                        choices: request.choices,
+                        allowFreeform: request.allowFreeform,
+                    }),
+                    streaming: true,
+                })
+                : await client.createSession({
+                    sessionId: input.conversation.sessionId,
+                    model: input.conversation.model,
+                    onPermissionRequest: approveAll,
+                    onUserInputRequest: (request, invocation) => this.questionRegistry.register({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        sessionId: invocation.sessionId,
+                        question: request.question,
+                        choices: request.choices,
+                        allowFreeform: request.allowFreeform,
+                    }),
+                    streaming: true,
+                });
+            this.store.updateConversation(input.conversation.id, {
+                status: 'running',
+                hasStarted: true,
+                profileId: input.profile.id,
+                profileConfigDir: input.profile.configDir,
+            });
+            const activeClient = client;
+            const activeClientKey = clientKey;
+            return await new Promise((resolve) => {
+                let finished = false;
+                let waitingForAnswer = false;
+                let startResolved = false;
+                let timeout;
+                const resolveStart = (result) => {
+                    if (startResolved) {
+                        return;
+                    }
+                    startResolved = true;
+                    resolve(result);
+                };
+                const cleanup = async (dropClient) => {
+                    await session.disconnect().catch(() => { });
+                    this.activeExecutions.delete(input.conversation.id);
+                    if (dropClient) {
+                        await activeClient.stop().catch(async () => {
+                            await activeClient.forceStop().catch(() => { });
+                        });
+                        this.clients.delete(activeClientKey);
+                    }
+                };
+                const finalizeFailure = async (failure, finalAfterQuestion) => {
+                    if (finished) {
+                        return;
+                    }
+                    finished = true;
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    input.writer?.event('error', { message: failure.message });
+                    await this.recordAttemptFailure({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        attempt: input.attempt,
+                        failure,
+                    });
+                    await cleanup(true);
+                    if (finalAfterQuestion) {
+                        await this.finalizeJobFailure(input.job.id, input.conversation.id, failure.message);
+                        input.rejectDone(new Error(failure.message));
+                    }
+                    else {
+                        resolveStart({ kind: 'failed', failure });
+                    }
+                };
+                const finalizeSuccess = async () => {
+                    if (finished) {
+                        return;
+                    }
+                    finished = true;
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    this.profileManager.markSuccess(input.profile.id);
+                    this.store.finalizeJobAttempt(input.attempt, {
+                        outcome: 'completed',
+                        endedAt: new Date().toISOString(),
+                    });
+                    const updatedJob = this.store.finalizeJob(input.job.id, 'completed');
+                    updatedJob.endEntryIndex = this.store.getConversation(input.conversation.id)?.nextEntryIndex ?? updatedJob.endEntryIndex;
+                    this.store.updateConversation(input.conversation.id, {
+                        status: 'idle',
+                        lastError: undefined,
+                        profileId: input.profile.id,
+                        profileConfigDir: input.profile.configDir,
+                    });
+                    await this.store.appendTranscript({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        role: 'status',
+                        content: 'Session is idle.',
+                    });
+                    await this.persistState();
+                    await cleanup(false);
+                    input.resolveDone({
+                        status: 'completed',
+                        job: updatedJob,
+                        conversation: this.store.getConversation(input.conversation.id),
+                    });
+                    resolveStart({ kind: 'completed' });
+                };
+                this.activeExecutions.set(input.conversation.id, {
+                    conversationId: input.conversation.id,
+                    jobId: input.job.id,
+                    attempt: input.attempt,
+                    profile: input.profile,
+                    session,
+                    client: activeClient,
+                    writer: input.writer,
+                    resolveDone: input.resolveDone,
+                    rejectDone: input.rejectDone,
+                    signalWaitingAnswer: () => {
+                        waitingForAnswer = true;
+                        resolveStart({ kind: 'waiting_answer' });
+                    },
+                });
+                session.on('assistant.message_delta', (event) => {
+                    input.writer?.event('assistant.delta', {
+                        text: event.data.deltaContent,
+                    });
+                });
+                session.on('assistant.message', (event) => {
+                    void this.store.appendTranscript({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        role: 'assistant',
+                        content: event.data.content,
+                    });
+                });
+                session.on('tool.execution_start', (event) => {
+                    input.writer?.event('tool.start', {
+                        toolName: event.data.toolName,
+                    });
+                    void this.store.appendTranscript({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        role: 'tool_use',
+                        content: event.data.toolName,
+                    });
+                });
+                session.on('tool.execution_complete', (event) => {
+                    const label = 'toolName' in event.data ? event.data.toolName : event.data.toolCallId;
+                    input.writer?.event('tool.complete', {
+                        toolName: label,
+                        success: event.data.success,
+                    });
+                    void this.store.appendTranscript({
+                        conversationId: input.conversation.id,
+                        jobId: input.job.id,
+                        role: 'tool_result',
+                        content: `${label} success=${String(event.data.success)}`,
+                    });
+                });
+                session.on('session.error', (event) => {
+                    void finalizeFailure(classifySessionErrorEvent({
+                        errorType: event.data.errorType,
+                        message: event.data.message,
+                        statusCode: event.data.statusCode,
+                    }), waitingForAnswer);
+                });
+                session.on('session.idle', () => {
+                    void finalizeSuccess();
+                });
+                timeout = setTimeout(() => {
+                    void finalizeFailure(classifyCopilotStartupFailure(new Error(`Timed out after ${input.timeoutMs}ms.`)), waitingForAnswer);
+                }, input.timeoutMs);
+                timeout.unref();
+                void this.persistState()
+                    .then(async () => {
+                    await session.send({ prompt: input.content });
+                })
+                    .catch((error) => {
+                    void finalizeFailure(classifyCopilotStartupFailure(error), waitingForAnswer);
+                });
+            });
+        }
+        catch (error) {
+            const failure = classifyCopilotStartupFailure(error);
+            await this.recordAttemptFailure({
+                conversationId: input.conversation.id,
+                jobId: input.job.id,
+                attempt: input.attempt,
+                failure,
+            });
+            if (client && clientKey) {
+                await this.disposeClient(clientKey, client);
+            }
+            return { kind: 'failed', failure };
+        }
+    }
+    planProfiles(conversation) {
+        const eligible = this.profileManager.getCandidateProfiles();
+        if (!conversation.profileConfigDir && !conversation.profileId) {
+            return eligible;
+        }
+        const prioritized = [];
+        const seen = new Set();
+        const push = (profile) => {
+            if (!profile || seen.has(profile.configDir)) {
+                return;
+            }
+            prioritized.push(profile);
+            seen.add(profile.configDir);
+        };
+        push(eligible.find((profile) => ((conversation.profileId && profile.id === conversation.profileId)
+            || (conversation.profileConfigDir && profile.configDir === conversation.profileConfigDir))));
+        eligible.forEach((profile) => push(profile));
+        return prioritized;
+    }
+    async getOrCreateClient(cwd, profile) {
+        const clientKey = `${cwd}:${profile.configDir}`;
+        let client = this.clients.get(clientKey);
+        if (!client) {
+            client = await this.createAuthenticatedClient({
+                cwd,
+                profile,
+            });
+            this.clients.set(clientKey, client);
+        }
+        return { client, clientKey };
+    }
+    async disposeClient(clientKey, client) {
+        await client.stop().catch(async () => {
+            await client.forceStop().catch(() => { });
+        });
+        this.clients.delete(clientKey);
+    }
+    async recordAttemptFailure(input) {
+        this.store.finalizeJobAttempt(input.attempt, {
+            outcome: 'failed',
+            endedAt: new Date().toISOString(),
+            failureCategory: input.failure.category,
+            failureMessage: input.failure.message,
+            sessionErrorType: input.failure.sessionErrorType,
+            sessionStatusCode: input.failure.sessionStatusCode,
+        });
+        await this.store.appendTranscript({
+            conversationId: input.conversationId,
+            jobId: input.jobId,
+            role: 'error',
+            content: input.failure.message,
+            data: {
+                failureCategory: input.failure.category,
+                sessionErrorType: input.failure.sessionErrorType,
+                sessionStatusCode: input.failure.sessionStatusCode,
+            },
+        });
+    }
+    async finalizeJobFailure(jobId, conversationId, message) {
+        const updatedJob = this.store.finalizeJob(jobId, 'failed', message);
+        updatedJob.endEntryIndex = this.store.getConversation(conversationId)?.nextEntryIndex ?? updatedJob.endEntryIndex;
+        this.store.updateConversation(conversationId, {
+            status: 'failed',
+            lastError: message,
+        });
+        await this.store.appendTranscript({
+            conversationId,
+            jobId,
+            role: 'status',
+            content: `Job failed: ${message}`,
+        });
+        await this.persistState();
+    }
+    buildConversationActions(conversation) {
+        return {
+            read: `cli-copilot-worker read ${conversation.id}`,
+            send: conversation.status === 'idle' ? `cli-copilot-worker send ${conversation.id} prompt.md` : null,
+            answer: conversation.pendingQuestion ? `cli-copilot-worker answer ${conversation.id} answer.md` : null,
+            info: `cli-copilot-worker info ${conversation.id}`,
+        };
+    }
+    buildJobActions(job) {
+        return {
+            status: `cli-copilot-worker job status ${job.id}`,
+            wait: job.status === 'running' ? `cli-copilot-worker job wait ${job.id}` : null,
+            read: `cli-copilot-worker job read ${job.id}`,
+            answer: job.status === 'waiting_answer'
+                ? `cli-copilot-worker answer ${job.conversationId} answer.md`
+                : null,
+            cancel: job.status === 'running' || job.status === 'waiting_answer'
+                ? `cli-copilot-worker job cancel ${job.id}`
+                : null,
+        };
+    }
+    async writeDaemonMeta(socketPath, token) {
+        await writeFile(ensureStateRoot().daemonMetaPath, JSON.stringify({
+            pid: process.pid,
+            socketPath,
+            token,
+            startedAt: new Date().toISOString(),
+        }, null, 2));
+    }
+    async persistState() {
+        this.store.setProfiles(this.profileManager.toPersistedState());
+        await this.store.persist();
+    }
+    resolveProfile(conversation) {
+        if (conversation.profileConfigDir && conversation.profileId) {
+            const match = this.profileManager
+                .getProfiles()
+                .find((profile) => profile.id === conversation.profileId || profile.configDir === conversation.profileConfigDir);
+            if (match) {
+                return match;
+            }
+            return {
+                id: conversation.profileId,
+                configDir: conversation.profileConfigDir,
+                failureCount: 0,
+            };
+        }
+        return this.profileManager.getCurrentProfile();
+    }
+}
+//# sourceMappingURL=service.js.map