vibe-coding-master 0.0.9 → 0.0.11

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 task shows a destructive confirmation, stops VCM-managed running role sessions for that task, 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 preflight 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
@@ -249,7 +258,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 # VCM:END
 ```
 
-`.ai/vcm/` is the active VCM local control area for task state, session state, orchestration state, and task worktrees.
+`.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.
 
@@ -281,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/
@@ -299,8 +308,9 @@ When it is off, VCM is in manual mode:
 - Roles may send messages through `vcmctl`.
 - Messages appear in the `Messages` modal.
 - The user can inspect them.
-- Clicking `Stage` writes a prompt into the target embedded terminal input line.
-- VCM does not press Enter for the user.
+- The current GUI shows sequence, timestamp, status, body preview, path, and a `Copy` button for each message.
+- The user decides what to do next by copying or manually acting on the message.
+- VCM does not write to the target terminal or press Enter for the user.
 
 When it is on, VCM is in auto mode:
 
@@ -311,12 +321,14 @@ When it is on, VCM is in auto mode:
 
 The backend state model still contains a `paused` field for compatibility with existing API routes, but the current GUI exposes only a single on/off orchestration toggle.
 
+The backend still exposes stage/approve/reject compatibility APIs for automation and future UI work. They are not primary controls in the current Messages modal.
+
 ## Resume Behavior
 
 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 +344,22 @@ For a connected repository, VCM uses:
 
 ```text
 ~/.vcm/projects/<project-id>/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
+<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. `.ai/vcm/` stays repository-local runtime state for tasks, sessions, messages, orchestration snapshots, and nested task worktrees.
+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
 

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,19 +19,20 @@ 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 stopRunningRoleSessions(deps, 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 ?? {});
     });
 }
+async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
+    const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+    for (const session of sessions) {
+        if (session.status === "running") {
+            await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
+        }
+    }
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

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,
@@ -53,13 +54,15 @@ export async function createServer(deps, options = {}) {
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
+        sessionService: deps.sessionService,
         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 +80,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 +151,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

@@ -52,6 +52,21 @@ export function createAppSettingsService(deps) {
     }
     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: {} };
@@ -157,10 +172,23 @@ function normalizeProjectIndexFile(input) {
 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,

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

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { renderManualStagePrompt, renderMessageEnvelope } from "../templates/message-envelope.js";
 const PM_ROLE = "project-manager";
 const PM_TO_ROLE_TYPES = new Set(["task", "question", "review-request", "revise", "cancel"]);
@@ -12,7 +13,7 @@ export function createMessageService(deps) {
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
     return {
         listMessages(input) {
-            return readLatestMessages(deps.fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+            return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
         },
         async sendMessage(input) {
             await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
@@ -56,7 +57,7 @@ export function createMessageService(deps) {
                 deliveredAt: timestamp,
                 failureReason: undefined
             };
-            deps.runtime.write(session.id, `${renderMessageEnvelope(delivered)}\r`);
+            await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
             await appendMessageSnapshot(deps.fs, input, delivered);
             return { message: delivered, delivered: true, requiresUserApproval: false };
         },
@@ -95,7 +96,7 @@ export function createMessageService(deps) {
             return rejected;
         },
         async getOrchestrationState(input) {
-            const statePath = getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug);
+            const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
             if (!(await deps.fs.pathExists(statePath))) {
                 return {
                     taskSlug: input.taskSlug,
@@ -114,7 +115,7 @@ export function createMessageService(deps) {
                 paused: input.paused ?? current.paused,
                 updatedAt: now()
             };
-            await deps.fs.writeJsonAtomic(getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug), next);
+            await deps.fs.writeJsonAtomic(getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), next);
             return next;
         }
     };
@@ -183,7 +184,7 @@ ${artifactRefs}
 `;
 }
 async function getMessageOrThrow(fs, input) {
-    const messages = await readLatestMessages(fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+    const messages = await readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
     const message = messages.find((candidate) => candidate.id === input.messageId);
     if (!message) {
         throw new VcmError({
@@ -207,7 +208,7 @@ async function readLatestMessages(fs, messagesPath) {
     return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
 async function appendMessageSnapshot(fs, input, message) {
-    await fs.appendText(getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
+    await fs.appendText(getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
 }
 function getMessagesPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`);
@@ -215,3 +216,6 @@ function getMessagesPath(repoRoot, stateRoot, taskSlug) {
 function getOrchestrationStatePath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "orchestration", `${taskSlug}.json`);
 }
+function getStateRepoRoot(input) {
+    return input.stateRepoRoot ?? input.repoRoot;
+}

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

@@ -31,9 +31,6 @@ export function createProjectService(deps) {
             const config = await this.loadConfig(repoRoot);
             await deps.fs.ensureDir(path.join(repoRoot, config.handoffRoot));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "sessions"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "messages"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "orchestration"));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "worktrees"));
             await this.saveConfig(config, true);
             const warnings = [];

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

@@ -16,7 +16,7 @@ export function createSessionService(deps) {
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
-        const persisted = await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+        const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = input.permissionMode ?? persisted?.permissionMode ?? "default";
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
@@ -73,7 +73,7 @@ export function createSessionService(deps) {
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
-        await persistTaskSession(deps.fs, repoRoot, config.stateRoot, record);
+        await persistTaskSession(deps.fs, taskRepoRoot, config.stateRoot, record);
         await deps.taskService.updateTaskStatus(repoRoot, taskSlug, "running");
         return record;
     }
@@ -103,7 +103,8 @@ export function createSessionService(deps) {
             };
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
-            await persistTaskSession(deps.fs, repoRoot, config.stateRoot, updated);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
@@ -119,8 +120,10 @@ export function createSessionService(deps) {
         },
         async getRoleSession(repoRoot, taskSlug, role) {
             const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const record = deps.registry.getByRole(taskSlug, role)
-                ?? await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+                ?? await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
             if (!record) {
                 return undefined;
             }