vibe-coding-master 0.9.5 → 0.9.7

package/README.md

@@ -17,12 +17,30 @@ orchestration, translation, harness setup, and mobile gateway control.
 
 ## Requirements
 
-- Node.js 20 LTS or 22+
+- Node.js 20 LTS or 22+, with `node` on the `PATH` VCM starts with (role hooks
+  and `.ai/tools` scripts run with it)
 - npm
-- Git
+- Git 2.22 or newer
+- `sh` and `curl` (role hooks report Claude Code events to VCM through them)
+- Non-interactive credentials for the repository's upstream remote (an SSH key
+  in ssh-agent or a Git credential helper). Creating a task pulls the upstream
+  branch, and VCM runs Git without credential prompts.
+- Optional: GitHub CLI (`gh`). VCM never runs it, but when it is installed and
+  logged out VCM warns, because roles that use it will fail.
 - Claude Code installed and available as `claude` (verified with 2.1.310 or
   newer; VCM shows a Repository warning when an older release is detected)
 - Claude Code authenticated in the same environment where VCM runs
+- A Git commit identity (`user.name` and `user.email`) in the same environment.
+  When either is missing, VCM and its roles commit as `VCM <vcm@localhost>`
+  and the Repository panel shows a warning; VCM never changes your Git config.
+
+VCM checks these programs at startup, runs a hook self-test that sends one
+request through the installed hook pipeline, and checks access to the upstream
+remote when a repository connects. Any problem appears in the startup log and
+the Repository warnings, and the Repository header shows how many there are
+while the section is collapsed; none of them stops VCM from running. Role sessions
+add the VCM host to `NO_PROXY`, so an `http_proxy` setting does not capture
+their hook requests.
 
 For Linux containers, make sure common native build/runtime tools are available:
 
@@ -511,22 +529,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/adapters/command-runner.js

@@ -10,10 +10,15 @@ export function createCommandRunner() {
                     input: options.input,
                     reject: false
                 });
+                // A command that could not start, timed out, or died from a signal has
+                // no exit code; it failed, so it must not read as a clean exit.
+                const exitCode = result.exitCode ?? (result.failed ? 1 : 0);
                 return {
                     stdout: result.stdout,
-                    stderr: result.stderr,
-                    exitCode: result.exitCode ?? 0
+                    stderr: result.exitCode === undefined && result.failed
+                        ? [result.stderr, result.shortMessage].filter(Boolean).join("\n")
+                        : result.stderr,
+                    exitCode
                 };
             }
             catch (error) {

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

@@ -1,7 +1,24 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { VcmError } from "../errors.js";
+// Network Git commands run without a terminal prompt: VCM is driven from the
+// browser, so a credential prompt would hang the request on the terminal that
+// started VCM instead of failing with an error the UI can show.
+const REMOTE_COMMAND_TIMEOUT_MS = 20 * 1000;
+const PULL_TIMEOUT_MS = 5 * 60 * 1000;
+// Commit identity used when neither Git config nor the environment provides one.
+// Without it, Git either refuses to commit or invents an identity from the OS
+// account and hostname, which silently attributes commits to a machine name.
+export const DEFAULT_GIT_IDENTITY = { name: "VCM", email: "vcm@localhost" };
+const GIT_IDENTITY_CACHE_TTL_MS = 30 * 1000;
+export function renderGitIdentityWarning(location, identity) {
+    const missing = identity.defaulted.map((part) => `user.${part}`).join(" and ");
+    return `Git ${missing} is not configured for ${location}, so VCM and role commits use ${identity.name} <${identity.email}>. `
+        + "Set your own identity in the environment that runs VCM: "
+        + "git config --global user.name \"<name>\" and git config --global user.email \"<email>\".";
+}
 export function createGitAdapter(runner) {
+    const identityCache = new Map();
     return {
         async checkRepo(repoRoot) {
             return checkGitMarker(repoRoot);
@@ -303,7 +320,7 @@ export function createGitAdapter(runner) {
             }
         },
         async commit(repoRoot, message) {
-            const result = await runGit(runner, repoRoot, ["commit", "-m", message]);
+            const result = await runGit(runner, repoRoot, ["commit", "-m", message], (await this.resolveCommitIdentity(repoRoot)).env);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_COMMIT_FAILED",
@@ -318,7 +335,7 @@ export function createGitAdapter(runner) {
             if (paths.length === 0) {
                 return this.getHeadCommit(repoRoot);
             }
-            const result = await runGit(runner, repoRoot, ["commit", "--only", "-m", message, "--", ...paths]);
+            const result = await runGit(runner, repoRoot, ["commit", "--only", "-m", message, "--", ...paths], (await this.resolveCommitIdentity(repoRoot)).env);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_COMMIT_FAILED",
@@ -329,6 +346,29 @@ export function createGitAdapter(runner) {
             }
             return this.getHeadCommit(repoRoot);
         },
+        async resolveCommitIdentity(repoRoot) {
+            const cached = identityCache.get(repoRoot);
+            if (cached && Date.now() - cached.checkedAt < GIT_IDENTITY_CACHE_TTL_MS) {
+                return cached.identity;
+            }
+            const identity = { name: "", email: "", defaulted: [], env: {} };
+            for (const part of ["name", "email"]) {
+                const result = await runGit(runner, repoRoot, ["config", "--get", `user.${part}`]);
+                const configured = result.exitCode === 0 ? result.stdout.trim() : "";
+                const variables = [`GIT_AUTHOR_${part.toUpperCase()}`, `GIT_COMMITTER_${part.toUpperCase()}`];
+                for (const variable of variables) {
+                    if (!configured && !process.env[variable]) {
+                        identity.env[variable] = DEFAULT_GIT_IDENTITY[part];
+                    }
+                }
+                if (variables.some((variable) => identity.env[variable])) {
+                    identity.defaulted.push(part);
+                }
+                identity[part] = process.env[variables[0]] || configured || DEFAULT_GIT_IDENTITY[part];
+            }
+            identityCache.set(repoRoot, { checkedAt: Date.now(), identity });
+            return identity;
+        },
         async createWorktree(input) {
             const result = await runGit(runner, input.repoRoot, [
                 "worktree",
@@ -375,7 +415,7 @@ export function createGitAdapter(runner) {
             }
         },
         async pullFastForward(repoRoot) {
-            const result = await runGit(runner, repoRoot, ["pull", "--ff-only"]);
+            const result = await runGit(runner, repoRoot, ["pull", "--ff-only"], await buildNonInteractiveGitEnv(runner, repoRoot), PULL_TIMEOUT_MS);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_PULL_FAILED",
@@ -388,9 +428,47 @@ export function createGitAdapter(runner) {
                 stdout: result.stdout,
                 stderr: result.stderr
             };
+        },
+        async checkRemoteAccess(repoRoot) {
+            const branch = (await runGit(runner, repoRoot, ["branch", "--show-current"])).stdout.trim();
+            if (!branch) {
+                return { status: "skipped" };
+            }
+            const remoteResult = await runGit(runner, repoRoot, ["config", "--get", `branch.${branch}.remote`]);
+            const remote = remoteResult.stdout.trim();
+            if (remoteResult.exitCode !== 0 || !remote || remote === ".") {
+                return { status: "skipped" };
+            }
+            const result = await runGit(runner, repoRoot, ["ls-remote", remote, "HEAD"], await buildNonInteractiveGitEnv(runner, repoRoot), REMOTE_COMMAND_TIMEOUT_MS);
+            if (result.exitCode === 0) {
+                return { status: "ok", remote };
+            }
+            return {
+                status: "failed",
+                remote,
+                detail: firstMeaningfulLine(result.stderr) || firstMeaningfulLine(result.stdout) || `git ls-remote exited with ${result.exitCode}`
+            };
         }
     };
 }
+async function buildNonInteractiveGitEnv(runner, repoRoot) {
+    const env = {
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "never"
+    };
+    // Keep a configured SSH command; otherwise make ssh fail instead of asking
+    // for a passphrase or host-key confirmation.
+    if (!process.env.GIT_SSH_COMMAND && !process.env.GIT_SSH) {
+        const configured = await runGit(runner, repoRoot, ["config", "--get", "core.sshCommand"]);
+        if (configured.exitCode !== 0 || !configured.stdout.trim()) {
+            env.GIT_SSH_COMMAND = "ssh -o BatchMode=yes";
+        }
+    }
+    return { ...process.env, ...env };
+}
+function firstMeaningfulLine(value) {
+    return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
+}
 async function checkGitMarker(repoRoot) {
     const markerPath = path.join(repoRoot, ".git");
     try {
@@ -449,8 +527,8 @@ async function pathExists(targetPath) {
         return false;
     }
 }
-async function runGit(runner, repoRoot, args) {
-    return runner.run("git", [...await buildSafeDirectoryArgs(repoRoot), ...args], { cwd: repoRoot });
+async function runGit(runner, repoRoot, args, env, timeoutMs) {
+    return runner.run("git", [...await buildSafeDirectoryArgs(repoRoot), ...args], { cwd: repoRoot, env, timeoutMs });
 }
 function parseWorktreePaths(output) {
     return output

package/dist/backend/api/claude-hook-routes.js

@@ -1,4 +1,9 @@
+import { VCM_HOOK_PROBE_PATH } from "../services/harness-service.js";
 export function registerClaudeHookRoutes(app, deps) {
+    // The hook self-test posts here through the installed hook pipeline.
+    app.post(VCM_HOOK_PROBE_PATH, async (request) => {
+        return { received: deps.environmentCheck?.receiveHookProbe(request.body?.runtimeSessionToken) ?? false };
+    });
     app.post("/api/hooks/claude-code", async (request) => {
         return deps.claudeHookService.handleHook(request.body);
     });

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

@@ -1,3 +1,4 @@
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
@@ -10,7 +11,8 @@ import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
 import { createClaudeVersionCheck } from "./services/claude-version-check.js";
-import { createGitAdapter } from "./adapters/git-adapter.js";
+import { createEnvironmentCheck } from "./services/environment-check.js";
+import { createGitAdapter, renderGitIdentityWarning } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
@@ -35,7 +37,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";
@@ -93,7 +94,7 @@ export async function createServer(deps, options = {}) {
         appSettings: deps.appSettings,
         codexBridgeIntegration: deps.codexBridgeIntegration
     });
-    registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
+    registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService, environmentCheck: deps.environmentCheck });
     registerGateReviewRoutes(app, {
         projectService: deps.projectService,
         gateReviewService: deps.gateReviewService
@@ -216,6 +217,29 @@ async function cleanupRecentTranslationRuntime(deps) {
     const repoRoots = await deps.projectService.getRecentRepositoryPaths();
     await Promise.all(repoRoots.map((repoRoot) => deps.translationWorkerService.cleanupStartupRuntime(repoRoot)));
 }
+async function warnOnEnvironmentProblems(environmentCheck) {
+    try {
+        for (const warning of await environmentCheck?.getWarnings({ refresh: true }) ?? []) {
+            console.warn(`[VCM] ${warning}`);
+        }
+    }
+    catch {
+        // Project summaries report environment problems when a repository connects.
+    }
+}
+// Projects can still configure their own identity; this only reports the
+// identity VCM falls back to outside any repository-specific Git config.
+async function warnOnDefaultGitIdentity() {
+    try {
+        const identity = await createGitAdapter(createCommandRunner()).resolveCommitIdentity(os.homedir());
+        if (identity.defaulted.length > 0) {
+            console.warn(`[VCM] ${renderGitIdentityWarning("the VCM user", identity)}`);
+        }
+    }
+    catch {
+        // Project summaries report identity problems per repository.
+    }
+}
 export async function startServer(options = {}) {
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? 4173;
@@ -224,6 +248,8 @@ export async function startServer(options = {}) {
     });
     const app = await createServer(deps, options);
     await app.listen({ host, port });
+    await warnOnEnvironmentProblems(deps.environmentCheck);
+    await warnOnDefaultGitIdentity();
     return {
         url: `http://${host}:${port}`,
         close() {
@@ -238,6 +264,7 @@ export function createDefaultServerDeps(options = {}) {
     const runner = createCommandRunner();
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
+    const environmentCheck = createEnvironmentCheck({ runner, git, apiUrl: options.apiUrl });
     const appSettings = createAppSettingsService({ fs });
     const codexBridgeIntegration = createCodexBridgeIntegrationService({
         settings: appSettings,
@@ -253,13 +280,14 @@ export function createDefaultServerDeps(options = {}) {
     const projectService = createProjectService({
         fs,
         git,
+        environmentCheck,
         appSettings,
         claudeVersionCheck: createClaudeVersionCheck(claude)
     });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const taskWorkflowService = createTaskWorkflowService({ fs });
-    const codeIntelligenceDetector = createHarnessCodeIntelligenceDetector(fs, { runner });
     const sessionService = createSessionService({
+        gitIdentity: git,
         fs,
         runtime,
         registry,
@@ -268,13 +296,11 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         taskWorkflowService,
-        codeIntelligenceDetector,
         codexBridgeIntegration,
         apiUrl: options.apiUrl
     });
     const harnessService = createHarnessService({
         fs,
-        commandRunner: runner,
         git,
         runtime,
         harnessEngineerSessions: sessionService,
@@ -330,6 +356,7 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         taskWorkflowService,
         workflowControlService,
+        probeHookDelivery: () => environmentCheck.probeHookDelivery(),
         onRouteDelivered: ({ repoRoot, taskSlug, message }) => architectRestartService.recordRouteDelivered(repoRoot, taskSlug, message)
     });
     const taskLaunchService = createTaskLaunchService({
@@ -513,7 +540,8 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         diagnosticsService,
         usageAnalyticsService,
-        workflowControlService
+        workflowControlService,
+        environmentCheck
     };
 }
 export function getDefaultStaticDir() {