vibe-coding-master 0.0.9 → 0.0.10

package/dist/backend/services/task-service.js

@@ -8,8 +8,13 @@ export function createTaskService(deps) {
             assertValidTaskSlug(input.taskSlug);
             const config = await deps.projectService.loadConfig(repoRoot);
             const taskPath = getTaskPath(repoRoot, config.stateRoot, input.taskSlug);
-            const branch = `feature/${input.taskSlug}`;
-            const worktreePath = getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug);
+            const shouldCreateWorktree = input.createWorktree !== false;
+            const taskBranch = shouldCreateWorktree
+                ? `feature/${input.taskSlug}`
+                : await deps.git.getCurrentBranch(repoRoot);
+            const worktreePath = shouldCreateWorktree
+                ? getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug)
+                : undefined;
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
                     code: "TASK_EXISTS",
@@ -17,22 +22,6 @@ export function createTaskService(deps) {
                     statusCode: 409
                 });
             }
-            if (await deps.git.branchExists(repoRoot, branch)) {
-                throw new VcmError({
-                    code: "TASK_BRANCH_EXISTS",
-                    message: `Task branch already exists: ${branch}`,
-                    statusCode: 409,
-                    hint: "Choose a different task name or clean up the existing branch."
-                });
-            }
-            if (await deps.fs.pathExists(worktreePath)) {
-                throw new VcmError({
-                    code: "TASK_WORKTREE_EXISTS",
-                    message: `Task worktree already exists: ${worktreePath}`,
-                    statusCode: 409,
-                    hint: "Choose a different task name or clean up the existing worktree."
-                });
-            }
             if (!(await deps.git.isIgnored(repoRoot, `${config.stateRoot}/tasks/.probe`))) {
                 throw new VcmError({
                     code: "VCM_STATE_NOT_IGNORED",
@@ -41,23 +30,42 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore contains the VCM managed block."
                 });
             }
-            const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
-            if (baseStatus.trim()) {
-                throw new VcmError({
-                    code: "BASE_REPO_DIRTY",
-                    message: "The connected repository has uncommitted changes.",
-                    statusCode: 409,
-                    hint: "Commit, stash, or discard base repository changes before creating a task worktree."
+            if (shouldCreateWorktree && worktreePath) {
+                if (await deps.git.branchExists(repoRoot, taskBranch)) {
+                    throw new VcmError({
+                        code: "TASK_BRANCH_EXISTS",
+                        message: `Task branch already exists: ${taskBranch}`,
+                        statusCode: 409,
+                        hint: "Choose a different task name or clean up the existing branch."
+                    });
+                }
+                if (await deps.fs.pathExists(worktreePath)) {
+                    throw new VcmError({
+                        code: "TASK_WORKTREE_EXISTS",
+                        message: `Task worktree already exists: ${worktreePath}`,
+                        statusCode: 409,
+                        hint: "Choose a different task name or clean up the existing worktree."
+                    });
+                }
+                const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
+                if (baseStatus.trim()) {
+                    throw new VcmError({
+                        code: "BASE_REPO_DIRTY",
+                        message: "The connected repository has uncommitted changes.",
+                        statusCode: 409,
+                        hint: "Commit, stash, or discard base repository changes before creating a task worktree."
+                    });
+                }
+                await deps.fs.ensureDir(path.dirname(worktreePath));
+                await deps.git.createWorktree({
+                    repoRoot,
+                    branch: taskBranch,
+                    worktreePath,
+                    baseRef: "HEAD"
                 });
             }
-            await deps.fs.ensureDir(path.dirname(worktreePath));
-            await deps.git.createWorktree({
-                repoRoot,
-                branch,
-                worktreePath,
-                baseRef: "HEAD"
-            });
             const timestamp = now();
+            const taskRepoRoot = worktreePath ?? repoRoot;
             const task = {
                 version: 1,
                 taskSlug: input.taskSlug,
@@ -66,19 +74,20 @@ export function createTaskService(deps) {
                 updatedAt: timestamp,
                 repoRoot,
                 worktreePath,
-                branch,
+                branch: taskBranch,
                 handoffDir: path.posix.join(config.handoffRoot, input.taskSlug),
                 status: "created",
                 specPath: input.specPath,
                 cleanupStatus: "active"
             };
+            await ensureTaskRuntimeStateDirs(deps.fs, taskRepoRoot, config.stateRoot);
             await deps.artifactService.ensureHandoffStructure({
-                repoRoot: worktreePath,
+                repoRoot: taskRepoRoot,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
             await deps.artifactService.createArtifactTemplates({
-                repoRoot: worktreePath,
+                repoRoot: taskRepoRoot,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
@@ -136,30 +145,23 @@ export function createTaskService(deps) {
             }
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await this.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const statePaths = getTaskStatePaths(repoRoot, taskRepoRoot, config.stateRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
             if (task.worktreePath) {
                 assertTaskWorktreePath(repoRoot, config.stateRoot, task.worktreePath);
-                const status = await deps.git.getStatusPorcelain(task.worktreePath);
-                if (status.trim() && !options.force) {
-                    throw new VcmError({
-                        code: "TASK_WORKTREE_DIRTY",
-                        message: `Task worktree has uncommitted changes: ${task.worktreePath}`,
-                        statusCode: 409,
-                        hint: "Commit, stash, or discard the task worktree changes before cleanup, or retry with force."
-                    });
-                }
-                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force });
-            }
-            for (const statePath of getTaskStatePaths(repoRoot, config.stateRoot, taskSlug)) {
-                await deps.fs.removePath(statePath, { force: true });
-                removedStatePaths.push(statePath);
+                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
             }
             let deletedBranch;
-            if (options.deleteBranch) {
-                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch });
+            if (task.worktreePath && (options.deleteBranch ?? true)) {
+                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
                 deletedBranch = task.branch;
             }
+            for (const statePath of statePaths) {
+                await deps.fs.removePath(statePath, { recursive: true, force: true });
+                removedStatePaths.push(statePath);
+            }
             return {
                 taskSlug,
                 removedWorktreePath: task.worktreePath,
@@ -179,12 +181,19 @@ function getTaskPath(repoRoot, stateRoot, taskSlug) {
 function getTaskWorktreePath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "worktrees", taskSlug);
 }
-function getTaskStatePaths(repoRoot, stateRoot, taskSlug) {
+async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "sessions"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "messages"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "orchestration"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
+}
+function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, taskSlug) {
     return [
-        path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`),
-        path.join(repoRoot, stateRoot, "sessions", `${taskSlug}.json`),
-        path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
-        path.join(repoRoot, stateRoot, "orchestration", `${taskSlug}.json`)
+        path.join(baseRepoRoot, stateRoot, "tasks", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "sessions", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
+        path.join(taskRepoRoot, stateRoot, "orchestration", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "translation", taskSlug)
     ];
 }
 function assertTaskWorktreePath(repoRoot, stateRoot, worktreePath) {

package/dist/backend/services/translation-service.js

@@ -1,11 +1,13 @@
+import path from "node:path";
 import { TRANSLATION_PROMPT_KEYS } from "../../shared/types/translation.js";
 import { TranslationProviderError } from "../adapters/translation-provider.js";
 import { VcmError } from "../errors.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { buildTranslationPrompt, getTranslationPromptPreviews, parseTranslationWarning } from "./translation-prompts.js";
 import { createTranslationQueueRegistry } from "./translation-queue.js";
 const DEFAULT_SETTINGS = {
     version: 1,
-    enabled: false,
+    enabled: true,
     providerType: "openai-compatible",
     baseUrl: "https://api.openai.com/v1",
     model: "gpt-4o-mini",
@@ -59,7 +61,10 @@ export function createTranslationService(deps) {
             state = {
                 listeners: new Set(),
                 seenTranscriptIds: new Set(),
-                entries: []
+                entries: [],
+                status: "ready",
+                events: [],
+                nextSeq: 1
             };
             sessionStates.set(sessionId, state);
         }
@@ -71,40 +76,154 @@ export function createTranslationService(deps) {
             listener(message);
         }
     }
-    async function handleTranscriptEvent(sessionId, event) {
+    function publishEntry(sessionId, entry) {
+        appendEvent(sessionId, { type: "entry", entry });
+        emit(sessionId, { type: "translation-entry", entry });
+    }
+    function publishStatus(sessionId, status) {
         const state = getState(sessionId);
-        if (state.seenTranscriptIds.has(event.id)) {
+        state.status = status;
+        appendEvent(sessionId, { type: "status", status });
+        emit(sessionId, { type: "translation-status", status });
+    }
+    function publishError(sessionId, message, id) {
+        const state = getState(sessionId);
+        state.status = "failed";
+        appendEvent(sessionId, { type: "error", id, message });
+        emit(sessionId, { type: "translation-error", id, message });
+    }
+    function appendEvent(sessionId, input) {
+        const state = getState(sessionId);
+        const event = {
+            ...input,
+            seq: state.nextSeq++,
+            createdAt: now()
+        };
+        state.events.push(event);
+        void persistEvents(state);
+        return event;
+    }
+    async function prepareCache(input) {
+        const state = getState(input.sessionId);
+        state.repoRoot = input.repoRoot;
+        state.taskSlug = input.taskSlug;
+        state.role = input.role;
+        if (!deps.fs || !deps.projectService) {
+            return state;
+        }
+        const config = await deps.projectService.loadConfig(input.repoRoot);
+        const cachePath = getTranslationCachePath(input.repoRoot, config.stateRoot, input.taskSlug, input.role, input.sessionId);
+        state.cachePath = cachePath;
+        if (!state.cacheLoaded) {
+            await loadCachedEvents(state);
+            state.cacheLoaded = true;
+        }
+        await deps.fs.ensureDir(path.dirname(cachePath));
+        return state;
+    }
+    async function loadCachedEvents(state) {
+        if (!deps.fs || !state.cachePath || state.events.length > 0 || !(await deps.fs.pathExists(state.cachePath))) {
             return;
         }
-        state.seenTranscriptIds.add(event.id);
-        if (event.kind === "text") {
-            state.lastAssistantText = event.text;
+        const text = await deps.fs.readText(state.cachePath);
+        const events = [];
+        for (const line of text.split("\n")) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // Ignore corrupt cache lines; transcript tailing remains the source of truth.
+            }
+        }
+        state.events = events.sort((left, right) => left.seq - right.seq);
+        state.nextSeq = Math.max(state.nextSeq, ...state.events.map((event) => event.seq + 1), 1);
+        for (const event of state.events) {
+            if (event.type === "entry") {
+                state.entries = upsertEntry(state.entries, event.entry);
+            }
+            else if (event.type === "status") {
+                state.status = event.status;
+            }
+            else if (event.type === "error") {
+                state.status = "failed";
+            }
         }
-        const { settings } = await loadConfig();
-        if (!settings.enabled || !settings.translateOutput) {
+    }
+    async function persistEvents(state) {
+        if (!deps.fs || !state.cachePath) {
             return;
         }
-        if (event.kind === "text") {
-            await processClaudeOutputText(sessionId, event.text, event.id);
+        const write = async () => {
+            const text = state.events.map((event) => JSON.stringify(event)).join("\n");
+            await deps.fs.writeText(state.cachePath, text ? `${text}\n` : "");
+        };
+        state.persistChain = (state.persistChain ?? Promise.resolve()).catch(() => undefined).then(write);
+        await state.persistChain;
+    }
+    async function compactEventsBefore(state, nextCursor) {
+        const normalizedCursor = Math.max(1, Math.floor(nextCursor));
+        const beforeCount = state.events.length;
+        state.events = state.events.filter((event) => event.seq >= normalizedCursor);
+        if (beforeCount !== state.events.length) {
+            await persistEvents(state);
+        }
+    }
+    function startTranscriptTail(roleSession) {
+        const state = getState(roleSession.id);
+        if (state.unsubscribeTranscript) {
             return;
         }
-        if (event.kind === "question" || event.kind === "todo" || event.kind === "agent") {
-            await processClaudeOutputText(sessionId, formatStructuredTranscriptEvent(event), event.id);
+        const replaySince = getTranscriptReplaySince(roleSession);
+        state.unsubscribeTranscript = deps.transcripts.subscribeToRoleSession(roleSession, (event) => {
+            void handleTranscriptEvent(roleSession.id, event).catch((error) => {
+                publishError(roleSession.id, error instanceof Error ? error.message : "Translation failed.");
+            });
+        }, {
+            onError(error) {
+                publishError(roleSession.id, error.message);
+            },
+            onPoll(checkedAt) {
+                emit(roleSession.id, { type: "translation-poll", checkedAt });
+            },
+            replaySince
+        });
+    }
+    async function handleTranscriptEvent(sessionId, event) {
+        const state = getState(sessionId);
+        if (state.seenTranscriptIds.has(event.id)) {
             return;
         }
-        if (event.kind === "tool_use" || event.kind === "tool_result") {
-            await pushPreservedTranscriptEntry(sessionId, event.id, formatRawTranscriptEvent(event));
+        const config = await loadConfig();
+        const { settings } = config;
+        let displayed = false;
+        if (event.kind === "text") {
+            displayed = processClaudeOutputText(sessionId, event.text, config, event.id);
+            if (displayed) {
+                state.lastAssistantText = event.text;
+            }
+        }
+        else if (event.kind === "question" || event.kind === "todo" || event.kind === "agent") {
+            displayed = processClaudeOutputText(sessionId, formatStructuredTranscriptEvent(event), config, event.id);
+        }
+        else if (event.kind === "tool_use" || event.kind === "tool_result") {
+            displayed = pushPreservedTranscriptEntry(sessionId, event.id, formatRawTranscriptEvent(event), settings);
+        }
+        if (displayed) {
+            state.seenTranscriptIds.add(event.id);
         }
     }
-    async function processClaudeOutputText(sessionId, rawText, entryId) {
+    function processClaudeOutputText(sessionId, rawText, config, entryId) {
         const session = deps.runtime.getSession(sessionId);
         const roleSession = deps.sessionRegistry.get(sessionId);
         if (!session && !roleSession) {
-            return;
+            return false;
         }
-        const { settings, secrets } = await loadConfig();
+        const { settings, secrets } = config;
         if (!rawText.trim()) {
-            return;
+            return false;
         }
         const text = rawText;
         const baseEntry = {
@@ -123,8 +242,8 @@ export function createTranslationService(deps) {
         };
         pushEntry(sessionId, baseEntry);
         const queue = queues.getQueue(sessionId);
-        await queue.enqueue(async () => {
-            emit(sessionId, { type: "translation-status", status: "translating" });
+        void queue.enqueue(async () => {
+            publishStatus(sessionId, "translating");
             try {
                 const prompt = buildTranslationPrompt({
                     direction: "cc-output-to-user",
@@ -147,7 +266,7 @@ export function createTranslationService(deps) {
                 };
                 replaceEntry(sessionId, completed);
                 getState(sessionId).lastAssistantText = text;
-                emit(sessionId, { type: "translation-status", status: "ready" });
+                publishStatus(sessionId, "ready");
             }
             catch (error) {
                 const failed = {
@@ -157,43 +276,43 @@ export function createTranslationService(deps) {
                     completedAt: now()
                 };
                 replaceEntry(sessionId, failed);
-                emit(sessionId, { type: "translation-status", status: "failed" });
+                publishStatus(sessionId, "failed");
             }
+        }).catch((error) => {
+            publishError(sessionId, error instanceof Error ? error.message : "Translation failed.");
         });
+        return true;
     }
     function pushEntry(sessionId, entry) {
         getState(sessionId).entries.push(entry);
-        emit(sessionId, { type: "translation-entry", entry });
+        publishEntry(sessionId, entry);
     }
-    async function pushPreservedTranscriptEntry(sessionId, entryId, sourceText) {
+    function pushPreservedTranscriptEntry(sessionId, entryId, sourceText, settings) {
         const session = deps.runtime.getSession(sessionId);
         const roleSession = deps.sessionRegistry.get(sessionId);
         if (!session && !roleSession) {
-            return;
+            return false;
         }
-        const { settings } = await loadConfig();
-        const queue = queues.getQueue(sessionId);
-        await queue.enqueue(async () => {
-            const entry = createEntry({
-                taskSlug: roleSession?.taskSlug ?? session.taskSlug,
-                role: roleSession?.role ?? session.role,
-                direction: "cc-output-to-user",
-                sourceKind: "tool-output",
-                sourceText,
-                settings,
-                status: "preserved",
-                contextUsed: false,
-                id: entryId,
-                translatedText: sourceText,
-                completedAt: now()
-            });
-            pushEntry(sessionId, entry);
+        const entry = createEntry({
+            taskSlug: roleSession?.taskSlug ?? session.taskSlug,
+            role: roleSession?.role ?? session.role,
+            direction: "cc-output-to-user",
+            sourceKind: "tool-output",
+            sourceText,
+            settings,
+            status: "preserved",
+            contextUsed: false,
+            id: entryId,
+            translatedText: sourceText,
+            completedAt: now()
         });
+        pushEntry(sessionId, entry);
+        return true;
     }
     function replaceEntry(sessionId, entry) {
         const state = getState(sessionId);
         state.entries = state.entries.map((current) => current.id === entry.id ? entry : current);
-        emit(sessionId, { type: "translation-entry", entry });
+        publishEntry(sessionId, entry);
     }
     function createEntry(input) {
         return {
@@ -214,6 +333,23 @@ export function createTranslationService(deps) {
             model: input.settings.model
         };
     }
+    async function stopSessionInternal(sessionId, options = {}) {
+        const state = sessionStates.get(sessionId);
+        if (!state) {
+            return;
+        }
+        if (state.unsubscribeTranscript) {
+            state.unsubscribeTranscript();
+            state.unsubscribeTranscript = undefined;
+        }
+        queues.clearQueue(sessionId);
+        if (options.clearCache && state.cachePath && deps.fs?.removePath) {
+            await deps.fs.removePath(state.cachePath, { force: true });
+            state.events = [];
+            state.entries = [];
+            state.nextSeq = 1;
+        }
+    }
     return {
         async getSettings() {
             const { settings, secrets } = await loadConfig();
@@ -239,15 +375,46 @@ export function createTranslationService(deps) {
             const { settings, secrets } = await loadConfig();
             return deps.provider.testConnection(settings, secrets);
         },
-        async translateUserInput(input) {
-            const { settings, secrets } = await loadConfig();
-            if (!settings.enabled || !settings.translateUserInput) {
+        async startSession(input) {
+            const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            if (!roleSession || roleSession.status !== "running") {
                 throw new VcmError({
-                    code: "TRANSLATION_DISABLED",
-                    message: "Translation input is disabled.",
+                    code: "SESSION_NOT_RUNNING",
+                    message: `${input.role} session is not running.`,
                     statusCode: 409
                 });
             }
+            const state = await prepareCache({
+                repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            startTranscriptTail(roleSession);
+            return {
+                sessionId: roleSession.id,
+                status: state.status,
+                nextCursor: 1
+            };
+        },
+        async pollSessionEvents(sessionId, after, limit = 200) {
+            const state = getState(sessionId);
+            const cursor = Number.isFinite(after) ? Math.max(1, Math.floor(after)) : 1;
+            const maxEvents = Math.min(Math.max(1, Math.floor(limit)), 500);
+            await compactEventsBefore(state, cursor);
+            const events = state.events
+                .filter((event) => event.seq >= cursor)
+                .slice(0, maxEvents);
+            const nextCursor = events.length > 0 ? (events.at(-1)?.seq ?? cursor) + 1 : cursor;
+            return {
+                sessionId,
+                status: state.status,
+                nextCursor,
+                events
+            };
+        },
+        async translateUserInput(input) {
+            const { settings, secrets } = await loadConfig();
             if (!input.text.trim()) {
                 throw new VcmError({
                     code: "TRANSLATION_INPUT_EMPTY",
@@ -256,6 +423,14 @@ export function createTranslationService(deps) {
                 });
             }
             const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            if (roleSession) {
+                await prepareCache({
+                    repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    sessionId: roleSession.id
+                });
+            }
             const sessionState = roleSession ? getState(roleSession.id) : undefined;
             const contextText = settings.contextEnabled && input.useContext !== false
                 ? sessionState?.lastAssistantText
@@ -357,40 +532,40 @@ export function createTranslationService(deps) {
                     });
                 }
                 else {
-                    const replaySince = getTranscriptReplaySince(roleSession);
-                    state.unsubscribeTranscript = deps.transcripts.subscribeToRoleSession(roleSession, (event) => {
-                        void handleTranscriptEvent(sessionId, event).catch((error) => {
-                            emit(sessionId, {
-                                type: "translation-error",
-                                message: error instanceof Error ? error.message : "Translation failed."
-                            });
-                        });
-                    }, {
-                        onError(error) {
-                            emit(sessionId, {
-                                type: "translation-error",
-                                message: error.message
-                            });
-                        },
-                        replaySince
-                    });
+                    startTranscriptTail(roleSession);
                 }
             }
             void loadConfig().then(({ settings }) => {
-                listener({ type: "translation-status", status: settings.enabled ? "ready" : "paused" });
+                listener({ type: "translation-status", status: "ready" });
             });
             return () => {
                 state.listeners.delete(listener);
-                if (state.listeners.size === 0 && state.unsubscribeTranscript) {
-                    state.unsubscribeTranscript();
-                    state.unsubscribeTranscript = undefined;
-                }
             };
         },
-        clearSession(sessionId) {
+        async clearSession(sessionId) {
             const state = getState(sessionId);
             state.entries = [];
+            state.events = [];
+            state.nextSeq = 1;
             queues.clearQueue(sessionId);
+            await persistEvents(state);
+        },
+        async stopSession(sessionId, options = {}) {
+            await stopSessionInternal(sessionId, options);
+        },
+        async stopTask(repoRoot, taskSlug, options = {}) {
+            for (const [sessionId, state] of sessionStates) {
+                if (state.repoRoot === repoRoot && state.taskSlug === taskSlug) {
+                    await stopSessionInternal(sessionId, options);
+                }
+            }
+            if (options.clearCache && deps.fs?.removePath && deps.projectService) {
+                const config = await deps.projectService.loadConfig(repoRoot);
+                await deps.fs.removePath(path.join(repoRoot, config.stateRoot, "translation", taskSlug), {
+                    recursive: true,
+                    force: true
+                });
+            }
         },
         async retryTranslation(sessionId, translationId) {
             const state = getState(sessionId);
@@ -409,7 +584,8 @@ export function createTranslationService(deps) {
                     statusCode: 400
                 });
             }
-            await processClaudeOutputText(sessionId, original.sourceText);
+            const config = await loadConfig();
+            processClaudeOutputText(sessionId, original.sourceText, config);
             return state.entries[state.entries.length - 1] ?? original;
         }
     };
@@ -422,12 +598,9 @@ export function createTranslationService(deps) {
                 statusCode: 409
             });
         }
-        deps.runtime.write(record.id, formatTerminalSubmit(text));
+        await submitTerminalInput(deps.runtime, record.id, text);
     }
 }
-export function formatTerminalSubmit(text) {
-    return `${text.replace(/[\r\n]+$/g, "")}\r`;
-}
 function getTranscriptReplaySince(roleSession) {
     const rawTimestamp = roleSession.startedAt ?? roleSession.updatedAt;
     const timestampMs = Date.parse(rawTimestamp);
@@ -485,14 +658,28 @@ function formatUnknown(value) {
         return String(value);
     }
 }
+function upsertEntry(entries, entry) {
+    const index = entries.findIndex((current) => current.id === entry.id);
+    if (index === -1) {
+        return [...entries, entry];
+    }
+    return entries.map((current) => current.id === entry.id ? entry : current);
+}
+function getTranslationCachePath(repoRoot, stateRoot, taskSlug, role, sessionId) {
+    return path.join(repoRoot, stateRoot, "translation", taskSlug, role, `${sessionId}.jsonl`);
+}
 function normalizeSettings(input) {
     const { apiKey: _apiKey, ...settings } = input;
     return {
         ...DEFAULT_SETTINGS,
         ...settings,
         version: 1,
+        enabled: true,
         providerType: "openai-compatible",
         workingLanguage: "en",
+        inputMode: "review-before-send",
+        translateOutput: true,
+        translateUserInput: true,
         requestTimeoutMs: clampNumber(input.requestTimeoutMs, 3000, 120000, DEFAULT_SETTINGS.requestTimeoutMs),
         temperature: clampNumber(input.temperature, 0, 1, DEFAULT_SETTINGS.temperature),
         prompts: normalizePromptMap(input.prompts)

package/dist/shared/types/app-settings.js

@@ -0,0 +1 @@
+export const THEME_MODES = ["system", "light", "dark"];