vibe-coding-master 0.3.25 → 0.3.26

package/dist/backend/cli/install-vcm-harness.js

@@ -31,6 +31,8 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
+    { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const AGENT_FRONTMATTER = {

package/dist/backend/server.js

@@ -266,6 +266,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         translationService,
         appSettings,
+        runtime,
         gatewayService,
         jobGuard: createJobGuardService()
     });

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

@@ -1,7 +1,10 @@
 import { isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const MAX_STOP_FAILURE_RECOVERY_ATTEMPTS = 2;
 export function createClaudeHookService(deps) {
+    const stopFailureRecoveryAttempts = new Map();
     async function getHookContext(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -92,6 +95,7 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -113,23 +117,72 @@ export function createClaudeHookService(deps) {
                 };
             }
         }
-        const scopedRouteDispatchInput = {
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            handoffDir: context.task.handoffDir,
+        return recordTurnEnd(input, context, eventName, {
+            dispatchRouteFiles: true,
+            notifyGateway: true,
+            settleGuard: true
+        });
+    }
+    async function processStopFailureHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "StopFailure") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const routeDispatchInput = createRouteDispatchInput(input, context);
+        const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
+        const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
+        if (hasCompletionEvidence) {
+            clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: true,
+                notifyGateway: false,
+                settleGuard: true
+            });
+        }
+        const recovered = await dispatchStopFailureRecovery(input, context);
+        if (recovered) {
+            return {
+                ok: true,
+                eventName,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionUpdated: true,
+                dispatchedCount: 0
+            };
+        }
+        return recordTurnEnd(input, context, eventName, {
+            dispatchRouteFiles: false,
+            notifyGateway: false,
+            settleGuard: false
+        });
+    }
+    async function processPostCompactHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "PostCompact") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
-            stoppedRole: input.role
-        };
-        const settleRouteDispatchInput = {
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            handoffDir: context.task.handoffDir,
-            taskSlug: input.taskSlug
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
         };
+    }
+    async function recordTurnEnd(input, context, eventName, options) {
+        const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
+        const settleRouteDispatchInput = createRouteDispatchInput(input, context);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
             role: input.role,
@@ -145,16 +198,20 @@ export function createClaudeHookService(deps) {
             taskSlug: input.taskSlug,
             role: input.role,
             eventName,
-            settleGuard: async () => {
-                const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
-                if (pending.length === 0) {
-                    return { action: "stop" };
+            ...(options.settleGuard
+                ? {
+                    settleGuard: async () => {
+                        const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
+                        if (pending.length === 0) {
+                            return { action: "stop" };
+                        }
+                        const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
+                        return retried.some((result) => result.delivered)
+                            ? { action: "continue", reason: "pending route message dispatched" }
+                            : { action: "stop" };
+                    }
                 }
-                const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
-                return retried.some((result) => result.delivered)
-                    ? { action: "continue", reason: "pending route message dispatched" }
-                    : { action: "stop" };
-            }
+                : {})
         });
         if (session) {
             await deps.translationService.recordConversationBoundary({
@@ -167,14 +224,16 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
-        if (session && input.role === "project-manager") {
+        if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,
                 taskSlug: input.taskSlug,
                 session
             }).catch(() => undefined);
         }
-        const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput);
+        const dispatched = options.dispatchRouteFiles
+            ? await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput)
+            : [];
         return {
             ok: true,
             eventName,
@@ -184,6 +243,51 @@ export function createClaudeHookService(deps) {
             dispatchedCount: dispatched.filter((result) => result.delivered).length
         };
     }
+    function createRouteDispatchInput(input, context, stoppedRole) {
+        return {
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug,
+            ...(stoppedRole ? { stoppedRole } : {})
+        };
+    }
+    async function dispatchStopFailureRecovery(input, context) {
+        if (!deps.runtime) {
+            return false;
+        }
+        const key = stopFailureRecoveryKey(context.project.repoRoot, input.taskSlug, input.role);
+        const attempt = (stopFailureRecoveryAttempts.get(key) ?? 0) + 1;
+        if (attempt > MAX_STOP_FAILURE_RECOVERY_ATTEMPTS) {
+            return false;
+        }
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, input.taskSlug, input.role);
+        if (!session || session.status !== "running") {
+            return false;
+        }
+        stopFailureRecoveryAttempts.set(key, attempt);
+        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt(attempt));
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, input.taskSlug, input.role);
+        return true;
+    }
+    function clearStopFailureRecovery(repoRoot, taskSlug, role) {
+        stopFailureRecoveryAttempts.delete(stopFailureRecoveryKey(repoRoot, taskSlug, role));
+    }
+    function stopFailureRecoveryKey(repoRoot, taskSlug, role) {
+        return `${repoRoot}:${taskSlug}:${role}`;
+    }
+    function renderStopFailureRecoveryPrompt(attempt) {
+        return [
+            "[VCM Recovery]",
+            "Your previous turn ended unexpectedly after context compaction or an API error.",
+            "Continue the same assigned work from the current repository and VCM handoff state.",
+            "Do not repeat completed edits, duplicate validation, or duplicate route messages.",
+            "If the assigned work is already complete, write/send the expected VCM handoff now.",
+            `Recovery attempt: ${attempt}/${MAX_STOP_FAILURE_RECOVERY_ATTEMPTS}.`
+        ].join("\n");
+    }
     async function handlePermissionRequestHook(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -220,6 +324,12 @@ export function createClaudeHookService(deps) {
             if (eventName === "UserPromptSubmit") {
                 return handleUserPromptSubmitHook(input);
             }
+            if (eventName === "StopFailure") {
+                return processStopFailureHook(input);
+            }
+            if (eventName === "PostCompact") {
+                return processPostCompactHook(input);
+            }
             // Legacy combined endpoint: the installed hook discards the response,
             // so a block decision could not be enforced. Never block here.
             return processStopHook(input, { allowBlock: false });
@@ -231,14 +341,14 @@ export function createClaudeHookService(deps) {
     };
 }
 function parseHookEvent(value) {
-    if (value === "UserPromptSubmit" || value === "Stop") {
+    if (value === "UserPromptSubmit" || value === "Stop" || value === "StopFailure" || value === "PostCompact") {
         return value;
     }
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",
         message: `Unsupported Claude Code hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts UserPromptSubmit and Stop hooks only."
+        hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
     });
 }
 function throwUnsupportedEvent(eventName) {

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

@@ -34,6 +34,8 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
+    { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const HARNESS_FILES = [

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

@@ -228,16 +228,18 @@ export function createSessionService(deps) {
                 return undefined;
             }
             const timestamp = now();
-            const isStop = input.eventName === "Stop";
+            const isTurnEnd = isTurnEndHook(input.eventName);
+            const isCompact = isCompactHook(input.eventName);
             const updated = {
                 ...current,
                 claudeSessionId: input.sessionId ?? current.claudeSessionId,
                 transcriptPath: input.transcriptPath ?? current.transcriptPath,
                 cwd: input.cwd ?? current.cwd,
-                activityStatus: isStop ? "idle" : "running",
+                activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
                 lastHookEventAt: timestamp,
-                lastTurnEndedAt: isStop ? timestamp : current.lastTurnEndedAt,
-                lastTurnStartedAt: isStop ? current.lastTurnStartedAt : timestamp,
+                lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
+                lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -347,16 +349,18 @@ export function createSessionService(deps) {
                 return undefined;
             }
             const timestamp = now();
-            const isStop = input.eventName === "Stop";
+            const isTurnEnd = isTurnEndHook(input.eventName);
+            const isCompact = isCompactHook(input.eventName);
             const updated = {
                 ...current,
                 claudeSessionId: input.sessionId ?? current.claudeSessionId,
                 transcriptPath: input.transcriptPath ?? current.transcriptPath,
                 cwd: input.cwd ?? current.cwd,
-                activityStatus: isStop ? "idle" : "running",
+                activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
                 lastHookEventAt: timestamp,
-                lastTurnEndedAt: isStop ? timestamp : current.lastTurnEndedAt,
-                lastTurnStartedAt: isStop ? current.lastTurnStartedAt : timestamp,
+                lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
+                lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -521,6 +525,12 @@ function matchesRoleHookSession(record, input) {
     }
     return false;
 }
+function isTurnEndHook(eventName) {
+    return eventName === "Stop" || eventName === "StopFailure";
+}
+function isCompactHook(eventName) {
+    return eventName === "PostCompact";
+}
 function getRecoverableStatus(record) {
     if (!record.claudeSessionId) {
         return record.status === "running" ? "missing" : record.status;

package/docs/product-design.md

@@ -29,13 +29,13 @@ Session = n x Round = m x Turn
 
 - `Session`: one VCM task. It is the statistics container for the whole task, from task creation until Close Task.
 - `Round`: one VCM conversation cycle. It starts with an accepted user prompt or VCM-delivered prompt, continues through sequential role orchestration, and ends when the final role turn stops and no next turn starts inside the 10 second stop window. In the normal orchestrated workflow, the final visible result comes back from `project-manager`.
-- `Turn`: one role-level Claude Code conversation. It starts when a prompt is submitted to one role session and ends when that role's Claude Code process emits `Stop`.
+- `Turn`: one role-level Claude Code conversation. It starts when a prompt is submitted to one role session and ends when that role's Claude Code process emits `Stop` or `StopFailure`.
 
 Turns inside one Round are strictly sequential. VCM should finish one role Turn before starting the next role Turn in that Round.
 
 Session state is intentionally small: `created` means no Round has started yet, `running` means there is a current running Round, and `stopped` means there is no current running Round after at least one Round has stopped. Starting Claude Code role sessions does not make the VCM Session `running`.
 
-Round state is only `running` or `stopped`. After a `Stop` hook, the 10 second stop window still counts as `running`; the Round becomes `stopped` only when the timer expires without another `UserPromptSubmit`.
+Round state is only `running` or `stopped`. After a turn-end hook, the 10 second stop window still counts as `running`; the Round becomes `stopped` only when the timer expires without another `UserPromptSubmit`.
 
 This `Session` term is only for VCM statistics. It must not be confused with a Claude Code role session, terminal runtime session, or Claude transcript session id. VCM still runs one Claude Code role session per role inside one task-level VCM Session.
 
@@ -395,6 +395,8 @@ Backend role state:
 
 - VCM terminal submit: role becomes `running`.
 - `Stop`: role becomes `idle` and records `lastTurnEndedAt`.
+- `PostCompact`: refreshes role session metadata and records `lastCompactAt` without changing `running`/`idle`.
+- `StopFailure`: first checks completion evidence. If the role already wrote an outgoing route file, VCM marks the role idle and dispatches normally. If not, VCM sends a recovery prompt to the same role without marking it idle.
 - The role tab and flow pause state both react to Claude Code and Codex Reviewer hook events.
 
 Task-level Round state:
@@ -402,14 +404,15 @@ Task-level Round state:
 - The first `UserPromptSubmit` starts a Round for the current VCM Session.
 - Each accepted `UserPromptSubmit` is the start of one Turn.
 - `Stop` ends the current Turn and starts a 10 second stop timer; during that timer, the Round is still `running`.
+- `StopFailure` ends the Turn only after VCM decides the role completed or recovery is unavailable. When recovery is sent, the existing Turn stays running.
 - A new `UserPromptSubmit` inside the window continues the same Round and starts the next Turn.
 - If no new prompt is accepted before the deadline, the Round becomes `stopped`.
-- The stop transition is timer-driven from the `Stop` event. Round-state reads do not end a Round.
+- The stop transition is timer-driven from the turn-end event. Round-state reads do not end a Round.
 - Before stopping, VCM checks `.ai/vcm/handoffs/messages`; if a pending route message exists and can be delivered, VCM retries delivery and extends the stop window instead of alerting.
-- The same Round state stores total Round count, Turn count, completed Turn count, and role active runtime. Active runtime is measured only between `UserPromptSubmit` and `Stop`, not during the stop window.
+- The same Round state stores total Round count, Turn count, completed Turn count, and role active runtime. Active runtime is measured only between `UserPromptSubmit` and the turn-end event, not during the stop window.
 - The Round dock shows both wall-clock Round duration and role active runtime. For a running Round, `Total` is `now - Round.startedAt`; for a stopped Round, it is `stoppedAt - Round.startedAt`. `Role runtime` is the accumulated active runtime across Turns in that Round; `Turn count` is the number of accepted prompts in the Round.
 
-The frontend polls this task-level Round state and deduplicates each stopped Round so the same stopped state does not alert on every poll. Flow duration is measured from the first `UserPromptSubmit` to `stoppedAt`, falling back to the last `Stop` when needed. Runs under 2 minutes trigger the weak 3-chime reminder at 1.4 second intervals. Runs at or above 2 minutes trigger the strong alert dialog and repeating sound until confirmation.
+The frontend polls this task-level Round state and deduplicates each stopped Round so the same stopped state does not alert on every poll. Flow duration is measured from the first `UserPromptSubmit` to `stoppedAt`, falling back to the last turn-end timestamp when needed. Runs under 2 minutes trigger the weak 3-chime reminder at 1.4 second intervals. Runs at or above 2 minutes trigger the strong alert dialog and repeating sound until confirmation.
 
 ## 9. Session Lifecycle
 
@@ -542,9 +545,9 @@ Default route policy:
 - Peer routes such as `coder-reviewer.md` may exist for explicit task designs, but VCM still serializes delivery per target role.
 - `user` talks to `project-manager` through the normal active terminal or translation composer, not through a route file.
 
-Claude Stop-triggered scan:
+Claude turn-end scan:
 
-- VCM injects Claude Code `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks into `.claude/settings.json`.
+- VCM injects Claude Code `UserPromptSubmit`, `Stop`, `StopFailure`, `PostCompact`, and `PermissionRequest` hooks into `.claude/settings.json`.
 - The hooks do not call `vcmctl`; they POST directly to the local VCM backend.
 - When a Claude Code role stops, VCM marks that role idle, then scans pending route files.
 - VCM scans the stopped role's outgoing files and also any pending files targeting newly idle roles, so messages that were blocked by a busy target can be delivered after that target stops.
@@ -578,6 +581,8 @@ VCM Harness injects Claude Code hooks into `.claude/settings.json`:
 
 - `UserPromptSubmit`: posts directly to the VCM backend, marks the role running, and confirms any matching VCM message by recording `acceptedAt`
 - `Stop`: posts directly to the VCM backend, marks the role idle, and triggers pending route-file dispatch
+- `StopFailure`: posts directly to the VCM backend; VCM checks for outgoing route-file completion evidence before marking idle. If no evidence exists, VCM sends a same-role recovery prompt and keeps the Turn running.
+- `PostCompact`: posts directly to the VCM backend, refreshes `session_id`/`transcript_path`/`cwd`, and records `lastCompactAt`
 - `PermissionRequest`: posts directly to the VCM backend and prints the backend response to stdout so Claude Code can consume an allow decision when the local VCM setting is enabled
 
 VCM uses `UserPromptSubmit` as the Claude Code acceptance signal. A successful PTY write only proves VCM delivered text to the embedded terminal; `UserPromptSubmit` proves Claude Code accepted the prompt.

package/package.json

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