vibe-coding-master 0.0.1

package/dist/backend/server.js

@@ -0,0 +1,159 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import { createArtifactService } from "./services/artifact-service.js";
+import { createClaudeAdapter } from "./adapters/claude-adapter.js";
+import { createCommandRunner } from "./adapters/command-runner.js";
+import { createCommandDispatcher } from "./services/command-dispatcher.js";
+import { createGitAdapter } from "./adapters/git-adapter.js";
+import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
+import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
+import { createProjectService } from "./services/project-service.js";
+import { createSessionRegistry } from "./runtime/session-registry.js";
+import { createSessionService } from "./services/session-service.js";
+import { createMessageService } from "./services/message-service.js";
+import { createStatusService } from "./services/status-service.js";
+import { createTaskService } from "./services/task-service.js";
+import { registerArtifactRoutes } from "./api/artifact-routes.js";
+import { registerMessageRoutes } from "./api/message-routes.js";
+import { registerProjectRoutes } from "./api/project-routes.js";
+import { registerSessionRoutes } from "./api/session-routes.js";
+import { registerTaskRoutes } from "./api/task-routes.js";
+import { registerTerminalWs } from "./ws/terminal-ws.js";
+import { toVcmError } from "./errors.js";
+export async function createServer(deps, options = {}) {
+    const app = Fastify({
+        logger: false
+    });
+    app.setErrorHandler((error, _request, reply) => {
+        const vcmError = toVcmError(error);
+        reply.status(vcmError.statusCode).send({
+            error: {
+                code: vcmError.code,
+                message: vcmError.message,
+                hint: vcmError.hint
+            }
+        });
+    });
+    registerProjectRoutes(app, { projectService: deps.projectService });
+    registerTaskRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        statusService: deps.statusService
+    });
+    registerSessionRoutes(app, {
+        projectService: deps.projectService,
+        sessionService: deps.sessionService,
+        commandDispatcher: deps.commandDispatcher
+    });
+    registerArtifactRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        artifactService: deps.artifactService
+    });
+    registerMessageRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        messageService: deps.messageService
+    });
+    registerTerminalWs(app, { runtime: deps.runtime });
+    if (options.staticDir) {
+        await app.register(fastifyStatic, {
+            root: options.staticDir,
+            prefix: "/"
+        });
+        app.setNotFoundHandler((_request, reply) => {
+            reply.sendFile("index.html");
+        });
+    }
+    return app;
+}
+export async function startServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 4173;
+    const deps = createDefaultServerDeps({
+        apiUrl: `http://${host}:${port}`
+    });
+    const app = await createServer(deps, options);
+    await app.listen({ host, port });
+    return {
+        url: `http://${host}:${port}`,
+        close() {
+            return app.close();
+        }
+    };
+}
+export function createDefaultServerDeps(options = {}) {
+    const fs = createNodeFileSystemAdapter();
+    const runner = createCommandRunner();
+    const git = createGitAdapter(runner);
+    const claude = createClaudeAdapter(runner);
+    const runtime = createNodePtyTerminalRuntime({ fs });
+    const registry = createSessionRegistry();
+    const artifactService = createArtifactService(fs);
+    const projectService = createProjectService({ fs, git, claude });
+    const taskService = createTaskService({ fs, git, artifactService, projectService });
+    const sessionService = createSessionService({
+        fs,
+        runtime,
+        registry,
+        claude,
+        artifactService,
+        projectService,
+        taskService,
+        apiUrl: options.apiUrl,
+        vcmctlCommand: options.vcmctlCommand ?? resolveVcmctlCommand()
+    });
+    const commandDispatcher = createCommandDispatcher({
+        runtime,
+        sessionService,
+        taskService,
+        artifactService
+    });
+    const statusService = createStatusService({
+        taskService,
+        sessionService,
+        artifactService
+    });
+    const messageService = createMessageService({
+        fs,
+        runtime,
+        sessionService,
+        taskService
+    });
+    return {
+        projectService,
+        taskService,
+        sessionService,
+        artifactService,
+        commandDispatcher,
+        messageService,
+        statusService,
+        runtime
+    };
+}
+export function getDefaultStaticDir() {
+    return path.resolve("dist-frontend");
+}
+function resolveVcmctlCommand() {
+    const currentModulePath = fileURLToPath(import.meta.url);
+    const appRoot = path.resolve(path.dirname(currentModulePath), "../..");
+    const sourceCli = path.join(appRoot, "src", "cli", "vcmctl.ts");
+    const tsxCli = path.join(appRoot, "node_modules", "tsx", "dist", "cli.mjs");
+    if (currentModulePath.includes(`${path.sep}src${path.sep}`) && existsSync(tsxCli) && existsSync(sourceCli)) {
+        return `${quoteShellArg(process.execPath)} ${quoteShellArg(tsxCli)} ${quoteShellArg(sourceCli)}`;
+    }
+    const distCli = path.join(appRoot, "dist", "cli", "vcmctl.js");
+    if (existsSync(distCli)) {
+        return `${quoteShellArg(process.execPath)} ${quoteShellArg(distCli)}`;
+    }
+    if (existsSync(tsxCli) && existsSync(sourceCli)) {
+        return `${quoteShellArg(process.execPath)} ${quoteShellArg(tsxCli)} ${quoteShellArg(sourceCli)}`;
+    }
+    return "vcmctl";
+}
+function quoteShellArg(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

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

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
+import { VcmError } from "../errors.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { renderArchitecturePlanTemplate, renderImplementationLogTemplate, renderReviewReportTemplate, renderValidationLogTemplate } from "../templates/handoff.js";
+import { renderRoleCommandTemplate } from "../templates/role-command.js";
+const ARTIFACT_PATH_KEYS = [
+    ["architecture-plan", "architecturePlanPath"],
+    ["implementation-log", "implementationLogPath"],
+    ["validation-log", "validationLogPath"],
+    ["review-report", "reviewReportPath"]
+];
+const ROLE_COMMAND_PLACEHOLDER_PATTERN = /(^|\n)\s*(TBD|status:\s*draft)\s*(\n|$)/i;
+export function createArtifactService(fs) {
+    return {
+        getHandoffPaths(_repoRoot, handoffDir) {
+            const roleCommandsDir = path.posix.join(handoffDir, "role-commands");
+            const logsDir = path.posix.join(handoffDir, "logs");
+            return {
+                handoffDir,
+                roleCommandsDir,
+                logsDir,
+                roleCommandPaths: {
+                    architect: path.posix.join(roleCommandsDir, "architect.md"),
+                    coder: path.posix.join(roleCommandsDir, "coder.md"),
+                    reviewer: path.posix.join(roleCommandsDir, "reviewer.md")
+                },
+                roleLogPaths: {
+                    "project-manager": path.posix.join(logsDir, "project-manager.log"),
+                    architect: path.posix.join(logsDir, "architect.log"),
+                    coder: path.posix.join(logsDir, "coder.log"),
+                    reviewer: path.posix.join(logsDir, "reviewer.log")
+                },
+                architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),
+                implementationLogPath: path.posix.join(handoffDir, "implementation-log.md"),
+                validationLogPath: path.posix.join(handoffDir, "validation-log.md"),
+                reviewReportPath: path.posix.join(handoffDir, "review-report.md")
+            };
+        },
+        async ensureHandoffStructure(input) {
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.handoffDir));
+            await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.roleCommandsDir));
+            await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.logsDir));
+            return paths;
+        },
+        async createArtifactTemplates(input) {
+            const paths = await this.ensureHandoffStructure(input);
+            const files = [
+                [paths.roleCommandPaths.architect, renderRoleCommandTemplate(input.taskSlug, "architect")],
+                [paths.roleCommandPaths.coder, renderRoleCommandTemplate(input.taskSlug, "coder")],
+                [paths.roleCommandPaths.reviewer, renderRoleCommandTemplate(input.taskSlug, "reviewer")],
+                [paths.architecturePlanPath, renderArchitecturePlanTemplate(input.taskSlug)],
+                [paths.implementationLogPath, renderImplementationLogTemplate(input.taskSlug)],
+                [paths.validationLogPath, renderValidationLogTemplate(input.taskSlug)],
+                [paths.reviewReportPath, renderReviewReportTemplate(input.taskSlug)]
+            ];
+            const created = [];
+            for (const [artifactPath, content] of files) {
+                const didCreate = await fs.ensureFile(resolveRepoPath(input.repoRoot, artifactPath), content, {
+                    overwrite: input.overwrite
+                });
+                if (didCreate) {
+                    created.push(artifactPath);
+                }
+            }
+            return created;
+        },
+        async listArtifacts(input) {
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            const checks = [];
+            for (const [kind, pathKey] of ARTIFACT_PATH_KEYS) {
+                const artifactPath = paths[pathKey];
+                if (typeof artifactPath !== "string") {
+                    continue;
+                }
+                const content = await readTextOrNull(fs, resolveRepoPath(input.repoRoot, artifactPath));
+                checks.push(checkMarkdownArtifact(kind, artifactPath, content));
+            }
+            return { paths, checks };
+        },
+        async readArtifact(input) {
+            const absolutePath = resolveRepoPath(input.repoRoot, input.artifactPath);
+            if (!(await fs.pathExists(absolutePath))) {
+                throw new VcmError({
+                    code: "ARTIFACT_MISSING",
+                    message: `Artifact does not exist: ${input.artifactPath}`,
+                    statusCode: 404
+                });
+            }
+            return fs.readText(absolutePath);
+        },
+        async resolveRoleCommandPath(input) {
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            if (!DISPATCHABLE_ROLES.includes(input.role)) {
+                throw new VcmError({
+                    code: "ROLE_NOT_DISPATCHABLE",
+                    message: `${input.role} cannot receive role commands.`,
+                    statusCode: 400
+                });
+            }
+            const commandPath = paths.roleCommandPaths[input.role];
+            if (await fs.pathExists(resolveRepoPath(input.repoRoot, commandPath))) {
+                return commandPath;
+            }
+            const legacyCommandPath = getLegacyRoleCommandPath(paths.roleCommandsDir, input.role);
+            if (await fs.pathExists(resolveRepoPath(input.repoRoot, legacyCommandPath))) {
+                return legacyCommandPath;
+            }
+            return commandPath;
+        },
+        async readRoleCommand(input) {
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            const primaryCommandPath = paths.roleCommandPaths[input.role];
+            const commandPath = await this.resolveRoleCommandPath(input);
+            const absolutePath = resolveRepoPath(input.repoRoot, commandPath);
+            if (!(await fs.pathExists(absolutePath))) {
+                throw new VcmError({
+                    code: "ROLE_COMMAND_MISSING",
+                    message: `Missing role command: ${commandPath}`,
+                    statusCode: 404,
+                    hint: "Ask project-manager to produce the role command first."
+                });
+            }
+            const content = await fs.readText(absolutePath);
+            if (!content.trim()) {
+                throw new VcmError({
+                    code: "ROLE_COMMAND_EMPTY",
+                    message: `Role command is empty: ${commandPath}`,
+                    statusCode: 400,
+                    hint: `Ask project-manager to write the real instruction in ${primaryCommandPath}. Keep all files under ${input.handoffDir}.`
+                });
+            }
+            if (ROLE_COMMAND_PLACEHOLDER_PATTERN.test(content)) {
+                throw new VcmError({
+                    code: "ROLE_COMMAND_NOT_READY",
+                    message: `Role command is not ready: ${commandPath}`,
+                    statusCode: 409,
+                    hint: `Ask project-manager to write the real instruction in ${primaryCommandPath}. Keep all files under ${input.handoffDir}.`
+                });
+            }
+            return content;
+        },
+        async saveRoleCommand(input) {
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            await fs.writeText(resolveRepoPath(input.repoRoot, paths.roleCommandPaths[input.role]), input.content);
+        },
+        async appendRoleLog(input) {
+            if (!ROLE_NAMES.includes(input.role)) {
+                throw new VcmError({
+                    code: "UNKNOWN_ROLE",
+                    message: `Unknown role: ${input.role}`,
+                    statusCode: 400
+                });
+            }
+            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
+            await fs.appendText(resolveRepoPath(input.repoRoot, paths.roleLogPaths[input.role]), input.content);
+        }
+    };
+}
+function getLegacyRoleCommandPath(roleCommandsDir, role) {
+    return path.posix.join(roleCommandsDir, `${role}-command.md`);
+}
+async function readTextOrNull(fs, absolutePath) {
+    if (!(await fs.pathExists(absolutePath))) {
+        return null;
+    }
+    return fs.readText(absolutePath);
+}

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

@@ -0,0 +1,37 @@
+import { VcmError } from "../errors.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);
+            await deps.artifactService.readRoleCommand({
+                repoRoot: input.repoRoot,
+                handoffDir: task.handoffDir,
+                role: input.role
+            });
+            const commandPath = await deps.artifactService.resolveRoleCommandPath({
+                repoRoot: input.repoRoot,
+                handoffDir: task.handoffDir,
+                role: input.role
+            });
+            const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            if (!session || session.status !== "running") {
+                throw new VcmError({
+                    code: "SESSION_NOT_RUNNING",
+                    message: `${input.role} session is not running.`,
+                    statusCode: 409,
+                    hint: `Start the ${input.role} session before sending a role command.`
+                });
+            }
+            const instruction = `Please read and execute the role command at: ${commandPath}`;
+            deps.runtime.write(session.id, `${instruction}\r`);
+            return {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                commandPath,
+                instruction,
+                dispatchedAt: now()
+            };
+        }
+    };
+}

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

@@ -0,0 +1,217 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { ROLE_NAMES } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { resolveRepoPath } from "../adapters/filesystem.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"]);
+const ROLE_TO_PM_TYPES = new Set(["result", "question", "blocked", "finding"]);
+export function createMessageService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    const id = deps.id ?? (() => `msg_${randomUUID()}`);
+    return {
+        listMessages(input) {
+            return readLatestMessages(deps.fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+        },
+        async sendMessage(input) {
+            await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
+            validateMessagePolicy(input.fromRole, input.toRole, input.type);
+            const timestamp = now();
+            const message = {
+                id: id(),
+                taskSlug: input.taskSlug,
+                fromRole: input.fromRole,
+                toRole: input.toRole,
+                type: input.type,
+                body: input.body,
+                artifactRefs: input.artifactRefs ?? [],
+                parentMessageId: input.parentMessageId,
+                status: "queued",
+                createdAt: timestamp
+            };
+            message.bodyPath = await writeMessageBody(deps.fs, 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") {
+                message.status = "queued";
+                message.failureReason = `${input.toRole} session is not running.`;
+                await appendMessageSnapshot(deps.fs, input, message);
+                return { message, delivered: false, requiresUserApproval: false };
+            }
+            if (state.mode === "manual") {
+                message.status = "pending_approval";
+                await appendMessageSnapshot(deps.fs, input, message);
+                return { message, delivered: false, requiresUserApproval: true };
+            }
+            if (state.paused) {
+                message.status = "queued";
+                message.failureReason = "Auto orchestration is paused.";
+                await appendMessageSnapshot(deps.fs, input, message);
+                return { message, delivered: false, requiresUserApproval: false };
+            }
+            const delivered = {
+                ...message,
+                status: "delivered",
+                deliveredAt: timestamp,
+                failureReason: undefined
+            };
+            deps.runtime.write(session.id, `${renderMessageEnvelope(delivered)}\r`);
+            await appendMessageSnapshot(deps.fs, input, delivered);
+            return { message: delivered, delivered: true, requiresUserApproval: false };
+        },
+        async stageMessage(input) {
+            const message = await getMessageOrThrow(deps.fs, input);
+            const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, message.toRole);
+            if (!session || session.status !== "running") {
+                throw new VcmError({
+                    code: "MESSAGE_TARGET_NOT_RUNNING",
+                    message: `${message.toRole} session is not running.`,
+                    statusCode: 409,
+                    hint: `Start the ${message.toRole} session before staging this message.`
+                });
+            }
+            const staged = {
+                ...message,
+                status: "staged",
+                stagedAt: now(),
+                failureReason: undefined
+            };
+            deps.runtime.write(session.id, renderManualStagePrompt(staged));
+            await appendMessageSnapshot(deps.fs, input, staged);
+            return staged;
+        },
+        approveMessage(input) {
+            return this.stageMessage(input);
+        },
+        async rejectMessage(input) {
+            const message = await getMessageOrThrow(deps.fs, input);
+            const rejected = {
+                ...message,
+                status: "rejected",
+                failureReason: undefined
+            };
+            await appendMessageSnapshot(deps.fs, input, rejected);
+            return rejected;
+        },
+        async getOrchestrationState(input) {
+            const statePath = getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug);
+            if (!(await deps.fs.pathExists(statePath))) {
+                return {
+                    taskSlug: input.taskSlug,
+                    mode: "manual",
+                    paused: false,
+                    updatedAt: now()
+                };
+            }
+            return deps.fs.readJson(statePath);
+        },
+        async updateOrchestrationState(input) {
+            const current = await this.getOrchestrationState(input);
+            const next = {
+                ...current,
+                mode: input.mode ?? current.mode,
+                paused: input.paused ?? current.paused,
+                updatedAt: now()
+            };
+            await deps.fs.writeJsonAtomic(getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug), next);
+            return next;
+        }
+    };
+}
+function validateMessagePolicy(fromRole, toRole, type) {
+    if (!ROLE_NAMES.includes(toRole)) {
+        throw new VcmError({
+            code: "MESSAGE_TARGET_UNKNOWN",
+            message: `Unknown target role: ${toRole}`,
+            statusCode: 400
+        });
+    }
+    if (fromRole === "user") {
+        if (toRole === PM_ROLE && type === "user-request") {
+            return;
+        }
+        throw new VcmError({
+            code: "MESSAGE_POLICY_DENIED",
+            message: "User messages can only target project-manager as user-request.",
+            statusCode: 403
+        });
+    }
+    if (!ROLE_NAMES.includes(fromRole)) {
+        throw new VcmError({
+            code: "MESSAGE_SENDER_UNKNOWN",
+            message: `Unknown sender role: ${fromRole}`,
+            statusCode: 400
+        });
+    }
+    if (fromRole === PM_ROLE && toRole !== PM_ROLE && PM_TO_ROLE_TYPES.has(type)) {
+        return;
+    }
+    if (fromRole !== PM_ROLE && toRole === PM_ROLE && ROLE_TO_PM_TYPES.has(type)) {
+        return;
+    }
+    throw new VcmError({
+        code: "MESSAGE_POLICY_DENIED",
+        message: `${fromRole} cannot send ${type} messages to ${toRole}.`,
+        statusCode: 403,
+        hint: "Use project-manager as the orchestration hub."
+    });
+}
+async function writeMessageBody(fs, repoRoot, handoffDir, message) {
+    const bodyPath = path.posix.join(handoffDir, "messages", `${message.id}.md`);
+    await fs.writeText(resolveRepoPath(repoRoot, bodyPath), renderMessageBodyFile(message));
+    return bodyPath;
+}
+function renderMessageBodyFile(message) {
+    const artifactRefs = message.artifactRefs.length > 0
+        ? message.artifactRefs.map((artifact) => `- ${artifact}`).join("\n")
+        : "- none";
+    return `# VCM Message ${message.id}
+
+- Task: ${message.taskSlug}
+- From: ${message.fromRole}
+- To: ${message.toRole}
+- Type: ${message.type}
+
+## Body
+
+${message.body}
+
+## Artifact Refs
+
+${artifactRefs}
+`;
+}
+async function getMessageOrThrow(fs, input) {
+    const messages = await readLatestMessages(fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+    const message = messages.find((candidate) => candidate.id === input.messageId);
+    if (!message) {
+        throw new VcmError({
+            code: "MESSAGE_MISSING",
+            message: `Message does not exist: ${input.messageId}`,
+            statusCode: 404
+        });
+    }
+    return message;
+}
+async function readLatestMessages(fs, messagesPath) {
+    if (!(await fs.pathExists(messagesPath))) {
+        return [];
+    }
+    const latest = new Map();
+    const lines = (await fs.readText(messagesPath)).split(/\r?\n/).filter(Boolean);
+    for (const line of lines) {
+        const message = JSON.parse(line);
+        latest.set(message.id, message);
+    }
+    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`);
+}
+function getMessagesPath(repoRoot, stateRoot, taskSlug) {
+    return path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`);
+}
+function getOrchestrationStatePath(repoRoot, stateRoot, taskSlug) {
+    return path.join(repoRoot, stateRoot, "orchestration", `${taskSlug}.json`);
+}

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

@@ -0,0 +1,71 @@
+import path from "node:path";
+import { ROLE_NAMES } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+export function createProjectService(deps) {
+    let currentProject = null;
+    return {
+        async connectProject(input) {
+            const repoRoot = path.resolve(input.repoPath);
+            if (!(await deps.git.isRepo(repoRoot))) {
+                throw new VcmError({
+                    code: "INVALID_REPO",
+                    message: "Selected path is not a Git repository.",
+                    statusCode: 400
+                });
+            }
+            const config = buildDefaultProjectConfig(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 this.saveConfig(config, true);
+            const branch = await deps.git.getCurrentBranch(repoRoot);
+            const isDirty = await deps.git.isDirty(repoRoot);
+            const warnings = [];
+            if (branch === "main" || branch === "master") {
+                warnings.push(`You are on ${branch}. Consider creating a task branch before coding.`);
+            }
+            if (!(await deps.claude.isAvailable(config.claudeCommand))) {
+                warnings.push("Claude Code command is not available. You can still inspect artifacts, but sessions will not start.");
+            }
+            currentProject = {
+                repoRoot,
+                branch,
+                isDirty,
+                config,
+                warnings
+            };
+            return currentProject;
+        },
+        async getCurrentProject() {
+            return currentProject;
+        },
+        async loadConfig(repoRoot) {
+            const configPath = this.getConfigPath(repoRoot);
+            if (!(await deps.fs.pathExists(configPath))) {
+                return buildDefaultProjectConfig(repoRoot);
+            }
+            return deps.fs.readJson(configPath);
+        },
+        async saveConfig(config, force = false) {
+            const configPath = this.getConfigPath(config.repoRoot);
+            if (!force && await deps.fs.pathExists(configPath)) {
+                return;
+            }
+            await deps.fs.writeJsonAtomic(configPath, config);
+        },
+        getConfigPath(repoRoot) {
+            return path.join(repoRoot, ".vcm", "config.json");
+        }
+    };
+}
+export function buildDefaultProjectConfig(repoRoot) {
+    return {
+        version: 1,
+        repoRoot,
+        defaultRoles: [...ROLE_NAMES],
+        handoffRoot: ".ai/handoffs",
+        stateRoot: ".vcm",
+        terminalBackend: "node-pty",
+        claudeCommand: process.env.VCM_CLAUDE_COMMAND || "claude"
+    };
+}