vibe-coding-master 0.0.15 → 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:
 
@@ -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,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
+  -> 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:
@@ -301,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.
 
@@ -318,25 +322,27 @@ 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 submission, VCM snapshots the body in message history and clears the source route file.
-- 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.
+- 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`, `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 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 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 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/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

@@ -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,
+            acceptedMessageId: 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) {