vibe-coding-master 0.9.5 → 0.9.6

package/README.md

@@ -511,22 +511,16 @@ Use it to:
 - merge task harness commits back to the connected repository branch when
   appropriate
 
-VCM bundles the Claude Code LSP bridge and loads it for Architect and Reviewer
-sessions, including Codex Bridge launches; Architect's evidence worker can use it
-too. While a language server is still indexing, VCM holds LSP queries until it
-is ready and fails them explicitly if indexing does not finish, instead of
-returning partial results. The project environment must still
-provide the language server for each detected language: `rust-analyzer`,
-`typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
-`jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic
-relationships. Accessors, backing fields, trait items, implementations, wrappers,
-and aliases are queried as separate symbols; a bounded source-text fallback may
-only locate candidates after the correct LSP query is demonstrably partial.
-At the architecture-plan gate, Reviewer checks that every decision-bearing
-relationship cites its evidence source and re-queries it with LSP. Other roles
-use generated context and ordinary source reads. Harness Studio
-reports whether the server executable and plugin can run; the role Session
-performs the real workspace indexing and semantic query retries.
+VCM roles navigate code without language servers, so a task does not hold a
+semantic index in memory per session. Architect preloads `vcm-code-navigation`
+and establishes relationships with exact source-text search over the whole
+project source tree, searching every spelling that can reach a symbol and
+reading every match. Accessors, backing fields, trait items, implementations,
+wrappers, and aliases are searched as separate symbols, and each relationship
+records the search that produced it. At the architecture-plan gate, Reviewer
+checks that every decision-bearing relationship cites its evidence source and
+reruns the recorded search. Other roles use generated context and ordinary
+source reads.
 
 Harness Engineer is task-scoped and runs from the active task worktree. The
 backend automatically starts a fresh Harness Engineer for each active task or

package/dist/backend/adapters/claude-adapter.js

@@ -1,4 +1,4 @@
-import { roleRuntimeDisallowedTools, roleUsesLsp } from "../role-tool-policy.js";
+import { roleRuntimeDisallowedTools, roleUsesRuntimeDenyList } from "../role-tool-policy.js";
 import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 export function createClaudeAdapter(runner) {
@@ -20,10 +20,9 @@ export function createClaudeAdapter(runner) {
             }
             return result.stdout.trim();
         },
-        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt, pluginDirs = []) {
-            const args = pluginDirs.flatMap((pluginDir) => ["--plugin-dir", pluginDir]);
-            const lspEnabled = roleUsesLsp(role) && pluginDirs.length > 0;
-            if (lspEnabled) {
+        buildRoleStartCommand(role, command = "claude", permissionMode = "default", claudeSessionId, resume = false, model = "default", effort = "default", settingsOverride, appendSystemPrompt) {
+            const args = [];
+            if (roleUsesRuntimeDenyList(role)) {
                 args.push("--disallowedTools", roleRuntimeDisallowedTools(role).join(","));
             }
             else {

package/dist/backend/role-tool-policy.js

@@ -1,4 +1,4 @@
-const LSP_FRONTMATTER_DISALLOWED_TOOLS = [
+const FRONTMATTER_DISALLOWED_TOOLS = [
     "NotebookEdit",
     "WebFetch",
     "WebSearch"
@@ -32,19 +32,19 @@ const NON_VCM_ROLE_RUNTIME_TOOLS = [
     "WebSearch",
     "Workflow"
 ];
-export const CODE_ROLE_DISALLOWED_TOOLS = [...LSP_FRONTMATTER_DISALLOWED_TOOLS];
+export const CODE_ROLE_DISALLOWED_TOOLS = [...FRONTMATTER_DISALLOWED_TOOLS];
 export const REVIEWER_DISALLOWED_TOOLS = [
     "Agent",
     "Edit",
-    ...LSP_FRONTMATTER_DISALLOWED_TOOLS
+    ...FRONTMATTER_DISALLOWED_TOOLS
 ];
-// The evidence worker reads and queries LSP but never runs commands, edits code,
-// or delegates. A deny list keeps the parent session's LSP tool available.
+// The evidence worker reads and searches but never runs commands, edits code,
+// or delegates.
 export const EVIDENCE_WORKER_DISALLOWED_TOOLS = [
     "Agent",
     "Bash",
     "Edit",
-    ...LSP_FRONTMATTER_DISALLOWED_TOOLS
+    ...FRONTMATTER_DISALLOWED_TOOLS
 ];
 export const CODE_ROLE_RUNTIME_DISALLOWED_TOOLS = [...NON_VCM_ROLE_RUNTIME_TOOLS];
 export const REVIEWER_RUNTIME_DISALLOWED_TOOLS = [
@@ -52,10 +52,11 @@ export const REVIEWER_RUNTIME_DISALLOWED_TOOLS = [
     "Edit",
     ...NON_VCM_ROLE_RUNTIME_TOOLS
 ];
-// Architect makes semantic code claims; Reviewer verifies them at Gate Review.
-const LSP_ROLE_NAMES = new Set(["architect", "reviewer"]);
-export function roleUsesLsp(role) {
-    return LSP_ROLE_NAMES.has(role);
+// Architect and Reviewer Agent frontmatter uses a deny list, so their launch
+// also removes the runtime tools no VCM workflow role may use.
+const RUNTIME_DENY_LIST_ROLE_NAMES = new Set(["architect", "reviewer"]);
+export function roleUsesRuntimeDenyList(role) {
+    return RUNTIME_DENY_LIST_ROLE_NAMES.has(role);
 }
 export function roleRuntimeDisallowedTools(role) {
     if (role === "reviewer") {

package/dist/backend/runtime/node-pty-runtime.js

@@ -46,7 +46,7 @@ export function createNodePtyTerminalRuntime(deps) {
             process: child,
             listeners: new Set(),
             logWriter,
-            replayBuffer: "",
+            replayBuffer: new TerminalReplayBuffer(),
             disposed: false
         };
         entries.set(session.id, entry);
@@ -55,7 +55,7 @@ export function createNodePtyTerminalRuntime(deps) {
                 return;
             }
             entry.session.lastOutputAt = now();
-            entry.replayBuffer = appendTerminalReplay(entry.replayBuffer, data);
+            entry.replayBuffer.append(data);
             entry.logWriter.append(data);
             emit(entry, {
                 sessionId: session.id,
@@ -150,7 +150,8 @@ export function createNodePtyTerminalRuntime(deps) {
         subscribe(sessionId, listener, options = {}) {
             const entry = getEntry(entries, sessionId);
             entry.listeners.add(listener);
-            if (options.replay !== false && entry.replayBuffer) {
+            const replay = options.replay !== false ? entry.replayBuffer.text() : "";
+            if (replay) {
                 listener({
                     id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
                     sessionId,
@@ -158,7 +159,7 @@ export function createNodePtyTerminalRuntime(deps) {
                     role: entry.session.role,
                     type: "output",
                     timestamp: now(),
-                    data: entry.replayBuffer
+                    data: replay
                 });
             }
             else if (options.replay !== false && entry.input.logPath) {
@@ -257,11 +258,41 @@ export function tailTerminalReplay(data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT
     const firstLineBreak = tail.indexOf("\n");
     return firstLineBreak >= 0 ? tail.slice(firstLineBreak + 1) : tail;
 }
-export function appendTerminalReplay(current, data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT_BYTES) {
-    if (!data) {
-        return current;
+// Keeps the recent terminal output for subscriber replay. PTY output arrives in
+// many small chunks, so appending measures only the new chunk and drops whole
+// old chunks; the exact tail is cut only when a subscriber asks for it.
+export class TerminalReplayBuffer {
+    limitBytes;
+    chunks = [];
+    head = 0;
+    bytes = 0;
+    constructor(limitBytes = TERMINAL_REPLAY_TAIL_LIMIT_BYTES) {
+        this.limitBytes = limitBytes;
+    }
+    append(data) {
+        if (!data) {
+            return;
+        }
+        const bytes = Buffer.byteLength(data, "utf8");
+        this.chunks.push({ data, bytes });
+        this.bytes += bytes;
+        // Drop a chunk only while the rest still covers the limit.
+        while (this.head < this.chunks.length - 1 && this.bytes - this.chunks[this.head].bytes >= this.limitBytes) {
+            this.bytes -= this.chunks[this.head].bytes;
+            this.head += 1;
+        }
+        if (this.head > 1024 && this.head * 2 > this.chunks.length) {
+            this.chunks = this.chunks.slice(this.head);
+            this.head = 0;
+        }
+    }
+    text() {
+        if (this.head >= this.chunks.length) {
+            return "";
+        }
+        const joined = this.chunks.slice(this.head).map((chunk) => chunk.data).join("");
+        return tailTerminalReplay(joined, this.limitBytes);
     }
-    return tailTerminalReplay(`${current}${data}`, limitBytes);
 }
 export function buildPtyEnvironment(baseEnv, inputEnv = {}) {
     const env = {

package/dist/backend/server.js

@@ -35,7 +35,6 @@ 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";
@@ -258,7 +257,6 @@ export function createDefaultServerDeps(options = {}) {
     });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
-    const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(fs, { runner });
     const sessionService = createSessionService({
         fs,
         runtime,
@@ -268,13 +266,11 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
-        codeIntelligenceDetector,
         codexBridgeIntegration,
         apiUrl: options.apiUrl
     });
     const harnessService = createHarnessService({
         fs,
-        commandRunner: runner,
         git,
         runtime,
         harnessEngineerSessions: sessionService,

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

@@ -1568,10 +1568,14 @@ async function captureGateInputSnapshots(fs, taskRepoRoot, requestId, sourcePath
     return snapshots;
 }
 // The reviewer judges authorization and scope against the flow's PM route
-// messages, captured like any other immutable Gate input.
+// messages, captured like any other immutable Gate input. Tester commits are
+// part of every reviewed range, so routes to Tester are always included.
 async function captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources) {
     const sourcePath = path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`);
-    const roles = new Set(codeDiffSources.map((source) => source === "coder" ? "coder" : "architect"));
+    const roles = new Set([
+        ...codeDiffSources.map((source) => source === "coder" ? "coder" : "architect"),
+        "tester"
+    ]);
     const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, roles);
     if (flow.messages.length === 0) {
         return { sourcePath, status: "missing" };

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

@@ -38,8 +38,6 @@ import { renderResolveDurableDocAssignmentTool } from "../templates/harness/reso
 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";
@@ -369,20 +367,14 @@ export function createHarnessService(deps) {
             ? normalizeArchitectWorkerSettings(await deps.getArchitectWorkerSettings())
             : DEFAULT_ARCHITECT_WORKER_SETTINGS;
     }
-    const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(deps.fs, {
-        runner: deps.commandRunner
-    });
     return {
         async getHarnessStatus(repoRoot) {
-            const [analyses, codeIntelligence] = await Promise.all([
-                analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings()),
-                codeIntelligenceDetector.detect(repoRoot)
-            ]);
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings());
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
             const manifestChange = deps.runFixedInstaller
                 ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
                 : undefined;
-            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange, codeIntelligence);
+            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange);
         },
         async getHarnessFileContent(repoRoot, filePath) {
             return readHarnessFileContent(deps.fs, repoRoot, filePath);
@@ -411,17 +403,14 @@ export function createHarnessService(deps) {
                 harnessCommit = (await commitHarnessVisibleChanges(deps.git, repoRoot, "[VCM Harness] Update harness file")).harnessCommit;
             }
             const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
-            const [analyses, codeIntelligence] = await Promise.all([
-                analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings()),
-                codeIntelligenceDetector.detect(repoRoot)
-            ]);
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot, await resolveArchitectWorkerSettings());
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
             const manifestChange = deps.runFixedInstaller
                 ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
                 : undefined;
             return {
                 file,
-                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange, codeIntelligence),
+                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange),
                 harnessCommit
             };
         },
@@ -1393,7 +1382,7 @@ async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
     }
     return changes;
 }
-function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], manifestChange, codeIntelligence) {
+function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], manifestChange) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
@@ -1419,13 +1408,7 @@ function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], mani
         files,
         needsApply: plannedChanges.length > 0,
         plannedChanges,
-        codeIntelligence,
-        warnings: [
-            ...(plannedChanges.length > 0 ? ["Review and commit VCM Harness changes before starting long-running work."] : []),
-            ...((codeIntelligence?.languages ?? [])
-                .filter((language) => language.state !== "server_runnable")
-                .map(lspUnavailableWarning))
-        ]
+        warnings: plannedChanges.length > 0 ? ["Review and commit VCM Harness changes before starting long-running work."] : []
     };
 }
 async function readHarnessRevisionValue(fs, repoRoot) {

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

@@ -7,7 +7,6 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readHarnessRevisionState } from "./harness-revision.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-import { roleUsesLsp, prepareTaskLspPlugin, renderLspNotice, VCM_LSP_PLUGIN_DIR } from "./lsp-plugin.js";
 const TRANSLATOR_ROLE = "translator";
 const HARNESS_ENGINEER_ROLE = "harness-engineer";
 const TRANSLATION_DIR = ".ai/vcm/translations";
@@ -79,16 +78,8 @@ export function createSessionService(deps) {
         // Transcript paths come from Claude Code hook payloads; VCM does not derive
         // them from Claude Code's project-directory encoding.
         const transcriptPath = launchMode === "resume" ? persisted?.transcriptPath : undefined;
-        const lspStatus = roleUsesLsp(role) && deps.codeIntelligenceDetector
-            ? await deps.codeIntelligenceDetector.detect(taskRepoRoot, { refresh: true })
-            : undefined;
-        const lspPluginDirs = roleUsesLsp(role)
-            ? lspStatus ? await prepareTaskLspPlugin(deps.fs, taskRepoRoot, lspStatus) : [VCM_LSP_PLUGIN_DIR]
-            : [];
-        const appendSystemPrompt = [input.appendSystemPrompt, lspStatus && renderLspNotice(lspStatus, role)]
-            .filter(Boolean).join("\n\n") || undefined;
         const startCommand = {
-            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, appendSystemPrompt, lspPluginDirs),
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, resumeClaudeSessionId, launchMode === "resume", model, effort, modelSettingsOverride, input.appendSystemPrompt),
             cwd: taskRepoRoot
         };
         const runtimeSessionToken = randomUUID();
@@ -107,15 +98,7 @@ export function createSessionService(deps) {
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId || undefined,
                 VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
-            }, modelEnvironment, {
-                ...buildUsageTelemetryEnvironment(deps.apiUrl, role, model),
-                ...(lspPluginDirs.length > 0
-                    ? {
-                        ENABLE_LSP_TOOL: "true",
-                        ENABLE_TOOL_SEARCH: "false"
-                    }
-                    : {})
-            }),
+            }, modelEnvironment, buildUsageTelemetryEnvironment(deps.apiUrl, role, model)),
             cols: input.cols,
             rows: input.rows
         });

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

@@ -890,10 +890,16 @@ async function allowedAfterTester(fs, input, state, currentFlow, codeSource, opt
     if (test.value === "incomplete" || test.infrastructure === "repair-required")
         return [`${currentFlow}/tester`];
     const validation = await gateState(fs, input, "validation-adequacy");
+    const unapprovedFailure = test.value === "fail" && !test.hasUserApprovedCoverageGap;
     if (freshGateDecision(state, currentFlow, "tester", "validation-adequacy", validation) === "request_changes") {
-        return [`${currentFlow}/tester`];
-    }
-    if (test.value === "fail" && !test.hasUserApprovedCoverageGap) {
+        // Findings on a genuine failure may be Tester-owned (wrong tests or
+        // evidence) or need the production investigation that Tester Failure
+        // starts; PM routes by who can dispose of them.
+        return unapprovedFailure && options.testerFailureFlow
+            ? [`${currentFlow}/tester`, `${options.testerFailureFlow}/architect`]
+            : [`${currentFlow}/tester`];
+    }
+    if (unapprovedFailure) {
         return options.testerFailureFlow ? [`${options.testerFailureFlow}/architect`] : [];
     }
     if (!gatePassedForDispatch(state, currentFlow, "tester", "validation-adequacy", validation))

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

@@ -21,13 +21,10 @@ ${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 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.
-- Use Glob to locate files and Read to inspect complete code. Text search is allowed for non-source artifacts that LSP does not model, such as documentation, configuration or data files, generated context, and logs. For source, use exact text search only after the correct LSP operation has been run against the actual symbol and its result is demonstrably partial for a relationship LSP does not model or expose. Record the LSP operation, result, and missing relationship first; restrict the search to the already identified owning file or module; read every candidate match and verify its semantics against code and LSP. Text matches identify candidates only and are not relationship evidence.
-- Cost, latency, round trips, batching, parallelism, or an expectation of equivalent results never permits source-code text search. Wait for the role-session LSP and follow the skill's bounded retry procedure.
-- If LSP cannot resolve a required project-owned relationship, record it as unresolved. Do not replace semantic evidence with text matches.
+- Navigate project source with exact source-text search (\`Grep\` or \`rg\`), Glob, generated context, and complete reads. Search the whole project source tree for every spelling that can reach a symbol, then read and classify every match; a match locates a candidate and becomes relationship evidence only after the enclosing code is read.
+- Search results are symbol-name evidence. An accessor, its backing field, a trait declaration, its implementation method, a wrapper, and an alias are separate symbols. Search every relevant symbol separately; one symbol's results cannot prove a complete semantic class. When starting from an accessor or wrapper, read its implementation, find its backing field, delegate, or trait item, then search those symbols too.
+- Record the exact search pattern and scope behind each relationship claim, so a reviewer can rerun it.
+- If a project-owned relationship cannot be established from searches and reads, for example because a macro, code generation, configuration-excluded code, or runtime dispatch hides it, record it as unresolved with the reason. Do not treat a missing match as proof of absence.
 
 ### Work Persistence
 
@@ -72,9 +69,9 @@ ${renderRoleMemoryRules("architect")}
 ### Planning Code Reading
 
 - Do not plan from session memory, architecture docs, generated context, or code comments alone. Re-read current-worktree source and verify actual behavior from implementation.
-- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation, then personally read every decision-bearing callable unit in full.
-- Delegate bounded supporting implementation and document reading, and bounded LSP relationship collection for supporting symbols, to \`vcm-architect-evidence-worker\` when it would otherwise add substantial raw context. Worker reports cite the LSP operation behind each relationship but do not replace Architect's own LSP verification of decision-bearing symbols, relationships, public surfaces, ownership, lifecycle, failure paths, contradictions, or unresolved evidence.
-- If LSP cannot resolve a required project-owned relationship, record the limitation in \`architecture-evidence.md\` and leave it unresolved.
+- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use exhaustive source-text search, then personally read every decision-bearing callable unit in full.
+- Delegate bounded supporting implementation and document reading, and bounded relationship collection for supporting symbols, to \`vcm-architect-evidence-worker\` when it would otherwise add substantial raw context. Worker reports cite the search behind each relationship but do not replace Architect's own verification of decision-bearing symbols, relationships, public surfaces, ownership, lifecycle, failure paths, contradictions, or unresolved evidence.
+- If searches and reads cannot establish a required project-owned relationship, record the limitation in \`architecture-evidence.md\` and leave it unresolved.
 - Define the planning boundary as the affected feature or module and identify every existing or intended observable entry point for the behavior being changed.
 - Personally read the complete implementation of each decision-bearing existing entry point. Supporting entry points may be covered by accepted evidence-worker reports when their facts do not determine the architecture decision.
 - Follow every project-owned call path the plan will change through cross-module calls, state reads and writes, persistence, side effects, completion and failure signals, and consumers.
@@ -237,7 +234,7 @@ The code-reading phase is complete only when:
 - every indirect callback, event, hook, queue, route, and dynamic dispatch path has been resolved
 - every relevant state reader and writer has been read
 - every relevant cross-file surface caller and consumer has been read
-- every semantic relationship records LSP, runtime, verified bounded source, external-boundary, or generated-boundary evidence
+- every semantic relationship records search, runtime, external-boundary, or generated-boundary evidence
 - no unresolved project-owned symbol remains
 
 Do not diagnose the root cause or choose a fix before the Code Reading Closure is complete.

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

@@ -12,8 +12,8 @@ You are \`vcm-architect-evidence-worker\`, a foreground evidence-collection suba
 - Record repository facts with exact repo-relative file paths and symbol or section names.
 - Separate verified facts, contradictions, and unresolved items.
 - Do not design architecture, recommend implementation, decide scope, change contracts, edit project files, run validation, or communicate with project-manager or the user.
-- Use LSP for every definition, reference, caller, callee, and implementation relationship you report. LSP results are symbol-specific: query an accessor, its backing field, a trait declaration, its implementation, a wrapper, and an alias separately.
-- If LSP is unavailable for the language, reports that the server is still indexing, or cannot resolve the relationship, record the relationship as unresolved with the operation and result. Never report a relationship from text matches; text search only locates candidate files.
+- Establish every definition, reference, caller, callee, and implementation relationship you report with exact Grep searches over the whole project source tree, then read and classify every match. Search an accessor, its backing field, a trait declaration, its implementation, a wrapper, and an alias separately, and search every spelling that can reach each symbol.
+- A match becomes relationship evidence only after you read its enclosing code. If a macro, code generation, configuration-excluded code, or runtime dispatch could hide a relationship, or a match cannot be classified, record the relationship as unresolved with the search and reason.
 - Architect remains responsible for verifying decision-bearing behavior paths before relying on them.
 - Do not reconstruct command output. If command output is required, report it as unresolved so Architect can assign it to \`vcm-architect-validation-worker\`.
 
@@ -21,7 +21,7 @@ You are \`vcm-architect-evidence-worker\`, a foreground evidence-collection suba
 
 - 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.
-- In Verified Facts, set Source to \`LSP <operation>\` for each relationship and \`read\` for facts read directly from code or documents.
+- In Verified Facts, set Source to \`search <pattern> in <scope>\` for each relationship and \`read\` for facts read directly from code or documents.
 - 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/gate-review.js

@@ -36,13 +36,14 @@ matches locate evidence; they do not establish behavior or relationship correctn
 without inspection of the corresponding code.
 
 Establish definitions, references, callers, callees, and implementations with
-LSP when a language server is registered for the language. LSP results are
-symbol-specific: query an accessor, backing field, trait declaration,
-implementation, wrapper, and alias separately. An LSP query that fails because
-the server is still indexing returned no result; retry it, and if it still fails,
-record the relationship as not re-verified instead of treating it as empty or
-verified. When no server is registered for a language, say so in the report and
-verify relationships by reading the complete candidate code.
+exact source-text searches over the whole project source tree, then read and
+classify every match. Search an accessor, backing field, trait declaration,
+implementation, wrapper, and alias separately, and search every spelling that
+can reach each symbol, including imports, re-exports, renaming aliases, macro
+invocations, and string or configuration names used for dispatch. When a macro,
+code generation, configuration-excluded code, or runtime dispatch could hide a
+relationship, read the generator, configuration, or dispatch site and record
+the limitation instead of treating a missing match as absence.
 
 Every Gate Review is a complete review of the current gate inputs. Review all
 required evidence and rerun every required mechanical check before deciding.
@@ -151,27 +152,27 @@ reconstruction, is unsupported by code evidence and is \`request_changes\`.
 
 When a claimed semantic class spans an accessor, backing field, trait
 declaration, implementation method, wrapper, or alias, verify that Architect
-queried every relevant symbol separately. One symbol's reference result cannot
-prove the class complete. If Architect used bounded source fallback, verify the
-evidence records the correct prior LSP operation and its missing relationship,
-limits candidate search to the identified owning file or module, and
-semantically verifies every candidate; text matches alone are not evidence.
+searched every relevant symbol separately. One symbol's results cannot prove
+the class complete. Verify that each recorded search covers every spelling that
+can reach the symbol and that every match was read and classified; unread text
+matches are not evidence.
 
 Verify relationship evidence for the plan (record it under Relationship Evidence):
 
 - Every definition, reference, caller, callee, or implementation relationship
   the design depends on must cite its source in \`architecture-evidence.md\` or
-  the plan: an LSP operation, runtime evidence, verified bounded source fallback,
-  an external boundary, a generated boundary, or an explicit unresolved status.
-  A decision-bearing relationship with no source, or supported only by text
-  matches, is \`request_changes\`.
-- Re-run the LSP query for each decision-bearing relationship (the callers of a
-  changed surface, the implementations of a changed trait or interface, the
-  producers and consumers of changed data) and compare it with the recorded
-  result. A missing caller, implementation, or consumer is \`request_changes\`.
-- Record each relationship checked, its recorded source, and your re-query
-  result. A relationship that LSP could not re-verify is listed as such; it does
-  not count as verified.
+  the plan: a recorded search with its pattern and scope, runtime evidence, an
+  external boundary, a generated boundary, or an explicit unresolved status.
+  A decision-bearing relationship with no source, or supported only by unread
+  text matches, is \`request_changes\`.
+- Re-run the recorded search, and any spelling it omitted, for each
+  decision-bearing relationship (the callers of a changed surface, the
+  implementations of a changed trait or interface, the producers and consumers
+  of changed data), read the matches, and compare them with the recorded result.
+  A missing caller, implementation, or consumer is \`request_changes\`.
+- Record each relationship checked, its recorded source, and your re-search
+  result. A relationship you could not re-verify is listed as such; it does not
+  count as verified.
 
 Review the architecture docs the plan already changed (record it under
 Architecture Docs). Read every doc named in Docs Impact and the diff the task
@@ -350,8 +351,9 @@ Before deciding:
   contract changes, read its project-owned callers, consumers, readers,
   writers, and adjacent completion, failure, cancellation, retry, recovery, and
   cleanup paths. Find the callers and implementations of every changed callable
-  or type with LSP references and implementations, not text search, and record
-  under Callers And Public Surface any that LSP could not resolve.
+  or type with exact searches over the whole project source tree for every
+  spelling that can reach it, read every match, and record under Callers And
+  Public Surface any relationship the searches could not establish.
 - Keep this reading bounded to behavior affected by the named commits. Do
   not expand review to unrelated code, the whole task, whole branch, or PR.
 - Derive applicable boundary and failure cases from the actual changed behavior.
@@ -364,8 +366,8 @@ contracts.
 
 When the range contains Tester-authored changes recorded in \`test-report.md\`,
 review those tests, fixtures, test-only helpers, and \`docs/TESTING.md\` against
-the Tester role, the repair or coverage evidence, and
-\`docs/CODING_STANDARDS.md\`. Do not reject a valid Tester-owned change merely
+the Tester role, the repair or coverage evidence, the captured PM route messages
+to Tester, and \`docs/CODING_STANDARDS.md\`. Do not reject a valid Tester-owned change merely
 because it is not a Coder scaffold item. Verify that Tester changes remain
 test-only, preserve real behavior paths, and are committed and validated.
 

package/dist/backend/templates/harness/project-manager-agent.js

@@ -107,7 +107,7 @@ PM may leave this path only through the allowed branches below.
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation. Do not enter Debug, Diagnosis, or validation-adequacy Gate Review.
 - **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined test-infrastructure defect, rerun required validation, and replace \`test-report.md\`. Do not enter Architect Debug while this Tester-owned repair remains available.
 - **Tester Failure:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: none\`, \`repaired\`, or \`production-change-required\`, suspend the main flow and enter Architect Debug Branch.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. Tester must correct the tests or evidence, rerun required validation, commit tracked Tester-owned changes, and replace \`test-report.md\` before PM reruns the Gate. If corrected validation returns \`fail\`, apply Tester Test-Infrastructure Repair or Tester Failure from that result.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. Tester must correct the tests or evidence, rerun required validation, commit tracked Tester-owned changes, and replace \`test-report.md\` before PM reruns the Gate. If corrected validation returns \`fail\`, apply Tester Test-Infrastructure Repair or Tester Failure from that result. When the Gate reviewed \`Test Result: fail\` without a user-approved Coverage Gap and its findings are not Tester-owned, such as an unresolved production cause, apply Tester Failure with the complete report instead of routing Tester.
 - **Tester Code-Diff Correction:** If every code-diff finding has \`Finding Scope: test-only\`, route the complete report to Tester. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source coder\`.
 - **Docs Code-Diff Correction:** If every code-diff finding has \`Finding Scope: docs-only\`, or the findings are only \`docs-only\` and \`test-only\`, route the complete report to Architect to correct the docs first, then rerun the code-diff Gate with the same \`--source\`; the rerun reviews the doc commits incrementally and routes any remaining \`test-only\` finding to Tester. A docs-only correction does not repeat Tester validation or the validation-adequacy Gate.
 - **Docs Coverage Correction:** If the code-diff Gate returns \`failed_to_start\` with a message that starts with \`Docs coverage check failed:\`, route the message to Architect to update the owning docs of the listed modules, then rerun the code-diff Gate with the same \`--source\`.
@@ -173,7 +173,7 @@ Architect updates the owning architecture docs in the same commits as any fix th
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined test-infrastructure defect, rerun required validation, and replace \`test-report.md\`.
 - **Architecture Diagnosis:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: none\`, \`repaired\`, or \`production-change-required\`, enter Architecture Diagnosis Branch.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. After Tester corrects tests or evidence, reruns validation, commits tracked Tester-owned changes, and replaces \`test-report.md\`, rerun the Gate.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. After Tester corrects tests or evidence, reruns validation, commits tracked Tester-owned changes, and replaces \`test-report.md\`, rerun the Gate. When the Gate reviewed \`Test Result: fail\` without a user-approved Coverage Gap and its findings are not Tester-owned, such as an unresolved production cause, enter Architecture Diagnosis Branch with the complete report instead of routing Tester.
 - **Tester Code-Diff Correction:** If every code-diff finding has \`Finding Scope: test-only\`, route the complete report to Tester. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-debug\`.
 - **Docs Code-Diff Correction:** If the code-diff findings are only \`docs-only\` (or \`docs-only\` and \`test-only\`), or the Gate fails to start with \`Docs coverage check failed:\`, route the report or message to Architect to correct the docs, then rerun \`code-diff --source architect-debug\`.
 - **User-Approved Post-Validation Work:** After Tester returns \`pass\` and the validation-adequacy and code-diff Gates succeed, the user may explicitly approve additional Tester-owned work. Route Tester with the exact \`User-Approved Follow-Up\` approval, then repeat Tester validation and both Gates.