vibe-coding-master 0.9.4 → 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,
@@ -320,7 +316,8 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         projectService,
         taskService,
-        sessionService
+        sessionService,
+        workflowControlService
     });
     const messageService = createMessageService({
         fs,

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

@@ -7,6 +7,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 import { parseGateReviewReportArtifact } from "./managed-artifact-validation.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 const REVIEWER_AGENT_PATH = ".claude/agents/reviewer.md";
 const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
 const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
@@ -39,10 +40,7 @@ const CODE_DIFF_SOURCE_ARTIFACTS = {
         ".ai/vcm/handoffs/architecture-plan.md",
         ".ai/vcm/handoffs/coder-completion.md"
     ],
-    "architect-debug": [
-        ".ai/vcm/handoffs/role-commands/architect.md",
-        ".ai/vcm/handoffs/architect-debug.md"
-    ],
+    "architect-debug": [".ai/vcm/handoffs/architect-debug.md"],
     "architect-diagnosis": [
         ".ai/vcm/handoffs/architecture-diagnosis.md"
     ]
@@ -438,6 +436,9 @@ export function createGateReviewService(deps) {
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const requestReportPath = reportPathForRequest(requestId);
         const inputSnapshots = await captureGateInputSnapshots(deps.fs, context.taskRepoRoot, requestId, getSourceArtifacts(gate, codeDiffSources));
+        if (gate === "code-diff" && codeDiffSources) {
+            inputSnapshots.push(await captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources));
+        }
         const nextRecord = {
             ...record,
             status: "running",
@@ -1487,7 +1488,12 @@ function splitLines(value) {
 function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
     const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
-    const evidence = getSourceArtifacts(gate, codeDiffSources)
+    const evidence = [
+        ...getSourceArtifacts(gate, codeDiffSources),
+        ...(gate === "code-diff"
+            ? [`${path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`)} (PM route messages for the reviewed flow)`]
+            : [])
+    ]
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
     const capturedEvidence = inputSnapshots.length > 0
@@ -1561,6 +1567,23 @@ 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. 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"),
+        "tester"
+    ]);
+    const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, roles);
+    if (flow.messages.length === 0) {
+        return { sourcePath, status: "missing" };
+    }
+    const snapshotPath = inputSnapshotPathForRequest(requestId, ".ai/vcm/messages/route-messages.md");
+    await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, snapshotPath), renderRouteMessages(context.taskSlug, [`Code sources: ${codeDiffSources.join(" -> ")}`], flow));
+    return { sourcePath, snapshotPath, status: "captured" };
+}
 function isTaskEvidencePath(sourcePath) {
     return sourcePath.startsWith(".ai/vcm/handoffs/")
         || sourcePath.startsWith(".ai/vcm/gate-reviews/");

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

@@ -527,6 +527,11 @@ function arraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
+// Reads the task's message log outside the service's task lock, for consumers
+// that only need a point-in-time view, such as Gate Review evidence capture.
+export function readTaskMessages(fs, input) {
+    return readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+}
 async function readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];

package/dist/backend/services/role-context-restart-service.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { toVcmError, VcmError } from "../errors.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const STATE_DIR = "restart-with-context";
 export function createRoleContextRestartService(deps) {
@@ -126,7 +127,11 @@ export function createRoleContextRestartService(deps) {
         ]);
         const handoffDir = task.handoffDir;
         const stateRoot = config.stateRoot;
-        const files = roleContextFiles(role, handoffDir, stateRoot);
+        const routeMessagesPath = await writeRouteMessages(repoRoot, task, stateRoot, role);
+        const files = [
+            ...(routeMessagesPath ? [routeMessagesPath] : []),
+            ...roleContextFiles(role, handoffDir, stateRoot)
+        ];
         return {
             system: [
                 `This fresh ${role} session continues the current VCM task after Restart With Context.`,
@@ -140,6 +145,28 @@ export function createRoleContextRestartService(deps) {
             user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
         };
     }
+    // A delivery role's assignment lives only in the PM route messages, so render
+    // the current flow run's messages to that role for the fresh session.
+    async function writeRouteMessages(repoRoot, task, stateRoot, role) {
+        if (role !== "architect" && role !== "coder" && role !== "tester") {
+            return undefined;
+        }
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const context = {
+            repoRoot,
+            taskRepoRoot,
+            stateRoot,
+            handoffDir: task.handoffDir,
+            taskSlug: task.taskSlug
+        };
+        const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, new Set([role]));
+        if (flow.messages.length === 0) {
+            return undefined;
+        }
+        const relativePath = path.posix.join(stateRoot, STATE_DIR, `${role}-route-messages.md`);
+        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, relativePath), renderRouteMessages(task.taskSlug, [`Role: ${role}`], flow));
+        return relativePath;
+    }
     async function persist(repoRoot, state) {
         await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
         pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
@@ -205,7 +232,6 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "architect":
             return [
-                `${handoffDir}/role-commands/architect.md`,
                 `${handoffDir}/architecture-brief.md`,
                 `${handoffDir}/architecture-evidence.md`,
                 `${handoffDir}/planning-progress.md`,
@@ -216,14 +242,12 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "coder":
             return [
-                `${handoffDir}/role-commands/coder.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 ".ai/vcm/coder-workers/"
             ];
         case "tester":
             return [
-                `${handoffDir}/role-commands/tester.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 `${handoffDir}/test-report.md`

package/dist/backend/services/route-message-evidence.js

@@ -0,0 +1,83 @@
+import { readTaskMessages } from "./message-service.js";
+// PM route messages are the operative instructions for a role: the dispatch
+// that started the current flow run and every later relay of a user decision.
+// They exist only in the task message log, so callers render this slice of it.
+export async function collectFlowRouteMessages(fs, workflowControlService, context, roles) {
+    const messages = await readTaskMessages(fs, {
+        repoRoot: context.repoRoot,
+        stateRepoRoot: context.taskRepoRoot,
+        stateRoot: context.stateRoot,
+        taskSlug: context.taskSlug
+    });
+    const flowRunStart = await findFlowRunStart(workflowControlService, context);
+    const acceptedPmMessages = messages
+        .filter((message) => message.fromRole === "project-manager" && message.acceptedAt)
+        .sort((left, right) => left.acceptedAt.localeCompare(right.acceptedAt));
+    // A PM message is accepted immediately before Workflow Progress confirms its
+    // dispatch, so the flow's starting message is the last one accepted at or
+    // before the first confirmation of the flow run.
+    const windowStart = flowRunStart
+        ? acceptedPmMessages.filter((message) => message.acceptedAt <= flowRunStart).at(-1)?.acceptedAt ?? flowRunStart
+        : undefined;
+    return {
+        windowStart,
+        messages: messages
+            .filter((message) => message.fromRole === "user"
+            ? !windowStart || message.createdAt >= windowStart
+            : message.fromRole === "project-manager"
+                && roles.has(message.toRole)
+                && Boolean(message.acceptedAt)
+                && (!windowStart || message.acceptedAt >= windowStart))
+            .sort((left, right) => messageTime(left).localeCompare(messageTime(right)))
+    };
+}
+export function renderRouteMessages(taskSlug, header, flow) {
+    return [
+        "# PM Route Messages",
+        "",
+        `Task: ${taskSlug}`,
+        ...header,
+        flow.windowStart
+            ? `Scope: messages since the current flow run started at ${flow.windowStart}`
+            : "Scope: the whole task message log; the current flow run start was unavailable",
+        "",
+        "PM route messages to the listed roles and user messages to PM, oldest first.",
+        "A later message overrides an earlier one where they conflict.",
+        ...flow.messages.flatMap((message, index) => [
+            "",
+            `## ${index + 1}. ${message.fromRole} -> ${message.toRole} (${message.type})`,
+            "",
+            `Message: ${message.id}`,
+            `Time: ${messageTime(message)}`,
+            ...(message.artifactRefs.length > 0 ? [`Artifacts: ${message.artifactRefs.join(", ")}`] : []),
+            "",
+            message.body.trimEnd()
+        ]),
+        ""
+    ].join("\n");
+}
+async function findFlowRunStart(workflowControlService, context) {
+    if (!workflowControlService) {
+        return undefined;
+    }
+    try {
+        const workflowContext = {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            handoffDir: context.handoffDir,
+            taskSlug: context.taskSlug
+        };
+        const [state, progress] = await Promise.all([
+            workflowControlService.getState(workflowContext),
+            workflowControlService.getProgress(workflowContext)
+        ]);
+        const startedAtSequence = state.flowRun?.startedAtSequence;
+        return progress.history.find((entry) => entry.sequence === startedAtSequence)?.confirmedAt;
+    }
+    catch {
+        return undefined;
+    }
+}
+function messageTime(message) {
+    return message.acceptedAt ?? message.createdAt;
+}

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