vibe-coding-master 0.0.12 → 0.0.14

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

@@ -8,58 +8,191 @@ import { renderManualStagePrompt, renderMessageEnvelope } from "../templates/mes
 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"]);
+const MARK_ALL_DONE_STATUSES = new Set([
+    "pending_approval",
+    "queued",
+    "staged",
+    "delivering",
+    "submitted",
+    "delivered",
+    "failed",
+    "delivery_failed",
+    "response_ready_missing_result"
+]);
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
+    const taskLocks = new Map();
+    async function getOrchestrationState(input) {
+        const statePath = getOrchestrationStatePath(getStateRepoRoot(input), 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 function sendMessageLocked(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.taskRepoRoot ?? input.repoRoot, input.handoffDir, message);
+        let messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+        if (isRoleActor(input.fromRole)) {
+            const acknowledged = acknowledgeActiveMessages(messages, input.fromRole, timestamp);
+            for (const acknowledgedMessage of acknowledged) {
+                await appendMessageSnapshot(deps.fs, input, acknowledgedMessage);
+            }
+            messages = applyMessageSnapshots(messages, acknowledged);
+        }
+        const state = await getOrchestrationState(input);
+        const result = await routeOutboundMessage(input, message, messages, state, timestamp);
+        await appendMessageSnapshot(deps.fs, input, result.message);
+        if (isRoleActor(input.fromRole)) {
+            await deliverNextQueuedMessage(input, input.fromRole);
+        }
+        return result;
+    }
+    async function routeOutboundMessage(input, message, existingMessages, state, timestamp) {
+        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.toRole);
+        if (!session || session.status !== "running") {
+            const queued = {
+                ...message,
+                status: "queued",
+                failureReason: `${input.toRole} session is not running.`
+            };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        if (state.mode === "manual") {
+            const pending = {
+                ...message,
+                status: "pending_approval"
+            };
+            return { message: pending, delivered: false, requiresUserApproval: true };
+        }
+        if (state.paused) {
+            const queued = {
+                ...message,
+                status: "queued",
+                failureReason: "Auto orchestration is paused."
+            };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        const activeMessage = findActiveMessageForRole(existingMessages, input.toRole);
+        if (activeMessage) {
+            const queued = {
+                ...message,
+                status: "queued",
+                queuedBehindMessageId: activeMessage.id,
+                failureReason: `${input.toRole} is still handling VCM message ${activeMessage.id}.`
+            };
+            return { message: queued, delivered: false, requiresUserApproval: false };
+        }
+        const delivered = await deliverMessageToSession(session.id, message, timestamp);
+        return { message: delivered, delivered: true, requiresUserApproval: false };
+    }
+    async function deliverNextQueuedMessage(input, targetRole) {
+        const state = await getOrchestrationState(input);
+        if (state.mode !== "auto" || state.paused) {
+            return undefined;
+        }
+        const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+        if (findActiveMessageForRole(messages, targetRole)) {
+            return undefined;
+        }
+        const nextMessage = messages.find((message) => message.toRole === targetRole && message.status === "queued");
+        if (!nextMessage) {
+            return undefined;
+        }
+        const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, targetRole);
+        if (!session || session.status !== "running") {
+            return undefined;
+        }
+        const delivered = await deliverMessageToSession(session.id, nextMessage, now());
+        await appendMessageSnapshot(deps.fs, input, delivered);
+        return delivered;
+    }
+    async function deliverMessageToSession(sessionId, message, timestamp) {
+        const delivering = {
+            ...message,
+            status: "delivering",
+            deliveredAt: timestamp,
+            queuedBehindMessageId: undefined,
+            failureReason: undefined
+        };
+        await submitTerminalInput(deps.runtime, sessionId, renderMessageEnvelope(delivering));
+        return delivering;
+    }
     return {
         listMessages(input) {
             return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), 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.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") {
-                message.status = "queued";
-                message.failureReason = `${input.toRole} session is not running.`;
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: false };
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => sendMessageLocked(input));
+        },
+        async confirmPromptSubmitted(input) {
+            const messageId = extractSubmittedMessageId(input.prompt);
+            if (!messageId) {
+                return undefined;
             }
-            if (state.mode === "manual") {
-                message.status = "pending_approval";
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: true };
+            const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+            const message = messages.find((candidate) => candidate.id === messageId && candidate.toRole === input.role);
+            if (!message) {
+                return undefined;
             }
-            if (state.paused) {
-                message.status = "queued";
-                message.failureReason = "Auto orchestration is paused.";
-                await appendMessageSnapshot(deps.fs, input, message);
-                return { message, delivered: false, requiresUserApproval: false };
+            if (message.status === "submitted" || message.status === "acknowledged") {
+                return message;
             }
-            const delivered = {
+            if (!isSubmittableMessageStatus(message.status)) {
+                return undefined;
+            }
+            const submitted = {
                 ...message,
-                status: "delivered",
-                deliveredAt: timestamp,
+                status: "submitted",
+                submittedAt: now(),
                 failureReason: undefined
             };
-            await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
-            await appendMessageSnapshot(deps.fs, input, delivered);
-            return { message: delivered, delivered: true, requiresUserApproval: false };
+            await appendMessageSnapshot(deps.fs, input, submitted);
+            return submitted;
+        },
+        async markAllDone(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const timestamp = now();
+                const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+                const updated = messages
+                    .filter((message) => MARK_ALL_DONE_STATUSES.has(message.status))
+                    .map((message) => ({
+                    ...message,
+                    status: "acknowledged",
+                    acknowledgedAt: timestamp,
+                    queuedBehindMessageId: undefined,
+                    failureReason: undefined
+                }));
+                for (const message of updated) {
+                    await appendMessageSnapshot(deps.fs, input, message);
+                }
+                const latest = applyMessageSnapshots(messages, updated);
+                return {
+                    taskSlug: input.taskSlug,
+                    updatedCount: updated.length,
+                    messages: latest
+                };
+            });
         },
         async stageMessage(input) {
             const message = await getMessageOrThrow(deps.fs, input);
@@ -96,19 +229,10 @@ export function createMessageService(deps) {
             return rejected;
         },
         async getOrchestrationState(input) {
-            const statePath = getOrchestrationStatePath(getStateRepoRoot(input), 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);
+            return getOrchestrationState(input);
         },
         async updateOrchestrationState(input) {
-            const current = await this.getOrchestrationState(input);
+            const current = await getOrchestrationState(input);
             const next = {
                 ...current,
                 mode: input.mode ?? current.mode,
@@ -158,6 +282,55 @@ function validateMessagePolicy(fromRole, toRole, type) {
         hint: "Use project-manager as the orchestration hub."
     });
 }
+async function withTaskLock(locks, key, run) {
+    const previous = locks.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(run);
+    locks.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (locks.get(key) === next) {
+            locks.delete(key);
+        }
+    }
+}
+function isRoleActor(actor) {
+    return ROLE_NAMES.includes(actor);
+}
+function findActiveMessageForRole(messages, role) {
+    return messages.find((message) => message.toRole === role && isActiveMessageStatus(message.status));
+}
+function acknowledgeActiveMessages(messages, role, timestamp) {
+    return messages
+        .filter((message) => message.toRole === role && isActiveMessageStatus(message.status))
+        .map((message) => ({
+        ...message,
+        status: "acknowledged",
+        acknowledgedAt: timestamp,
+        failureReason: undefined
+    }));
+}
+function isActiveMessageStatus(status) {
+    return status === "delivering" || status === "submitted" || status === "delivered" || status === "staged";
+}
+function isSubmittableMessageStatus(status) {
+    return status === "delivering" || status === "delivered" || status === "staged" || status === "pending_approval";
+}
+function extractSubmittedMessageId(prompt) {
+    const match = prompt.match(/\bmsg_[A-Za-z0-9_-]+\b/);
+    return match?.[0];
+}
+function applyMessageSnapshots(messages, snapshots) {
+    if (snapshots.length === 0) {
+        return messages;
+    }
+    const latest = new Map(messages.map((message) => [message.id, message]));
+    for (const snapshot of snapshots) {
+        latest.set(snapshot.id, snapshot);
+    }
+    return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+}
 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));

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

@@ -31,7 +31,7 @@ export function createProjectService(deps) {
             const config = await this.loadConfig(repoRoot);
             await deps.fs.ensureDir(path.join(repoRoot, config.handoffRoot));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "worktrees"));
+            await deps.fs.ensureDir(path.join(repoRoot, ".claude", "worktrees"));
             await this.saveConfig(config, true);
             const warnings = [];
             let branch = "unknown";

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

@@ -0,0 +1,117 @@
+import { ROLE_NAMES } from "../../shared/constants.js";
+export function createRoundService(deps = {}) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        getTaskRoundState(input) {
+            const roleStates = ROLE_NAMES.map((role) => toRoleTurnState(role, input.sessions));
+            const latestDelivered = getLatestDeliveredMessage(input.messages);
+            const queuedMessageCount = input.messages.filter((message) => message.status === "queued").length;
+            const pendingMessageCount = input.messages.filter((message) => message.status === "pending_approval").length;
+            const state = evaluateTaskRoundState({
+                taskSlug: input.taskSlug,
+                messages: input.messages,
+                roleStates,
+                updatedAt: now()
+            });
+            return {
+                ...state,
+                latestMessageId: latestDelivered?.id,
+                latestMessageDeliveredAt: getMessageDeliveredAt(latestDelivered),
+                queuedMessageCount,
+                pendingMessageCount
+            };
+        },
+        stopSession() { },
+        stopTask() { }
+    };
+}
+export function evaluateTaskRoundState(input) {
+    const latestDelivered = getLatestDeliveredMessage(input.messages);
+    const hasQueuedOrPending = input.messages.some((message) => message.status === "queued" || message.status === "pending_approval");
+    if (latestDelivered) {
+        const deliveredAt = getMessageDeliveredAt(latestDelivered);
+        const targetState = input.roleStates.find((roleState) => roleState.role === latestDelivered.toRole);
+        const completedAt = targetState && deliveredAt
+            ? getCompletedAtForDelivery(targetState, deliveredAt)
+            : undefined;
+        if (completedAt && !hasQueuedOrPending) {
+            return {
+                taskSlug: input.taskSlug,
+                status: "completed",
+                activeRole: latestDelivered.toRole,
+                completionId: `${latestDelivered.id}:${completedAt}`,
+                completedAt,
+                roles: input.roleStates,
+                updatedAt: input.updatedAt
+            };
+        }
+        return {
+            taskSlug: input.taskSlug,
+            status: targetState?.status === "waiting_user" ? "waiting_user" : "active",
+            activeRole: latestDelivered.toRole,
+            roles: input.roleStates,
+            updatedAt: input.updatedAt
+        };
+    }
+    const latestIdleRole = !hasQueuedOrPending ? getLatestIdleRole(input.roleStates) : undefined;
+    if (latestIdleRole?.lastAnswerEndedAt) {
+        return {
+            taskSlug: input.taskSlug,
+            status: "completed",
+            activeRole: latestIdleRole.role,
+            completionId: `direct:${latestIdleRole.role}:${latestIdleRole.lastAnswerEndedAt}`,
+            completedAt: latestIdleRole.lastAnswerEndedAt,
+            roles: input.roleStates,
+            updatedAt: input.updatedAt
+        };
+    }
+    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
+        roleState.status === "using_tools" ||
+        roleState.status === "waiting_user" ||
+        roleState.status === "abnormal");
+    return {
+        taskSlug: input.taskSlug,
+        status: activeRole?.status === "waiting_user" ? "waiting_user" : activeRole ? "active" : "idle",
+        activeRole: activeRole?.role,
+        roles: input.roleStates,
+        updatedAt: input.updatedAt
+    };
+}
+function toRoleTurnState(role, sessions) {
+    const session = sessions.find((candidate) => candidate.role === role && candidate.status === "running");
+    const activityStatus = session?.activityStatus ?? "idle";
+    return {
+        role,
+        sessionId: session?.id,
+        status: session ? activityStatus === "running" ? "answering" : "idle" : "unknown",
+        pendingToolUseCount: 0,
+        lastActivityAt: session?.lastPromptSubmittedAt ?? session?.lastHookEventAt,
+        lastAnswerEndedAt: session?.lastStopAt,
+        reason: session
+            ? activityStatus === "running"
+                ? "Claude Code accepted a prompt and has not emitted Stop yet."
+                : "Claude Code emitted Stop or has not started a prompt in this process."
+            : undefined
+    };
+}
+function getLatestDeliveredMessage(messages) {
+    return messages
+        .filter((message) => message.status === "delivering" || message.status === "submitted" || message.status === "delivered" || message.status === "staged")
+        .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
+        .at(-1);
+}
+function getMessageDeliveredAt(message) {
+    return message?.submittedAt ?? message?.deliveredAt ?? message?.stagedAt ?? message?.createdAt ?? "";
+}
+function getCompletedAtForDelivery(roleState, deliveredAt) {
+    if (roleState.status !== "idle" || !roleState.lastAnswerEndedAt) {
+        return undefined;
+    }
+    return roleState.lastAnswerEndedAt >= deliveredAt ? roleState.lastAnswerEndedAt : undefined;
+}
+function getLatestIdleRole(roleStates) {
+    return roleStates
+        .filter((roleState) => roleState.status === "idle" && roleState.lastAnswerEndedAt)
+        .sort((left, right) => (left.lastAnswerEndedAt ?? "").localeCompare(right.lastAnswerEndedAt ?? ""))
+        .at(-1);
+}

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

@@ -57,6 +57,7 @@ export function createSessionService(deps) {
             taskSlug,
             role,
             status: runtimeSession.status,
+            activityStatus: "idle",
             command: startCommand.display,
             permissionMode,
             cwd: taskRepoRoot,
@@ -99,6 +100,7 @@ export function createSessionService(deps) {
             const updated = {
                 ...existing,
                 status: "exited",
+                activityStatus: "idle",
                 updatedAt: now()
             };
             deps.registry.upsert(updated);
@@ -139,6 +141,7 @@ export function createSessionService(deps) {
             return {
                 ...record,
                 status: runtimeSession.status,
+                activityStatus: record.activityStatus ?? "idle",
                 pid: runtimeSession.pid,
                 lastOutputAt: runtimeSession.lastOutputAt,
                 exitCode: runtimeSession.exitCode
@@ -153,9 +156,45 @@ export function createSessionService(deps) {
                 }
             }
             return sessions;
+        },
+        async recordClaudeHookEvent(repoRoot, input) {
+            const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
+            if (!current || !matchesClaudeHookSession(current, input)) {
+                return undefined;
+            }
+            const timestamp = now();
+            const updated = {
+                ...current,
+                activityStatus: input.eventName === "UserPromptSubmit" ? "running" : "idle",
+                lastHookEventAt: timestamp,
+                lastPromptSubmittedAt: input.eventName === "UserPromptSubmit"
+                    ? timestamp
+                    : current.lastPromptSubmittedAt,
+                lastStopAt: input.eventName === "Stop"
+                    ? timestamp
+                    : current.lastStopAt,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, input.taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            return updated;
         }
     };
 }
+function matchesClaudeHookSession(record, input) {
+    if (input.claudeSessionId && record.claudeSessionId === input.claudeSessionId) {
+        return true;
+    }
+    if (input.transcriptPath && record.transcriptPath === input.transcriptPath) {
+        return true;
+    }
+    if (!input.claudeSessionId && !input.transcriptPath) {
+        return true;
+    }
+    return false;
+}
 function getRecoverableStatus(record) {
     if (!record.claudeSessionId) {
         return record.status === "running" ? "missing" : record.status;

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

@@ -16,84 +16,8 @@ export function createStatusService(deps) {
                 task,
                 sessions,
                 artifacts,
-                workflow: buildWorkflowReport(artifacts, sessions),
                 warnings
             };
         }
     };
 }
-function buildWorkflowReport(artifacts, sessions) {
-    const isComplete = (kind) => artifacts.checks.find((check) => check.kind === kind)?.status === "ok";
-    const roleIsRunning = (role) => sessions.some((session) => session.role === role && session.status === "running");
-    const architectureComplete = isComplete("architecture-plan");
-    const implementationComplete = isComplete("implementation-log") && isComplete("validation-log");
-    const reviewComplete = isComplete("review-report");
-    const docsSyncComplete = isComplete("docs-sync-report");
-    const steps = [
-        {
-            id: "architecture-plan",
-            label: "Architecture",
-            role: "architect",
-            artifactPaths: [artifacts.paths.architecturePlanPath],
-            status: architectureComplete ? "complete" : "ready",
-            detail: architectureComplete
-                ? "architecture-plan.md is ready."
-                : roleIsRunning("architect")
-                    ? "Architect is running; produce architecture-plan.md before coder work."
-                    : "Start architect and produce architecture-plan.md before coder work."
-        },
-        {
-            id: "implementation",
-            label: "Implementation",
-            role: "coder",
-            artifactPaths: [artifacts.paths.implementationLogPath, artifacts.paths.validationLogPath],
-            status: implementationComplete ? "complete" : architectureComplete ? "ready" : "blocked",
-            detail: implementationComplete
-                ? "implementation-log.md and validation-log.md are ready."
-                : architectureComplete
-                    ? "Start coder, then update implementation-log.md and validation-log.md."
-                    : "Blocked until architecture-plan.md is complete."
-        },
-        {
-            id: "review",
-            label: "Review",
-            role: "reviewer",
-            artifactPaths: [artifacts.paths.reviewReportPath],
-            status: reviewComplete ? "complete" : implementationComplete ? "ready" : "blocked",
-            detail: reviewComplete
-                ? "review-report.md is ready."
-                : implementationComplete
-                    ? "Start reviewer for independent review and final test adequacy."
-                    : "Blocked until implementation-log.md and validation-log.md are complete."
-        },
-        {
-            id: "docs-sync",
-            label: "Docs Sync",
-            role: "architect",
-            artifactPaths: [artifacts.paths.docsSyncReportPath],
-            status: docsSyncComplete ? "complete" : reviewComplete ? "ready" : "blocked",
-            detail: docsSyncComplete
-                ? "docs-sync-report.md is ready."
-                : reviewComplete
-                    ? "Send architect a docs-sync / architecture drift check task."
-                    : "Blocked until review-report.md is complete."
-        },
-        {
-            id: "final-acceptance",
-            label: "PM Final",
-            role: "project-manager",
-            artifactPaths: [],
-            status: docsSyncComplete ? "ready" : "blocked",
-            detail: docsSyncComplete
-                ? "Project Manager can prepare final acceptance, commit, and PR."
-                : "Blocked until architect docs sync is complete."
-        }
-    ];
-    const current = steps.find((step) => step.status !== "complete") ?? steps[steps.length - 1];
-    return {
-        currentStepId: current.id,
-        nextAction: current.detail,
-        blocked: current.status === "blocked",
-        steps
-    };
-}

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

@@ -13,7 +13,7 @@ export function createTaskService(deps) {
                 ? `feature/${input.taskSlug}`
                 : await deps.git.getCurrentBranch(repoRoot);
             const worktreePath = shouldCreateWorktree
-                ? getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug)
+                ? getTaskWorktreePath(repoRoot, input.taskSlug)
                 : undefined;
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
@@ -30,6 +30,14 @@ 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"))) {
+                throw new VcmError({
+                    code: "VCM_WORKTREES_NOT_IGNORED",
+                    message: ".claude/worktrees/ is not ignored by Git.",
+                    statusCode: 409,
+                    hint: "Apply VCM Harness first so .gitignore ignores Claude-compatible task worktrees."
+                });
+            }
             if (!shouldCreateWorktree) {
                 const activeInlineTask = await findActiveInlineTask(deps.fs, repoRoot, config.stateRoot);
                 if (activeInlineTask) {
@@ -161,7 +169,7 @@ export function createTaskService(deps) {
             const removedStatePaths = [];
             const cleanedAt = now();
             if (task.worktreePath) {
-                assertTaskWorktreePath(repoRoot, config.stateRoot, task.worktreePath);
+                assertTaskWorktreePath(repoRoot, task.worktreePath);
                 await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
             }
             let deletedBranch;
@@ -189,8 +197,8 @@ export function getTaskRuntimeRepoRoot(task) {
 function getTaskPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`);
 }
-function getTaskWorktreePath(repoRoot, stateRoot, taskSlug) {
-    return path.join(repoRoot, stateRoot, "worktrees", taskSlug);
+function getTaskWorktreePath(repoRoot, taskSlug) {
+    return path.join(repoRoot, ".claude", "worktrees", taskSlug);
 }
 async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "sessions"));
@@ -222,8 +230,8 @@ function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, handoffRoot, t
         path.join(taskRepoRoot, handoffRoot)
     ];
 }
-function assertTaskWorktreePath(repoRoot, stateRoot, worktreePath) {
-    const worktreeRoot = path.resolve(repoRoot, stateRoot, "worktrees");
+function assertTaskWorktreePath(repoRoot, worktreePath) {
+    const worktreeRoot = path.resolve(repoRoot, ".claude", "worktrees");
     const resolvedWorktreePath = path.resolve(worktreePath);
     const relative = path.relative(worktreeRoot, resolvedWorktreePath);
     if (relative.startsWith("..") || path.isAbsolute(relative) || relative === "") {

package/dist/backend/templates/harness/architect-agent.js

@@ -8,5 +8,10 @@ export function renderArchitectHarnessRules() {
 - Update stale architecture/module/testing/security/dependency docs when the final code made them stale.
 - Write docs-sync-report.md with docs changed, docs intentionally left unchanged, remaining documentation risks, and decision.
 - Stop and reply to project-manager if implementation drift changes architecture, public contracts, dependency direction, schema, auth, permission, payment, or design assumptions.
+- Reply to project-manager once per received VCM message when complete, blocked, or unclear; do not send fragmented progress updates unless project-manager explicitly requested them.
+- If you need to send a VCM message, send at most one message to any single target role in the current Claude Code turn, then end the turn.
+- After a successful vcmctl reply or vcmctl result, end the turn immediately. Do not run vcmctl inbox, poll, loop, or keep working while waiting for project-manager to answer.
+- Do not wait in a loop for another role to answer. VCM will deliver later replies in a new turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; communicate through vcmctl only.
 `;
 }

package/dist/backend/templates/harness/claude-root.js

@@ -8,6 +8,12 @@ export function renderRootClaudeHarnessRules() {
 - Do not create or write task handoffs outside .ai/vcm/handoffs/ for the current task.
 - Use vcmctl for role-to-role messaging instead of asking the user to copy prompts.
 - Non-PM roles only reply to project-manager; they do not message other roles directly.
+- Role messaging is turn-based: do not send more than one active message to the same target role.
+- After sending a message to a role, wait for that role to reply with vcmctl reply or vcmctl result before sending another message to the same role.
+- After any successful vcmctl send, vcmctl reply, or vcmctl result, end the current Claude Code turn. Treat the command as the final coordination action of this turn.
+- Do not run vcmctl inbox, poll files, start shell loops, or keep the turn open waiting for another role's answer. VCM will deliver replies in a later turn.
+- Do not use Claude Code Task/Subagent for VCM role delegation; VCM owns the four role sessions and the message queue.
+- If new information arrives while a role is still processing, update the relevant handoff artifact or wait; do not spam the target role's terminal.
 - High-risk decisions involving schema, auth, permissions, payment, billing, security, data deletion, or unclear user intent must stop for project-manager/user approval.
 - Required workflow gates: architect plan -> coder implementation/validation -> reviewer review -> architect docs sync -> project-manager final acceptance/commit/PR.
 `;