vibe-coding-master 0.0.8 → 0.0.10

package/README.md

@@ -160,13 +160,13 @@ The workflow status is shown in the sidebar `Workflow` section. It is a soft gui
 
 ## Task Worktree Management
 
-VCM uses task-level worktree management:
+VCM uses task-level worktree management by default:
 
 ```text
 one task = one branch + one git worktree + one handoff directory + one role-session set
 ```
 
-The default when creating a task:
+The `Create worktree and branch` option is selected by default when creating a task:
 
 - task name: `<task>`
 - branch: `feature/<task>`
@@ -175,11 +175,13 @@ The default when creating a task:
 
 VCM will not create worktrees per role. `project-manager`, `architect`, `coder`, and `reviewer` for the same task share the same task worktree.
 
-VCM will not offer a separate `Create task worktree` button after a task exists, and a task should not be switched to another branch/worktree after creation.
+The user can turn this option off. In that mode, VCM creates the task metadata and handoff structure in the connected repository, records the current branch, and starts role sessions from the connected repository path.
+
+VCM will not offer a separate `Create task worktree` button after a task exists, and a task should not be switched to another branch/worktree mode after creation.
 
 Because worktrees live under `.ai/vcm/worktrees/`, the connected repository must ignore `.ai/vcm/`. Apply the VCM Harness before creating tasks so `.gitignore` contains the managed ignore block. The base repository must also be clean because the task branch/worktree is created from the connected repo's current `HEAD`.
 
-When a task is complete, VCM provides a guarded cleanup action that removes the task worktree and VCM task metadata. Cleanup refuses to remove a dirty task worktree unless a force cleanup is requested through the API. Branch deletion stays separate and requires explicit confirmation.
+When a task is complete, VCM provides a red `Close Task` action. Closing a worktree-backed task shows a destructive confirmation, then deletes the task worktree, deletes the task branch by default, removes the base task index entry, and removes task runtime metadata. VCM does not check running sessions or uncommitted changes before closing. Tasks created without a worktree only remove VCM metadata because they do not own a separate branch/worktree.
 
 ## Sidebar UI
 
@@ -188,7 +190,7 @@ The left sidebar is intentionally compact and collapsible:
 - `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
 - `Repository`: connected path, branch, and working tree state. `Working tree: uncommitted changes` means `git status --porcelain` is not empty.
 - `Workflow`: current soft gate and five workflow steps.
-- `Settings`: `Messages`, `Events`, and the `Auto orchestration` on/off toggle.
+- `Settings`: `Theme`, `Messages`, `Events`, and the `Auto orchestration` on/off toggle.
 - `VCM Harness`: status for `CLAUDE.md`, role agent files, and `.gitignore`.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
@@ -207,17 +209,24 @@ Translation settings are local and stored in:
 
 The same file stores recent repository paths. The translation API key is stored locally under `translation.secrets.apiKey`; it is not written to the connected repository, `.ai/handoffs`, raw terminal logs, or git diffs.
 
+The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
+
 Translation behavior:
 
 - Provider type is OpenAI-compatible chat completions.
 - Prompt slots are `zh-to-en`, `zh-to-en-with-context`, and `en-to-zh`.
-- The settings modal shows default prompts and allows per-slot overrides.
+- The settings modal shows all three prompt slots as direct editors and includes `Reset prompts` to restore the built-in defaults.
 - Claude Code output translation reads semantic Claude transcript JSONL files under `~/.claude/projects`, not raw PTY output.
+- VCM tails those transcript files in the backend. Closing the translation panel does not stop capture; the tailer stops only when the role session is stopped/restarted or the task is closed.
+- Translation events are cached under the task runtime repo at `.ai/vcm/translation/<task>/<role>/<session-id>.jsonl` and delivered to the frontend through HTTP polling.
+- The polling cursor is the next expected seq: `after=18` acknowledges seq `1..17` and returns seq `18+`; there is no snapshot mismatch error.
 - Assistant prose is shown as English source while translating, then replaced by the translated Chinese result.
+- Assistant prose renders Markdown in the panel, including headings, lists, code fences, tables, and links.
 - Tool calls and tool results are preserved as dim one-line rows such as `● Bash({"command":"npm test"})`.
 - User input uses one textarea. Press `Enter` to translate or send the current English draft; press `Shift+Enter` for a newline.
 - After user input is translated, the English draft replaces the original text in the same textarea.
 - `Send English` writes the current English draft to the active embedded terminal and submits it.
+- Automatic terminal submission uses bracketed paste first, then sends Enter separately for Claude Code TUI reliability.
 - The translation panel `Auto-send` toggle sends the translated draft automatically when translation succeeds without warnings.
 
 ## Project Harness
@@ -246,11 +255,10 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 ```gitignore
 # VCM:BEGIN version=1
 .ai/vcm/
-.vcm/
 # VCM:END
 ```
 
-`.ai/vcm/` is the active VCM local control area. `.vcm/` is ignored only as a legacy safety rule so older local state cannot be accidentally committed during migration.
+`.ai/vcm/` is the active VCM local control area. The base repo keeps the task index and nested worktrees; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
 After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
 
@@ -282,8 +290,8 @@ vcmctl inbox
 Durable message and handoff files:
 
 ```text
-.ai/vcm/messages/<task>.jsonl
-.ai/vcm/orchestration/<task>.json
+.ai/vcm/messages/<task>.jsonl                 # under the task runtime repo
+.ai/vcm/orchestration/<task>.json             # under the task runtime repo
 .ai/handoffs/<task>/messages/<message-id>.md
 .ai/handoffs/<task>/role-commands/
 .ai/handoffs/<task>/logs/
@@ -317,7 +325,7 @@ The backend state model still contains a `paused` field for compatibility with e
 Each role session stores its Claude session id and transcript path under:
 
 ```text
-.ai/vcm/sessions/<task>.json
+.ai/vcm/sessions/<task>.json                  # under the task runtime repo
 ```
 
 Session buttons behave as follows:
@@ -332,21 +340,24 @@ Session buttons behave as follows:
 For a connected repository, VCM uses:
 
 ```text
-.ai/vcm/config.json
-.ai/vcm/tasks/<task>.json
-.ai/vcm/sessions/<task>.json
-.ai/vcm/messages/<task>.jsonl
-.ai/vcm/orchestration/<task>.json
-.ai/vcm/worktrees/<task>/
-.ai/handoffs/<task>/architecture-plan.md
-.ai/handoffs/<task>/implementation-log.md
-.ai/handoffs/<task>/validation-log.md
-.ai/handoffs/<task>/review-report.md
-.ai/handoffs/<task>/docs-sync-report.md
-.ai/handoffs/<task>/role-commands/{architect,coder,reviewer}.md
-.ai/handoffs/<task>/logs/{project-manager,architect,coder,reviewer}.log
+~/.vcm/projects/<project-id>/config.json
+<baseRepoRoot>/.ai/vcm/tasks/<task>.json
+<baseRepoRoot>/.ai/vcm/worktrees/<task>/
+<taskRepoRoot>/.ai/vcm/sessions/<task>.json
+<taskRepoRoot>/.ai/vcm/messages/<task>.jsonl
+<taskRepoRoot>/.ai/vcm/orchestration/<task>.json
+<taskRepoRoot>/.ai/vcm/translation/<task>/
+<taskRepoRoot>/.ai/handoffs/<task>/architecture-plan.md
+<taskRepoRoot>/.ai/handoffs/<task>/implementation-log.md
+<taskRepoRoot>/.ai/handoffs/<task>/validation-log.md
+<taskRepoRoot>/.ai/handoffs/<task>/review-report.md
+<taskRepoRoot>/.ai/handoffs/<task>/docs-sync-report.md
+<taskRepoRoot>/.ai/handoffs/<task>/role-commands/{architect,coder,reviewer}.md
+<taskRepoRoot>/.ai/handoffs/<task>/logs/{project-manager,architect,coder,reviewer}.log
 ```
 
+The project config is stored under `~/.vcm` so it is durable local app state and is not hidden inside a Git-ignored repository directory. For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.ai/vcm/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
+
 ## Packaging
 
 The npm package publishes built output, not raw TypeScript entry files. `package.json` includes:

package/dist/backend/adapters/filesystem.js

@@ -47,13 +47,6 @@ export function createNodeFileSystemAdapter() {
             await this.writeText(targetPath, content);
             return true;
         },
-        async copyDir(sourcePath, targetPath) {
-            await fs.cp(sourcePath, targetPath, {
-                recursive: true,
-                force: false,
-                errorOnExist: false
-            });
-        },
         async removePath(targetPath, options = {}) {
             await fs.rm(targetPath, {
                 recursive: options.recursive ?? false,

package/dist/backend/api/app-settings-routes.js

@@ -0,0 +1,8 @@
+export function registerAppSettingsRoutes(app, deps) {
+    app.get("/api/settings/preferences", async () => {
+        return deps.appSettings.getPreferences();
+    });
+    app.put("/api/settings/preferences", async (request) => {
+        return deps.appSettings.updatePreferences(request.body ?? {});
+    });
+}

package/dist/backend/api/message-routes.js

@@ -71,9 +71,11 @@ async function getRouteContext(deps, taskSlug) {
     const project = await requireCurrentProject(deps.projectService);
     const config = await deps.projectService.loadConfig(project.repoRoot);
     const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
+    const taskRepoRoot = getTaskRuntimeRepoRoot(task);
     return {
         repoRoot: project.repoRoot,
-        taskRepoRoot: getTaskRuntimeRepoRoot(task),
+        taskRepoRoot,
+        stateRepoRoot: taskRepoRoot,
         stateRoot: config.stateRoot,
         handoffDir: task.handoffDir,
         taskSlug

package/dist/backend/api/session-routes.js

@@ -13,11 +13,17 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
-        return deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
+        const session = await deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
+        await deps.translationService.stopSession(session.id);
+        return session;
     });
     app.post("/api/tasks/:taskSlug/sessions/:role/restart", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
+        if (existing) {
+            await deps.translationService.stopSession(existing.id, { clearCache: true });
+        }
         return deps.sessionService.restartRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
     app.post("/api/tasks/:taskSlug/sessions/:role/resume", async (request) => {

package/dist/backend/api/task-routes.js

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
     app.get("/api/tasks", async () => {
         const project = await requireCurrentProject(deps.projectService);
@@ -18,16 +19,8 @@ export function registerTaskRoutes(app, deps) {
     });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        const sessions = await deps.sessionService.listRoleSessions(project.repoRoot, request.params.taskSlug);
-        const running = sessions.filter((session) => session.status === "running");
-        if (running.length > 0) {
-            throw new VcmError({
-                code: "TASK_SESSIONS_RUNNING",
-                message: "Stop all role sessions before cleaning up the task.",
-                statusCode: 409,
-                hint: running.map((session) => session.role).join(", ")
-            });
-        }
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
         return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
     });
 }

package/dist/backend/api/translation-routes.js

@@ -1,5 +1,6 @@
 import { isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTranslationRoutes(app, deps) {
     app.get("/api/translation/settings", async () => {
         return deps.translationService.getSettings();
@@ -14,12 +15,28 @@ export function registerTranslationRoutes(app, deps) {
     app.post("/api/translation/test", async () => {
         return deps.translationService.testProvider();
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.startSession({
+            repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
+            taskSlug: request.params.taskSlug,
+            role
+        });
+    });
+    app.get("/api/translation/sessions/:sessionId/events", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        return deps.translationService.pollSessionEvents(request.params.sessionId, Number(request.query.after ?? "1"), request.query.limit === undefined ? undefined : Number(request.query.limit));
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/input", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
-        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         return deps.translationService.translateUserInput({
             repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
             taskSlug: request.params.taskSlug,
             role,
             ...(request.body ?? { text: "" })
@@ -28,9 +45,10 @@ export function registerTranslationRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/send", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
-        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         await deps.translationService.sendTranslatedInput({
             repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
             taskSlug: request.params.taskSlug,
             role,
             englishText: request.body?.englishText ?? ""
@@ -39,7 +57,7 @@ export function registerTranslationRoutes(app, deps) {
     });
     app.post("/api/translation/sessions/:sessionId/clear", async (request) => {
         await requireCurrentProject(deps.projectService);
-        deps.translationService.clearSession(request.params.sessionId);
+        await deps.translationService.clearSession(request.params.sessionId);
         return { ok: true };
     });
     app.post("/api/translation/sessions/:sessionId/retry/:translationId", async (request) => {

package/dist/backend/runtime/terminal-submit.js

@@ -0,0 +1,20 @@
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+const DEFAULT_ENTER_DELAY_MS = 75;
+export async function submitTerminalInput(runtime, sessionId, text, options = {}) {
+    runtime.write(sessionId, formatTerminalPaste(text));
+    await delay(options.enterDelayMs ?? DEFAULT_ENTER_DELAY_MS);
+    runtime.write(sessionId, "\r");
+}
+export function formatTerminalPaste(text) {
+    return `${BRACKETED_PASTE_START}${normalizeTerminalSubmitText(text)}${BRACKETED_PASTE_END}`;
+}
+export function normalizeTerminalSubmitText(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n+$/g, "");
+}
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/backend/server.js

@@ -21,6 +21,7 @@ import { createMessageService } from "./services/message-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
@@ -29,7 +30,6 @@ import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
-import { registerTranslationWs } from "./ws/translation-ws.js";
 import { toVcmError } from "./errors.js";
 export async function createServer(deps, options = {}) {
     const app = Fastify({
@@ -45,6 +45,7 @@ export async function createServer(deps, options = {}) {
             }
         });
     });
+    registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
     registerProjectRoutes(app, { projectService: deps.projectService });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -54,12 +55,13 @@ export async function createServer(deps, options = {}) {
         projectService: deps.projectService,
         taskService: deps.taskService,
         statusService: deps.statusService,
-        sessionService: deps.sessionService
+        translationService: deps.translationService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
         sessionService: deps.sessionService,
-        commandDispatcher: deps.commandDispatcher
+        commandDispatcher: deps.commandDispatcher,
+        translationService: deps.translationService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -77,7 +79,6 @@ export async function createServer(deps, options = {}) {
         translationService: deps.translationService
     });
     registerTerminalWs(app, { runtime: deps.runtime });
-    registerTranslationWs(app, { translationService: deps.translationService });
     if (options.staticDir) {
         await app.register(fastifyStatic, {
             root: options.staticDir,
@@ -149,10 +150,13 @@ export function createDefaultServerDeps(options = {}) {
         sessionRegistry: registry,
         transcripts: createClaudeTranscriptService(),
         sessionService,
+        fs,
+        projectService,
         appSettings,
         provider: createOpenAiCompatibleTranslationProvider()
     });
     return {
+        appSettings,
         projectService,
         taskService,
         sessionService,

package/dist/backend/services/app-settings-service.js

@@ -1,13 +1,13 @@
 import path from "node:path";
 import { homedir } from "node:os";
+import { createHash } from "node:crypto";
 const MAX_RECENT_REPOSITORIES = 5;
 export function createAppSettingsService(deps) {
     const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "settings.json");
-    const legacySettingsPath = deps.legacySettingsPath
-        ?? path.join(homedir(), ".vibe-coding-master", "settings.json");
-    const legacyTranslationPath = deps.legacyTranslationPath
-        ?? path.join(homedir(), ".vibe-coding-master", "translation.json");
+    const settingsRoot = path.dirname(settingsPath);
+    const projectIndexPath = path.join(settingsRoot, "projects", "index.json");
     let cachedSettings = null;
+    let cachedProjectIndex = null;
     async function loadSettings() {
         if (cachedSettings) {
             return cachedSettings;
@@ -17,20 +17,9 @@ export function createAppSettingsService(deps) {
         if (await deps.fs.pathExists(settingsPath)) {
             raw = await deps.fs.readJson(settingsPath);
         }
-        else if (await deps.fs.pathExists(legacySettingsPath)) {
-            raw = await deps.fs.readJson(legacySettingsPath);
-            shouldSave = true;
-        }
         else {
             shouldSave = true;
         }
-        if (!raw.translation && await deps.fs.pathExists(legacyTranslationPath)) {
-            raw = {
-                ...raw,
-                translation: normalizeTranslationConfig(await deps.fs.readJson(legacyTranslationPath))
-            };
-            shouldSave = true;
-        }
         cachedSettings = normalizeSettingsFile(raw);
         if (shouldSave) {
             await saveSettings(cachedSettings);
@@ -41,8 +30,43 @@ export function createAppSettingsService(deps) {
         cachedSettings = settings;
         await deps.fs.writeJsonAtomic(settingsPath, settings);
     }
+    async function loadProjectIndex() {
+        if (cachedProjectIndex) {
+            return cachedProjectIndex;
+        }
+        if (await deps.fs.pathExists(projectIndexPath)) {
+            cachedProjectIndex = normalizeProjectIndexFile(await deps.fs.readJson(projectIndexPath));
+        }
+        else {
+            cachedProjectIndex = { version: 1, projects: [] };
+            await saveProjectIndex(cachedProjectIndex);
+        }
+        return cachedProjectIndex;
+    }
+    async function saveProjectIndex(index) {
+        cachedProjectIndex = normalizeProjectIndexFile(index);
+        await deps.fs.writeJsonAtomic(projectIndexPath, cachedProjectIndex);
+    }
+    function getProjectConfigPath(repoRoot) {
+        return path.join(settingsRoot, "projects", getProjectId(repoRoot), "config.json");
+    }
     return {
         loadSettings,
+        async getPreferences() {
+            return (await loadSettings()).preferences;
+        },
+        async updatePreferences(input) {
+            const current = await loadSettings();
+            const preferences = normalizePreferences({
+                ...current.preferences,
+                ...input
+            });
+            await saveSettings({
+                ...current,
+                preferences
+            });
+            return preferences;
+        },
         async updateTranslationConfig(config) {
             const current = await loadSettings();
             const translation = normalizeTranslationConfig(config) ?? { settings: {}, secrets: {} };
@@ -74,18 +98,97 @@ export function createAppSettingsService(deps) {
             });
             return recentRepositoryPaths;
         },
+        loadProjectIndex,
+        async loadProjectConfig(repoRoot) {
+            const configPath = getProjectConfigPath(repoRoot);
+            if (!(await deps.fs.pathExists(configPath))) {
+                return undefined;
+            }
+            return deps.fs.readJson(configPath);
+        },
+        async saveProjectConfig(config) {
+            const configPath = getProjectConfigPath(config.repoRoot);
+            await deps.fs.writeJsonAtomic(configPath, config);
+            const projectId = getProjectId(config.repoRoot);
+            const current = await loadProjectIndex();
+            const projects = [
+                {
+                    projectId,
+                    repoRoot: config.repoRoot,
+                    configPath,
+                    lastOpenedAt: new Date().toISOString()
+                },
+                ...current.projects.filter((entry) => entry.projectId !== projectId)
+            ];
+            await saveProjectIndex({
+                version: 1,
+                projects
+            });
+            return config;
+        },
         getSettingsPath() {
             return settingsPath;
+        },
+        getProjectIndexPath() {
+            return projectIndexPath;
+        },
+        getProjectConfigPath
+    };
+}
+export function getProjectId(repoRoot) {
+    return createHash("sha256")
+        .update(path.resolve(repoRoot))
+        .digest("hex")
+        .slice(0, 16);
+}
+function normalizeProjectIndexFile(input) {
+    const rawProjects = Array.isArray(input.projects) ? input.projects : [];
+    const projects = [];
+    const seen = new Set();
+    for (const value of rawProjects) {
+        if (!isObject(value)) {
+            continue;
         }
+        const projectId = typeof value.projectId === "string" ? value.projectId.trim() : "";
+        const repoRoot = typeof value.repoRoot === "string" ? value.repoRoot.trim() : "";
+        const configPath = typeof value.configPath === "string" ? value.configPath.trim() : "";
+        const lastOpenedAt = typeof value.lastOpenedAt === "string" ? value.lastOpenedAt.trim() : "";
+        if (!projectId || !repoRoot || !configPath || seen.has(projectId)) {
+            continue;
+        }
+        seen.add(projectId);
+        projects.push({
+            projectId,
+            repoRoot,
+            configPath,
+            lastOpenedAt: lastOpenedAt || new Date(0).toISOString()
+        });
+    }
+    return {
+        version: 1,
+        projects
     };
 }
 function normalizeSettingsFile(input) {
     return {
         version: 1,
+        preferences: normalizePreferences(input.preferences),
         translation: normalizeTranslationConfig(input.translation),
         recentRepositoryPaths: normalizeRecentRepositoryPaths(input.recentRepositoryPaths)
     };
 }
+function normalizePreferences(input) {
+    const candidate = isObject(input) ? input : {};
+    return {
+        themeMode: normalizeThemeMode(candidate.themeMode)
+    };
+}
+function normalizeThemeMode(input) {
+    if (input === "light" || input === "dark" || input === "system") {
+        return input;
+    }
+    return "system";
+}
 function normalizeTranslationConfig(input) {
     if (!input || typeof input !== "object") {
         return undefined;

package/dist/backend/services/claude-transcript-service.js

@@ -1,7 +1,7 @@
 import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync, watch as fsWatch } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-const DEFAULT_TAIL_POLL_INTERVAL_MS = 500;
+const DEFAULT_TAIL_POLL_INTERVAL_MS = 200;
 /**
  * Adapted from CodingForMoney/cc-pm's transcript tailer.
  *
@@ -37,16 +37,16 @@ export class TranscriptTail {
         this.buffer = "";
         try {
             this.watcher = fsWatch(this.path, () => {
-                this.scheduleFlush();
+                this.scheduleFlush("watch");
             });
         }
         catch {
             this.watcher = null;
         }
         this.pollTimer = setInterval(() => {
-            this.scheduleFlush();
+            this.scheduleFlush("poll");
         }, opts?.pollIntervalMs ?? DEFAULT_TAIL_POLL_INTERVAL_MS);
-        this.scheduleFlush();
+        this.scheduleFlush("initial");
     }
     stop() {
         if (this.watcher) {
@@ -58,23 +58,26 @@ export class TranscriptTail {
             this.pollTimer = null;
         }
     }
-    scheduleFlush() {
+    scheduleFlush(source) {
         if (this.flushing || this.flushScheduled) {
             return;
         }
         this.flushScheduled = true;
         setImmediate(() => {
             this.flushScheduled = false;
-            this.flush();
+            this.flush(source);
         });
     }
-    flush() {
+    flush(source) {
         if (this.flushing) {
             return;
         }
         this.flushing = true;
         try {
             const stat = statSync(this.path);
+            if (source === "poll") {
+                this.handlers.onPoll?.(new Date().toISOString());
+            }
             if (stat.size < this.offset) {
                 this.offset = stat.size;
                 this.buffer = "";
@@ -173,7 +176,8 @@ export function createClaudeTranscriptService() {
                 try {
                     tail = new TranscriptTail(transcriptPath, {
                         onContent: listener,
-                        onError: options.onError
+                        onError: options.onError,
+                        onPoll: options.onPoll
                     });
                     tail.start({
                         replayLastN: options.replayLastN,

package/dist/backend/services/command-dispatcher.js

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createCommandDispatcher(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
@@ -26,7 +27,7 @@ export function createCommandDispatcher(deps) {
                 });
             }
             const instruction = `Please read and execute the role command at: ${commandPath}`;
-            deps.runtime.write(session.id, `${instruction}\r`);
+            await submitTerminalInput(deps.runtime, session.id, instruction);
             return {
                 taskSlug: input.taskSlug,
                 role: input.role,