vibe-coding-master 0.8.10 → 0.8.11

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/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"

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))

package/dist/backend/templates/harness/architect-agent.js

@@ -141,7 +141,7 @@ ${renderRoleMemoryRules("architect")}
 #### Code Scaffolding
 
 - Use the Agent tool to invoke \`vcm-architect-scaffold-worker\` in the foreground after the plan and Scaffold Manifest are complete. Give it the exact plan path and require it to return before this Architect turn continues.
-- Use one scaffold worker. Do not run it in the background or end the Architect turn while it is active.
+- Run at most one scaffold worker at a time. Do not run it in the background or end the Architect turn while it is active. If its report leaves scaffold items unfinished, verify the completed work and invoke another foreground scaffold worker with the previous report and exact remaining items. Continue until every item is complete or report the concrete failure to project-manager.
 - Review the worker commit, actual diff, callable surfaces, marker placement, ledger reconciliation, and L0 results yourself. Architect owns every final scaffold claim and must correct any worker error before marking planning complete.
 - Create or update only the minimum module/file scaffolding needed to make boundaries, callable surfaces, and placeholders unambiguous. Minimum limits depth (no business implementation), never breadth: every \`create\`, \`change\`, and \`delete\` item must be scaffolded.
 - When a required configuration, package manifest, or build-definition change cannot safely contain a \`VCM:CODE\` marker, complete and commit it directly as Architect-owned scaffold work. Record it in the Module/File Plan and Scaffold Build Evidence. Do not add it to the Scaffold Manifest.

package/dist/backend/templates/harness/vcm-propose-memory-skill.js

@@ -12,6 +12,11 @@ planning-session memory candidate and provides an exact path.
 - If VCM did not provide a path, do not create a proposal.
 - Propose only verified, durable, reusable project knowledge supported by task
   evidence.
+- Before proposing an add or update, check current durable documents, Harness
+  rules and skills, and the tool's help, usage, or error output. Cite the checked
+  source in Evidence. Do not duplicate existing knowledge in memory; propose
+  \`durable-doc\` only when the existing document is wrong or incomplete, or use
+  \`memory-reference\` when roles need a short pointer across tasks.
 - Target shared project knowledge to \`shared\`. Target knowledge used only by
   the current role to \`current-role\`.
 - For every add or update, explain why the memory is necessary, what future