vibe-coding-master 0.0.7 → 0.0.8

package/README.md

@@ -25,7 +25,7 @@ Each role runs as a real Claude Code process inside an embedded terminal. The GU
   - `--dangerously-skip-permissions`
 - PM-mediated role messaging through `vcmctl`.
 - Manual and automatic orchestration modes.
-- VCM harness installer for `CLAUDE.md` and `.claude/agents/*.md`.
+- VCM harness installer for `CLAUDE.md`, `.claude/agents/*.md`, and the VCM-managed `.gitignore` block.
 - Translation panel powered by an OpenAI-compatible low-cost model.
 - Durable task state, session state, raw terminal logs, handoff artifacts, and message history.
 
@@ -158,6 +158,29 @@ project-manager
 
 The workflow status is shown in the sidebar `Workflow` section. It is a soft guide in V1: VCM highlights missing or incomplete handoff artifacts and suggests the next step, but it does not hard-block the user from manually starting or switching roles.
 
+## Task Worktree Management
+
+VCM uses task-level worktree management:
+
+```text
+one task = one branch + one git worktree + one handoff directory + one role-session set
+```
+
+The default when creating a task:
+
+- task name: `<task>`
+- branch: `feature/<task>`
+- worktree path: `.ai/vcm/worktrees/<task>` inside the connected base repository
+- role session cwd: that task worktree
+
+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.
+
+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.
+
 ## Sidebar UI
 
 The left sidebar is intentionally compact and collapsible:
@@ -166,7 +189,7 @@ The left sidebar is intentionally compact and collapsible:
 - `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.
-- `VCM Harness`: status for `CLAUDE.md` and role agent files.
+- `VCM Harness`: status for `CLAUDE.md`, role agent files, and `.gitignore`.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
 
@@ -203,6 +226,7 @@ VCM works best when the connected repository contains VCM collaboration rules as
 
 ```text
 CLAUDE.md
+.gitignore
 .claude/agents/project-manager.md
 .claude/agents/architect.md
 .claude/agents/coder.md
@@ -217,6 +241,17 @@ VCM-managed rules live here.
 <!-- VCM:END -->
 ```
 
+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.
+
 After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
 
 Role sessions learn VCM rules from `CLAUDE.md` and `.claude/agents/*.md`. VCM does not paste a long context block into the terminal at session start.
@@ -247,8 +282,8 @@ vcmctl inbox
 Durable message and handoff files:
 
 ```text
-.vcm/messages/<task>.jsonl
-.vcm/orchestration/<task>.json
+.ai/vcm/messages/<task>.jsonl
+.ai/vcm/orchestration/<task>.json
 .ai/handoffs/<task>/messages/<message-id>.md
 .ai/handoffs/<task>/role-commands/
 .ai/handoffs/<task>/logs/
@@ -282,7 +317,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
-.vcm/sessions/<task>.json
+.ai/vcm/sessions/<task>.json
 ```
 
 Session buttons behave as follows:
@@ -297,11 +332,12 @@ Session buttons behave as follows:
 For a connected repository, VCM uses:
 
 ```text
-.vcm/config.json
-.vcm/tasks/<task>.json
-.vcm/sessions/<task>.json
-.vcm/messages/<task>.jsonl
-.vcm/orchestration/<task>.json
+.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
@@ -344,7 +380,7 @@ npm run build
 - VCM does not isolate roles with separate worktrees in V1.
 - VCM does not translate Claude output from raw PTY output; translation reads Claude transcript JSONL files.
 - VCM does not write translation output into handoff artifacts unless a user or role explicitly copies it there.
-- File writes still happen in the connected repository environment.
+- Role file writes happen in the task worktree when a task has a worktree.
 - The safest sandbox today is a container or VM boundary controlled by the user.
 
 See also:

package/dist/backend/adapters/filesystem.js

@@ -46,6 +46,19 @@ 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,
+                force: options.force ?? false
+            });
         }
     };
 }

package/dist/backend/adapters/git-adapter.js

@@ -22,6 +22,9 @@ export function createGitAdapter(runner) {
             return result.stdout.trim() || "detached";
         },
         async isDirty(repoRoot) {
+            return (await this.getStatusPorcelain(repoRoot)).trim().length > 0;
+        },
+        async getStatusPorcelain(repoRoot) {
             const result = await runGit(runner, repoRoot, ["status", "--porcelain"]);
             if (result.exitCode !== 0) {
                 throw new VcmError({
@@ -31,7 +34,82 @@ export function createGitAdapter(runner) {
                     hint: result.stderr
                 });
             }
-            return result.stdout.trim().length > 0;
+            return result.stdout;
+        },
+        async isIgnored(repoRoot, repoRelativePath) {
+            const result = await runGit(runner, repoRoot, ["check-ignore", "-q", "--", repoRelativePath]);
+            if (result.exitCode === 0) {
+                return true;
+            }
+            if (result.exitCode === 1) {
+                return false;
+            }
+            throw new VcmError({
+                code: "GIT_ERROR",
+                message: `Unable to check whether Git ignores ${repoRelativePath}.`,
+                statusCode: 400,
+                hint: result.stderr
+            });
+        },
+        async branchExists(repoRoot, branch) {
+            const result = await runGit(runner, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+            if (result.exitCode === 0) {
+                return true;
+            }
+            if (result.exitCode === 1) {
+                return false;
+            }
+            throw new VcmError({
+                code: "GIT_ERROR",
+                message: `Unable to check Git branch: ${branch}`,
+                statusCode: 400,
+                hint: result.stderr
+            });
+        },
+        async createWorktree(input) {
+            const result = await runGit(runner, input.repoRoot, [
+                "worktree",
+                "add",
+                "-b",
+                input.branch,
+                input.worktreePath,
+                input.baseRef ?? "HEAD"
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_WORKTREE_CREATE_FAILED",
+                    message: `Unable to create task worktree: ${input.worktreePath}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+        },
+        async removeWorktree(repoRoot, worktreePath, options = {}) {
+            const args = ["worktree", "remove"];
+            if (options.force) {
+                args.push("--force");
+            }
+            args.push(worktreePath);
+            const result = await runGit(runner, repoRoot, args);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_WORKTREE_REMOVE_FAILED",
+                    message: `Unable to remove task worktree: ${worktreePath}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+        },
+        async deleteBranch(repoRoot, branch, options = {}) {
+            const result = await runGit(runner, repoRoot, ["branch", options.force ? "-D" : "-d", branch]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_BRANCH_DELETE_FAILED",
+                    message: `Unable to delete Git branch: ${branch}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
         }
     };
 }

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

@@ -1,23 +1,26 @@
 import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerArtifactRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/artifacts", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return deps.artifactService.listArtifacts({
-            repoRoot: project.repoRoot,
+            repoRoot: taskRepoRoot,
             handoffDir: task.handoffDir
         });
     });
     app.get("/api/tasks/:taskSlug/artifacts/:artifactName", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const paths = deps.artifactService.getHandoffPaths(project.repoRoot, task.handoffDir);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const artifactPath = artifactNameToPath(paths, request.params.artifactName);
         return {
             path: artifactPath,
             content: await deps.artifactService.readArtifact({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 artifactPath
             })
         };
@@ -26,10 +29,11 @@ export function registerArtifactRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseDispatchableRole(request.params.role);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return {
             role,
             content: await deps.artifactService.readRoleCommand({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 handoffDir: task.handoffDir,
                 role
             })
@@ -39,8 +43,9 @@ export function registerArtifactRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseDispatchableRole(request.params.role);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         await deps.artifactService.saveRoleCommand({
-            repoRoot: project.repoRoot,
+            repoRoot: taskRepoRoot,
             handoffDir: task.handoffDir,
             role,
             content: request.body.content
@@ -57,11 +62,12 @@ export function registerArtifactRoutes(app, deps) {
             });
         }
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const paths = deps.artifactService.getHandoffPaths(project.repoRoot, task.handoffDir);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         return {
             role: request.params.role,
             content: await deps.artifactService.readArtifact({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 artifactPath: paths.roleLogPaths[request.params.role]
             })
         };

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

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerMessageRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/messages", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
@@ -72,6 +73,7 @@ async function getRouteContext(deps, taskSlug) {
     const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
     return {
         repoRoot: project.repoRoot,
+        taskRepoRoot: getTaskRuntimeRepoRoot(task),
         stateRoot: config.stateRoot,
         handoffDir: task.handoffDir,
         taskSlug

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

@@ -16,6 +16,20 @@ export function registerTaskRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.statusService.getTaskStatus(project.repoRoot, request.params.taskSlug);
     });
+    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(", ")
+            });
+        }
+        return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
+    });
 }
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();

package/dist/backend/server.js

@@ -53,7 +53,8 @@ export async function createServer(deps, options = {}) {
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        statusService: deps.statusService
+        statusService: deps.statusService,
+        sessionService: deps.sessionService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,

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

@@ -1,16 +1,18 @@
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createCommandDispatcher(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     return {
         async dispatchRoleCommand(input) {
             const task = await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             await deps.artifactService.readRoleCommand({
-                repoRoot: input.repoRoot,
+                repoRoot: taskRepoRoot,
                 handoffDir: task.handoffDir,
                 role: input.role
             });
             const commandPath = await deps.artifactService.resolveRoleCommandPath({
-                repoRoot: input.repoRoot,
+                repoRoot: taskRepoRoot,
                 handoffDir: task.handoffDir,
                 role: input.role
             });

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

@@ -2,10 +2,12 @@ import path from "node:path";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
+import { renderGitignoreHarnessRules } from "../templates/harness/gitignore.js";
 import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
 import { renderReviewerHarnessRules } from "../templates/harness/reviewer-agent.js";
 export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
+const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const HARNESS_FILES = [
     {
         kind: "root-claude",
@@ -13,6 +15,13 @@ const HARNESS_FILES = [
         title: "CLAUDE.md",
         renderRules: renderRootClaudeHarnessRules
     },
+    {
+        kind: "gitignore",
+        path: ".gitignore",
+        title: ".gitignore",
+        commentStyle: "hash",
+        renderRules: renderGitignoreHarnessRules
+    },
     {
         kind: "agent-project-manager",
         path: ".claude/agents/project-manager.md",
@@ -79,7 +88,8 @@ async function analyzeHarnessFiles(fs, repoRoot) {
 }
 async function analyzeHarnessFile(fs, repoRoot, definition) {
     const absolutePath = resolveHarnessPath(repoRoot, definition.path);
-    const expectedBlock = renderManagedBlock(definition.renderRules());
+    const expectedBlock = renderManagedBlock(definition, definition.renderRules());
+    const managedBlockPattern = getManagedBlockPattern(definition);
     const exists = await fs.pathExists(absolutePath);
     if (!exists) {
         return {
@@ -100,7 +110,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         };
     }
     const currentContent = await fs.readText(absolutePath);
-    const match = currentContent.match(MANAGED_BLOCK_PATTERN);
+    const match = currentContent.match(managedBlockPattern);
     if (!match) {
         return {
             definition,
@@ -143,7 +153,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             },
         nextContent: action === "ok"
             ? undefined
-            : currentContent.replace(MANAGED_BLOCK_PATTERN, expectedBlock)
+            : currentContent.replace(managedBlockPattern, expectedBlock)
     };
 }
 function renderHarnessStatus(analyses) {
@@ -161,9 +171,17 @@ function renderHarnessStatus(analyses) {
             : []
     };
 }
-function renderManagedBlock(rules) {
+function renderManagedBlock(definition, rules) {
+    if (definition.commentStyle === "hash") {
+        return `# VCM:BEGIN version=${VCM_HARNESS_VERSION}\n${rules.trimEnd()}\n# VCM:END`;
+    }
     return `<!-- VCM:BEGIN version=${VCM_HARNESS_VERSION} -->\n${rules.trimEnd()}\n<!-- VCM:END -->`;
 }
+function getManagedBlockPattern(definition) {
+    return definition.commentStyle === "hash"
+        ? HASH_MANAGED_BLOCK_PATTERN
+        : MANAGED_BLOCK_PATTERN;
+}
 function renderNewHarnessFile(definition, block) {
     const frontmatter = definition.frontmatter
         ? `${definition.frontmatter.trimEnd()}\n\n`

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

@@ -30,7 +30,7 @@ export function createMessageService(deps) {
                 status: "queued",
                 createdAt: timestamp
             };
-            message.bodyPath = await writeMessageBody(deps.fs, input.repoRoot, input.handoffDir, message);
+            message.bodyPath = await writeMessageBody(deps.fs, input.taskRepoRoot ?? input.repoRoot, input.handoffDir, message);
             const state = await this.getOrchestrationState(input);
             const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.toRole);
             if (!session || session.status !== "running") {

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

@@ -1,8 +1,22 @@
 import path from "node:path";
 import { ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+const DEFAULT_HANDOFF_ROOT = ".ai/handoffs";
+const DEFAULT_STATE_ROOT = ".ai/vcm";
+const LEGACY_STATE_ROOT = ".vcm";
 export function createProjectService(deps) {
     let currentProject = null;
+    async function migrateLegacyStateRoot(repoRoot) {
+        if (!deps.fs.copyDir) {
+            return;
+        }
+        const legacyStateRoot = path.join(repoRoot, LEGACY_STATE_ROOT);
+        const currentStateRoot = path.join(repoRoot, DEFAULT_STATE_ROOT);
+        if (!(await deps.fs.pathExists(legacyStateRoot)) || await deps.fs.pathExists(currentStateRoot)) {
+            return;
+        }
+        await deps.fs.copyDir(legacyStateRoot, currentStateRoot);
+    }
     return {
         async connectProject(input) {
             const requestedPath = input.repoPath.trim();
@@ -26,10 +40,13 @@ export function createProjectService(deps) {
                     statusCode: 400
                 });
             }
-            const config = buildDefaultProjectConfig(repoRoot);
+            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 = [];
             let branch = "unknown";
@@ -70,20 +87,28 @@ export function createProjectService(deps) {
         },
         async loadConfig(repoRoot) {
             const configPath = this.getConfigPath(repoRoot);
-            if (!(await deps.fs.pathExists(configPath))) {
-                return buildDefaultProjectConfig(repoRoot);
+            if (await deps.fs.pathExists(configPath)) {
+                return normalizeProjectConfig(await deps.fs.readJson(configPath), repoRoot);
             }
-            return deps.fs.readJson(configPath);
+            const legacyConfigPath = path.join(repoRoot, LEGACY_STATE_ROOT, "config.json");
+            if (await deps.fs.pathExists(legacyConfigPath)) {
+                const migratedConfig = normalizeProjectConfig(await deps.fs.readJson(legacyConfigPath), repoRoot);
+                await migrateLegacyStateRoot(repoRoot);
+                await this.saveConfig(migratedConfig, true);
+                return migratedConfig;
+            }
+            return buildDefaultProjectConfig(repoRoot);
         },
         async saveConfig(config, force = false) {
-            const configPath = this.getConfigPath(config.repoRoot);
+            const normalizedConfig = normalizeProjectConfig(config, config.repoRoot);
+            const configPath = this.getConfigPath(normalizedConfig.repoRoot);
             if (!force && await deps.fs.pathExists(configPath)) {
                 return;
             }
-            await deps.fs.writeJsonAtomic(configPath, config);
+            await deps.fs.writeJsonAtomic(configPath, normalizedConfig);
         },
         getConfigPath(repoRoot) {
-            return path.join(repoRoot, ".vcm", "config.json");
+            return path.join(repoRoot, DEFAULT_STATE_ROOT, "config.json");
         }
     };
 }
@@ -101,9 +126,21 @@ export function buildDefaultProjectConfig(repoRoot) {
         version: 1,
         repoRoot,
         defaultRoles: [...ROLE_NAMES],
-        handoffRoot: ".ai/handoffs",
-        stateRoot: ".vcm",
+        handoffRoot: DEFAULT_HANDOFF_ROOT,
+        stateRoot: DEFAULT_STATE_ROOT,
         terminalBackend: "node-pty",
         claudeCommand: process.env.VCM_CLAUDE_COMMAND || "claude"
     };
 }
+function normalizeProjectConfig(input, repoRoot) {
+    const fallback = buildDefaultProjectConfig(repoRoot);
+    return {
+        version: 1,
+        repoRoot,
+        defaultRoles: input.defaultRoles?.length ? input.defaultRoles : fallback.defaultRoles,
+        handoffRoot: input.handoffRoot || fallback.handoffRoot,
+        stateRoot: DEFAULT_STATE_ROOT,
+        terminalBackend: "node-pty",
+        claudeCommand: input.claudeCommand || fallback.claudeCommand
+    };
+}

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

@@ -4,6 +4,7 @@ import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
@@ -13,7 +14,8 @@ export function createSessionService(deps) {
         }
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-        const paths = deps.artifactService.getHandoffPaths(repoRoot, task.handoffDir);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = input.permissionMode ?? persisted?.permissionMode ?? "default";
         const claudeSessionId = launchMode === "resume"
@@ -29,14 +31,14 @@ export function createSessionService(deps) {
         }
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
-            : claudeTranscriptPath(repoRoot, claudeSessionId);
+            : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
         const startCommand = deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume");
         const runtimeSession = await deps.runtime.createSession({
             taskSlug,
             role,
             command: startCommand.command,
             args: startCommand.args,
-            cwd: repoRoot,
+            cwd: taskRepoRoot,
             env: {
                 VCM_API_URL: deps.apiUrl,
                 VCM_CTL_COMMAND: deps.vcmctlCommand,
@@ -45,7 +47,7 @@ export function createSessionService(deps) {
             },
             cols: input.cols,
             rows: input.rows,
-            logPath: resolveRepoPath(repoRoot, paths.roleLogPaths[role])
+            logPath: resolveRepoPath(taskRepoRoot, paths.roleLogPaths[role])
         });
         const timestamp = now();
         const record = {
@@ -57,7 +59,7 @@ export function createSessionService(deps) {
             status: runtimeSession.status,
             command: startCommand.display,
             permissionMode,
-            cwd: repoRoot,
+            cwd: taskRepoRoot,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
             logPath: paths.roleLogPaths[role],

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

@@ -1,9 +1,11 @@
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createStatusService(deps) {
     return {
         async getTaskStatus(repoRoot, taskSlug) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const artifacts = await deps.artifactService.listArtifacts({
-                repoRoot,
+                repoRoot: taskRepoRoot,
                 handoffDir: task.handoffDir
             });
             const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);