vibe-coding-master 0.0.7 → 0.0.9

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,16 @@ VCM-managed rules live here.
 <!-- VCM:END -->
 ```
 
+For `.gitignore`, VCM uses a gitignore-native managed block:
+
+```gitignore
+# VCM:BEGIN version=1
+.ai/vcm/
+# VCM:END
+```
+
+`.ai/vcm/` is the active VCM local control area for task state, session state, orchestration state, and task worktrees.
+
 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 +281,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 +316,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 +331,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
+~/.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
@@ -311,6 +346,8 @@ For a connected repository, VCM uses:
 .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.
+
 ## Packaging
 
 The npm package publishes built output, not raw TypeScript entry files. `package.json` includes:
@@ -344,7 +381,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,12 @@ export function createNodeFileSystemAdapter() {
             }
             await this.writeText(targetPath, content);
             return true;
+        },
+        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/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,6 +30,26 @@ 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 updateTranslationConfig(config) {
@@ -74,9 +83,75 @@ 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) {

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,6 +1,8 @@
 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";
 export function createProjectService(deps) {
     let currentProject = null;
     return {
@@ -26,10 +28,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";
@@ -69,21 +74,22 @@ export function createProjectService(deps) {
             return deps.appSettings.getRecentRepositoryPaths();
         },
         async loadConfig(repoRoot) {
-            const configPath = this.getConfigPath(repoRoot);
-            if (!(await deps.fs.pathExists(configPath))) {
-                return buildDefaultProjectConfig(repoRoot);
+            const appConfig = await deps.appSettings.loadProjectConfig(repoRoot);
+            if (appConfig) {
+                return normalizeProjectConfig(appConfig, repoRoot);
             }
-            return deps.fs.readJson(configPath);
+            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.appSettings.saveProjectConfig(normalizedConfig);
         },
         getConfigPath(repoRoot) {
-            return path.join(repoRoot, ".vcm", "config.json");
+            return deps.appSettings.getProjectConfigPath(repoRoot);
         }
     };
 }
@@ -101,9 +107,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
+    };
+}