vibe-coding-master 0.8.11 → 0.8.13

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/auto-memory-service.js

@@ -1470,7 +1470,8 @@ function buildRoleDraftPrompt(taskRepoRoot, state, draft, planningCandidatePath)
                 "Review that candidate against final task evidence. Carry forward only facts that remain verified after implementation and testing."
             ]
             : []),
-        `Assigned proposal path: ${resolveRepoPath(taskRepoRoot, draft.path)}`
+        `Assigned proposal path: ${draft.path}`,
+        "Pass the assigned repository-relative path to vcm-artifact --path."
     ];
     return [
         ...prompt,

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/pm-user-question.js

@@ -6,7 +6,8 @@ const markdown = unified().use(remarkParse).use(remarkGfm).freeze();
 const DIRECT_REQUESTS = [
     /^(?:can|could|do|did|are|have|should|will|would)\s+you\b/i,
     /^(?:should|shall|may|can|could)\s+(?:i|we)\b/i,
-    /^(?:which|what|how|where|when|who)\b[^.!?]*\b(?:you|your|(?:should|shall|can|may)\s+(?:i|we))\b/i,
+    /^(?:which|what|how|where|when|who)\s+(?:is|are|was|were|do|did|have|has|can|could|will|would|should|shall|may)\s+(?:you|your|i|we)\b/i,
+    /^(?:which|what|how|where|when|who)\b[^.!?:,;]*\b(?:do|did|can|could|will|would|should|shall|may)\s+(?:you|i|we)\b/i,
     /^(?:which|what)\s+(?:option|approach|behavior|behaviour|choice)\b[^.!?]*\bshould\s+be\b/i,
     /^(?:please\s+)?(?:answer|reply|respond|choose|confirm|decide|provide|select|tell\s+me|let\s+me\s+know|give\s+(?:me|your))\b/i,
     /^i\s+need\s+your\s+(?:decision|choice|confirmation|answer|approval)\b/i,

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.
@@ -42,7 +42,8 @@ ${renderRoleMemoryRules("architect")}
 
 - Architect may invoke only \`vcm-architect-evidence-worker\`, \`vcm-architect-scaffold-worker\`, and \`vcm-architect-validation-worker\`.
 - Every worker must run in the foreground and return before the current Architect turn continues. Do not run workers in the background or end the turn while a worker is active.
-- Give each worker an exact bounded assignment, repo-relative paths, and one report path. Pass paths instead of copying full source, documents, or plans into the worker prompt.
+- Give each worker an exact bounded assignment, repo-relative paths, and one report path under \`.ai/vcm/architect-workers/<worker-type>/worker-<worker-id>.md\`. Pass paths instead of copying full source, documents, or plans into the worker prompt.
+- Read the assigned report file before accepting a worker result or continuing its unfinished work; a text-only return is not a completed worker report.
 - Worker output is evidence or execution output, never an architecture decision. Architect owns every conclusion, plan, change boundary, validation interpretation, and final claim.
 - Use \`vcm-architect-evidence-worker\` for bounded bulk reading when relevant evidence spans multiple files or modules. Evidence workers may run in parallel only when their read scopes are disjoint.
 - Give evidence workers only repo-relative paths, symbols, documents, and questions. They have no shell access.

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

@@ -17,7 +17,8 @@ You are \`vcm-architect-evidence-worker\`, a foreground evidence-collection suba
 
 ### Evidence Output
 
-- Write only the assigned report under \`.ai/vcm/architect-workers/evidence/\`.
+- Write the assigned report under \`.ai/vcm/architect-workers/evidence/worker-<worker-id>.md\` before returning. Only that report and its candidate or staging files may be written.
+- For candidate or staging Markdown, use \`worker-<worker-id>-candidate.md\`; never start its basename with \`report\`, \`summary\`, \`findings\`, or \`analysis\` (case-insensitive). If Write rejects a candidate or staging basename, rename it and retry; still deliver the assigned final report file, not just response text.
 - Keep the report concise and factual. Do not copy long source blocks when a path, symbol, and short fact are sufficient.
 - Use this structure:
 

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

@@ -17,8 +17,14 @@ You are \`vcm-architect-scaffold-worker\`, a foreground subagent invoked by Arch
 
 - Run \`.ai/tools/check-scaffold-ledger --mode scaffold\` and the plan's scaffold L0 compile/typecheck checks.
 - Commit only the scaffold changes after the ledger reconciles and required checks pass.
-- Return the commit hash, changed files, ledger result, and exact check results to Architect.
-- If the assigned scaffold cannot be completed, return the concrete failure evidence without changing the plan.
+- If the assigned scaffold cannot be completed, record the concrete failure evidence without changing the plan.
+
+### Scaffold Output
+
+- Write the assigned report under \`.ai/vcm/architect-workers/scaffold/worker-<worker-id>.md\` before returning, including when scaffold work remains incomplete.
+- For candidate or staging Markdown, use \`worker-<worker-id>-candidate.md\`; never start its basename with \`report\`, \`summary\`, \`findings\`, or \`analysis\` (case-insensitive). If Write rejects a candidate or staging basename, rename it and retry; still deliver the assigned final report file, not just response text.
+- Record completed and remaining Scaffold Manifest IDs, changed files, commit hash (or no commit with the reason), ledger result, exact L0 check commands and results, and concrete failure evidence.
+- Return the report path and a concise completion summary to Architect.
 
 Architect reviews the worker's commit and remains responsible for the final scaffold, plan, and evidence.
 Do not invoke another subagent.`;

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

@@ -13,7 +13,8 @@ You are \`vcm-architect-validation-worker\`, a foreground command-execution suba
 
 ### Validation Output
 
-- Write only the assigned report under \`.ai/vcm/architect-workers/validation/\`.
+- Write the assigned report under \`.ai/vcm/architect-workers/validation/worker-<worker-id>.md\` before returning. Only that report and its candidate or staging files may be written.
+- For candidate or staging Markdown, use \`worker-<worker-id>-candidate.md\`; never start its basename with \`report\`, \`summary\`, \`findings\`, or \`analysis\` (case-insensitive). If Write rejects a candidate or staging basename, rename it and retry; still deliver the assigned final report file, not just response text.
 - Use this structure:
 
 \`\`\`md

package/dist/backend/templates/harness/coder-worker-agent.js

@@ -26,6 +26,7 @@ You are \`vcm-coder-worker\`, a bounded implementation worker invoked by Coder.
 \`\`\`
 
 - After the sweep of assigned items and their assigned checks, commit the assigned files. After the commit succeeds, write the assigned report to a candidate outside \`.ai/vcm\`, submit it with \`.ai/tools/vcm-artifact coder-worker-report --file <candidate> --path <assigned-report-path> --mode final\`, then update only the assigned worker state to \`completed\` with the same \`commitHash\` as the final step.
+- For candidate or staging Markdown, use \`worker-<worker-id>-candidate.md\`; never start its basename with \`report\`, \`summary\`, \`findings\`, or \`analysis\` (case-insensitive). If Write rejects a candidate or staging basename, rename it and retry; still submit the assigned final report through \`vcm-artifact\`, not just response text.
 - The completed state must retain \`workerId\`, \`reportPath\`, and \`handled: false\`, set \`status\` to \`completed\`, and add \`"commitHash": "<exact-report-commit-hash>"\`.
 - Use \`completed\` only after every assigned item reached a terminal state. A successful item has green assigned proof and its marker removed. A failed item has a genuine attempt committed with objective failure evidence and its marker retained. Use \`success\` only when every item succeeded; otherwise use \`has_failed_items\`.
 - If execution is interrupted before the sweep, commit, or report completes, leave the worker state as \`running\`. Coder must resume the worker or take over the remaining work.

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.

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

@@ -10,6 +10,10 @@ planning-session memory candidate and provides an exact path.
   under \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` or a planning candidate
   under \`.ai/vcm/memory-review/candidates/\` in the active task worktree.
 - If VCM did not provide a path, do not create a proposal.
+- Pass the assigned repository-relative destination unchanged to \`--path\`;
+  do not prefix it with the task worktree or base repository root. \`--file\`
+  names the candidate file, not the destination. VCM writes the accepted proposal
+  inside the active task worktree.
 - Propose only verified, durable, reusable project knowledge supported by task
   evidence.
 - Before proposing an add or update, check current durable documents, Harness

package/dist/backend/templates/harness/vcm-report-harness-issue-skill.js

@@ -5,16 +5,20 @@ This skill records feedback only. It must not call Harness Engineer directly and
 
 ## Write Location
 
-Submit one markdown file under:
+Submit one markdown file with this repository-relative \`--path\`:
 
 \`\`\`
-\${VCM_BASE_REPO_ROOT}/.ai/vcm/harness-feedback/pending/
+.ai/vcm/harness-feedback/pending/<UTC timestamp>-<reporter-role>-<short-slug>.md
 \`\`\`
 
 If \`VCM_BASE_REPO_ROOT\` is not set, do not guess a fallback path. Report the
 environment problem to project-manager so VCM can retry with the correct base
 repository root.
 
+VCM resolves this destination inside the base repository root, not the task
+worktree. Do not prefix \`--path\` with \`VCM_BASE_REPO_ROOT\` or an absolute
+directory. \`--file\` names the candidate file, not the destination.
+
 Use a filename like:
 
 \`\`\`