vibe-coding-master 0.0.16 → 0.0.17

package/README.md

@@ -194,7 +194,7 @@ All sidebar sections are collapsed by default. When no task is selected, `Reposi
 
 ## Translation
 
-The role toolbar has an `Auto orchestration` on/off button immediately to the left of the `Translate` button. The `Translate` button opens a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
+The task header has a global `Translate` button next to `Close Task`. It opens a translation panel beside the embedded terminal for the role consoles and keeps the same on/off setting while switching roles. The terminal and translation panel split the available width evenly.
 
 Translation settings are local and stored in:
 
@@ -276,8 +276,10 @@ Claude Code role
   -> ends the Claude Code turn
   -> Stop hook calls VCM backend directly
   -> VCM scans pending route files
-  -> VCM validates, snapshots, and dispatches pending messages as delivering
-  -> UserPromptSubmit hook confirms accepted VCM messages as submitted
+  -> VCM validates and dispatches at most one pending route file
+  -> VCM records dispatchingAt and the GUI switches to the target role
+  -> VCM snapshots only actually delivered message history
+  -> UserPromptSubmit hook records acceptedAt and clears the matching route file
 ```
 
 Examples:
@@ -302,15 +304,16 @@ Each directed role route has exactly one message file. If a role changes its min
 
 ## Orchestration Modes
 
-VCM has a task-level `Auto orchestration` switch in the active role toolbar, immediately to the left of `Translate`.
+VCM has a task-level `Auto orchestration` switch in the active role toolbar.
 
 When it is off, VCM is in manual mode:
 
 - Roles may write pending route files under `.ai/vcm/handoffs/messages/`.
 - Messages appear in the `Messages` modal.
 - The user can inspect them.
-- The current GUI shows sequence, timestamp, status, body preview, path, `Copy`, and `Mark All Done`.
-- `Mark All Done` marks open message records as `acknowledged` after the user manually copied or handled stuck queued/in-flight messages.
+- The current GUI shows newest message history first with stable increasing sequence numbers, timestamp, body preview, path, `Copy`, `Mark All Done`, and `Delete All`.
+- `Mark All Done` clears non-empty pending route files after the user manually copied or handled stuck handoff content.
+- `Delete All` removes message history from the Messages modal without touching pending route files.
 - The user decides what to do next by copying or manually acting on the message.
 - VCM does not write to the target terminal or press Enter for the user.
 
@@ -319,14 +322,15 @@ When it is on, VCM is in auto mode:
 - Backend policy still applies.
 - Roles write pending route files under `.ai/vcm/handoffs/messages/`.
 - On Claude Code `Stop`, VCM scans pending route files.
-- If the target role session is running, idle, and has no active message, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
-- After successful terminal write, VCM snapshots the body as `delivering`.
-- Claude Code `UserPromptSubmit` confirms that the prompt was accepted; VCM then marks the message `submitted` and clears the source route file if it still contains the same message.
-- When the GUI observes a newly submitted auto message, it switches the active role tab to that message's target role so the user can watch the next step.
-- VCM enforces per-role turn-taking: each target role can have at most one in-flight `delivering` or `submitted` message.
+- If the target role session is running and idle, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
+- Just before terminal submission, VCM records `dispatchingAt`, waits briefly for the GUI to switch tabs, then writes to the embedded terminal.
+- After successful terminal write, VCM snapshots the delivered body as message history.
+- Claude Code `UserPromptSubmit` confirms that the prompt was accepted; VCM stores `acceptedAt` and clears the source route file if it still contains the same message.
+- When the GUI observes a newly dispatching auto message, it switches the active role tab to that message's target role before the message is submitted.
+- VCM enforces sequential turn-taking from hook state: a role that has accepted a prompt is busy until its `Stop` hook fires.
 - Additional pending files to a busy target role remain non-empty and are not written to that terminal.
 - When the target role later reaches `Stop`, VCM scans again and may deliver the next pending route file.
-- If auto orchestration gets stuck after a manual copy/paste recovery, `Mark All Done` clears open `pending_approval`, `queued`, `delivering`, `submitted`, and failed message records to `acknowledged`, and clears pending route files.
+- If auto orchestration gets stuck after a manual copy/paste recovery, `Mark All Done` clears pending route files. It does not mutate message history.
 
 VCM Harness injects Claude Code `UserPromptSubmit` and `Stop` hooks into `.claude/settings.json`. Role tabs become `running` when Claude Code accepts a prompt and `idle` after `Stop`; VCM also marks a role `running` immediately after it writes a message to that embedded terminal. The terminal process status is still tracked separately. The injected role rules require a role to end its turn after writing or updating a message route file, rather than polling, looping, or waiting for another role inside the same Claude Code turn.
 
@@ -334,9 +338,9 @@ The implementation keeps only the active manual/auto orchestration mode. It does
 
 ## Round Completion Alerts
 
-VCM detects conversation completion from hook-driven role activity state, not PTY silence. `UserPromptSubmit` marks a role `running`, and `Stop` marks that role `idle` with a stop timestamp.
+VCM detects conversation completion from hook-driven role activity state, not PTY silence or message history. `UserPromptSubmit` marks a role `running`, and `Stop` marks that role `idle` with a stop timestamp.
 
-For role chains, VCM waits for the latest active message's target role to reach hook `Stop`. For example, if PM sends work to Coder and Coder sends a result back to PM, the round is not complete when Coder finishes; it is complete only after PM reaches `Stop` for the final response. If no VCM role message is involved, the latest direct role `Stop` can complete the round.
+For role chains, VCM waits for the final role to reach hook `Stop`. For example, if PM sends work to Coder and Coder sends a result back to PM, the round is not complete when Coder finishes; it is complete only after PM reaches `Stop` for the final response. Pending route files block completion because more dispatch work is waiting; message history does not define completion.
 
 When `Round alert` is enabled, the frontend polls the task round state, deduplicates each completion id, shows a small `Round complete` prompt, and plays the local completion chime.
 

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

@@ -9,10 +9,6 @@ export function registerMessageRoutes(app, deps) {
         const context = await getRouteContext(deps, request.params.taskSlug);
         return deps.messageService.listPendingRouteFiles(context);
     });
-    app.post("/api/tasks/:taskSlug/messages/scan", async (request) => {
-        const context = await getRouteContext(deps, request.params.taskSlug);
-        return deps.messageService.scanAndDispatchPendingRouteFiles(context);
-    });
     app.post("/api/tasks/:taskSlug/messages/mark-all-done", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
         return deps.messageService.markAllDone({
@@ -20,6 +16,10 @@ export function registerMessageRoutes(app, deps) {
             clearRouteFiles: true
         });
     });
+    app.delete("/api/tasks/:taskSlug/messages/history", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.deleteMessageHistory(context);
+    });
     app.get("/api/tasks/:taskSlug/orchestration", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
         return deps.messageService.getOrchestrationState(context);

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

@@ -7,16 +7,18 @@ export function registerRoundRoutes(app, deps) {
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const sessions = await deps.sessionService.listRoleSessions(project.repoRoot, request.params.taskSlug);
-        const messages = await deps.messageService.listMessages({
+        const pendingRoutes = await deps.messageService.listPendingRouteFiles({
             repoRoot: project.repoRoot,
+            taskRepoRoot,
             stateRepoRoot: taskRepoRoot,
             stateRoot: config.stateRoot,
+            handoffDir: task.handoffDir,
             taskSlug: request.params.taskSlug
         });
         return deps.roundService.getTaskRoundState({
             taskSlug: request.params.taskSlug,
             sessions,
-            messages
+            pendingRouteCount: pendingRoutes.length
         });
     });
 }

package/dist/backend/services/claude-hook-service.js

@@ -59,7 +59,7 @@ export function createClaudeHookService(deps) {
             role: input.role,
             sessionUpdated: Boolean(session),
             dispatchedCount: 0,
-            submittedMessageId: submitted?.id
+            acceptedMessageId: submitted?.id
         };
     }
     async function handleStopHook(input) {

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

@@ -8,25 +8,11 @@ import { 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"]);
-const OPEN_MESSAGE_STATUSES = new Set([
-    "pending_approval",
-    "queued",
-    "delivering",
-    "submitted",
-    "failed",
-    "delivery_failed",
-    "response_ready_missing_result"
-]);
-const MUTABLE_ROUTE_MESSAGE_STATUSES = new Set([
-    "pending_approval",
-    "queued",
-    "failed",
-    "delivery_failed",
-    "response_ready_missing_result"
-]);
+const DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS = 500;
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
+    const preDispatchSwitchDelayMs = deps.preDispatchSwitchDelayMs ?? DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS;
     const taskLocks = new Map();
     async function getOrchestrationState(input) {
         const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
@@ -49,32 +35,17 @@ export function createMessageService(deps) {
         const timestamp = now();
         const base = toRouteContext(input);
         const state = await getOrchestrationState(input);
-        const messagesPath = getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
-        let messages = await readLatestMessages(deps.fs, messagesPath);
-        const updates = [];
-        if (input.stoppedRole) {
-            const acknowledged = acknowledgeActiveMessages(messages, input.stoppedRole, timestamp);
-            for (const message of acknowledged) {
-                await appendMessageSnapshot(deps.fs, input, message);
-                await clearRouteFileIfStillMatchesMessage(deps.fs, input, message);
-            }
-            updates.push(...acknowledged);
-            messages = applyMessageSnapshots(messages, acknowledged);
-        }
         const pendingFiles = (await listRouteFiles(deps.fs, base)).filter((routeFile) => routeFile.pending);
         const candidates = selectDispatchCandidates(pendingFiles, input.stoppedRole);
         const results = [];
-        const deliveredTargets = new Set();
         for (const routeFile of candidates) {
-            if (deliveredTargets.has(routeFile.toRole)) {
-                continue;
-            }
-            const result = await dispatchRouteFile(input, routeFile, messages, state, timestamp);
+            const result = await dispatchRouteFile(input, routeFile, state, timestamp);
             results.push(result);
-            await appendMessageSnapshot(deps.fs, input, result.message);
-            messages = applyMessageSnapshots(messages, [result.message]);
+            if (result.message) {
+                await appendMessageSnapshot(deps.fs, input, result.message);
+            }
             if (result.delivered) {
-                deliveredTargets.add(routeFile.toRole);
+                break;
             }
         }
         return results;
@@ -84,73 +55,56 @@ export function createMessageService(deps) {
         const all = await listRouteFiles(deps.fs, context);
         return all.filter((routeFile) => routeFile.pending);
     }
-    async function dispatchRouteFile(input, routeFile, existingMessages, state, timestamp) {
+    async function dispatchRouteFile(input, routeFile, state, timestamp) {
         validateMessagePolicy(routeFile.fromRole, routeFile.toRole, routeFile.type);
-        const existingOpen = findOpenMessageForRoute(existingMessages, routeFile.path);
-        const message = {
-            ...(existingOpen ?? {
-                id: id(),
-                taskSlug: input.taskSlug,
-                createdAt: timestamp
-            }),
-            fromRole: routeFile.fromRole,
-            toRole: routeFile.toRole,
-            type: routeFile.type,
-            body: routeFile.body,
-            artifactRefs: routeFile.artifactRefs,
-            bodyPath: routeFile.path,
-            routePath: routeFile.path,
-            status: "queued",
-            queuedBehindMessageId: undefined,
-            failureReason: undefined
-        };
         const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, routeFile.toRole);
         if (!session || session.status !== "running") {
             return {
-                message: {
-                    ...message,
-                    status: "queued",
-                    failureReason: `${routeFile.toRole} session is not running.`
-                },
                 delivered: false,
                 requiresUserApproval: false,
-                clearedRouteFile: false
+                clearedRouteFile: false,
+                failureReason: `${routeFile.toRole} session is not running.`
             };
         }
         if (state.mode === "manual") {
             return {
-                message: {
-                    ...message,
-                    status: "pending_approval"
-                },
                 delivered: false,
                 requiresUserApproval: true,
                 clearedRouteFile: false
             };
         }
-        const activeMessage = findActiveMessageForRole(existingMessages, routeFile.toRole);
-        if (activeMessage) {
+        if (session.activityStatus === "running") {
             return {
-                message: {
-                    ...message,
-                    status: "queued",
-                    queuedBehindMessageId: activeMessage.id,
-                    failureReason: `${routeFile.toRole} is still handling VCM message ${activeMessage.id}.`
-                },
                 delivered: false,
                 requiresUserApproval: false,
-                clearedRouteFile: false
+                clearedRouteFile: false,
+                failureReason: `${routeFile.toRole} is still running.`
             };
         }
-        const delivering = {
+        const message = {
+            id: id(),
+            taskSlug: input.taskSlug,
+            createdAt: timestamp,
+            fromRole: routeFile.fromRole,
+            toRole: routeFile.toRole,
+            type: routeFile.type,
+            body: routeFile.body,
+            artifactRefs: routeFile.artifactRefs,
+            bodyPath: routeFile.path,
+            routePath: routeFile.path,
+            dispatchingAt: timestamp,
+            failureReason: undefined
+        };
+        await appendMessageSnapshot(deps.fs, input, message);
+        await delay(preDispatchSwitchDelayMs);
+        const delivered = {
             ...message,
-            status: "delivering",
             deliveredAt: timestamp
         };
-        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivering));
+        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
         await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole);
         return {
-            message: delivering,
+            message: delivered,
             delivered: true,
             requiresUserApproval: false,
             clearedRouteFile: false
@@ -174,48 +128,46 @@ export function createMessageService(deps) {
                 if (!messageId) {
                     return undefined;
                 }
-                const message = findDeliveringMessageForPrompt(messages, input.role, messageId);
+                const message = findDeliveredMessageForPrompt(messages, input.role, messageId);
                 if (!message) {
                     return undefined;
                 }
-                const submitted = {
+                const accepted = {
                     ...message,
-                    status: "submitted",
-                    submittedAt: timestamp,
-                    queuedBehindMessageId: undefined,
+                    acceptedAt: timestamp,
                     failureReason: undefined
                 };
-                await appendMessageSnapshot(deps.fs, input, submitted);
-                await clearRouteFileIfStillMatchesMessage(deps.fs, input, submitted);
-                return submitted;
+                await appendMessageSnapshot(deps.fs, input, accepted);
+                await clearRouteFileIfStillMatchesMessage(deps.fs, input, accepted);
+                return accepted;
             });
         },
         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) => OPEN_MESSAGE_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);
-                }
+                let clearedCount = 0;
                 if (input.clearRouteFiles) {
                     for (const routeFile of await listPendingRouteFiles(input)) {
                         await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
+                        clearedCount += 1;
                     }
                 }
-                const latest = applyMessageSnapshots(messages, updated);
                 return {
                     taskSlug: input.taskSlug,
-                    updatedCount: updated.length,
-                    messages: latest
+                    updatedCount: clearedCount,
+                    messages
+                };
+            });
+        },
+        async deleteMessageHistory(input) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const messagesPath = getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
+                const messages = await readLatestMessages(deps.fs, messagesPath);
+                await writeMessageSnapshots(deps.fs, messagesPath, []);
+                return {
+                    taskSlug: input.taskSlug,
+                    deletedCount: messages.length,
+                    messages: []
                 };
             });
         },
@@ -401,31 +353,11 @@ async function withTaskLock(locks, key, run) {
         }
     }
 }
-function findOpenMessageForRoute(messages, routePath) {
-    return [...messages]
-        .reverse()
-        .find((message) => (message.routePath ?? message.bodyPath) === routePath && MUTABLE_ROUTE_MESSAGE_STATUSES.has(message.status));
-}
-function findActiveMessageForRole(messages, role) {
-    return messages.find((message) => message.toRole === role &&
-        (message.status === "delivering" || message.status === "submitted"));
-}
-function acknowledgeActiveMessages(messages, role, timestamp) {
-    return messages
-        .filter((message) => message.toRole === role && (message.status === "delivering" || message.status === "submitted"))
-        .map((message) => ({
-        ...message,
-        status: "acknowledged",
-        submittedAt: message.submittedAt ?? message.deliveredAt ?? timestamp,
-        acknowledgedAt: timestamp,
-        failureReason: undefined
-    }));
-}
-function findDeliveringMessageForPrompt(messages, role, messageId) {
-    const delivering = messages.filter((message) => message.toRole === role &&
-        message.status === "delivering" &&
-        message.id === messageId);
-    return delivering.sort((left, right) => getMessageDeliveryTime(left).localeCompare(getMessageDeliveryTime(right))).at(-1);
+function findDeliveredMessageForPrompt(messages, role, messageId) {
+    const delivered = messages.filter((message) => message.toRole === role &&
+        message.id === messageId &&
+        message.deliveredAt);
+    return delivered.sort((left, right) => getMessageDeliveryTime(left).localeCompare(getMessageDeliveryTime(right))).at(-1);
 }
 function extractVcmMessageId(prompt) {
     return prompt?.match(/^\s*id:\s*(\S+)\s*$/m)?.[1];
@@ -455,16 +387,6 @@ function arraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
-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 readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];
@@ -480,6 +402,12 @@ async function readLatestMessages(fs, messagesPath) {
 async function appendMessageSnapshot(fs, input, message) {
     await fs.appendText(getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
 }
+async function writeMessageSnapshots(fs, messagesPath, messages) {
+    const content = messages.length > 0
+        ? `${messages.map((message) => JSON.stringify(message)).join("\n")}\n`
+        : "";
+    await fs.writeText(messagesPath, content);
+}
 function getMessagesPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`);
 }
@@ -489,3 +417,9 @@ function getOrchestrationStatePath(repoRoot, stateRoot, taskSlug) {
 function getStateRepoRoot(input) {
     return input.stateRepoRoot ?? input.repoRoot;
 }
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -4,21 +4,15 @@ export function createRoundService(deps = {}) {
     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,
+                pendingRouteCount: input.pendingRouteCount,
                 roleStates,
                 updatedAt: now()
             });
             return {
                 ...state,
-                latestMessageId: latestDelivered?.id,
-                latestMessageDeliveredAt: getMessageDeliveredAt(latestDelivered),
-                queuedMessageCount,
-                pendingMessageCount
+                pendingRouteCount: input.pendingRouteCount
             };
         },
         stopSession() { },
@@ -26,35 +20,22 @@ export function createRoundService(deps = {}) {
     };
 }
 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
-            };
-        }
+    const activeRole = input.roleStates.find((roleState) => roleState.status === "answering" ||
+        roleState.status === "using_tools" ||
+        roleState.status === "waiting_user" ||
+        roleState.status === "abnormal");
+    if (activeRole) {
         return {
             taskSlug: input.taskSlug,
-            status: targetState?.status === "waiting_user" ? "waiting_user" : "active",
-            activeRole: latestDelivered.toRole,
+            status: activeRole.status === "waiting_user" ? "waiting_user" : "active",
+            activeRole: activeRole.role,
             roles: input.roleStates,
             updatedAt: input.updatedAt
         };
     }
-    const latestIdleRole = !hasQueuedOrPending ? getLatestIdleRole(input.roleStates) : undefined;
-    if (latestIdleRole?.lastAnswerEndedAt) {
+    const latestIdleRole = getLatestIdleRole(input.roleStates);
+    const hasPendingRoutes = input.pendingRouteCount > 0;
+    if (latestIdleRole?.lastAnswerEndedAt && !hasPendingRoutes) {
         return {
             taskSlug: input.taskSlug,
             status: "completed",
@@ -65,14 +46,10 @@ export function evaluateTaskRoundState(input) {
             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,
+        status: hasPendingRoutes ? "active" : "idle",
+        activeRole: latestIdleRole?.role,
         roles: input.roleStates,
         updatedAt: input.updatedAt
     };
@@ -94,21 +71,6 @@ function toRoleTurnState(role, sessions) {
             : undefined
     };
 }
-function getLatestDeliveredMessage(messages) {
-    return messages
-        .filter((message) => message.status === "delivering" || message.status === "submitted")
-        .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
-        .at(-1);
-}
-function getMessageDeliveredAt(message) {
-    return message?.submittedAt ?? message?.deliveredAt ?? 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)

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

@@ -3,6 +3,7 @@ export function renderProjectManagerHarnessRules() {
 
 - You are the user-facing orchestration hub for the VCM task.
 - Clarify the user's request, classify task risk, and choose the role route.
+- VCM orchestration is strictly sequential. Do not parallelize work across multiple roles or dispatch messages to multiple target roles at once.
 - Assign work by writing or updating .ai/vcm/handoffs/messages/project-manager-architect.md, project-manager-coder.md, or project-manager-reviewer.md.
 - Send role work as durable instructions with optional YAML frontmatter, for example type: task and artifact_refs: .ai/vcm/handoffs/architecture-plan.md.
 - Enforce per-role turn-taking: keep at most one in-flight message per target role.