vibe-coding-master 0.0.15 → 0.0.16

package/README.md

@@ -206,7 +206,7 @@ The same file stores recent repository paths. The translation API key is stored
 
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
-The same sidebar also has a `Round alert` toggle. It is on by default and controls the in-app prompt plus short sound that fires when VCM detects that the current full conversation round is complete. The `Try alert` button triggers the same local prompt and sound for testing.
+The same sidebar also has a `Round alert` toggle. It is on by default and controls the in-app prompt plus a soft two-note completion chime that fires when VCM detects that the current full conversation round is complete. The `Try alert` button triggers the same local prompt and sound for testing.
 
 Translation behavior:
 
@@ -258,7 +258,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 
 `.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. The base repo keeps the task index; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
-VCM also JSON-merges `.claude/settings.json` to install a Claude Code `Stop` hook. The hook posts directly to the local VCM backend, so roles do not need a VCM CLI command to report turn completion.
+VCM also JSON-merges `.claude/settings.json` to install Claude Code `UserPromptSubmit` and `Stop` hooks. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion.
 
 After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
 
@@ -276,7 +276,8 @@ 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
+  -> VCM validates, snapshots, and dispatches pending messages as delivering
+  -> UserPromptSubmit hook confirms accepted VCM messages as submitted
 ```
 
 Examples:
@@ -319,24 +320,25 @@ When it is on, VCM is in auto mode:
 - 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 submission, VCM snapshots the body in message history and clears the source route file.
+- 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 `submitted` message.
+- VCM enforces per-role turn-taking: each target role can have at most one in-flight `delivering` or `submitted` message.
 - 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`, `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 open `pending_approval`, `queued`, `delivering`, `submitted`, and failed message records to `acknowledged`, and clears pending route files.
 
-VCM Harness injects a Claude Code `Stop` hook into `.claude/settings.json`. Role tabs become `running` when VCM submits user input or a message to that embedded terminal, and `idle` after `Stop`; 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.
+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.
 
 The implementation keeps only the active manual/auto orchestration mode. It does not expose pause/resume, stage/approve/reject, or a separate agent-facing message CLI.
 
 ## Round Completion Alerts
 
-VCM detects conversation completion from hook-driven role activity state, not PTY silence. VCM terminal submission 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. `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.
 
-When `Round alert` is enabled, the frontend polls the task round state, deduplicates each completion id, shows a small `Round complete` prompt, and plays a short local sound.
+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.
 
 ## Resume Behavior
 

package/dist/backend/api/claude-hook-routes.js

@@ -1,4 +1,7 @@
 export function registerClaudeHookRoutes(app, deps) {
+    app.post("/api/hooks/claude-code", async (request) => {
+        return deps.claudeHookService.handleHook(request.body);
+    });
     app.post("/api/hooks/claude-code/stop", async (request) => {
         return deps.claudeHookService.handleStopHook(request.body);
     });

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

@@ -2,64 +2,126 @@ import { isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createClaudeHookService(deps) {
-    return {
-        async handleStopHook(input) {
-            if (!isRoleName(input.role)) {
-                throw new VcmError({
-                    code: "HOOK_ROLE_INVALID",
-                    message: `Unknown hook role: ${input.role}`,
-                    statusCode: 400
-                });
-            }
-            const eventName = parseStopEvent(input.event.hook_event_name);
-            const project = await deps.projectService.getCurrentProject();
-            if (!project) {
-                throw new VcmError({
-                    code: "PROJECT_NOT_CONNECTED",
-                    message: "Connect a repository before accepting Claude Code hooks.",
-                    statusCode: 409
-                });
-            }
-            const session = await deps.sessionService.recordClaudeHookEvent(project.repoRoot, {
-                taskSlug: input.taskSlug,
-                role: input.role,
-                eventName,
-                claudeSessionId: stringOrUndefined(input.event.session_id),
-                transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd)
+    async function getHookContext(input) {
+        if (!isRoleName(input.role)) {
+            throw new VcmError({
+                code: "HOOK_ROLE_INVALID",
+                message: `Unknown hook role: ${input.role}`,
+                statusCode: 400
             });
-            const config = await deps.projectService.loadConfig(project.repoRoot);
-            const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
-            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles({
-                repoRoot: project.repoRoot,
-                taskRepoRoot,
-                stateRepoRoot: taskRepoRoot,
-                stateRoot: config.stateRoot,
-                handoffDir: task.handoffDir,
-                taskSlug: input.taskSlug,
-                stoppedRole: input.role
+        }
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: "Connect a repository before accepting Claude Code hooks.",
+                statusCode: 409
             });
-            return {
-                ok: true,
-                eventName,
-                taskSlug: input.taskSlug,
-                role: input.role,
-                sessionUpdated: Boolean(session),
-                dispatchedCount: dispatched.filter((result) => result.delivered).length
-            };
         }
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        return {
+            project,
+            config,
+            task,
+            taskRepoRoot
+        };
+    }
+    async function handleUserPromptSubmitHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "UserPromptSubmit") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
+            taskSlug: input.taskSlug,
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        const submitted = await deps.messageService.confirmPromptSubmitted({
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            prompt: stringOrUndefined(input.event.prompt)
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0,
+            submittedMessageId: submitted?.id
+        };
+    }
+    async function handleStopHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name ?? "Stop");
+        if (eventName !== "Stop") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
+            taskSlug: input.taskSlug,
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles({
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug,
+            stoppedRole: input.role
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: dispatched.filter((result) => result.delivered).length
+        };
+    }
+    return {
+        async handleHook(input) {
+            const eventName = parseHookEvent(input.event.hook_event_name);
+            if (eventName === "UserPromptSubmit") {
+                return handleUserPromptSubmitHook(input);
+            }
+            return handleStopHook(input);
+        },
+        handleStopHook
     };
 }
-function parseStopEvent(value) {
-    if (value === undefined || value === "Stop") {
-        return "Stop";
+function parseHookEvent(value) {
+    if (value === "UserPromptSubmit" || value === "Stop") {
+        return value;
     }
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",
         message: `Unsupported Claude Code hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts Stop hooks only."
+        hint: "VCM accepts UserPromptSubmit and Stop hooks only."
+    });
+}
+function throwUnsupportedEvent(eventName) {
+    throw new VcmError({
+        code: "HOOK_EVENT_UNSUPPORTED",
+        message: `Unsupported Claude Code hook event: ${eventName}`,
+        statusCode: 400,
+        hint: "Use the matching VCM hook endpoint for this event."
     });
 }
 function stringOrUndefined(value) {

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

@@ -9,8 +9,8 @@ export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
-const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_HOOK_EVENTS = ["Stop"];
+const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
+const VCM_HOOK_EVENTS = ["UserPromptSubmit", "Stop"];
 const HARNESS_FILES = [
     {
         kind: "root-claude",
@@ -227,7 +227,7 @@ async function analyzeClaudeSettingsFile(fs, repoRoot) {
                 path: CLAUDE_SETTINGS_PATH,
                 action,
                 reason: exists
-                    ? "Claude Code hook settings do not contain the VCM Stop hook bridge."
+                    ? "Claude Code hook settings do not contain the VCM UserPromptSubmit/Stop hook bridge."
                     : "Claude Code hook settings are missing; VCM will create them."
             },
         nextContent: action === "ok" ? undefined : nextContent
@@ -294,7 +294,7 @@ function isVcmHookMatcher(value) {
         if (!isPlainObject(hook)) {
             return false;
         }
-        return typeof hook.command === "string" && hook.command.includes("/api/hooks/claude-code/stop");
+        return typeof hook.command === "string" && hook.command.includes("/api/hooks/claude-code");
     });
 }
 function isPlainObject(value) {

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

@@ -11,6 +11,7 @@ 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",
@@ -55,6 +56,7 @@ export function createMessageService(deps) {
             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);
@@ -140,20 +142,18 @@ export function createMessageService(deps) {
                 clearedRouteFile: false
             };
         }
-        const submitted = {
+        const delivering = {
             ...message,
-            status: "submitted",
-            deliveredAt: timestamp,
-            submittedAt: timestamp
+            status: "delivering",
+            deliveredAt: timestamp
         };
-        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(submitted));
+        await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivering));
         await deps.sessionService.markRoleActivityRunning(input.repoRoot, input.taskSlug, routeFile.toRole);
-        await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
         return {
-            message: submitted,
+            message: delivering,
             delivered: true,
             requiresUserApproval: false,
-            clearedRouteFile: true
+            clearedRouteFile: false
         };
     }
     return {
@@ -166,6 +166,30 @@ export function createMessageService(deps) {
         async scanAndDispatchPendingRouteFiles(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), () => scanLocked(input));
         },
+        async confirmPromptSubmitted(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 messageId = extractVcmMessageId(input.prompt);
+                if (!messageId) {
+                    return undefined;
+                }
+                const message = findDeliveringMessageForPrompt(messages, input.role, messageId);
+                if (!message) {
+                    return undefined;
+                }
+                const submitted = {
+                    ...message,
+                    status: "submitted",
+                    submittedAt: timestamp,
+                    queuedBehindMessageId: undefined,
+                    failureReason: undefined
+                };
+                await appendMessageSnapshot(deps.fs, input, submitted);
+                await clearRouteFileIfStillMatchesMessage(deps.fs, input, submitted);
+                return submitted;
+            });
+        },
         async markAllDone(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
                 const timestamp = now();
@@ -384,18 +408,53 @@ function findOpenMessageForRoute(messages, routePath) {
 }
 function findActiveMessageForRole(messages, role) {
     return messages.find((message) => message.toRole === role &&
-        message.status === "submitted");
+        (message.status === "delivering" || message.status === "submitted"));
 }
 function acknowledgeActiveMessages(messages, role, timestamp) {
     return messages
-        .filter((message) => message.toRole === role && message.status === "submitted")
+        .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 extractVcmMessageId(prompt) {
+    return prompt?.match(/^\s*id:\s*(\S+)\s*$/m)?.[1];
+}
+function getMessageDeliveryTime(message) {
+    return message.deliveredAt ?? message.createdAt;
+}
+async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
+    if (!message.routePath || !isRoleName(String(message.fromRole))) {
+        return;
+    }
+    const absolutePath = resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, message.routePath);
+    if (!(await fs.pathExists(absolutePath))) {
+        return;
+    }
+    const routeContent = await fs.readText(absolutePath);
+    const parsed = parseRouteFileContent(routeContent, message.fromRole, message.toRole);
+    if (parsed.body.trim() === message.body.trim() &&
+        parsed.type === message.type &&
+        arraysEqual(parsed.artifactRefs, message.artifactRefs)) {
+        await fs.writeText(absolutePath, "");
+    }
+}
+function arraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
 function applyMessageSnapshots(messages, snapshots) {
     if (snapshots.length === 0) {
         return messages;

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

@@ -96,7 +96,7 @@ function toRoleTurnState(role, sessions) {
 }
 function getLatestDeliveredMessage(messages) {
     return messages
-        .filter((message) => message.status === "submitted")
+        .filter((message) => message.status === "delivering" || message.status === "submitted")
         .sort((left, right) => getMessageDeliveredAt(left).localeCompare(getMessageDeliveredAt(right)))
         .at(-1);
 }

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

@@ -163,11 +163,13 @@ export function createSessionService(deps) {
                 return undefined;
             }
             const timestamp = now();
+            const isStop = input.eventName === "Stop";
             const updated = {
                 ...current,
-                activityStatus: "idle",
+                activityStatus: isStop ? "idle" : "running",
                 lastHookEventAt: timestamp,
-                lastStopAt: timestamp,
+                lastStopAt: isStop ? timestamp : current.lastStopAt,
+                lastPromptSubmittedAt: isStop ? current.lastPromptSubmittedAt : timestamp,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);