vibe-coding-master 0.2.9 → 0.2.10

package/README.md

@@ -548,6 +548,7 @@ When it is on, VCM is in auto mode:
 - 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.
+- If `UserPromptSubmit` does not confirm the auto-delivered message, VCM retries Enter from the backend PTY and finally records `failureReason` on the message if submission is still not confirmed.
 - 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.

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

@@ -9,10 +9,18 @@ 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 DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS = 500;
+const DEFAULT_AUTO_DISPATCH_ENTER_DELAY_MS = 500;
+const DEFAULT_DISPATCH_CONFIRMATION_RETRY_DELAYS_MS = [1500, 3000];
+const DEFAULT_DISPATCH_CONFIRMATION_FAILURE_DELAY_MS = 3000;
+const DISPATCH_NOT_CONFIRMED_REASON = "Auto orchestration pasted the message, but Claude Code did not confirm submission. Press Enter in the target terminal or resend the route message.";
 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 autoDispatchEnterDelayMs = deps.autoDispatchEnterDelayMs ?? DEFAULT_AUTO_DISPATCH_ENTER_DELAY_MS;
+    const dispatchConfirmationEnabled = deps.dispatchConfirmationEnabled ?? true;
+    const dispatchConfirmationRetryDelaysMs = deps.dispatchConfirmationRetryDelaysMs ?? DEFAULT_DISPATCH_CONFIRMATION_RETRY_DELAYS_MS;
+    const dispatchConfirmationFailureDelayMs = deps.dispatchConfirmationFailureDelayMs ?? DEFAULT_DISPATCH_CONFIRMATION_FAILURE_DELAY_MS;
     const taskLocks = new Map();
     async function getOrchestrationState(input) {
         const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
@@ -101,8 +109,11 @@ export function createMessageService(deps) {
             ...message,
             deliveredAt: timestamp
         };
-        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
+        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered), {
+            enterDelayMs: autoDispatchEnterDelayMs
+        });
         await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole);
+        scheduleDispatchConfirmation(input, delivered, session.id);
         return {
             message: delivered,
             delivered: true,
@@ -185,6 +196,53 @@ export function createMessageService(deps) {
             return next;
         }
     };
+    function scheduleDispatchConfirmation(input, message, sessionId) {
+        if (!dispatchConfirmationEnabled) {
+            return;
+        }
+        void monitorDispatchConfirmation(input, message, sessionId).catch(() => undefined);
+    }
+    async function monitorDispatchConfirmation(input, message, sessionId) {
+        for (const retryDelayMs of dispatchConfirmationRetryDelaysMs) {
+            await delay(retryDelayMs);
+            const current = await readMessageById(input, message.id);
+            if (!current || current.acceptedAt) {
+                return;
+            }
+            try {
+                deps.runtime.write(sessionId, "\r");
+            }
+            catch (error) {
+                await markDispatchConfirmationFailure(input, message.id, `Auto orchestration could not retry Enter: ${errorMessage(error)}`);
+                return;
+            }
+        }
+        await delay(dispatchConfirmationFailureDelayMs);
+        const current = await readMessageById(input, message.id);
+        if (!current || current.acceptedAt) {
+            return;
+        }
+        await markDispatchConfirmationFailure(input, message.id, DISPATCH_NOT_CONFIRMED_REASON);
+    }
+    async function readMessageById(input, messageId) {
+        return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+            const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+            return messages.find((message) => message.id === messageId);
+        });
+    }
+    async function markDispatchConfirmationFailure(input, messageId, failureReason) {
+        await withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+            const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+            const current = messages.find((message) => message.id === messageId);
+            if (!current || current.acceptedAt) {
+                return;
+            }
+            await appendMessageSnapshot(deps.fs, input, {
+                ...current,
+                failureReason
+            });
+        });
+    }
 }
 function toRouteContext(input) {
     return {
@@ -423,3 +481,6 @@ function delay(ms) {
     }
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/docs/product-design.md

@@ -802,6 +802,7 @@ VCM V1 is successful when:
 - Manual orchestration lets the user inspect pending route-file messages without auto-submitting Enter.
 - Auto orchestration can deliver pending route-file messages to idle running target roles.
 - Auto orchestration switches to the target role tab when VCM records `dispatchingAt`, before VCM submits the route-file message.
+- Auto orchestration treats `UserPromptSubmit` as the reliable acceptance confirmation; if confirmation does not arrive, backend PTY retries Enter and records a message `failureReason` after retry exhaustion.
 - Round completion detection waits for the final role in a chained conversation and can alert with prompt plus sound.
 - Translation settings save to `~/.vcm/settings.json`.
 - Translation reads Claude transcript JSONL reliably after start, resume, and restart.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [