vibe-coding-master 0.8.9 → 0.8.11

package/README.md

@@ -253,10 +253,9 @@ such as a Dev Container or VM.
 
 Model and effort can be selected before start/resume/restart. Changes affect the
 next launched process, not a currently running Claude Code process.
-The native model list includes explicit `Fable 5.1` (`claude-fable-5-1`) and a
-separate `Fable Alias` whose resolved version is selected by Claude Code and the
-active account provider. `Opus` and `Sonnet` continue to track their Claude Code
-aliases, while `Opus 4.8` remains available as a pinned model.
+The native model list is `Default`, `Fable`, `Opus`, and `Sonnet`. The latter
+three use Claude Code aliases, so the resolved model depends on the installed
+Claude Code version and provider.
 
 ## Usage Analytics
 

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

@@ -51,21 +51,22 @@ 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,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_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" -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_SUBAGENT_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-subagent-guard" ]; then guard="$repo/.ai/tools/vcm-subagent-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-subagent-guard" ]; then guard="$dir/.ai/tools/vcm-subagent-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard"; fi; fi; [ -n "$guard" ] || { printf "%s\\n" "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"VCM subagent policy is unavailable. Refresh the VCM Harness before invoking subagents.\\"}}"; exit 0; }; python3 "$guard"'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
+const VCM_FAST_HOOK_COMMAND = VCM_HOOK_COMMAND.replace(" --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1", "");
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Agent", command: VCM_SUBAGENT_GUARD_HOOK_COMMAND, timeout: 10 },
-    { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 10 },
     { 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: "StopFailure", command: VCM_FAST_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostCompact", command: VCM_FAST_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const AGENT_FRONTMATTER = {

package/dist/backend/server.js

@@ -33,6 +33,7 @@ import { createJobGuardService } from "./services/job-guard-service.js";
 import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
+import { createHarnessCodeIntelligenceDetector } from "./services/code-intelligence-service.js";
 import { createMessageService } from "./services/message-service.js";
 import { createRoundService } from "./services/round-service.js";
 import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-service.js";
@@ -250,6 +251,7 @@ export function createDefaultServerDeps(options = {}) {
     const projectService = createProjectService({ fs, git, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
+    const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(fs, { runner });
     const sessionService = createSessionService({
         fs,
         runtime,
@@ -259,6 +261,7 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
+        codeIntelligenceDetector,
         codexBridgeIntegration,
         apiUrl: options.apiUrl
     });

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

@@ -355,6 +355,12 @@ function normalizeClaudeModel(input, fallback) {
     if (typeof input !== "string") {
         return fallback;
     }
+    if (input === "claude-fable-5-1") {
+        return "fable";
+    }
+    if (input === "claude-opus-4-8") {
+        return "opus";
+    }
     if (isCodexBridgeSessionModel(input)) {
         return input;
     }

package/dist/backend/services/gate-review-service.js

@@ -148,7 +148,15 @@ export function createGateReviewService(deps) {
             };
         }
         if (gate === "code-diff") {
-            const dirtyStatus = await getDirtyCodeDiffStatus(deps.runner, context.taskRepoRoot);
+            let dirtyStatus;
+            try {
+                dirtyStatus = await getDirtyCodeDiffStatus(deps.runner, context.taskRepoRoot);
+            }
+            catch (error) {
+                const message = errorMessage(error);
+                index = await recordCodeDiffStartFailure(index, context, gate, codeDiffSource, message);
+                return { status: "failed_to_start", gate, record: index.gates[gate], message };
+            }
             if (dirtyStatus) {
                 const message = `code-diff requires committed inputs; commit or clean these changes first: ${dirtyStatus}`;
                 index = applyGateState(index, gate, {
@@ -319,9 +327,17 @@ export function createGateReviewService(deps) {
                 };
             }
         }
-        const codeDiffInput = gate === "code-diff"
-            ? await resolveCodeDiffInput(deps, context, record)
-            : undefined;
+        let codeDiffInput;
+        if (gate === "code-diff") {
+            try {
+                codeDiffInput = await resolveCodeDiffInput(deps, context, record);
+            }
+            catch (error) {
+                const message = errorMessage(error);
+                index = await recordCodeDiffStartFailure(index, context, gate, codeDiffSource, message);
+                return { status: "failed_to_start", gate, record: index.gates[gate], message };
+            }
+        }
         if (gate === "code-diff" && (!codeDiffInput || codeDiffInput.commits.length === 0)) {
             index = applyGateState(index, gate, {
                 status: "not_required",
@@ -1157,7 +1173,7 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
             "merge-base",
             "HEAD",
             rootBranch
-        ])).trim();
+        ], { allowFailure: true })).trim();
         if (mergeBase
             && mergeBase !== headCommit
             && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
@@ -1169,13 +1185,13 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
         "--abbrev-ref",
         "--symbolic-full-name",
         "@{upstream}"
-    ])).trim();
+    ], { allowFailure: true })).trim();
     if (upstream) {
         const mergeBase = (await commandStdout(deps.runner, context.taskRepoRoot, [
             "merge-base",
             "HEAD",
             upstream
-        ])).trim();
+        ], { allowFailure: true })).trim();
         if (mergeBase
             && mergeBase !== headCommit
             && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
@@ -1395,9 +1411,27 @@ async function readCodeDiffSourceArtifactError(fs, taskRepoRoot, source) {
     }
     return undefined;
 }
-async function commandStdout(runner, cwd, args) {
-    const result = await runner.run("git", args, { cwd });
-    return result.exitCode === 0 ? result.stdout : "";
+async function commandStdout(runner, cwd, args, options = {}) {
+    const retryHead = args.length === 2 && args[0] === "rev-parse" && args[1] === "HEAD";
+    const attempts = retryHead ? 3 : 1;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const result = await runner.run("git", args, { cwd });
+        if (result.exitCode === 0)
+            return result.stdout;
+        if (attempt + 1 < attempts) {
+            await delay(100 * (attempt + 1));
+            continue;
+        }
+        if (options.allowFailure)
+            return "";
+        const detail = result.stderr.trim() || result.stdout.trim() || "Git did not provide an error message.";
+        throw new VcmError({
+            code: "GATE_REVIEW_GIT_COMMAND_FAILED",
+            message: `Git ${args.join(" ")} failed in ${cwd} (exit ${result.exitCode}): ${detail}`,
+            statusCode: 409
+        });
+    }
+    return "";
 }
 function splitLines(value) {
     return value

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

@@ -52,15 +52,6 @@ export function createHarnessFeedbackService(deps) {
                 statusCode: 409
             });
         }
-        const existingMarker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
-        if (existingMarker && existingMarker.status !== "failed") {
-            throw new VcmError({
-                code: "TASK_HARNESS_RETROSPECTIVE_EXISTS",
-                message: `Task Harness Retrospective has already been triggered for task: ${taskSlug}`,
-                statusCode: 409,
-                hint: "Review the existing retrospective result instead of starting another retrospective for the same task."
-            });
-        }
         const finalAcceptancePath = path.posix.join(input.handoffDir, "final-acceptance.md");
         const finalAcceptanceAbsolutePath = resolveRepoPath(input.taskRepoRoot, finalAcceptancePath);
         const finalAcceptanceContent = await readAbsoluteOptionalText(finalAcceptanceAbsolutePath);
@@ -78,10 +69,25 @@ export function createHarnessFeedbackService(deps) {
                 hint: `${finalAcceptancePath} must pass the final-acceptance artifact check before Task Harness Retrospective can start.`
             });
         }
+        const finalAcceptanceHash = `sha256:${sha256(finalAcceptanceContent)}`;
+        const existingMarker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
+        if (existingMarker && (existingMarker.status === "running"
+            || existingMarker.status === "triggered"
+            || existingMarker.status === "waiting-docs"
+            || (existingMarker.finalAcceptanceHash === finalAcceptanceHash && existingMarker.status !== "failed"))) {
+            throw new VcmError({
+                code: "TASK_HARNESS_RETROSPECTIVE_EXISTS",
+                message: `Task Harness Retrospective has already been triggered for this acceptance or is still active: ${taskSlug}`,
+                statusCode: 409,
+                hint: "Wait for the active retrospective, or review its result before retrying the same acceptance."
+            });
+        }
         const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
         const pendingFeedback = await listPendingFeedback(repoRoot);
         const timestamp = now();
-        const analysisPath = `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
+        const analysisPath = existingMarker && existingMarker.finalAcceptanceHash !== finalAcceptanceHash
+            ? `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.${finalAcceptanceHash.slice(7)}.md`
+            : existingMarker?.analysisPath ?? `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
         const analysisAbsolutePath = resolveRepoPath(repoRoot, analysisPath);
         const memoryReview = await deps.autoMemoryService?.prepareTaskRetrospectiveReview(input.taskRepoRoot, analysisAbsolutePath);
         const marker = {
@@ -90,13 +96,17 @@ export function createHarnessFeedbackService(deps) {
             trigger: input.trigger,
             status: "running",
             analysisPath,
-            finalAcceptanceHash: `sha256:${sha256(finalAcceptanceContent)}`,
+            finalAcceptanceHash,
             pendingFeedbackPaths: pendingFeedback.map((item) => item.path),
             ...(memoryReview ? { memoryRunId: memoryReview.runId } : {}),
             createdAt: timestamp,
             updatedAt: timestamp
         };
         try {
+            if (existingMarker && existingMarker.finalAcceptanceHash !== finalAcceptanceHash) {
+                const archivePath = resolveRepoPath(repoRoot, `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.${existingMarker.finalAcceptanceHash.slice(7)}.json`);
+                await deps.fs.writeJsonAtomic(archivePath, existingMarker);
+            }
             await persistTaskRetrospectiveMarker(repoRoot, marker);
             await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedback.map((item) => item.path), memoryReview));
         }

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

@@ -51,21 +51,22 @@ 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,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_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" -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_SUBAGENT_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-subagent-guard" ]; then guard="$repo/.ai/tools/vcm-subagent-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-subagent-guard" ]; then guard="$dir/.ai/tools/vcm-subagent-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-subagent-guard"; fi; fi; [ -n "$guard" ] || { printf "%s\\n" "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"PreToolUse\\",\\"permissionDecision\\":\\"deny\\",\\"permissionDecisionReason\\":\\"VCM subagent policy is unavailable. Refresh the VCM Harness before invoking subagents.\\"}}"; exit 0; }; python3 "$guard"'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
+const VCM_FAST_HOOK_COMMAND = VCM_HOOK_COMMAND.replace(" --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1", "");
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Agent", command: VCM_SUBAGENT_GUARD_HOOK_COMMAND, timeout: 10 },
-    { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 10 },
     { 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: "StopFailure", command: VCM_FAST_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostCompact", command: VCM_FAST_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const HARNESS_FILES = [
@@ -1405,9 +1406,12 @@ function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], mani
         needsApply: plannedChanges.length > 0,
         plannedChanges,
         codeIntelligence,
-        warnings: plannedChanges.length > 0
-            ? ["Review and commit VCM Harness changes before starting long-running work."]
-            : []
+        warnings: [
+            ...(plannedChanges.length > 0 ? ["Review and commit VCM Harness changes before starting long-running work."] : []),
+            ...((codeIntelligence?.languages ?? [])
+                .filter((language) => language.state !== "server_runnable")
+                .map((language) => `Architect LSP for ${language.label} is unavailable: ${language.error ?? `${language.serverCommand} is not runnable.`}`))
+        ]
     };
 }
 async function readHarnessRevisionValue(fs, repoRoot) {

package/dist/backend/services/lsp-plugin.js

@@ -4,3 +4,16 @@ export { roleUsesLsp } from "../role-tool-policy.js";
 export const VCM_LSP_PLUGIN_NAME = "vcm-lsp-bridge";
 export const VCM_LSP_PLUGIN_DIR = fileURLToPath(new URL("../../../scripts/claude-plugins/vcm-lsp-bridge", import.meta.url));
 export const VCM_LSP_PLUGIN_MANIFEST = path.join(VCM_LSP_PLUGIN_DIR, ".claude-plugin", "plugin.json");
+export async function prepareTaskLspPlugin(fs, taskRepoRoot, status) {
+    const runnable = status.languages.filter((language) => language.state === "server_runnable");
+    if (runnable.length === 0)
+        return [];
+    const manifest = await fs.readJson(VCM_LSP_PLUGIN_MANIFEST);
+    const commands = new Set(runnable.map((language) => language.serverCommand));
+    const lspServers = Object.fromEntries(Object.entries(manifest.lspServers).filter(([, server]) => commands.has(server.command)));
+    const pluginDir = path.join(taskRepoRoot, ".ai/vcm/lsp-plugin");
+    const pluginManifestPath = path.join(pluginDir, ".claude-plugin/plugin.json");
+    await fs.ensureDir(path.dirname(pluginManifestPath));
+    await fs.writeJsonAtomic(pluginManifestPath, { ...manifest, lspServers });
+    return [pluginDir];
+}

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

@@ -193,6 +193,8 @@ export function createMessageService(deps) {
                 if (!message) {
                     return undefined;
                 }
+                if (message.acceptedAt)
+                    return message;
                 const accepted = {
                     ...message,
                     acceptedAt: timestamp,
@@ -353,7 +355,7 @@ export function createMessageService(deps) {
                 return;
             }
             if (current.fromRole === PM_ROLE) {
-                await deps.workflowControlService?.releaseDispatch(toWorkflowContext(input), messageId);
+                await deps.workflowControlService?.markDispatchUnconfirmed(toWorkflowContext(input), messageId, failureReason);
             }
             await appendMessageSnapshot(deps.fs, input, {
                 ...current,

package/dist/backend/services/runtime-coordinator-service.js

@@ -192,7 +192,7 @@ export function createRuntimeCoordinatorService(deps) {
             });
         }
         catch (error) {
-            if (error instanceof VcmError && (EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES.has(error.code) || error.statusCode === 409)) {
+            if (error instanceof VcmError && EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES.has(error.code)) {
                 return;
             }
             throw error;

package/dist/backend/services/runtime-recovery-service.js

@@ -193,10 +193,12 @@ export function createRuntimeRecoveryService(deps) {
             if (message.dispatchingAt && !message.acceptedAt) {
                 const next = {
                     ...message,
-                    failureReason: "VCM restarted before this dispatch was confirmed. Resend the message if it is still needed."
+                    failureReason: message.deliveredAt
+                        ? "VCM restarted before this delivered dispatch was confirmed. Inspect the target session before retrying."
+                        : "VCM restarted before this dispatch was delivered. Resend the message if it is still needed."
                 };
-                delete next.dispatchingAt;
-                delete next.deliveredAt;
+                if (!message.deliveredAt)
+                    delete next.dispatchingAt;
                 changed = true;
                 return next;
             }

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

@@ -8,7 +8,7 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { readHarnessRevisionState } from "./harness-revision.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-import { roleUsesLsp, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
+import { roleUsesLsp, prepareTaskLspPlugin, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
 const TRANSLATOR_ROLE = "translator";
 const HARNESS_ENGINEER_ROLE = "harness-engineer";
 const TRANSLATION_DIR = ".ai/vcm/translations";
@@ -82,8 +82,13 @@ export function createSessionService(deps) {
             : resumeClaudeSessionId
                 ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
                 : undefined;
+        const lspPluginDirs = roleUsesLsp(role)
+            ? deps.codeIntelligenceDetector
+                ? await prepareTaskLspPlugin(deps.fs, taskRepoRoot, await deps.codeIntelligenceDetector.detect(taskRepoRoot))
+                : [VCM_LSP_PLUGIN_DIR]
+            : [];
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt, roleUsesLsp(role) ? [VCM_LSP_PLUGIN_DIR] : []),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt, lspPluginDirs),
             cwd: taskRepoRoot
         };
         const runtimeSessionToken = randomUUID();
@@ -104,7 +109,7 @@ export function createSessionService(deps) {
                 VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
             }, modelEnvironment, {
                 ...buildUsageTelemetryEnvironment(deps.apiUrl, role, model),
-                ...(roleUsesLsp(role)
+                ...(lspPluginDirs.length > 0
                     ? {
                         ENABLE_LSP_TOOL: "true",
                         ENABLE_TOOL_SEARCH: "false"
@@ -1608,9 +1613,13 @@ function normalizeClaudePermissionMode(value) {
     return "default";
 }
 function normalizeClaudeModel(value) {
-    if (value === "claude-fable-5-1"
-        || value === "opus"
-        || value === "claude-opus-4-8"
+    if (value === "claude-fable-5-1") {
+        return "fable";
+    }
+    if (value === "claude-opus-4-8") {
+        return "opus";
+    }
+    if (value === "opus"
         || value === "sonnet"
         || value === "fable"
         || isCodexBridgeSessionModel(value)) {

package/dist/backend/services/workflow-control-service.js

@@ -215,18 +215,36 @@ export function createWorkflowControlService(deps) {
                     status: "pending",
                     routeContentHash: undefined,
                     messageId: undefined,
+                    confirmationError: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
             });
         });
     }
+    async function markDispatchUnconfirmed(input, messageId, reason) {
+        await withLock(statePath(input), async () => {
+            const state = await getState(input);
+            const pending = state.pendingDispatch;
+            if (!pending || pending.status !== "dispatching" || pending.messageId !== messageId)
+                return;
+            await saveState(input, {
+                ...state,
+                pendingDispatch: { ...pending, confirmationError: reason, updatedAt: now() },
+                updatedAt: now()
+            });
+        });
+    }
     async function cancelPendingDispatch(input) {
         await withLock(statePath(input), async () => {
             const state = await getState(input);
             const pending = state.pendingDispatch;
             if (!pending)
                 return;
+            if (pending.status === "dispatching" && !pending.confirmationError) {
+                throw workflowError("WORKFLOW_DISPATCH_PENDING", `Message ${pending.messageId} is being delivered and cannot be cleared before confirmation.`);
+            }
+            const timestamp = now();
             const progress = await readProgress(deps.fs, input);
             await commitStateAndProgress(input, renderWorkflowProgress({
                 ...progress,
@@ -234,16 +252,18 @@ export function createWorkflowControlService(deps) {
             }), {
                 ...state,
                 pendingDispatch: null,
-                userAuthorizations: state.userAuthorizations.filter((entry) => entry.id !== pending.overrideAuthorizationId),
-                userApprovedFollowUps: state.userApprovedFollowUps.filter((entry) => entry.id !== pending.followUpApprovalId),
-                updatedAt: now()
+                ...abandonPendingApprovals(state, pending, "Pending route was cleared before confirmation.", timestamp),
+                updatedAt: timestamp
             });
         });
     }
     async function confirmDispatch(input, messageId) {
         await withLock(statePath(input), async () => {
             const state = await getState(input);
-            failOnStateWarnings(state);
+            failOnStateWarnings({
+                ...state,
+                warnings: state.warnings.filter((warning) => warning !== unconfirmedDispatchWarning(state.pendingDispatch))
+            });
             failWhileAwaitingUser(state);
             const pending = state.pendingDispatch;
             if (!pending || pending.status !== "dispatching" || pending.messageId !== messageId) {
@@ -293,8 +313,24 @@ export function createWorkflowControlService(deps) {
         return withLock(statePath(input), async () => {
             await recoverCommitJournal(input);
             const state = await getState(input);
-            if (state.warnings.length > 0 || state.pendingDispatch?.status !== "dispatching")
+            if (state.pendingDispatch?.status !== "dispatching"
+                || state.warnings.some((warning) => warning !== unconfirmedDispatchWarning(state.pendingDispatch)))
                 return false;
+            if (await wasDispatchDelivered(deps.fs, input, state.pendingDispatch.messageId)) {
+                if (state.pendingDispatch.confirmationError)
+                    return false;
+                const timestamp = now();
+                await saveState(input, {
+                    ...state,
+                    pendingDispatch: {
+                        ...state.pendingDispatch,
+                        confirmationError: "VCM restarted before the delivered message received UserPromptSubmit confirmation.",
+                        updatedAt: timestamp
+                    },
+                    updatedAt: timestamp
+                });
+                return true;
+            }
             await saveState(input, {
                 ...state,
                 pendingDispatch: {
@@ -302,6 +338,7 @@ export function createWorkflowControlService(deps) {
                     status: "pending",
                     routeContentHash: undefined,
                     messageId: undefined,
+                    confirmationError: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
@@ -323,6 +360,7 @@ export function createWorkflowControlService(deps) {
         assertRouteAuthorized,
         claimDispatch,
         releaseDispatch,
+        markDispatchUnconfirmed,
         cancelPendingDispatch,
         confirmDispatch,
         recoverTask
@@ -361,10 +399,12 @@ export function createWorkflowControlService(deps) {
     async function requestUserInput(input, question) {
         return withLock(statePath(input), async () => {
             const state = await getState(input);
-            failOnStateWarnings(state);
             if (state.pendingDispatch?.status === "dispatching") {
-                throw workflowError("WORKFLOW_DISPATCH_PENDING", "A role dispatch is already being submitted and cannot be canceled by a user question.", "Wait for the target UserPromptSubmit confirmation or recover the dispatch before asking the user.");
+                throw workflowError("WORKFLOW_DISPATCH_PENDING", state.pendingDispatch.confirmationError
+                    ? `A delivered role dispatch is unconfirmed: ${state.pendingDispatch.confirmationError}`
+                    : "A role dispatch is already being submitted and cannot be canceled by a user question.", "Inspect the target session and confirm or clear the pending dispatch before asking the user.");
             }
+            failOnStateWarnings(state);
             const normalizedQuestion = question.trim();
             if (!normalizedQuestion) {
                 throw workflowError("WORKFLOW_USER_QUESTION_REQUIRED", "A non-empty user question is required.");
@@ -378,8 +418,7 @@ export function createWorkflowControlService(deps) {
                     requestedAt: timestamp
                 },
                 pendingDispatch: null,
-                userAuthorizations: state.userAuthorizations.filter((entry) => entry.id !== pending?.overrideAuthorizationId),
-                userApprovedFollowUps: state.userApprovedFollowUps.filter((entry) => entry.id !== pending?.followUpApprovalId),
+                ...(pending ? abandonPendingApprovals(state, pending, "PM asked the user before dispatch confirmation.", timestamp) : {}),
                 updatedAt: timestamp
             };
             if (pending) {
@@ -1226,6 +1265,9 @@ function validateCandidateAgainstCurrent(current, candidate) {
 function stateProgressConsistencyWarnings(state, progress) {
     const warnings = [];
     const pending = state.pendingDispatch;
+    const unconfirmedWarning = unconfirmedDispatchWarning(pending);
+    if (unconfirmedWarning)
+        warnings.push(unconfirmedWarning);
     if (!pending && progress.proposal) {
         warnings.push("Workflow Progress contains a dispatch proposal without a runtime approval.");
     }
@@ -1248,6 +1290,40 @@ function stateProgressConsistencyWarnings(state, progress) {
     }
     return warnings;
 }
+function unconfirmedDispatchWarning(pending) {
+    return pending?.confirmationError
+        ? `PM dispatch ${pending.messageId ?? "unknown"} to ${pending.targetRole} was delivered but not confirmed: ${pending.confirmationError} Inspect the target session before clearing or retrying this route.`
+        : undefined;
+}
+function abandonPendingApprovals(state, pending, reason, timestamp) {
+    return {
+        userAuthorizations: state.userAuthorizations.map((entry) => entry.id === pending.overrideAuthorizationId
+            ? { ...entry, status: "abandoned", abandonedAt: timestamp, abandonReason: reason }
+            : entry),
+        userApprovedFollowUps: state.userApprovedFollowUps.map((entry) => entry.id === pending.followUpApprovalId
+            ? { ...entry, status: "abandoned", abandonedAt: timestamp, abandonReason: reason }
+            : entry)
+    };
+}
+async function wasDispatchDelivered(fs, input, messageId) {
+    if (!messageId)
+        return false;
+    const messagesPath = path.join(input.taskRepoRoot, input.stateRoot, "messages", `${input.taskSlug}.jsonl`);
+    if (!(await fs.pathExists(messagesPath)))
+        return false;
+    try {
+        let latest;
+        for (const line of (await fs.readText(messagesPath)).split(/\r?\n/).filter(Boolean)) {
+            const message = JSON.parse(line);
+            if (message.id === messageId)
+                latest = message;
+        }
+        return Boolean(latest?.deliveredAt);
+    }
+    catch {
+        return true;
+    }
+}
 function createUserAuthorization(authorizationId, current, candidate, effectiveFlow, baseHistoryHash, violation, authorizationText, timestamp) {
     return {
         id: authorizationId,
@@ -1492,6 +1568,7 @@ function isPendingDispatch(value) {
         && (value.status === "pending" || value.status === "dispatching")
         && (value.routeContentHash === undefined || typeof value.routeContentHash === "string")
         && (value.messageId === undefined || typeof value.messageId === "string")
+        && (value.confirmationError === undefined || typeof value.confirmationError === "string")
         && typeof value.createdAt === "string"
         && typeof value.updatedAt === "string";
 }
@@ -1499,7 +1576,7 @@ function isUserAuthorization(value) {
     if (!isRecord(value))
         return false;
     return typeof value.id === "string"
-        && (value.status === "accepted" || value.status === "consumed")
+        && (value.status === "accepted" || value.status === "consumed" || value.status === "abandoned")
         && value.role === "project-manager"
         && value.operation === "workflow-dispatch"
         && Number.isInteger(value.baseRevision)
@@ -1511,13 +1588,15 @@ function isUserAuthorization(value) {
         && typeof value.violatedRule === "string"
         && typeof value.authorizationText === "string"
         && typeof value.createdAt === "string"
-        && (value.consumedAt === undefined || typeof value.consumedAt === "string");
+        && (value.consumedAt === undefined || typeof value.consumedAt === "string")
+        && (value.abandonedAt === undefined || typeof value.abandonedAt === "string")
+        && (value.abandonReason === undefined || typeof value.abandonReason === "string");
 }
 function isUserApprovedFollowUp(value) {
     if (!isRecord(value))
         return false;
     return typeof value.id === "string"
-        && (value.status === "accepted" || value.status === "consumed")
+        && (value.status === "accepted" || value.status === "consumed" || value.status === "abandoned")
         && value.role === "project-manager"
         && value.operation === "post-validation-follow-up"
         && Number.isInteger(value.baseRevision)
@@ -1529,7 +1608,9 @@ function isUserApprovedFollowUp(value) {
         && typeof value.evidence === "string"
         && typeof value.approvalText === "string"
         && typeof value.createdAt === "string"
-        && (value.consumedAt === undefined || typeof value.consumedAt === "string");
+        && (value.consumedAt === undefined || typeof value.consumedAt === "string")
+        && (value.abandonedAt === undefined || typeof value.abandonedAt === "string")
+        && (value.abandonReason === undefined || typeof value.abandonReason === "string");
 }
 function normalizeDispatchEvidenceBaseline(value) {
     if (!isRecord(value) || !isRecord(value.artifactHashes) || !isRecord(value.gateFingerprints))