vibe-coding-master 0.4.0 → 0.4.2

package/README.md

@@ -30,7 +30,7 @@ When Gate Review Gates are enabled for a task, or when a Gate Reviewer session a
 - Manual and automatic orchestration modes.
 - Two-stage VCM harness setup: deterministic fixed install plus AI-assisted bootstrap.
 - VCM-managed root rules, role agents, repo-local VCM skills, Claude Code hooks, generated-context tools, and PR template.
-- Rust generated context for module indexing and crate-external public surface indexing.
+- Generated context for Rust and npm workspace module indexing plus public surface indexing.
 - Translation panel powered by the long-lived Translator session.
 - Mobile Gateway through Tencent iLink Bot API / Weixin DM, for talking to PM and managing tasks from Weixin.
 - Durable task state, role session state, handoff artifacts, and message history.
@@ -486,7 +486,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 
 VCM also JSON-merges `.claude/settings.json` to install Claude Code `PreToolUse`, `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks plus a managed `env.BASH_DEFAULT_TIMEOUT_MS` so foreground watch windows fit inside the Bash tool timeout. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion. The `Stop` hook forwards the backend response to Claude Code, which lets VCM block turn-end while a validation job is still running.
 
-Bootstrap is AI-assisted. VCM starts a visible temporary Claude Code session in the connected repository and asks it to use the `vcm-harness-bootstrap` skill. Bootstrap fills project-specific content and generated context:
+Bootstrap is AI-assisted. VCM starts or resumes the project-scoped Harness Engineer Claude Code session in the connected repository and asks it to use the `vcm-harness-bootstrap` skill. Bootstrap fills project-specific content and generated context:
 
 ```text
 CLAUDE.md project context outside the VCM managed block
@@ -497,7 +497,7 @@ docs/TESTING.md
 .ai/generated/public-surface.json
 ```
 
-The generated-context tools currently target Rust projects. Non-Rust repositories can still install the fixed harness, but generated context should be treated as unsupported until project-specific generators exist.
+The generated-context tools support Rust/Cargo projects and npm workspace TypeScript/JavaScript projects. Other repository shapes can still install the fixed harness, but generated context should be treated as unsupported until project-specific generators exist.
 
 After applying harness changes or completing bootstrap, VCM reports the exact files changed or checks completed and reminds the user to review and commit them before starting long-running work.
 

package/dist/backend/cli/install-vcm-harness.js

@@ -314,7 +314,7 @@ Installs only fixed VCM harness content.
 This deterministic installer handles VCM-owned managed blocks, VCM-owned whole
 files, VCM Claude settings hooks, generic long-running helper tools, and the
 harness manifest. It also creates blank durable project doc templates when
-missing and installs Rust generated-context generator tools. It does not copy
+missing and installs generated-context tools for Rust and npm workspace projects. It does not copy
 example project docs, generated context artifacts, module-level architecture
 docs, or task runtime handoff artifacts.`);
 }

package/dist/backend/server.js

@@ -167,14 +167,6 @@ export function createDefaultServerDeps(options = {}) {
     const registry = createSessionRegistry();
     const artifactService = createArtifactService(fs);
     const projectService = createProjectService({ fs, git, appSettings });
-    const harnessService = createHarnessService({
-        fs,
-        git,
-        runtime,
-        projectService,
-        apiUrl: options.apiUrl,
-        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
-    });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const sessionService = createSessionService({
         fs,
@@ -186,6 +178,13 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         apiUrl: options.apiUrl
     });
+    const harnessService = createHarnessService({
+        fs,
+        git,
+        runtime,
+        harnessEngineerSessions: sessionService,
+        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
+    });
     const commandDispatcher = createCommandDispatcher({
         runtime,
         sessionService,
@@ -264,6 +263,7 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         appSettings,
         runtime,
+        harnessService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService

package/dist/backend/services/claude-hook-service.js

@@ -83,6 +83,11 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd)
         });
+        await deps.harnessService?.recordHarnessBootstrapHook(context.project.repoRoot, {
+            eventName,
+            sessionId: session?.id,
+            claudeSessionId: stringOrUndefined(input.event.session_id)
+        });
         return {
             ok: true,
             eventName,

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -19,10 +18,8 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
 const execFileAsync = promisify(execFile);
-const BOOTSTRAP_TASK_SLUG = "__vcm-harness-bootstrap__";
-const BOOTSTRAP_RUNTIME_ROLE = "project-manager";
-const BOOTSTRAP_LOG_PATH = ".ai/vcm/bootstrap/bootstrap.log";
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
+const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
@@ -307,7 +304,7 @@ export function createHarnessService(deps) {
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async startHarnessBootstrap(repoRoot, input = {}) {
-            const session = await launchHarnessBootstrapSession(deps, repoRoot, now, input, { forceFresh: false });
+            const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, now, input);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -319,11 +316,7 @@ export function createHarnessService(deps) {
             };
         },
         async restartHarnessBootstrap(repoRoot, input = {}) {
-            const existing = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
-            if (existing && deps.runtime?.getSession(existing.id)) {
-                await deps.runtime.stop(existing.id);
-            }
-            const session = await launchHarnessBootstrapSession(deps, repoRoot, now, input, { forceFresh: true });
+            const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, now, input);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -335,26 +328,20 @@ export function createHarnessService(deps) {
             };
         },
         async stopHarnessBootstrap(repoRoot) {
-            const existing = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
+            const existing = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
             if (!existing) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_SESSION_MISSING",
-                    message: "Harness bootstrap terminal has not been started.",
+                    message: "Harness Engineer session has not been started.",
                     statusCode: 404
                 });
             }
-            if (deps.runtime?.getSession(existing.id)) {
-                await deps.runtime.stop(existing.id);
-            }
-            await persistHarnessBootstrapSession(deps.fs, repoRoot, {
-                ...existing,
-                status: "exited",
-                updatedAt: now()
-            });
+            await deps.harnessEngineerSessions?.stopProjectHarnessEngineerSession(repoRoot);
+            await clearHarnessBootstrapRunState(deps.fs, repoRoot);
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async runHarnessBootstrap(repoRoot) {
-            if (!deps.runtime) {
+            if (!deps.runtime || !deps.harnessEngineerSessions) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
                     message: "Harness bootstrap sessions are not available in this VCM runtime.",
@@ -366,11 +353,20 @@ export function createHarnessService(deps) {
             if (!session || session.status !== "running" || !deps.runtime.getSession(session.id)) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_SESSION_NOT_RUNNING",
-                    message: "Start the Harness Bootstrap terminal before running bootstrap.",
+                    message: "Start the Harness Engineer session before running bootstrap.",
                     statusCode: 409
                 });
             }
             const prompt = buildHarnessBootstrapPrompt(repoRoot);
+            const timestamp = now();
+            await persistHarnessBootstrapRunState(deps.fs, repoRoot, {
+                version: 1,
+                status: "running",
+                sessionId: session.id,
+                claudeSessionId: session.claudeSessionId,
+                startedAt: timestamp,
+                updatedAt: timestamp
+            });
             await submitTerminalInput(deps.runtime, session.id, prompt);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
@@ -381,6 +377,21 @@ export function createHarnessService(deps) {
                 session,
                 prompt
             };
+        },
+        async recordHarnessBootstrapHook(repoRoot, input) {
+            const state = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
+            if (state?.status !== "running" || !matchesBootstrapRunState(state, input)) {
+                return getHarnessBootstrapStatus(deps, repoRoot, now);
+            }
+            const timestamp = now();
+            await persistHarnessBootstrapRunState(deps.fs, repoRoot, {
+                ...state,
+                status: input.eventName === "Stop" ? "complete" : state.status,
+                completedAt: input.eventName === "Stop" ? timestamp : state.completedAt,
+                updatedAt: timestamp,
+                lastHookEvent: input.eventName
+            });
+            return getHarnessBootstrapStatus(deps, repoRoot, now);
         }
     };
 }
@@ -400,8 +411,8 @@ function dedupeHarnessChanges(changedFiles) {
     }
     return changes;
 }
-async function launchHarnessBootstrapSession(deps, repoRoot, now, input, options) {
-    if (!deps.runtime || !deps.projectService) {
+async function ensureHarnessEngineerForBootstrap(deps, repoRoot, now, input) {
+    if (!deps.harnessEngineerSessions) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
             message: "Harness bootstrap sessions are not available in this VCM runtime.",
@@ -409,56 +420,62 @@ async function launchHarnessBootstrapSession(deps, repoRoot, now, input, options
         });
     }
     const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
-    if (!options.forceFresh && currentStatus.session?.status === "running") {
+    if (currentStatus.session?.status === "running") {
         return currentStatus.session;
     }
-    if (!currentStatus.canStart && !(options.forceFresh && currentStatus.session?.status === "running")) {
+    if (!currentStatus.canStart) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_NOT_READY",
             message: "Install the fixed VCM harness before starting harness bootstrap.",
             statusCode: 409
         });
     }
-    const config = await deps.projectService.loadConfig(repoRoot);
-    const claudeSessionId = randomUUID();
-    const permissionMode = normalizeClaudePermissionMode(input.permissionMode);
-    const model = normalizeClaudeModel(input.model);
-    const effort = normalizeClaudeEffort(input.effort);
-    const command = buildClaudeStartCommand(config.claudeCommand, permissionMode, claudeSessionId, model, effort);
-    const logPath = path.join(repoRoot, BOOTSTRAP_LOG_PATH);
-    const runtimeSession = await deps.runtime.createSession({
-        taskSlug: BOOTSTRAP_TASK_SLUG,
-        role: BOOTSTRAP_RUNTIME_ROLE,
-        command: command.command,
-        args: command.args,
-        cwd: repoRoot,
-        env: {
-            VCM_API_URL: deps.apiUrl,
-            VCM_TASK_REPO_ROOT: repoRoot,
-            VCM_HARNESS_BOOTSTRAP: "1",
-            VCM_SESSION_ID: claudeSessionId
-        },
-        cols: input.cols,
-        rows: input.rows,
-        logPath
-    });
-    const session = {
-        id: runtimeSession.id,
-        claudeSessionId,
-        status: runtimeSession.status === "crashed" ? "crashed" : runtimeSession.status === "exited" ? "exited" : "running",
-        command: command.display,
-        permissionMode,
-        model,
-        effort,
-        cwd: repoRoot,
-        logPath: BOOTSTRAP_LOG_PATH,
-        startedAt: runtimeSession.startedAt,
-        updatedAt: now(),
-        lastOutputAt: runtimeSession.lastOutputAt,
-        exitCode: runtimeSession.exitCode
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.ensureProjectHarnessEngineerSession(repoRoot, input));
+}
+async function restartHarnessEngineerForBootstrap(deps, repoRoot, now, input) {
+    if (!deps.harnessEngineerSessions) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
+            message: "Harness bootstrap sessions are not available in this VCM runtime.",
+            statusCode: 501
+        });
+    }
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+    if (!currentStatus.canStart) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_NOT_READY",
+            message: "Install the fixed VCM harness before starting harness bootstrap.",
+            statusCode: 409
+        });
+    }
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.restartProjectHarnessEngineerSession(repoRoot, input));
+}
+async function getCurrentHarnessEngineerBootstrapSession(deps, repoRoot) {
+    const session = await deps.harnessEngineerSessions?.getProjectHarnessEngineerSession(repoRoot);
+    return session ? toHarnessBootstrapSession(session) : undefined;
+}
+function toHarnessBootstrapSession(session) {
+    return {
+        id: session.id,
+        claudeSessionId: session.claudeSessionId,
+        status: toBootstrapSessionStatus(session.status),
+        command: session.command,
+        permissionMode: session.permissionMode,
+        model: session.model,
+        effort: session.effort,
+        cwd: session.cwd,
+        logPath: HARNESS_ENGINEER_SESSION_PATH,
+        startedAt: session.startedAt,
+        updatedAt: session.updatedAt,
+        lastOutputAt: session.lastOutputAt,
+        exitCode: session.exitCode
     };
-    await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
-    return session;
+}
+function toBootstrapSessionStatus(status) {
+    if (status === "running" || status === "crashed" || status === "exited" || status === "resumable") {
+        return status;
+    }
+    return status === "missing" ? "resumable" : "exited";
 }
 function normalizeHarnessGitPath(value) {
     if (!value || value.includes("\0") || path.posix.isAbsolute(value)) {
@@ -909,26 +926,28 @@ async function getHarnessBootstrapStatus(deps, repoRoot, now) {
         await checkModuleArchitectureDocs(deps.fs, repoRoot, moduleIndex),
         await checkFilledMarkdown(deps.fs, repoRoot, "docs/TESTING.md", "Testing doc", "testing-doc")
     ];
-    const session = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
+    const runState = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
+    const session = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
     const fixedHarnessReady = checks[0]?.status === "ok";
     const projectChecks = checks.slice(1);
     const projectComplete = projectChecks.every((check) => check.status === "ok");
     const projectStarted = projectChecks.some((check) => check.status === "ok" || check.status === "incomplete");
+    const runActive = runState?.status === "running" && session?.status === "running";
     const status = !fixedHarnessReady
         ? "not_ready"
-        : session?.status === "running"
+        : runActive
             ? "running"
-            : projectComplete
+            : runState?.status === "complete" || projectComplete
                 ? "complete"
                 : projectStarted
                     ? "incomplete"
                     : "not_started";
     return {
         status,
-        canStart: fixedHarnessReady && session?.status !== "running",
+        canStart: fixedHarnessReady && !runActive,
         checks,
         session,
-        warnings: bootstrapWarnings(status, checks, session)
+        warnings: bootstrapWarnings(status, checks, session, runState)
     };
 }
 async function checkFixedHarness(fs, repoRoot) {
@@ -1129,74 +1148,47 @@ function isFilledMarkdown(content) {
         .filter((line) => line && !line.startsWith("#"));
     return meaningfulLines.join("\n").length >= 120;
 }
-async function getCurrentHarnessBootstrapSession(deps, repoRoot, now) {
-    const persisted = await loadPersistedHarnessBootstrapSession(deps.fs, repoRoot);
-    const runtimeSession = deps.runtime
-        ?.listSessions(BOOTSTRAP_TASK_SLUG)
-        .find((session) => session.id === persisted?.id || session.status === "running");
-    if (runtimeSession) {
-        const session = {
-            id: runtimeSession.id,
-            claudeSessionId: persisted?.claudeSessionId ?? runtimeSession.id,
-            status: runtimeSession.status === "crashed" ? "crashed" : runtimeSession.status === "exited" ? "exited" : "running",
-            command: persisted?.command ?? "claude",
-            permissionMode: persisted?.permissionMode,
-            model: persisted?.model,
-            effort: persisted?.effort,
-            cwd: persisted?.cwd ?? repoRoot,
-            logPath: persisted?.logPath ?? BOOTSTRAP_LOG_PATH,
-            startedAt: runtimeSession.startedAt,
-            updatedAt: now(),
-            lastOutputAt: runtimeSession.lastOutputAt,
-            exitCode: runtimeSession.exitCode
-        };
-        await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
-        return session;
-    }
-    if (persisted?.status === "running") {
-        return {
-            ...persisted,
-            status: "resumable",
-            updatedAt: now()
-        };
-    }
-    return undefined;
-}
-async function loadPersistedHarnessBootstrapSession(fs, repoRoot) {
+async function loadPersistedHarnessBootstrapRunState(fs, repoRoot) {
     const payload = await readOptionalJsonObject(fs, repoRoot, BOOTSTRAP_SESSION_PATH);
     if (!payload) {
         return undefined;
     }
-    if (typeof payload.id !== "string" ||
-        typeof payload.claudeSessionId !== "string" ||
-        typeof payload.command !== "string" ||
-        typeof payload.cwd !== "string" ||
-        typeof payload.logPath !== "string" ||
+    if (payload.version !== 1 ||
         typeof payload.updatedAt !== "string") {
         return undefined;
     }
     const status = payload.status;
-    if (status !== "running" && status !== "exited" && status !== "crashed" && status !== "resumable") {
+    if (status !== "running" && status !== "complete") {
         return undefined;
     }
     return {
-        id: payload.id,
-        claudeSessionId: payload.claudeSessionId,
+        version: 1,
         status,
-        command: payload.command,
-        permissionMode: normalizeClaudePermissionMode(payload.permissionMode),
-        model: normalizeClaudeModel(payload.model),
-        effort: normalizeClaudeEffort(payload.effort),
-        cwd: payload.cwd,
-        logPath: payload.logPath,
+        sessionId: typeof payload.sessionId === "string" ? payload.sessionId : undefined,
+        claudeSessionId: typeof payload.claudeSessionId === "string" ? payload.claudeSessionId : undefined,
         startedAt: typeof payload.startedAt === "string" ? payload.startedAt : undefined,
+        completedAt: typeof payload.completedAt === "string" ? payload.completedAt : undefined,
         updatedAt: payload.updatedAt,
-        lastOutputAt: typeof payload.lastOutputAt === "string" ? payload.lastOutputAt : undefined,
-        exitCode: typeof payload.exitCode === "number" || payload.exitCode === null ? payload.exitCode : undefined
+        lastHookEvent: isHarnessBootstrapHookEvent(payload.lastHookEvent) ? payload.lastHookEvent : undefined
     };
 }
-async function persistHarnessBootstrapSession(fs, repoRoot, session) {
-    await fs.writeJsonAtomic(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), session);
+async function persistHarnessBootstrapRunState(fs, repoRoot, state) {
+    await fs.writeJsonAtomic(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), state);
+}
+async function clearHarnessBootstrapRunState(fs, repoRoot) {
+    await fs.removePath?.(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), { force: true });
+}
+function isHarnessBootstrapHookEvent(value) {
+    return value === "Stop" || value === "StopFailure" || value === "UserPromptSubmit" || value === "PostCompact";
+}
+function matchesBootstrapRunState(state, input) {
+    if (state.sessionId && input.sessionId && state.sessionId !== input.sessionId) {
+        return false;
+    }
+    if (state.claudeSessionId && input.claudeSessionId && state.claudeSessionId !== input.claudeSessionId) {
+        return false;
+    }
+    return true;
 }
 async function readOptionalText(fs, repoRoot, relativePath) {
     const absolutePath = resolveHarnessPath(repoRoot, relativePath);
@@ -1220,13 +1212,16 @@ async function readOptionalJsonObject(fs, repoRoot, relativePath) {
         return undefined;
     }
 }
-function bootstrapWarnings(status, checks, session) {
+function bootstrapWarnings(status, checks, session, runState) {
     const warnings = [];
     if (status === "not_ready") {
         warnings.push("Install or update the fixed VCM harness before running harness bootstrap.");
     }
     if (session?.status === "resumable") {
-        warnings.push("The previous bootstrap terminal is no longer active; start bootstrap again or finish the remaining files manually.");
+        warnings.push("The Harness Engineer session is resumable; resume it before running harness bootstrap.");
+    }
+    if (runState?.status === "running" && session?.status !== "running") {
+        warnings.push("The previous bootstrap run did not finish with an active Harness Engineer session; resume the session or run bootstrap again.");
     }
     const unknownChecks = checks.filter((check) => check.status === "unknown");
     if (unknownChecks.length > 0) {
@@ -1234,56 +1229,6 @@ function bootstrapWarnings(status, checks, session) {
     }
     return warnings;
 }
-function buildClaudeStartCommand(command = "claude", permissionMode = "default", claudeSessionId, model = "default", effort = "default") {
-    const args = ["--session-id", claudeSessionId, "--model", model];
-    if (effort === "ultracode") {
-        args.push("--settings", JSON.stringify({ ultracode: true }));
-    }
-    else if (effort !== "default") {
-        args.push("--effort", effort);
-    }
-    if (permissionMode === "bypassPermissions") {
-        args.push("--permission-mode", "bypassPermissions");
-    }
-    return {
-        command,
-        args,
-        display: [command, ...args].map(formatDisplayArg).join(" ")
-    };
-}
-function formatDisplayArg(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function normalizeClaudePermissionMode(value) {
-    return value === "bypassPermissions" || value === "dangerously-skip-permissions"
-        ? "bypassPermissions"
-        : "default";
-}
-function normalizeClaudeModel(value) {
-    if (value === "best"
-        || value === "fable"
-        || value === "opus"
-        || value === "opus[1m]"
-        || value === "claude-opus-4-8"
-        || value === "claude-opus-4-8[1m]") {
-        return value;
-    }
-    return "default";
-}
-function normalizeClaudeEffort(value) {
-    if (value === "low"
-        || value === "medium"
-        || value === "high"
-        || value === "xhigh"
-        || value === "max"
-        || value === "ultracode") {
-        return value;
-    }
-    return "default";
-}
 function buildHarnessBootstrapPrompt(repoRoot) {
     return `Use the vcm-harness-bootstrap skill to finish the VCM harness bootstrap for this repository.
 

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

@@ -1,13 +1,10 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { CORE_VCM_ROLE_NAMES } from "../../shared/constants.js";
-import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { renderMessageEnvelope } from "../templates/message-envelope.js";
 const PM_ROLE = "project-manager";
-const PM_TO_ROLE_TYPES = new Set(["task", "question", "review-request", "revise", "cancel"]);
-const ROLE_TO_PM_TYPES = new Set(["result", "question", "blocked", "finding"]);
 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];
@@ -64,7 +61,6 @@ export function createMessageService(deps) {
         return all.filter((routeFile) => routeFile.pending);
     }
     async function dispatchRouteFile(input, routeFile, state, timestamp) {
-        validateMessagePolicy(routeFile.fromRole, routeFile.toRole, routeFile.type);
         const session = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, routeFile.toRole);
         if (!session || session.status !== "running") {
             return {
@@ -370,34 +366,6 @@ function selectDispatchCandidates(routeFiles, stoppedRole) {
         return updated !== 0 ? updated : left.path.localeCompare(right.path);
     });
 }
-function validateMessagePolicy(fromRole, toRole, type) {
-    if (!CORE_VCM_ROLE_NAMES.some((role) => role === toRole)) {
-        throw new VcmError({
-            code: "MESSAGE_TARGET_UNKNOWN",
-            message: `Unknown target role: ${toRole}`,
-            statusCode: 400
-        });
-    }
-    if (!CORE_VCM_ROLE_NAMES.some((role) => role === fromRole)) {
-        throw new VcmError({
-            code: "MESSAGE_SENDER_UNKNOWN",
-            message: `Unknown sender role: ${fromRole}`,
-            statusCode: 400
-        });
-    }
-    if (fromRole === PM_ROLE && toRole !== PM_ROLE && PM_TO_ROLE_TYPES.has(type)) {
-        return;
-    }
-    if (fromRole !== PM_ROLE && toRole === PM_ROLE && ROLE_TO_PM_TYPES.has(type)) {
-        return;
-    }
-    throw new VcmError({
-        code: "MESSAGE_POLICY_DENIED",
-        message: `${fromRole} cannot send ${type} messages to ${toRole}.`,
-        statusCode: 403,
-        hint: "Use project-manager as the orchestration hub unless this task explicitly allows a peer route."
-    });
-}
 async function withTaskLock(locks, key, run) {
     const previous = locks.get(key) ?? Promise.resolve();
     const next = previous.catch(() => undefined).then(run);

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

@@ -80,7 +80,7 @@ export function renderArchitectHarnessRules() {
 - Update affected \`<module>/ARCHITECTURE.md\` when module-level detailed design changes: boundaries, behavior, important public surface explanations, internal risks, or module-specific architecture notes.
 - Treat \`.ai/generated/public-surface.json\` as the full machine index for public surface. Verify or report its freshness when public APIs changed; do not replace it with prose in architecture docs.
 - When module structure changes, require \`.ai/tools/generate-module-index --check\` or regeneration.
-- When crate-external public APIs change, require \`.ai/tools/generate-public-surface --check\` or regeneration.
+- When public APIs, routes, or externally consumed surfaces change, require \`.ai/tools/generate-public-surface --check\` or regeneration.
 - Read \`.ai/vcm/handoffs/known-issues.md\` and promote confirmed unresolved issues to \`docs/known-issues.md\`.
 - Write \`.ai/vcm/handoffs/docs-sync-report.md\` with decision, evidence reviewed, architecture drift check, docs updated, docs left unchanged, remaining documentation risks, and handoff notes.
 

package/dist/backend/templates/harness/claude-root.js

@@ -22,7 +22,7 @@ export function renderRootClaudeHarnessRules() {
 - \`docs/TESTING.md\`: validation strategy, commands, validation levels, integration/E2E case definitions, final-validation cleanup, and known testing gaps; reviewer-owned.
 - \`docs/known-issues.md\`: durable known issues and accepted limitations; architect-owned.
 - \`.ai/generated/module-index.json\`: generated module index; use it to find layers, modules, manifests, module docs, source files, test files, and workspace dependencies.
-- \`.ai/generated/public-surface.json\`: generated crate-external public API index; use it to inspect module-to-module public interfaces and source evidence.
+- \`.ai/generated/public-surface.json\`: generated public surface index; use it to inspect module-to-module public APIs, routes, and source evidence.
 
 ## VCM Task Flow
 

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

@@ -48,7 +48,7 @@ export function renderCoderHarnessRules() {
 ### Generated Context
 
 - Regenerate \`.ai/generated/module-index.json\` with \`.ai/tools/generate-module-index\` after module, manifest, source-file, or test-file changes.
-- Regenerate \`.ai/generated/public-surface.json\` with \`.ai/tools/generate-public-surface\` after crate-external public API or public visibility changes.
+- Regenerate \`.ai/generated/public-surface.json\` with \`.ai/tools/generate-public-surface\` after public API, route, externally consumed surface, or public visibility changes.
 - Do not hand-edit generated context files.
 
 ### Baseline Tests

package/dist/backend/templates/harness/vcm-harness-bootstrap-skill.js

@@ -49,7 +49,7 @@ This skill is an operating procedure. It does not replace the deterministic VCM
 
 - Document the project-level module overview, module responsibilities, module relationships, dependency direction, and project-wide constraints.
 - Link to module-level \`ARCHITECTURE.md\` files when present.
-- Explain generated-context ownership, especially that \`.ai/generated/public-surface.json\` is the machine index for crate-external public APIs.
+- Explain generated-context ownership, especially that \`.ai/generated/public-surface.json\` is the machine index for public APIs, routes, and externally consumed surfaces.
 
 ### Module-Level \`ARCHITECTURE.md\`