vibe-coding-master 0.8.11 → 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/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

@@ -1173,7 +1173,7 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
             "merge-base",
             "HEAD",
             rootBranch
-        ], { allowFailure: true })).trim();
+        ], { expectedFailure: "no-common-ancestor" })).trim();
         if (mergeBase
             && mergeBase !== headCommit
             && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
@@ -1185,13 +1185,13 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
         "--abbrev-ref",
         "--symbolic-full-name",
         "@{upstream}"
-    ], { allowFailure: true })).trim();
+    ], { expectedFailure: "missing-upstream" })).trim();
     if (upstream) {
         const mergeBase = (await commandStdout(deps.runner, context.taskRepoRoot, [
             "merge-base",
             "HEAD",
             upstream
-        ], { allowFailure: true })).trim();
+        ], { expectedFailure: "no-common-ancestor" })).trim();
         if (mergeBase
             && mergeBase !== headCommit
             && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
@@ -1201,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) {
@@ -1412,18 +1414,19 @@ async function readCodeDiffSourceArtifactError(fs, taskRepoRoot, source) {
     return undefined;
 }
 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));
+    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;
         }
-        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",
@@ -1431,7 +1434,13 @@ async function commandStdout(runner, cwd, args, options = {}) {
             statusCode: 409
         });
     }
-    return "";
+}
+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

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";
@@ -1410,7 +1411,7 @@ function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], mani
             ...(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.`}`))
+                .map(lspUnavailableWarning))
         ]
     };
 }

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

@@ -17,3 +17,29 @@ export async function prepareTaskLspPlugin(fs, taskRepoRoot, status) {
     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());
@@ -208,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));

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, prepareTaskLspPlugin, 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,13 +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)
-            ? deps.codeIntelligenceDetector
-                ? await prepareTaskLspPlugin(deps.fs, taskRepoRoot, await deps.codeIntelligenceDetector.detect(taskRepoRoot))
-                : [VCM_LSP_PLUGIN_DIR]
+            ? 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, lspPluginDirs),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, appendSystemPrompt, lspPluginDirs),
             cwd: taskRepoRoot
         };
         const runtimeSessionToken = randomUUID();

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

@@ -189,6 +189,9 @@ export function createWorkflowControlService(deps) {
             await assertRouteAuthorized(input);
             const state = await getState(input);
             const pending = state.pendingDispatch;
+            const timestamp = now();
+            const progress = await readProgress(deps.fs, input);
+            const evidenceBaseline = await captureEvidenceBaseline(deps.fs, input, progress.history.length + 1, pending.effectiveFlow, pending.targetRole, timestamp);
             await saveState(input, {
                 ...state,
                 pendingDispatch: {
@@ -196,7 +199,8 @@ export function createWorkflowControlService(deps) {
                     status: "dispatching",
                     routeContentHash: input.routeContentHash,
                     messageId: input.messageId,
-                    updatedAt: now()
+                    evidenceBaseline,
+                    updatedAt: timestamp
                 },
                 updatedAt: now()
             });
@@ -216,6 +220,7 @@ export function createWorkflowControlService(deps) {
                     routeContentHash: undefined,
                     messageId: undefined,
                     confirmationError: undefined,
+                    evidenceBaseline: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
@@ -257,7 +262,7 @@ export function createWorkflowControlService(deps) {
             });
         });
     }
-    async function confirmDispatch(input, messageId) {
+    async function confirmDispatch(input, messageId, source = "hook") {
         await withLock(statePath(input), async () => {
             const state = await getState(input);
             failOnStateWarnings({
@@ -269,6 +274,9 @@ export function createWorkflowControlService(deps) {
             if (!pending || pending.status !== "dispatching" || pending.messageId !== messageId) {
                 throw workflowError("WORKFLOW_DISPATCH_CONFIRMATION_MISMATCH", `Message ${messageId} does not own the pending workflow dispatch.`, "Do not advance Workflow Progress from an unrelated UserPromptSubmit event.");
             }
+            if (source === "manual" && !pending.confirmationError) {
+                throw workflowError("WORKFLOW_DISPATCH_NOT_UNCONFIRMED", "Manual confirmation is only available for a delivered dispatch whose confirmation failed.");
+            }
             const current = await readProgress(deps.fs, input);
             if (current.revision !== pending.revision || historyHash(current.history) !== pending.baseHistoryHash) {
                 throw workflowError("WORKFLOW_APPROVAL_STALE", "Workflow Progress changed before the approved dispatch was confirmed.", "Repair workflow-progress.md before continuing.");
@@ -278,12 +286,14 @@ export function createWorkflowControlService(deps) {
                 sequence: current.history.length + 1,
                 flow: pending.effectiveFlow,
                 targetRole: pending.targetRole,
-                evidence: pending.evidence,
+                evidence: source === "manual"
+                    ? `${pending.evidence} [User manually confirmed execution of message ${messageId}.]`
+                    : pending.evidence,
                 overrideAuthorizationId: pending.overrideAuthorizationId,
                 followUpApprovalId: pending.followUpApprovalId,
                 confirmedAt: timestamp
             };
-            const activeDispatch = await captureEvidenceBaseline(deps.fs, input, entry.sequence, entry.flow, entry.targetRole, timestamp);
+            const activeDispatch = pending.evidenceBaseline ?? await captureEvidenceBaseline(deps.fs, input, entry.sequence, entry.flow, entry.targetRole, timestamp);
             const flowRun = await advanceFlowRun(deps.fs, input, state, current, pending.effectiveFlow, entry.sequence);
             const completed = {
                 ...current,
@@ -339,6 +349,7 @@ export function createWorkflowControlService(deps) {
                     routeContentHash: undefined,
                     messageId: undefined,
                     confirmationError: undefined,
+                    evidenceBaseline: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
@@ -1292,7 +1303,7 @@ function stateProgressConsistencyWarnings(state, progress) {
 }
 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.`
+        ? `PM dispatch ${pending.messageId ?? "unknown"} to ${pending.targetRole} was delivered but not confirmed: ${pending.confirmationError} Inspect the target session and use Confirm Executed if it already ran; do not resend executed work.`
         : undefined;
 }
 function abandonPendingApprovals(state, pending, reason, timestamp) {
@@ -1569,6 +1580,7 @@ function isPendingDispatch(value) {
         && (value.routeContentHash === undefined || typeof value.routeContentHash === "string")
         && (value.messageId === undefined || typeof value.messageId === "string")
         && (value.confirmationError === undefined || typeof value.confirmationError === "string")
+        && (value.evidenceBaseline === undefined || Boolean(normalizeDispatchEvidenceBaseline(value.evidenceBaseline)))
         && typeof value.createdAt === "string"
         && typeof value.updatedAt === "string";
 }

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

@@ -22,7 +22,7 @@ ${renderRoleMemoryRules("architect")}
 ### Semantic Code Navigation
 
 - Follow the preloaded \`vcm-code-navigation\` skill whenever work requires code definitions, implementations, references, callers, callees, or behavior paths. This applies in every Architect mode and in direct user communication.
-- LSP is mandatory and directly available for navigating project source code. Start source-code navigation with LSP. If it is unavailable, report a VCM LSP configuration failure; do not substitute source text search.
+- LSP is mandatory for navigating project source code. Start source-code navigation with a registered LSP server. If a required language server is unavailable, stop the affected work and report its language, command, error, and installation hint through the current communication channel. Resume after the environment is fixed and Architect is restarted; do not substitute source text search.
 - Use LSP definitions, implementations, references, document or workspace symbols, and incoming or outgoing calls for all source-code symbol and relationship queries.
 - LSP reference results are symbol-specific. An accessor, its backing field, a trait declaration, its implementation method, a wrapper, and an alias are separate symbols. Query every relevant symbol separately; one symbol's reference result cannot prove a complete semantic class. When starting from an accessor or wrapper, read its implementation, resolve its backing field, delegate, or trait item with LSP, then query those symbols too.
 - Do not use the built-in \`Grep\` tool or shell text-search commands such as \`grep\`, \`rg\`, \`git grep\`, \`ag\`, or \`ack\` to search project source code, test code, or executable scripts, except for the bounded fallback below. This prohibition includes locating or inferring definitions, implementations, references, callers, callees, symbols, and behavior paths.

package/dist/backend/templates/harness/vcm-code-navigation-skill.js

@@ -6,7 +6,7 @@ Use this skill when Architect must establish symbol definitions, implementations
 ## Navigation Order
 
 1. Define the affected feature or module boundary and locate entry symbols with \`.ai/generated/module-index.json\` and \`.ai/generated/public-surface.json\` when available.
-2. Use LSP workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships. If \`LSP\` is unavailable, report a VCM LSP configuration failure instead of substituting text search.
+2. Use LSP workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships. If a required language server is unavailable, stop the affected work and report its language, command, error, and installation hint through the current communication channel. Resume after the environment is fixed and Architect is restarted; do not substitute text search.
 3. Treat LSP results as symbol-specific. An accessor, backing field, trait declaration, implementation method, wrapper, and alias are separate symbols. Query every relevant symbol separately. When starting from an accessor or wrapper, read its implementation, resolve the backing field, delegate, or trait item with LSP, then query those symbols too. Never use one symbol's references as proof of a complete semantic class.
 4. If an initial workspace-symbol request is empty or reports indexing, wait and retry; startup or indexing time does not permit replacing a required semantic query with text matching. Retry the same bounded workspace query at most two more times. If it still cannot resolve, record the operation and result as unresolved.
 5. Read the complete project-owned callable unit at every resolved location.