vibe-coding-master 0.8.10 → 0.8.12

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

@@ -24,6 +24,10 @@ export function registerMessageRoutes(app, deps) {
         const context = await getRouteContext(deps, request.params.taskSlug);
         return deps.messageService.deleteMessageHistory(context);
     });
+    app.post("/api/tasks/:taskSlug/messages/:messageId/confirm-delivered", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.confirmDeliveredDispatch(context, request.params.messageId);
+    });
     app.get("/api/tasks/:taskSlug/orchestration", async (request) => {
         return withOpenFileLimitFallback(async () => {
             const context = await getRouteContext(deps, request.params.taskSlug);

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/code-intelligence-service.js

@@ -64,7 +64,9 @@ export function createHarnessCodeIntelligenceDetector(fs, options = {}) {
     const now = options.now ?? Date.now;
     const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
     return {
-        async detect(repoRoot) {
+        async detect(repoRoot, detectOptions) {
+            if (detectOptions?.refresh)
+                probeCache.clear();
             return detectCodeIntelligence(fs, repoRoot, options, async (definition, executablePath) => {
                 const cacheKey = `${executablePath}\u0000${definition.probeArgs.join("\u0000")}`;
                 const cached = probeCache.get(cacheKey);

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();
+        ], { expectedFailure: "no-common-ancestor" })).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();
+    ], { expectedFailure: "missing-upstream" })).trim();
     if (upstream) {
         const mergeBase = (await commandStdout(deps.runner, context.taskRepoRoot, [
             "merge-base",
             "HEAD",
             upstream
-        ])).trim();
+        ], { expectedFailure: "no-common-ancestor" })).trim();
         if (mergeBase
             && mergeBase !== headCommit
             && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
@@ -1185,7 +1201,9 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
     return headCommit;
 }
 async function isAncestor(runner, cwd, ancestor, descendant) {
-    const result = await runner.run("git", ["merge-base", "--is-ancestor", ancestor, descendant], { cwd });
+    const result = await readGateGit(runner, cwd, ["merge-base", "--is-ancestor", ancestor, descendant], {
+        expectedFailure: "not-ancestor"
+    });
     return result.exitCode === 0;
 }
 async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDiffSources) {
@@ -1395,10 +1413,35 @@ async function readCodeDiffSourceArtifactError(fs, taskRepoRoot, source) {
     }
     return undefined;
 }
-async function commandStdout(runner, cwd, args) {
-    const result = await runner.run("git", args, { cwd });
+async function commandStdout(runner, cwd, args, options = {}) {
+    const result = await readGateGit(runner, cwd, args, options);
     return result.exitCode === 0 ? result.stdout : "";
 }
+async function readGateGit(runner, cwd, args, options = {}) {
+    const retryDelays = [500, 1000, 2000];
+    for (let attempt = 0;; attempt += 1) {
+        const result = await runner.run("git", ["-c", `safe.directory=${path.resolve(cwd)}`, ...args], { cwd });
+        if (result.exitCode === 0 || isExpectedGitFailure(result, options.expectedFailure))
+            return result;
+        if (attempt < retryDelays.length) {
+            await delay(retryDelays[attempt]);
+            continue;
+        }
+        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
+        });
+    }
+}
+function isExpectedGitFailure(result, expected) {
+    if (expected === "not-ancestor" || expected === "no-common-ancestor") {
+        return result.exitCode === 1 && !result.stderr.trim() && !result.stdout.trim();
+    }
+    return expected === "missing-upstream" && result.exitCode === 128
+        && /^fatal: (no upstream configured for branch |HEAD does not point to a branch)/.test(result.stderr.trim());
+}
 function splitLines(value) {
     return value
         .split(/\r?\n/)

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

@@ -37,6 +37,7 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
 import { createHarnessCodeIntelligenceDetector } from "./code-intelligence-service.js";
+import { lspUnavailableWarning } from "./lsp-plugin.js";
 const execFileAsync = promisify(execFile);
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
@@ -51,21 +52,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 +1407,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(lspUnavailableWarning))
+        ]
     };
 }
 async function readHarnessRevisionValue(fs, repoRoot) {

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

@@ -4,3 +4,42 @@ 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];
+}
+export function lspUnavailableWarning(language) {
+    const installCommands = {
+        "rust-analyzer": "rustup component add rust-analyzer",
+        "typescript-language-server": "npm install -g typescript typescript-language-server",
+        "pyright-langserver": "npm install -g pyright",
+        "gopls": "go install golang.org/x/tools/gopls@latest"
+    };
+    const recovery = language.state === "plugin_missing"
+        ? "Refresh the VCM Harness to restore the LSP plugin."
+        : `Install or repair ${language.serverCommand} in the environment running the VCM backend${installCommands[language.serverCommand] ? ` (${installCommands[language.serverCommand]})` : ""} and ensure it is executable on PATH.`;
+    return `Architect LSP for ${language.label} is unavailable: ${language.error ?? `${language.serverCommand} is not runnable.`} ${recovery} Restart Architect after fixing the environment so VCM can detect and register the server again.`;
+}
+export function renderArchitectLspNotice(status) {
+    if (status.languages.length === 0)
+        return undefined;
+    const available = status.languages.filter((language) => language.state === "server_runnable");
+    const unavailable = status.languages.filter((language) => language.state !== "server_runnable");
+    return [
+        "[VCM Architect LSP Availability]",
+        `Registered language servers: ${available.map((language) => `${language.label} (${language.serverCommand})`).join(", ") || "none"}.`,
+        ...unavailable.map(lspUnavailableWarning),
+        ...(unavailable.length > 0 ? [
+            "If your assignment requires a semantic query in an unavailable language, stop that work and report the environment prerequisite through the current communication channel. Do not substitute source text search or claim the relationship is verified. Continue only after the server is available."
+        ] : [])
+    ].join("\n");
+}

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

@@ -11,7 +11,7 @@ const DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS = 500;
 const DEFAULT_AUTO_DISPATCH_ENTER_DELAY_MS = 500;
 const DEFAULT_DISPATCH_CONFIRMATION_RETRY_DELAYS_MS = [1500, 3000];
 const DEFAULT_DISPATCH_CONFIRMATION_FAILURE_DELAY_MS = 3000;
-const DISPATCH_NOT_CONFIRMED_REASON = "Auto orchestration pasted the message, but Claude Code did not confirm submission. Press Enter in the target terminal or resend the route message.";
+const DISPATCH_NOT_CONFIRMED_REASON = "Auto orchestration pasted the message, but Claude Code did not confirm submission. Inspect the target terminal: press Enter if the prompt was not submitted, or use Confirm Executed if the role already executed it.";
 const INVALID_ROUTE_REASON = "Invalid route: non-PM roles must route through project-manager.";
 export function createMessageService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
@@ -193,6 +193,8 @@ export function createMessageService(deps) {
                 if (!message) {
                     return undefined;
                 }
+                if (message.acceptedAt)
+                    return message;
                 const accepted = {
                     ...message,
                     acceptedAt: timestamp,
@@ -206,6 +208,22 @@ export function createMessageService(deps) {
                 return accepted;
             });
         },
+        async confirmDeliveredDispatch(input, messageId) {
+            return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+                const message = messages.find((entry) => entry.id === messageId);
+                if (!message || message.fromRole !== PM_ROLE || !message.deliveredAt || !deps.workflowControlService) {
+                    throw new VcmError({ code: "MESSAGE_NOT_DELIVERED", message: `Message ${messageId} is not a delivered PM workflow dispatch.`, statusCode: 409 });
+                }
+                if (message.acceptedAt)
+                    return message;
+                await deps.workflowControlService.confirmDispatch(toWorkflowContext(input), messageId, "manual");
+                const accepted = { ...message, acceptedAt: now(), confirmationSource: "manual", failureReason: undefined };
+                await appendMessageSnapshot(deps.fs, input, accepted);
+                await clearRouteFileIfStillMatchesMessage(deps.fs, input, accepted);
+                return accepted;
+            });
+        },
         async markAllDone(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
                 const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
@@ -353,7 +371,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, renderArchitectLspNotice, 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,16 @@ export function createSessionService(deps) {
             : resumeClaudeSessionId
                 ? claudeTranscriptPath(taskRepoRoot, resumeClaudeSessionId, persisted?.claudeConfigDir)
                 : undefined;
+        const lspStatus = roleUsesLsp(role) && deps.codeIntelligenceDetector
+            ? await deps.codeIntelligenceDetector.detect(taskRepoRoot, { refresh: true })
+            : undefined;
+        const lspPluginDirs = roleUsesLsp(role)
+            ? lspStatus ? await prepareTaskLspPlugin(deps.fs, taskRepoRoot, lspStatus) : [VCM_LSP_PLUGIN_DIR]
+            : [];
+        const appendSystemPrompt = [input.appendSystemPrompt, lspStatus && renderArchitectLspNotice(lspStatus)]
+            .filter(Boolean).join("\n\n") || undefined;
         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, appendSystemPrompt, lspPluginDirs),
             cwd: taskRepoRoot
         };
         const runtimeSessionToken = randomUUID();
@@ -104,7 +112,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"