vibe-coding-master 0.3.23 → 0.3.25

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

@@ -9,13 +9,8 @@ export function createTaskService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const taskStoreRoot = deps.projectService.getProjectDataRoot(repoRoot);
             const taskPath = getTaskPath(taskStoreRoot, input.taskSlug);
-            const shouldCreateWorktree = input.createWorktree !== false;
-            const taskBranch = shouldCreateWorktree
-                ? `feature/${input.taskSlug}`
-                : await deps.git.getCurrentBranch(repoRoot);
-            const worktreePath = shouldCreateWorktree
-                ? getTaskWorktreePath(repoRoot, input.taskSlug)
-                : undefined;
+            const taskBranch = `feature/${input.taskSlug}`;
+            const worktreePath = getTaskWorktreePath(repoRoot, input.taskSlug);
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
                     code: "TASK_EXISTS",
@@ -31,7 +26,7 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore contains the VCM managed block."
                 });
             }
-            if (shouldCreateWorktree && !(await deps.git.isIgnored(repoRoot, ".claude/worktrees/.probe"))) {
+            if (!(await deps.git.isIgnored(repoRoot, ".claude/worktrees/.probe"))) {
                 throw new VcmError({
                     code: "VCM_WORKTREES_NOT_IGNORED",
                     message: ".claude/worktrees/ is not ignored by Git.",
@@ -39,53 +34,39 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore ignores Claude-compatible task worktrees."
                 });
             }
-            if (!shouldCreateWorktree) {
-                const activeInlineTask = await findActiveInlineTask(deps.fs, taskStoreRoot);
-                if (activeInlineTask) {
-                    throw new VcmError({
-                        code: "INLINE_TASK_EXISTS",
-                        message: `An inline task already exists: ${activeInlineTask.taskSlug}`,
-                        statusCode: 409,
-                        hint: "Close the existing inline task first, or enable Create worktree and branch for this task."
-                    });
-                }
+            if (await deps.git.branchExists(repoRoot, taskBranch)) {
+                throw new VcmError({
+                    code: "TASK_BRANCH_EXISTS",
+                    message: `Task branch already exists: ${taskBranch}`,
+                    statusCode: 409,
+                    hint: "Choose a different task name or clean up the existing branch."
+                });
+            }
+            if (await deps.fs.pathExists(worktreePath)) {
+                throw new VcmError({
+                    code: "TASK_WORKTREE_EXISTS",
+                    message: `Task worktree already exists: ${worktreePath}`,
+                    statusCode: 409,
+                    hint: "Choose a different task name or clean up the existing worktree."
+                });
             }
-            if (shouldCreateWorktree && worktreePath) {
-                if (await deps.git.branchExists(repoRoot, taskBranch)) {
-                    throw new VcmError({
-                        code: "TASK_BRANCH_EXISTS",
-                        message: `Task branch already exists: ${taskBranch}`,
-                        statusCode: 409,
-                        hint: "Choose a different task name or clean up the existing branch."
-                    });
-                }
-                if (await deps.fs.pathExists(worktreePath)) {
-                    throw new VcmError({
-                        code: "TASK_WORKTREE_EXISTS",
-                        message: `Task worktree already exists: ${worktreePath}`,
-                        statusCode: 409,
-                        hint: "Choose a different task name or clean up the existing worktree."
-                    });
-                }
-                const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
-                if (baseStatus.trim()) {
-                    throw new VcmError({
-                        code: "BASE_REPO_DIRTY",
-                        message: "The connected repository has uncommitted changes.",
-                        statusCode: 409,
-                        hint: "Commit, stash, or discard base repository changes before creating a task worktree."
-                    });
-                }
-                await deps.fs.ensureDir(path.dirname(worktreePath));
-                await deps.git.createWorktree({
-                    repoRoot,
-                    branch: taskBranch,
-                    worktreePath,
-                    baseRef: "HEAD"
+            const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
+            if (baseStatus.trim()) {
+                throw new VcmError({
+                    code: "BASE_REPO_DIRTY",
+                    message: "The connected repository has uncommitted changes.",
+                    statusCode: 409,
+                    hint: "Commit, stash, or discard base repository changes before creating a task worktree."
                 });
             }
             const timestamp = now();
-            const taskRepoRoot = worktreePath ?? repoRoot;
+            await deps.fs.ensureDir(path.dirname(worktreePath));
+            await deps.git.createWorktree({
+                repoRoot,
+                branch: taskBranch,
+                worktreePath,
+                baseRef: "HEAD"
+            });
             const task = {
                 version: 1,
                 taskSlug: input.taskSlug,
@@ -100,14 +81,14 @@ export function createTaskService(deps) {
                 specPath: input.specPath,
                 cleanupStatus: "active"
             };
-            await ensureTaskRuntimeStateDirs(deps.fs, taskRepoRoot, config.stateRoot);
+            await ensureTaskRuntimeStateDirs(deps.fs, worktreePath, config.stateRoot);
             await deps.artifactService.ensureHandoffStructure({
-                repoRoot: taskRepoRoot,
+                repoRoot: worktreePath,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
             await deps.artifactService.createArtifactTemplates({
-                repoRoot: taskRepoRoot,
+                repoRoot: worktreePath,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir,
                 branch: task.branch
@@ -123,7 +104,7 @@ export function createTaskService(deps) {
             const entries = await deps.fs.readDir(tasksDir);
             const tasks = [];
             for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
-                tasks.push(normalizeTaskRecord(await deps.fs.readJson(path.join(tasksDir, entry))));
+                tasks.push(await deps.fs.readJson(path.join(tasksDir, entry)));
             }
             return tasks.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
         },
@@ -137,7 +118,7 @@ export function createTaskService(deps) {
                     statusCode: 404
                 });
             }
-            return normalizeTaskRecord(await deps.fs.readJson(taskPath));
+            return deps.fs.readJson(taskPath);
         },
         async saveTask(repoRoot, task) {
             await deps.fs.writeJsonAtomic(getTaskPath(deps.projectService.getProjectDataRoot(repoRoot), task.taskSlug), task);
@@ -167,15 +148,9 @@ export function createTaskService(deps) {
             const statePaths = getTaskStatePaths(deps.projectService.getProjectDataRoot(repoRoot), taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
-            if (task.worktreePath) {
-                assertTaskWorktreePath(repoRoot, task.worktreePath);
-                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
-            }
-            let deletedBranch;
-            if (task.worktreePath && (options.deleteBranch ?? true)) {
-                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
-                deletedBranch = task.branch;
-            }
+            assertTaskWorktreePath(repoRoot, task.worktreePath);
+            await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
+            await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
             for (const statePath of statePaths) {
                 await deps.fs.removePath(statePath, { recursive: true, force: true });
                 removedStatePaths.push(statePath);
@@ -184,14 +159,14 @@ export function createTaskService(deps) {
                 taskSlug,
                 removedWorktreePath: task.worktreePath,
                 removedStatePaths,
-                deletedBranch,
+                deletedBranch: task.branch,
                 cleanedAt
             };
         }
     };
 }
 export function getTaskRuntimeRepoRoot(task) {
-    return task.worktreePath ?? task.repoRoot;
+    return task.worktreePath;
 }
 function getTaskPath(taskStoreRoot, taskSlug) {
     return path.join(taskStoreRoot, "tasks", `${taskSlug}.json`);
@@ -206,49 +181,6 @@ async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "codex-reviews"));
 }
-async function findActiveInlineTask(fs, taskStoreRoot) {
-    const tasksDir = path.join(taskStoreRoot, "tasks");
-    if (!(await fs.pathExists(tasksDir))) {
-        return undefined;
-    }
-    const entries = await fs.readDir(tasksDir);
-    for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
-        const task = normalizeTaskRecord(await fs.readJson(path.join(tasksDir, entry)));
-        if (!task.worktreePath && task.cleanupStatus !== "cleaned") {
-            return task;
-        }
-    }
-    return undefined;
-}
-function normalizeTaskRecord(input) {
-    return {
-        version: 1,
-        taskSlug: input.taskSlug ?? "",
-        title: input.title,
-        createdAt: input.createdAt ?? "",
-        updatedAt: input.updatedAt ?? input.createdAt ?? "",
-        repoRoot: input.repoRoot ?? "",
-        worktreePath: input.worktreePath,
-        branch: input.branch ?? "",
-        handoffDir: input.handoffDir ?? ".ai/vcm/handoffs",
-        status: normalizeTaskStatus(input.status),
-        specPath: input.specPath,
-        cleanupStatus: input.cleanupStatus,
-        cleanedAt: input.cleanedAt
-    };
-}
-function normalizeTaskStatus(value) {
-    if (value === "created" || value === "running" || value === "stopped") {
-        return value;
-    }
-    if (value === undefined || value === null) {
-        return "created";
-    }
-    if (value === "planning") {
-        return "created";
-    }
-    return "stopped";
-}
 function getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
     return [
         getTaskPath(taskStoreRoot, taskSlug),

package/dist/backend/templates/harness/project-manager-agent.js

@@ -35,10 +35,19 @@ export function renderProjectManagerHarnessRules() {
 ### Dispatch
 
 - Use the \`vcm-route-message\` skill for every role dispatch, question, result, blocker, or finding.
-- Route messages contain PM-owned routing context only: target role, user request summary, known user constraints, source of truth, required next gate, skipped gates when applicable, required handoff inputs, expected artifact, stop conditions, and confirmed worktree information.
+- Formal route messages contain PM-owned routing context only: target role, user request summary, known user constraints, source of truth, required next gate, skipped gates when applicable, required handoff inputs, expected artifact, stop conditions, and confirmed worktree information.
 - Do not write technical design into route messages; ask architect to determine architecture, file scope, public contracts, behavior/contract proof points, docs impact, and Replan triggers.
 - For coder or reviewer messages, reference existing handoff artifacts instead of making new technical judgments.
 
+### Simple User Relay
+
+When forwarding a user's answer, clarification, or small preference update to an active role, use a lightweight relay message.
+
+PM may lightly rewrite the user's words to:
+- clarify pronouns or references from the current context
+- translate the user's intent into clear role-facing language
+- state whether this is confirmation, rejection, preference, or a small constraint
+
 ### Phased Tasks
 
 - When architect provides a phased plan, dispatch only one phase at a time.

package/dist/backend/templates/harness/vcm-route-message-skill.js

@@ -33,6 +33,12 @@ If the same route file already contains a not-yet-delivered message, update that
 
 ## Message Format
 
+Use the smallest body that is complete. Include artifact refs instead of copying long documents.
+
+For simple user relay, use a lightweight body instead of the formal dispatch format.
+
+For formal dispatch, blocker, finding, review, or gate routing, use:
+
 \`\`\`md
 ---
 type: task
@@ -54,9 +60,9 @@ Expected next action:
 ...
 \`\`\`
 
-Use the smallest body that is complete. Include artifact refs instead of copying long documents.
+## Formal Body Content
 
-## Required Body Content
+Formal messages should include:
 
 - why this message exists
 - what the target role should do or what result is being reported