vibe-coding-master 0.7.17 → 0.7.18

package/README.md

@@ -282,7 +282,7 @@ not fall back to another model.
 
 ## Launch Template
 
-The launch template stores per-role defaults:
+The global launch template stores per-role defaults for the five workflow roles:
 
 - permission mode
 - model
@@ -293,7 +293,12 @@ One-click start launches the four core roles. If any Gate Review Gate is enabled
 it also launches Gate Reviewer.
 
 Translator and Harness Engineer are tool roles. They are controlled from their
-own panels, not from the main role tab bar.
+own panels, not from the main role tab bar or the one-click launch template.
+Their permission, model, and effort are stored as independent tool Session
+defaults only after an explicit Start or Restart succeeds. Selector changes,
+Resume, and backend automatic startup do not write these defaults. Without a
+saved value, both tools use `bypassPermissions`, the default model, and medium
+effort. An existing task Session keeps its own recorded values.
 
 ## Orchestration
 

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

@@ -1,4 +1,5 @@
 import { isOpenFileLimitError, VcmError } from "../errors.js";
+import { createDefaultToolSessionDefaults } from "../../shared/types/app-settings.js";
 export function registerHarnessRoutes(app, deps) {
     app.get("/api/projects/harness", async (request) => {
         const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
@@ -68,13 +69,17 @@ export function registerHarnessRoutes(app, deps) {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
-        return deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        const result = await deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        await persistHarnessEngineerDefaults(deps.appSettings, result.session);
+        return result;
     });
     app.post("/api/projects/harness/bootstrap/restart", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
-        return deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        const result = await deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
+        await persistHarnessEngineerDefaults(deps.appSettings, result.session);
+        return result;
     });
     app.post("/api/projects/harness/bootstrap/stop", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
@@ -111,7 +116,9 @@ export function registerHarnessRoutes(app, deps) {
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Harness Engineer");
         const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        return deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        const session = await deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        await persistHarnessEngineerDefaults(deps.appSettings, session);
+        return session;
     });
     app.post("/api/projects/harness/engineer/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -125,7 +132,9 @@ export function registerHarnessRoutes(app, deps) {
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Harness Engineer");
         const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        return deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        const session = await deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "harness-engineer", request.body);
+        await persistHarnessEngineerDefaults(deps.appSettings, session);
+        return session;
     });
     app.post("/api/projects/harness/engineer/session/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -201,6 +210,14 @@ export function registerHarnessRoutes(app, deps) {
         return deps.autoMemoryService.retryFailedReview(project.repoRoot, task.worktreePath);
     });
 }
+async function persistHarnessEngineerDefaults(appSettings, session) {
+    const defaults = createDefaultToolSessionDefaults()["harness-engineer"];
+    await appSettings.updateToolSessionDefaults("harness-engineer", {
+        permissionMode: session.permissionMode ?? defaults.permissionMode,
+        model: session.model ?? defaults.model,
+        effort: session.effort ?? defaults.effort
+    });
+}
 function requireTaskSlug(value, roleLabel) {
     const taskSlug = value?.trim();
     if (!taskSlug) {

package/dist/backend/api/translation-worker-routes.js

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { createDefaultToolSessionDefaults } from "../../shared/types/app-settings.js";
 export function registerTranslationWorkerRoutes(app, deps) {
     app.get("/api/translation/state", async () => {
         const project = await requireCurrentProject(deps.projectService);
@@ -29,7 +30,9 @@ export function registerTranslationWorkerRoutes(app, deps) {
     app.post("/api/translation/session/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const taskSlug = requireTaskSlug(request.body?.taskSlug, "Translator");
-        return deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        const session = await deps.sessionService.startRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        await persistToolSessionDefaults(deps.appSettings, "translator", session);
+        return session;
     });
     app.post("/api/translation/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -44,7 +47,9 @@ export function registerTranslationWorkerRoutes(app, deps) {
         if (existing) {
             await deps.translationService.stopSession(existing.id, { clearCache: true });
         }
-        return deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        const session = await deps.sessionService.restartRoleSession(project.repoRoot, taskSlug, "translator", request.body);
+        await persistToolSessionDefaults(deps.appSettings, "translator", session);
+        return session;
     });
     app.post("/api/translation/session/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
@@ -90,6 +95,14 @@ export function registerTranslationWorkerRoutes(app, deps) {
         return deps.translationWorkerService.promoteFileJob(project.repoRoot, request.params.jobId, targetPath);
     });
 }
+async function persistToolSessionDefaults(appSettings, role, session) {
+    const defaults = createDefaultToolSessionDefaults().translator;
+    await appSettings.updateToolSessionDefaults(role, {
+        permissionMode: session.permissionMode,
+        model: session.model ?? defaults.model,
+        effort: session.effort ?? defaults.effort
+    });
+}
 function requireTaskSlug(value, roleLabel) {
     const taskSlug = value?.trim();
     if (!taskSlug) {

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

@@ -42,9 +42,9 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".claude/skills/vcm-codex-review-gate",
     ".ai/tools/request-codex-review"
 ];
-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_STOP_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 --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
-const VCM_PERMISSION_REQUEST_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 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
+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,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,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_STOP_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,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_PERMISSION_REQUEST_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,runtimeSessionToken:process.env.VCM_RUNTIME_SESSION_TOKEN,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;

package/dist/backend/server.js

@@ -93,6 +93,7 @@ export async function createServer(deps, options = {}) {
         gateReviewService: deps.gateReviewService
     });
     registerTranslationWorkerRoutes(app, {
+        appSettings: deps.appSettings,
         projectService: deps.projectService,
         translationWorkerService: deps.translationWorkerService,
         sessionService: deps.sessionService,
@@ -103,6 +104,7 @@ export async function createServer(deps, options = {}) {
         runtimeRecoveryService: deps.runtimeRecoveryService
     });
     registerHarnessRoutes(app, {
+        appSettings: deps.appSettings,
         projectService: deps.projectService,
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,

package/dist/backend/services/app-settings-service.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
-import { createDefaultLaunchTemplate, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
+import { createDefaultLaunchTemplate, createDefaultToolSessionDefaults, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, CCR_GPT_SESSION_MODEL, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -73,6 +73,21 @@ export function createAppSettingsService(deps) {
             });
             return preferences;
         },
+        async updateToolSessionDefaults(role, input) {
+            const current = await loadSettings();
+            const preferences = normalizePreferences({
+                ...current.preferences,
+                toolSessionDefaults: {
+                    ...current.preferences.toolSessionDefaults,
+                    [role]: input
+                }
+            });
+            await saveSettings({
+                ...current,
+                preferences
+            });
+            return preferences.toolSessionDefaults[role];
+        },
         async getRecentRepositoryPaths() {
             return (await loadSettings()).recentRepositoryPaths;
         },
@@ -274,7 +289,8 @@ function normalizePreferences(input) {
         translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),
         translationOutputMode: normalizeTranslationOutputMode(candidate.translationOutputMode),
-        launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate)
+        launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate),
+        toolSessionDefaults: normalizeToolSessionDefaults(candidate.toolSessionDefaults)
     };
 }
 function normalizeThemeMode(input) {
@@ -313,6 +329,14 @@ function normalizeLaunchTemplate(input) {
         autoOrchestration: input.autoOrchestration !== false
     };
 }
+function normalizeToolSessionDefaults(input) {
+    const defaults = createDefaultToolSessionDefaults();
+    const candidate = isObject(input) ? input : {};
+    return {
+        translator: normalizeRoleLaunchTemplateEntry(candidate.translator, defaults.translator),
+        "harness-engineer": normalizeRoleLaunchTemplateEntry(candidate["harness-engineer"], defaults["harness-engineer"])
+    };
+}
 function normalizeRoleLaunchTemplateEntry(input, fallback) {
     const candidate = isObject(input) ? input : {};
     return {

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

@@ -2,6 +2,7 @@ import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorTool
 import { VcmError } from "../errors.js";
 import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { matchesRoleHookSession } from "./session-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
 const ROLE_RETRY_BASE_DELAY_MS = 60_000;
@@ -18,6 +19,7 @@ const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
 const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
     const stopFailureRetryTimers = new Map();
+    const roleHookLocks = new Map();
     const now = deps.now ?? (() => new Date().toISOString());
     const retrySetTimeout = deps.retrySetTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
     const retryClearTimeout = deps.retryClearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
@@ -79,7 +81,9 @@ export function createClaudeHookService(deps) {
                 eventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             })
             : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
                 taskSlug: input.taskSlug,
@@ -88,9 +92,12 @@ export function createClaudeHookService(deps) {
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
-                allowSessionMismatch: true
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             });
-        await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        if (session) {
+            await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        }
         return {
             ok: true,
             eventName,
@@ -109,7 +116,9 @@ export function createClaudeHookService(deps) {
                 eventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             })
             : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
                 taskSlug: input.taskSlug,
@@ -118,8 +127,12 @@ export function createClaudeHookService(deps) {
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
-                allowSessionMismatch: true
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
         const activeTask = deps.autoMemoryService
             ? (await deps.taskService.listTasks(context.project.repoRoot))
                 .find((task) => task.cleanupStatus !== "cleaned" && (projectScoped || task.taskSlug === input.taskSlug))
@@ -176,27 +189,33 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
         }
-        const boundToTask = await isHookSessionBoundToTask(context, input.role);
-        if (boundToTask) {
-            deps.jobGuard?.notePromptSubmitted({
-                repoRoot: context.project.repoRoot,
-                taskSlug: context.taskSlug,
-                role: input.role
-            });
-        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
+            deps.jobGuard?.notePromptSubmitted({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role
+            });
             await deps.roundService.recordClaudeHookEvent({
                 repoRoot: context.project.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,
@@ -246,6 +265,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -312,6 +334,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -372,6 +397,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -382,7 +410,9 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
         return {
             ok: true,
@@ -396,15 +426,20 @@ export function createClaudeHookService(deps) {
     async function recordTurnEnd(input, context, eventName, options) {
         const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
         const settleRouteDispatchInput = createRouteDispatchInput(input, context);
-        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             await deps.roundService.recordClaudeHookEvent({
                 repoRoot: context.project.repoRoot,
@@ -483,8 +518,13 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask && eventName !== "PostCompact") {
             await deps.roundService.recordClaudeHookEvent({
@@ -523,6 +563,31 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
+    async function isCurrentRoleHook(context, input, eventName) {
+        const current = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        return Boolean(current && matchesRoleHookSession(current, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
+        }));
+    }
+    async function withRoleHookLock(input, run) {
+        const key = `${input.taskSlug}:${input.role}`;
+        const previous = roleHookLocks.get(key) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(run);
+        const tail = result.then(() => undefined, () => undefined);
+        roleHookLocks.set(key, tail);
+        try {
+            return await result;
+        }
+        finally {
+            if (roleHookLocks.get(key) === tail) {
+                roleHookLocks.delete(key);
+            }
+        }
+    }
     async function scheduleStopFailureRetry(input, context, failure) {
         const preferences = await deps.appSettings.getPreferences();
         if (!preferences.roleRetryEnabled || !deps.runtime) {
@@ -562,7 +627,10 @@ export function createClaudeHookService(deps) {
                 nextRetryAt
             }
         });
-        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        if (session) {
+            await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role, session.id);
+        }
         scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
         return "scheduled";
     }
@@ -630,7 +698,7 @@ export function createClaudeHookService(deps) {
             }
         });
         await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt());
-        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role, session.id);
     }
     async function markStopFailureRecoveryFailed(input, context, failure, attempt, timestamp = now()) {
         clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
@@ -736,44 +804,50 @@ export function createClaudeHookService(deps) {
     }
     return {
         async handleHook(input) {
-            if (isTranslatorToolRoleName(input.role)) {
-                return processTranslatorHook(input);
-            }
-            if (isHarnessEngineerToolRoleName(input.role)) {
-                return processHarnessEngineerHook(input);
-            }
-            const eventName = parseHookEvent(input.event.hook_event_name);
-            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 });
+            return withRoleHookLock(input, async () => {
+                if (isTranslatorToolRoleName(input.role)) {
+                    return processTranslatorHook(input);
+                }
+                if (isHarnessEngineerToolRoleName(input.role)) {
+                    return processHarnessEngineerHook(input);
+                }
+                const eventName = parseHookEvent(input.event.hook_event_name);
+                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 });
+            });
         },
         handleStopHook(input) {
-            if (isTranslatorToolRoleName(input.role)) {
-                return processTranslatorHook(input);
-            }
-            if (isHarnessEngineerToolRoleName(input.role)) {
-                return processHarnessEngineerHook(input);
-            }
-            return processStopHook(input, { allowBlock: true });
+            return withRoleHookLock(input, async () => {
+                if (isTranslatorToolRoleName(input.role)) {
+                    return processTranslatorHook(input);
+                }
+                if (isHarnessEngineerToolRoleName(input.role)) {
+                    return processHarnessEngineerHook(input);
+                }
+                return processStopHook(input, { allowBlock: true });
+            });
         },
         handleReconciledTurnEnd(input) {
-            const eventName = parseHookEvent(input.event.hook_event_name);
-            if (eventName === "Stop") {
-                return processStopHook(input, { allowBlock: false });
-            }
-            if (eventName === "StopFailure") {
-                return processStopFailureHook(input);
-            }
-            throwUnsupportedEvent(eventName);
+            return withRoleHookLock(input, async () => {
+                const eventName = parseHookEvent(input.event.hook_event_name);
+                if (eventName === "Stop") {
+                    return processStopHook(input, { allowBlock: false });
+                }
+                if (eventName === "StopFailure") {
+                    return processStopFailureHook(input);
+                }
+                throwUnsupportedEvent(eventName);
+            });
         },
         handlePermissionRequestHook
     };