vibeman 0.0.12 → 0.0.14

package/dist/api.js

@@ -15677,6 +15677,51 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// ../shared/runtime/vibeman-env.ts
+function readVibemanEnv(env, key) {
+  const value = env[key];
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  return;
+}
+var VIBEMAN_ENV_PREFIX = "VIBEMAN_", VIBEMAN_ENV_KEYS;
+var init_vibeman_env = __esm(() => {
+  VIBEMAN_ENV_KEYS = {
+    ROOT: "VIBEMAN_ROOT",
+    PORT: "VIBEMAN_PORT",
+    DATABASE_URL: "VIBEMAN_DATABASE_URL",
+    VERBOSE: "VIBEMAN_VERBOSE",
+    LOG_FORMAT: "VIBEMAN_LOG_FORMAT",
+    UI_DIST: "VIBEMAN_UI_DIST",
+    CODEX_PATH: "VIBEMAN_CODEX_PATH",
+    GEMINI_PATH: "VIBEMAN_GEMINI_PATH",
+    CLAUDE_CODE_PATH: "VIBEMAN_CLAUDE_CODE_PATH",
+    TRACE: "VIBEMAN_TRACE",
+    DIST_ROOT: "VIBEMAN_DIST_ROOT",
+    DB_AUTORECOVER: "VIBEMAN_DB_AUTORECOVER"
+  };
+});
+
+// ../api/src/services/env-policy.ts
+function isVibemanPrefixedEnvKey(key) {
+  return key.startsWith(VIBEMAN_ENV_PREFIX);
+}
+function shouldFilterForExternalAppLaunch(input) {
+  if (isVibemanPrefixedEnvKey(input.key))
+    return true;
+  return false;
+}
+function shouldFilterForWorktreeShellInheritance(input) {
+  if (isVibemanPrefixedEnvKey(input.key))
+    return true;
+  return false;
+}
+var init_env_policy = __esm(() => {
+  init_vibeman_env();
+  init_vibeman_env();
+});
+
 // ../../node_modules/pino-std-serializers/lib/err-helpers.js
 var require_err_helpers = __commonJS((exports, module) => {
   var isErrorLike = (err) => {
@@ -19959,7 +20004,7 @@ function formatExtraPayloadWithMode(payload, verboseDetails) {
     kvParts.push(`${key}=${summarizeSuppressedValue(value)}`);
   }
   if (hiddenDetailCount > 0 && !verboseDetails) {
-    kvParts.push("detail=hidden(use VERBOSE=debug|trace)");
+    kvParts.push(`detail=hidden(use ${VIBEMAN_ENV_KEYS.VERBOSE}=debug|trace)`);
   }
   return kvParts.join(" ");
 }
@@ -20109,15 +20154,16 @@ function parseBooleanEnv(raw2) {
 }
 var import_pino, levelEnv, allowedLevels, level, logFormatEnv, logFormat, usePrettyLogs, useColor, includeVerboseDetails, homeDir, cwd, levelLabels, colors, hiddenDetailKeyMatchers, sensitiveKeySegments, sensitiveSegmentPairs, bannerPrinted = false, stream, logger;
 var init_log = __esm(() => {
+  init_env_policy();
   import_pino = __toESM(require_pino(), 1);
-  levelEnv = process.env.VERBOSE?.toLowerCase();
+  levelEnv = readVibemanEnv(process.env, VIBEMAN_ENV_KEYS.VERBOSE)?.toLowerCase();
   allowedLevels = new Set(["error", "warn", "info", "debug", "trace"]);
   level = allowedLevels.has(levelEnv ?? "") ? levelEnv : "info";
-  logFormatEnv = process.env.LOG_FORMAT?.toLowerCase();
+  logFormatEnv = readVibemanEnv(process.env, VIBEMAN_ENV_KEYS.LOG_FORMAT)?.toLowerCase();
   logFormat = logFormatEnv === "json" || logFormatEnv === "pretty" ? logFormatEnv : "pretty";
   usePrettyLogs = logFormat === "pretty";
   useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
-  includeVerboseDetails = level === "debug" || level === "trace" || parseBooleanEnv(process.env.VIBEMAN_TRACE);
+  includeVerboseDetails = level === "debug" || level === "trace" || parseBooleanEnv(process.env[VIBEMAN_ENV_KEYS.TRACE]);
   homeDir = homedir();
   cwd = process.cwd();
   levelLabels = {
@@ -42319,23 +42365,29 @@ var init_log_sanitizer = __esm(() => {
 import { execFile, spawn } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import { delimiter, resolve as resolve3 } from "node:path";
+function safeLog(method, ...args) {
+  const fn = logger[method];
+  if (typeof fn === "function") {
+    fn.call(logger, ...args);
+  }
+}
 function resolveClaudeCodeCliPath(env, logContext) {
-  const envOverride = env?.CLAUDE_CODE_PATH ?? process.env.CLAUDE_CODE_PATH;
+  const envOverride = env?.[VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH] ?? process.env[VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH];
   if (envOverride) {
     const resolved = envOverride.trim();
     if (resolved && existsSync3(resolved)) {
       if (logContext) {
-        logger.debug({ ...logContext, executable: resolved, source: "env" }, "Claude CLI resolved.");
+        safeLog("debug", { ...logContext, executable: resolved, source: "env" }, "Claude CLI resolved.");
       }
       return resolved;
     }
     if (logContext) {
-      logger.warn({ ...logContext, executable: resolved }, "Claude CLI path override not found.");
+      safeLog("warn", { ...logContext, executable: resolved }, "Claude CLI path override not found.");
     }
   }
   const fromPath = findClaudeExecutableOnPath();
   if (fromPath && logContext) {
-    logger.debug({ ...logContext, executable: fromPath }, "Claude CLI resolved.");
+    safeLog("debug", { ...logContext, executable: fromPath }, "Claude CLI resolved.");
   }
   return fromPath || undefined;
 }
@@ -42758,7 +42810,7 @@ function formatParamsForLog(params) {
     agentTurnOptionsKeys: params.agentTurnOptions ? Object.keys(params.agentTurnOptions).sort() : undefined,
     signal: params.signal ? { aborted: params.signal.aborted } : undefined,
     logContext: params.logContext,
-    detail: "hidden (set VERBOSE=debug|trace for full prompt/env/context)"
+    detail: `hidden (set ${VIBEMAN_ENV_KEYS.VERBOSE}=debug|trace for full prompt/env/context)`
   });
   try {
     return JSON.stringify(summarized, null, 2);
@@ -42768,6 +42820,7 @@ function formatParamsForLog(params) {
 }
 var CLAUDE_EXECUTABLE_CANDIDATES, ClaudeRunError, ClaudeCodeCliProvider;
 var init_claude_code_cli_provider = __esm(() => {
+  init_env_policy();
   init_log();
   init_log_sanitizer();
   CLAUDE_EXECUTABLE_CANDIDATES = process.platform === "win32" ? ["claude.exe", "claude.cmd", "claude.bat"] : ["claude"];
@@ -42865,10 +42918,10 @@ ${formatParamsForLog(params)}`);
     resolveExecutable() {
       const resolved = findClaudeExecutableOnPath();
       if (resolved) {
-        logger.debug({ ...this.logContext, executable: resolved }, "Claude CLI resolved.");
+        safeLog("debug", { ...this.logContext, executable: resolved }, "Claude CLI resolved.");
         return resolved;
       }
-      logger.warn(this.logContext, "Claude CLI not found on PATH.");
+      safeLog("warn", this.logContext, "Claude CLI not found on PATH.");
       return "";
     }
     async validateSetup() {
@@ -42881,7 +42934,7 @@ ${formatParamsForLog(params)}`);
         };
       }
       const version3 = await this.getVersion(executable);
-      logger.info({ ...this.logContext, executable, version: version3 }, "Claude CLI validated.");
+      safeLog("info", { ...this.logContext, executable, version: version3 }, "Claude CLI validated.");
       return { success: true, message: "Claude CLI available.", version: version3 };
     }
     async getVersion(executable) {
@@ -43324,23 +43377,29 @@ function buildCodexTurnOptions(params) {
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
 import { delimiter as delimiter2, dirname as dirname2, resolve as resolve4 } from "node:path";
+function safeLog2(method, ...args) {
+  const fn = logger[method];
+  if (typeof fn === "function") {
+    fn.call(logger, ...args);
+  }
+}
 function resolveCodexCliPath(env, logContext) {
-  const envOverride = env?.CODEX_PATH ?? process.env.CODEX_PATH;
+  const envOverride = env?.[VIBEMAN_ENV_KEYS.CODEX_PATH] ?? process.env[VIBEMAN_ENV_KEYS.CODEX_PATH];
   if (envOverride) {
     const resolved = envOverride.trim();
     if (resolved && existsSync4(resolved)) {
       if (logContext) {
-        logger.debug({ ...logContext, executable: resolved, source: "env" }, "Codex CLI resolved.");
+        safeLog2("debug", { ...logContext, executable: resolved, source: "env" }, "Codex CLI resolved.");
       }
       return resolved;
     }
     if (logContext) {
-      logger.warn({ ...logContext, executable: resolved }, "Codex CLI path override not found.");
+      safeLog2("warn", { ...logContext, executable: resolved }, "Codex CLI path override not found.");
     }
   }
   const fromPath = findCodexExecutableOnPath();
   if (fromPath && logContext) {
-    logger.debug({ ...logContext, executable: fromPath }, "Codex CLI resolved.");
+    safeLog2("debug", { ...logContext, executable: fromPath }, "Codex CLI resolved.");
   }
   return fromPath || undefined;
 }
@@ -43495,7 +43554,7 @@ function summarizeRunParamsForLog(params) {
       agentThreadOptionsKeys: params.agentThreadOptions ? Object.keys(params.agentThreadOptions).sort() : undefined,
       agentTurnOptionsKeys: params.agentTurnOptions ? Object.keys(params.agentTurnOptions).sort() : undefined,
       logContext: params.logContext,
-      detail: "hidden (set VERBOSE=debug|trace for full prompt/env/context)"
+      detail: `hidden (set ${VIBEMAN_ENV_KEYS.VERBOSE}=debug|trace for full prompt/env/context)`
     });
   }
   return sanitizeForLog({
@@ -43541,6 +43600,7 @@ function emitRunEvent(onEvent, event, log) {
 var CodexRunError, CodexCliProvider;
 var init_codex_cli_provider = __esm(() => {
   init_dist3();
+  init_env_policy();
   init_log_sanitizer();
   init_log();
   CodexRunError = class CodexRunError extends Error {
@@ -43674,10 +43734,10 @@ ${formatParamsForLog2(summarizeRunParamsForLog(params))}`);
     resolveExecutable() {
       const resolved = findCodexExecutableOnPath();
       if (resolved) {
-        logger.debug({ ...this.logContext, executable: resolved }, "Codex CLI resolved.");
+        safeLog2("debug", { ...this.logContext, executable: resolved }, "Codex CLI resolved.");
         return resolved;
       }
-      logger.warn(this.logContext, "Codex CLI not found on PATH.");
+      safeLog2("warn", this.logContext, "Codex CLI not found on PATH.");
       return "";
     }
     async validateSetup() {
@@ -43697,7 +43757,7 @@ ${formatParamsForLog2(summarizeRunParamsForLog(params))}`);
           details: "Ensure the CLI can execute (for example, `node` is available on PATH)."
         };
       }
-      logger.info({ ...this.logContext, executable, version: version3 }, "Codex CLI validated.");
+      safeLog2("info", { ...this.logContext, executable, version: version3 }, "Codex CLI validated.");
       return { success: true, message: "Codex CLI available.", version: version3 };
     }
     async getVersion(executable) {
@@ -43718,23 +43778,29 @@ ${formatParamsForLog2(summarizeRunParamsForLog(params))}`);
 import { execFile as execFile3, spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { delimiter as delimiter3, resolve as resolve5 } from "node:path";
+function safeLog3(method, ...args) {
+  const fn = logger[method];
+  if (typeof fn === "function") {
+    fn.call(logger, ...args);
+  }
+}
 function resolveGeminiCliPath(env, logContext) {
-  const envOverride = env?.GEMINI_PATH ?? process.env.GEMINI_PATH;
+  const envOverride = env?.[VIBEMAN_ENV_KEYS.GEMINI_PATH] ?? process.env[VIBEMAN_ENV_KEYS.GEMINI_PATH];
   if (envOverride) {
     const resolved = envOverride.trim();
     if (resolved && existsSync5(resolved)) {
       if (logContext) {
-        logger.debug({ ...logContext, executable: resolved, source: "env" }, "Gemini CLI resolved.");
+        safeLog3("debug", { ...logContext, executable: resolved, source: "env" }, "Gemini CLI resolved.");
       }
       return resolved;
     }
     if (logContext) {
-      logger.warn({ ...logContext, executable: resolved }, "Gemini CLI path override not found.");
+      safeLog3("warn", { ...logContext, executable: resolved }, "Gemini CLI path override not found.");
     }
   }
   const fromPath = findGeminiExecutableOnPath();
   if (fromPath && logContext) {
-    logger.debug({ ...logContext, executable: fromPath }, "Gemini CLI resolved.");
+    safeLog3("debug", { ...logContext, executable: fromPath }, "Gemini CLI resolved.");
   }
   return fromPath || undefined;
 }
@@ -44082,7 +44148,7 @@ function formatParamsForLog3(params) {
     agentTurnOptionsKeys: params.agentTurnOptions ? Object.keys(params.agentTurnOptions).sort() : undefined,
     signal: params.signal ? { aborted: params.signal.aborted } : undefined,
     logContext: params.logContext,
-    detail: "hidden (set VERBOSE=debug|trace for full prompt/env/context)"
+    detail: `hidden (set ${VIBEMAN_ENV_KEYS.VERBOSE}=debug|trace for full prompt/env/context)`
   });
   try {
     return JSON.stringify(summarized, null, 2);
@@ -44092,6 +44158,7 @@ function formatParamsForLog3(params) {
 }
 var GEMINI_EXECUTABLE_CANDIDATES, GeminiRunError, GeminiCliProvider;
 var init_gemini_cli_provider = __esm(() => {
+  init_env_policy();
   init_log();
   init_log_sanitizer();
   GEMINI_EXECUTABLE_CANDIDATES = process.platform === "win32" ? ["gemini.exe", "gemini.cmd", "gemini.bat"] : ["gemini"];
@@ -44189,10 +44256,10 @@ ${formatParamsForLog3(params)}`);
     resolveExecutable() {
       const resolved = findGeminiExecutableOnPath();
       if (resolved) {
-        logger.debug({ ...this.logContext, executable: resolved }, "Gemini CLI resolved.");
+        safeLog3("debug", { ...this.logContext, executable: resolved }, "Gemini CLI resolved.");
         return resolved;
       }
-      logger.warn(this.logContext, "Gemini CLI not found on PATH.");
+      safeLog3("warn", this.logContext, "Gemini CLI not found on PATH.");
       return "";
     }
     async validateSetup() {
@@ -44205,7 +44272,7 @@ ${formatParamsForLog3(params)}`);
         };
       }
       const version3 = await this.getVersion(executable);
-      logger.info({ ...this.logContext, executable, version: version3 }, "Gemini CLI validated.");
+      safeLog3("info", { ...this.logContext, executable, version: version3 }, "Gemini CLI validated.");
       return { success: true, message: "Gemini CLI available.", version: version3 };
     }
     async getVersion(executable) {
@@ -44235,6 +44302,7 @@ var init_dist_layout = __esm(() => {
     prismaRoot: "prisma",
     prismaSchema: "prisma/schema.prisma",
     resourcesRoot: "resources",
+    nodePtyPackageRoot: "node_modules/node-pty",
     scriptsRoot: "scripts",
     fixtureInitScript: "scripts/init-test-repo.mjs",
     fixtureSeedScript: "scripts/seed-test-fixtures.mjs",
@@ -44249,8 +44317,9 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 var currentDir, distRoot, packagedSchema, isPackaged, packagedDistRoot, apiRoot, schemaPath, prismaConfigPath, migrationsDir;
 var init_paths = __esm(() => {
   init_dist_layout();
+  init_vibeman_env();
   currentDir = dirname3(fileURLToPath3(import.meta.url));
-  distRoot = process.env.VIBEMAN_DIST_ROOT;
+  distRoot = process.env[VIBEMAN_ENV_KEYS.DIST_ROOT];
   packagedSchema = distRoot ? resolve6(distRoot, DIST_LAYOUT.prismaSchema) : "";
   isPackaged = Boolean(packagedSchema) && existsSync6(packagedSchema);
   packagedDistRoot = isPackaged && distRoot ? distRoot : "";
@@ -45339,7 +45408,7 @@ async function initializeDatabase(root) {
       const localDbPath = dbPath;
       await ensureGitignoreHasDbFile(root);
       const databaseUrl = `file:${dbPath}`;
-      process.env.DATABASE_URL = databaseUrl;
+      process.env[VIBEMAN_ENV_KEYS.DATABASE_URL] = databaseUrl;
       const databaseTarget = { kind: "local", path: localDbPath };
       startupStatus = { state: "initializing", database: databaseTarget };
       const migrationError = await runMigrations(databaseUrl, databaseTarget, localDbPath);
@@ -45416,7 +45485,7 @@ async function runMigrations(databaseUrl, databaseTarget, localDbPath) {
   } catch (error48) {
     const kind = classifyMigrationError(error48);
     const details = formatMigrationDetails(error48);
-    const canAutoRecover = databaseTarget.kind === "local" && localDbPath && (kind === "failed-migrations" || kind === "schema-mismatch") && process.env.VIBEMAN_DB_AUTORECOVER === "1";
+    const canAutoRecover = databaseTarget.kind === "local" && localDbPath && (kind === "failed-migrations" || kind === "schema-mismatch") && process.env[VIBEMAN_ENV_KEYS.DB_AUTORECOVER] === "1";
     if (canAutoRecover) {
       console.warn(`[db] Migration failed (${kind}). Attempting auto-recovery by backing up and recreating the local database.`);
       try {
@@ -45689,18 +45758,18 @@ function logStartupError(error48) {
 `));
 }
 async function ensureCodexCliPath(db) {
-  const envPath = process.env.CODEX_PATH?.trim();
+  const envPath = readVibemanEnv(process.env, VIBEMAN_ENV_KEYS.CODEX_PATH);
   if (envPath) {
     if (existsSync10(envPath)) {
       await setCodexCliPathSetting(db, envPath);
       return "env";
     }
-    console.warn(`[config] CODEX_PATH is invalid and will be ignored: ${envPath}`);
+    console.warn(`[config] ${VIBEMAN_ENV_KEYS.CODEX_PATH} is invalid and will be ignored: ${envPath}`);
   }
   const storedPath = await getCodexCliPathSetting(db);
   if (storedPath) {
     if (existsSync10(storedPath)) {
-      process.env.CODEX_PATH = storedPath;
+      process.env[VIBEMAN_ENV_KEYS.CODEX_PATH] = storedPath;
       return "db";
     }
     await clearCodexCliPathSetting(db);
@@ -45709,24 +45778,24 @@ async function ensureCodexCliPath(db) {
   const detectedPath = resolveCodexCliPath();
   if (detectedPath && existsSync10(detectedPath)) {
     await setCodexCliPathSetting(db, detectedPath);
-    process.env.CODEX_PATH = detectedPath;
+    process.env[VIBEMAN_ENV_KEYS.CODEX_PATH] = detectedPath;
     return "auto-detected";
   }
   return "none";
 }
 async function ensureGeminiCliPath(db) {
-  const envPath = process.env.GEMINI_PATH?.trim();
+  const envPath = readVibemanEnv(process.env, VIBEMAN_ENV_KEYS.GEMINI_PATH);
   if (envPath) {
     if (existsSync10(envPath)) {
       await setGeminiCliPathSetting(db, envPath);
       return "env";
     }
-    console.warn(`[config] GEMINI_PATH is invalid and will be ignored: ${envPath}`);
+    console.warn(`[config] ${VIBEMAN_ENV_KEYS.GEMINI_PATH} is invalid and will be ignored: ${envPath}`);
   }
   const storedPath = await getGeminiCliPathSetting(db);
   if (storedPath) {
     if (existsSync10(storedPath)) {
-      process.env.GEMINI_PATH = storedPath;
+      process.env[VIBEMAN_ENV_KEYS.GEMINI_PATH] = storedPath;
       return "db";
     }
     await clearGeminiCliPathSetting(db);
@@ -45735,24 +45804,24 @@ async function ensureGeminiCliPath(db) {
   const detectedPath = resolveGeminiCliPath();
   if (detectedPath && existsSync10(detectedPath)) {
     await setGeminiCliPathSetting(db, detectedPath);
-    process.env.GEMINI_PATH = detectedPath;
+    process.env[VIBEMAN_ENV_KEYS.GEMINI_PATH] = detectedPath;
     return "auto-detected";
   }
   return "none";
 }
 async function ensureClaudeCodeCliPath(db) {
-  const envPath = process.env.CLAUDE_CODE_PATH?.trim();
+  const envPath = readVibemanEnv(process.env, VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH);
   if (envPath) {
     if (existsSync10(envPath)) {
       await setClaudeCodeCliPathSetting(db, envPath);
       return "env";
     }
-    console.warn(`[config] CLAUDE_CODE_PATH is invalid and will be ignored: ${envPath}`);
+    console.warn(`[config] ${VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH} is invalid and will be ignored: ${envPath}`);
   }
   const storedPath = await getClaudeCodeCliPathSetting(db);
   if (storedPath) {
     if (existsSync10(storedPath)) {
-      process.env.CLAUDE_CODE_PATH = storedPath;
+      process.env[VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH] = storedPath;
       return "db";
     }
     await clearClaudeCodeCliPathSetting(db);
@@ -45761,7 +45830,7 @@ async function ensureClaudeCodeCliPath(db) {
   const detectedPath = resolveClaudeCodeCliPath();
   if (detectedPath && existsSync10(detectedPath)) {
     await setClaudeCodeCliPathSetting(db, detectedPath);
-    process.env.CLAUDE_CODE_PATH = detectedPath;
+    process.env[VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH] = detectedPath;
     return "auto-detected";
   }
   return "none";
@@ -45772,6 +45841,7 @@ var init_db = __esm(() => {
   init_claude_code_cli_provider();
   init_codex_cli_provider();
   init_gemini_cli_provider();
+  init_env_policy();
   init_paths();
   init_migrate();
   init_storage();
@@ -101110,6 +101180,12 @@ var init_dist8 = __esm(() => {
 });
 
 // ../api/src/services/workflows/logs.ts
+function safeLog4(method, ...args) {
+  const fn = logger[method];
+  if (typeof fn === "function") {
+    fn.call(logger, ...args);
+  }
+}
 async function appendRunLog(db, runId, entry) {
   maybeCleanupWorkflowLogs(db);
   await db.workflowRunLog.create({
@@ -101211,7 +101287,7 @@ async function cleanupWorkflowLogs(db, now = Date.now()) {
       }
     });
     if (result.count > 0) {
-      logger.info({
+      safeLog4("info", {
         module: "workflow",
         retentionDays: workflowLogRetentionDays,
         deletedCount: result.count
@@ -101220,7 +101296,7 @@ async function cleanupWorkflowLogs(db, now = Date.now()) {
     return { deletedCount: result.count, skipped: false };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
-    logger.warn({ module: "workflow", errorMessage: message }, `Workflow log cleanup failed: ${message}`);
+    safeLog4("warn", { module: "workflow", errorMessage: message }, `Workflow log cleanup failed: ${message}`);
     return { deletedCount: 0, skipped: false, error: message };
   }
 }
@@ -101911,6 +101987,7 @@ var init_prompt_builder = __esm(() => {
 // ../api/src/services/workflows/executor.ts
 import { spawn as spawn5 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
+import { resolve as resolvePath4 } from "node:path";
 function createExecutorControl() {
   const abortController = new AbortController;
   let child = null;
@@ -102757,9 +102834,13 @@ function hasBunScript(cwd2, scriptName) {
   }
 }
 function buildShellEnv(input) {
+  const isolateWorktreeInheritedEnv = shouldIsolateWorktreeInheritedEnv(input);
   const baseEnv = {};
   for (const [key, value] of Object.entries(process.env)) {
     if (typeof value === "string") {
+      if (isolateWorktreeInheritedEnv && shouldFilterForWorktreeShellInheritance({ env: process.env, key, value })) {
+        continue;
+      }
       baseEnv[key] = value;
     }
   }
@@ -102788,6 +102869,26 @@ function buildShellEnv(input) {
   }
   return baseEnv;
 }
+function shouldIsolateWorktreeInheritedEnv(input) {
+  const payload = input.runPayload ?? {};
+  const worktreePath = normalizeEnvPath(payload.worktreePath);
+  if (!worktreePath) {
+    return false;
+  }
+  const repoRoot = normalizeEnvPath(payload.repoRoot ?? payload.root ?? input.root);
+  if (!repoRoot) {
+    return true;
+  }
+  return worktreePath !== repoRoot;
+}
+function normalizeEnvPath(raw2) {
+  if (typeof raw2 !== "string")
+    return null;
+  const trimmed2 = raw2.trim();
+  if (trimmed2.length === 0)
+    return null;
+  return resolvePath4(trimmed2);
+}
 function summarizeShellFailure(command, result) {
   const SNIPPET_LINES = 30;
   const statusLine = [
@@ -102878,6 +102979,7 @@ var init_executor = __esm(() => {
   init_codex_cli_provider();
   init_gemini_cli_provider();
   init_runtime_backend();
+  init_env_policy();
   init_provider_factory();
   init_provider_registry();
   init_model_aliases();
@@ -102891,6 +102993,12 @@ var init_executor = __esm(() => {
 // ../api/src/services/workflows/runner.ts
 import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { normalize as normalize7, resolve as resolve13 } from "node:path";
+function safeLog5(method, ...args) {
+  const fn = logger[method];
+  if (typeof fn === "function") {
+    fn.call(logger, ...args);
+  }
+}
 function isTerminalRunStatus(status) {
   return TERMINAL_RUN_STATUSES.has(status);
 }
@@ -103178,7 +103286,7 @@ function queueWorkflowExecution(db, input) {
       executorType: "coding_agent",
       error: error48
     });
-    logger.error({ module: "workflow", runId: input.runId, error: classified.message }, "safeExecuteWorkflow wrapper failed. Marking workflow run failed.");
+    safeLog5("error", { module: "workflow", runId: input.runId, error: classified.message }, "safeExecuteWorkflow wrapper failed. Marking workflow run failed.");
     markRunFailedFromUnhandledError(db, input.runId, {
       message: classified.message,
       failureReason: input.failureReason ?? classified.failureReason,
@@ -103186,7 +103294,7 @@ function queueWorkflowExecution(db, input) {
       currentNodeKey: input.currentNodeKey
     }).catch((persistError) => {
       const persistMessage = persistError instanceof Error ? persistError.message : String(persistError);
-      logger.error({ module: "workflow", runId: input.runId, error: persistMessage }, "Unable to persist failed status after safeExecuteWorkflow wrapper failure.");
+      safeLog5("error", { module: "workflow", runId: input.runId, error: persistMessage }, "Unable to persist failed status after safeExecuteWorkflow wrapper failure.");
     });
   });
 }
@@ -103198,7 +103306,7 @@ async function safeExecuteWorkflow(db, input) {
       executorType: "coding_agent",
       error: error48
     });
-    logger.error({ module: "workflow", runId: input.runId, error: classified.message }, "Workflow failed.");
+    safeLog5("error", { module: "workflow", runId: input.runId, error: classified.message }, "Workflow failed.");
     await markRunFailedFromUnhandledError(db, input.runId, {
       message: classified.message,
       failureReason: input.failureReason ?? classified.failureReason,
@@ -103261,7 +103369,7 @@ async function markRunFailedFromUnhandledError(db, runId, input) {
     });
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
-    logger.error({ module: "workflow", runId, error: message }, "Failed to persist workflow state via read/persist path. Trying fallback update.");
+    safeLog5("error", { module: "workflow", runId, error: message }, "Failed to persist workflow state via read/persist path. Trying fallback update.");
     await updateRunFailureFallback(db, {
       runId,
       message: input.message,
@@ -103709,7 +103817,7 @@ function createNode(db, node) {
     }));
     if (result.paused) {
       const detail = formatExecutorFailureForLog(result);
-      logger.warn({ module: "workflow", runId: state.runId, nodeKey: node.nodeKey, attempt }, `Node paused: ${node.nodeKey} (attempt ${attempt})${detail ? `
+      safeLog5("warn", { module: "workflow", runId: state.runId, nodeKey: node.nodeKey, attempt }, `Node paused: ${node.nodeKey} (attempt ${attempt})${detail ? `
 ${detail}` : ""}`);
     } else if (result.success) {
       logWorkflow(state.runId, `Node completed: ${node.nodeKey} (attempt ${attempt})`, {
@@ -103718,7 +103826,7 @@ ${detail}` : ""}`);
       });
     } else {
       const detail = formatExecutorFailureForLog(result);
-      logger.error({ module: "workflow", runId: state.runId, nodeKey: node.nodeKey, attempt }, `Node failed: ${node.nodeKey} (attempt ${attempt})${detail ? `
+      safeLog5("error", { module: "workflow", runId: state.runId, nodeKey: node.nodeKey, attempt }, `Node failed: ${node.nodeKey} (attempt ${attempt})${detail ? `
 ${detail}` : ""}`);
     }
     const basePayload = buildRunPayloadAfterNodeResult({
@@ -103930,13 +104038,13 @@ async function updateRunStatus(db, runId, status, nodeKey, message, options2) {
   if (status === "failed") {
     const detail = typeof message === "string" && message.trim().length > 0 ? `
 ${tailText(message, 8000)}` : "";
-    logger.error(logData, `Run status: failed${nodeSuffix}${detail}`);
+    safeLog5("error", logData, `Run status: failed${nodeSuffix}${detail}`);
   } else if (status === "paused") {
     const detail = typeof message === "string" && message.trim().length > 0 ? `
 ${tailText(message, 8000)}` : "";
-    logger.warn(logData, `Run status: paused${nodeSuffix}${detail}`);
+    safeLog5("warn", logData, `Run status: paused${nodeSuffix}${detail}`);
   } else {
-    logger.info(logData, `Run status: ${status}${nodeSuffix}`);
+    safeLog5("info", logData, `Run status: ${status}${nodeSuffix}`);
   }
   const current = await readRunState(db, runId);
   if (isTerminalRunStatus(current.status)) {
@@ -104750,7 +104858,7 @@ async function updateTaskStatusForRunPayload(input) {
     }
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
-    logger.warn({
+    safeLog5("warn", {
       module: "workflow",
       runId: input.runId,
       nodeKey: input.nodeKey,
@@ -104785,7 +104893,7 @@ async function autoCommitTaskStatusUpdate(input) {
     if (isNothingToCommitError(message)) {
       return;
     }
-    logger.warn({
+    safeLog5("warn", {
       module: "workflow",
       runId: input.runId,
       nodeKey: input.nodeKey,
@@ -104798,7 +104906,7 @@ function createLog2(event, data) {
   return { ts: new Date().toISOString(), level: "info", event, data };
 }
 function logWorkflow(runId, message, data) {
-  logger.info({ module: "workflow", runId, ...data }, message);
+  safeLog5("info", { module: "workflow", runId, ...data }, message);
 }
 function tailText(text, maxChars) {
   const normalized = text.replace(/\r\n/g, `
@@ -107486,6 +107594,17 @@ function isWithin2(rootPath, targetPath) {
   const relativePath = relative6(rootPath, targetPath);
   return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep3}`);
 }
+function buildAppLaunchEnv(env) {
+  const next = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value !== "string")
+      continue;
+    if (shouldFilterForExternalAppLaunch({ env, key, value }))
+      continue;
+    next[key] = value;
+  }
+  return next;
+}
 function resolveDetectionPath(rawPath) {
   if (rawPath.startsWith("~/")) {
     return resolve16(homedir2(), rawPath.slice(2));
@@ -107543,7 +107662,10 @@ function resolveAppDefinition(category, appId) {
   return app;
 }
 async function openInApp(appName, targetPath) {
-  const child = spawn7("open", ["-a", appName, targetPath], { stdio: "ignore" });
+  const child = spawn7("open", ["-a", appName, targetPath], {
+    stdio: "ignore",
+    env: buildAppLaunchEnv(process.env)
+  });
   await new Promise((resolvePromise, rejectPromise) => {
     child.once("error", (error48) => rejectPromise(error48));
     child.once("close", (code) => {
@@ -107560,6 +107682,7 @@ var init_system2 = __esm(() => {
   init_dist4();
   init_zod();
   init_trpc();
+  init_env_policy();
   init_remote_access();
   appCategories = ["terminal", "editor"];
   appCatalog = [
@@ -108307,6 +108430,7 @@ var init_cli_settings = __esm(() => {
   init_model_catalog();
   init_model_aliases();
   init_settings();
+  init_env_policy();
   cliIdSchema = exports_external.enum(AGENT_PROVIDER_IDS);
   updatePathSchema = exports_external.object({
     id: cliIdSchema,
@@ -108357,9 +108481,9 @@ var init_cli_settings = __esm(() => {
     id: exports_external.string().trim().min(1)
   });
   CLI_ENV_BY_PROVIDER = {
-    "codex-cli": "CODEX_PATH",
-    "gemini-cli": "GEMINI_PATH",
-    "claude-code": "CLAUDE_CODE_PATH"
+    "codex-cli": VIBEMAN_ENV_KEYS.CODEX_PATH,
+    "gemini-cli": VIBEMAN_ENV_KEYS.GEMINI_PATH,
+    "claude-code": VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH
   };
   BASE_PROVIDER_BY_RUNTIME_ADAPTER = new Map(AGENT_PROVIDER_IDS.map((providerId) => {
     const definition = getAgentProviderDefinition(providerId);
@@ -122980,16 +123104,463 @@ function isAddressInUseError(error48) {
 var MIN_PORT = 1, MAX_PORT = 65535;
 var init_port_utils = () => {};
 
+// ../api/src/services/pty-session.ts
+import { chmodSync, statSync as statSync3 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname6, join as join8 } from "node:path";
+import * as pty from "node-pty";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function buildShellCandidates() {
+  if (process.platform === "win32") {
+    return ["powershell.exe", "pwsh.exe", "cmd.exe"];
+  }
+  const candidates = new Set;
+  const configured = process.env.SHELL?.trim();
+  if (configured) {
+    candidates.add(configured);
+  }
+  for (const fallbackShell of NON_WINDOWS_FALLBACK_SHELLS) {
+    try {
+      const stats = statSync3(fallbackShell);
+      if (stats.isFile()) {
+        candidates.add(fallbackShell);
+      }
+    } catch {}
+  }
+  return Array.from(candidates);
+}
+function generateId() {
+  return `pty_${randomUUID2()}`;
+}
+function ensureNodePtySpawnHelperExecutable() {
+  if (process.platform !== "darwin")
+    return;
+  const helperCandidates = new Set;
+  try {
+    const packageJsonPath = require2.resolve("node-pty/package.json");
+    helperCandidates.add(join8(dirname6(packageJsonPath), "prebuilds", `darwin-${process.arch}`, "spawn-helper"));
+  } catch {}
+  const bundledDistHelperPath = join8(dirname6(fileURLToPath4(import.meta.url)), "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+  helperCandidates.add(bundledDistHelperPath);
+  for (const helperPath of helperCandidates) {
+    try {
+      const stats = statSync3(helperPath);
+      if ((stats.mode & 73) !== 0) {
+        return;
+      }
+      chmodSync(helperPath, stats.mode | 493);
+      log.info({ helperPath }, "Restored execute bit on node-pty spawn-helper");
+      return;
+    } catch {}
+  }
+  log.warn({ helperPaths: Array.from(helperCandidates) }, "Failed to ensure node-pty spawn-helper is executable");
+}
+function createSession(options2) {
+  const id = generateId();
+  const cols = options2.cols ?? DEFAULT_COLS;
+  const rows = options2.rows ?? DEFAULT_ROWS;
+  const shellCandidates = buildShellCandidates();
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    VIBEMAN_TERMINAL: options2.scope
+  };
+  ensureNodePtySpawnHelperExecutable();
+  let proc = null;
+  let resolvedShell = "";
+  let lastError;
+  for (const shell of shellCandidates) {
+    try {
+      proc = pty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: options2.cwd,
+        env
+      });
+      resolvedShell = shell;
+      break;
+    } catch (error48) {
+      lastError = error48;
+      log.warn({ shell, error: error48 }, "Failed to spawn PTY with shell candidate");
+    }
+  }
+  if (!proc) {
+    const fallbackText = shellCandidates.length > 0 ? shellCandidates.join(", ") : process.platform === "win32" ? "powershell.exe" : NON_WINDOWS_FALLBACK_SHELLS.join(", ");
+    const suffix = lastError instanceof Error ? `${lastError.name}: ${lastError.message}` : typeof lastError === "string" ? lastError : "unknown error";
+    throw new Error(`Failed to spawn terminal shell. Tried: ${fallbackText}. Last error: ${suffix}`);
+  }
+  const session = {
+    meta: { id, scope: options2.scope, cwd: options2.cwd, createdAt: Date.now() },
+    process: proc,
+    listeners: new Set,
+    exitListeners: new Set,
+    scrollback: [],
+    scrollbackBytes: 0,
+    exited: false
+  };
+  proc.onData((data) => {
+    session.scrollback.push(data);
+    session.scrollbackBytes += data.length;
+    if (session.scrollback.length > SCROLLBACK_LIMIT) {
+      const removed = session.scrollback.splice(0, session.scrollback.length - SCROLLBACK_LIMIT);
+      for (const chunk of removed)
+        session.scrollbackBytes -= chunk.length;
+    }
+    while (session.scrollbackBytes > SCROLLBACK_BYTE_LIMIT && session.scrollback.length > 0) {
+      const removed = session.scrollback.shift();
+      session.scrollbackBytes -= removed.length;
+    }
+    for (const listener of session.listeners) {
+      try {
+        listener(data);
+      } catch {}
+    }
+  });
+  proc.onExit(({ exitCode, signal }) => {
+    log.info({ sessionId: id, exitCode, signal }, "PTY session exited");
+    session.exited = true;
+    const exitInfo = { exitCode, signal };
+    for (const listener of session.exitListeners) {
+      try {
+        listener(exitInfo);
+      } catch {}
+    }
+    session.exitListeners.clear();
+    setTimeout(() => {
+      if (sessions.get(id) === session) {
+        sessions.delete(id);
+        log.debug({ sessionId: id }, "Exited session removed after retention period");
+      }
+    }, EXITED_SESSION_RETENTION_MS);
+  });
+  sessions.set(id, session);
+  log.info({ sessionId: id, scope: options2.scope, cwd: options2.cwd, shell: resolvedShell }, "PTY session created");
+  return session.meta;
+}
+function writeToSession(sessionId, data) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.write(data);
+  } catch (error48) {
+    log.warn({ sessionId, error: error48 }, "Failed to write to PTY session");
+    return false;
+  }
+  return true;
+}
+function resizeSession(sessionId, cols, rows) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.resize(cols, rows);
+  } catch (error48) {
+    log.warn({ sessionId, cols, rows, error: error48 }, "Failed to resize PTY");
+  }
+  return true;
+}
+function destroySession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  try {
+    session.process.kill();
+  } catch {}
+  sessions.delete(sessionId);
+  log.info({ sessionId }, "PTY session destroyed");
+  return true;
+}
+function getSession(sessionId) {
+  return sessions.get(sessionId)?.meta ?? null;
+}
+function addDataListener(sessionId, listener) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  session.listeners.add(listener);
+  return true;
+}
+function removeDataListener(sessionId, listener) {
+  sessions.get(sessionId)?.listeners.delete(listener);
+}
+function addExitListener(sessionId, listener) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return false;
+  if (session.exited) {
+    try {
+      listener({ exitCode: -1 });
+    } catch {}
+    return true;
+  }
+  session.exitListeners.add(listener);
+  return true;
+}
+function removeExitListener(sessionId, listener) {
+  sessions.get(sessionId)?.exitListeners.delete(listener);
+}
+function getScrollback(sessionId) {
+  return sessions.get(sessionId)?.scrollback ?? [];
+}
+function destroyAllSessions() {
+  for (const [id] of sessions) {
+    destroySession(id);
+  }
+}
+async function gracefulShutdownSessions(timeoutMs = 3000) {
+  const ids = Array.from(sessions.keys());
+  if (ids.length === 0)
+    return;
+  log.info({ count: ids.length }, "Gracefully shutting down PTY sessions");
+  for (const id of ids) {
+    const session = sessions.get(id);
+    if (!session || session.exited)
+      continue;
+    try {
+      session.process.kill();
+    } catch {}
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (sessions.size > 0 && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (sessions.size > 0) {
+    log.warn({ remaining: sessions.size }, "Force destroying remaining PTY sessions");
+    destroyAllSessions();
+  }
+}
+var log, require2, SCROLLBACK_LIMIT = 500, SCROLLBACK_BYTE_LIMIT, DEFAULT_COLS = 120, DEFAULT_ROWS = 30, EXITED_SESSION_RETENTION_MS = 60000, NON_WINDOWS_FALLBACK_SHELLS, sessions;
+var init_pty_session = __esm(() => {
+  init_log();
+  log = logger.child({ module: "pty-session" });
+  require2 = createRequire3(import.meta.url);
+  SCROLLBACK_BYTE_LIMIT = 1024 * 1024;
+  NON_WINDOWS_FALLBACK_SHELLS = ["/bin/bash", "/bin/zsh", "/bin/sh"];
+  sessions = new Map;
+});
+
+// ../api/src/server/terminal-ws.ts
+import { dirname as dirname7, resolve as resolve21, sep as sep6 } from "node:path";
+import { existsSync as existsSync13, statSync as statSync4 } from "node:fs";
+function validateCwd(cwd2, root) {
+  if (!cwd2 || typeof cwd2 !== "string")
+    return null;
+  const resolved = resolve21(cwd2);
+  const resolvedRoot = resolve21(root);
+  const parentDir = dirname7(resolvedRoot) + sep6;
+  const isWithinRoot2 = resolved === resolvedRoot || resolved.startsWith(resolvedRoot + sep6);
+  const isSibling = resolved.startsWith(parentDir);
+  if (!isWithinRoot2 && !isSibling)
+    return null;
+  if (!existsSync13(resolved))
+    return null;
+  try {
+    if (!statSync4(resolved).isDirectory())
+      return null;
+  } catch {
+    return null;
+  }
+  return resolved;
+}
+function createTerminalWebSocketServer(root) {
+  if (root)
+    configuredRoot = root;
+  if (wss)
+    return wss;
+  wss = new import_websocket_server.default({ noServer: true });
+  wss.on("connection", (ws) => {
+    let currentSessionId = null;
+    let dataListener = null;
+    let exitListener = null;
+    const cleanup = () => {
+      if (currentSessionId && dataListener) {
+        removeDataListener(currentSessionId, dataListener);
+      }
+      if (currentSessionId && exitListener) {
+        removeExitListener(currentSessionId, exitListener);
+      }
+      dataListener = null;
+      exitListener = null;
+      currentSessionId = null;
+    };
+    const sendJson = (payload) => {
+      if (ws.readyState === import_websocket.default.OPEN) {
+        ws.send(JSON.stringify(payload));
+      }
+    };
+    const attachToSession = (sessionId) => {
+      cleanup();
+      cancelOrphanDestroy(sessionId);
+      const meta3 = getSession(sessionId);
+      if (!meta3) {
+        sendJson({ type: "error", message: `Session ${sessionId} not found` });
+        return false;
+      }
+      currentSessionId = sessionId;
+      dataListener = (data) => {
+        sendJson({ type: "output", data });
+      };
+      exitListener = (info) => {
+        sendJson({ type: "exited", exitCode: info.exitCode });
+        cleanup();
+      };
+      const scrollback = getScrollback(sessionId);
+      if (scrollback.length > 0) {
+        sendJson({ type: "output", data: scrollback.join("") });
+      }
+      addDataListener(sessionId, dataListener);
+      addExitListener(sessionId, exitListener);
+      return true;
+    };
+    ws.on("message", (raw2) => {
+      let msg;
+      try {
+        msg = JSON.parse(typeof raw2 === "string" ? raw2 : raw2.toString("utf-8"));
+      } catch {
+        sendJson({ type: "error", message: "Invalid JSON" });
+        return;
+      }
+      switch (msg.type) {
+        case "create": {
+          if (!msg.cwd || !msg.scope) {
+            sendJson({ type: "error", message: "Missing required fields: scope, cwd" });
+            return;
+          }
+          const root2 = configuredRoot;
+          if (!root2) {
+            sendJson({ type: "error", message: "Server root not configured" });
+            return;
+          }
+          const validatedCwd = validateCwd(msg.cwd, root2) ?? root2;
+          try {
+            const meta3 = createSession({
+              scope: msg.scope,
+              cwd: validatedCwd,
+              cols: msg.cols,
+              rows: msg.rows
+            });
+            sendJson({ type: "created", sessionId: meta3.id, scope: meta3.scope, cwd: meta3.cwd });
+            attachToSession(meta3.id);
+          } catch (error48) {
+            log2.error({ error: error48, cwd: validatedCwd, scope: msg.scope }, "Failed to create PTY session");
+            sendJson({
+              type: "error",
+              message: `Failed to create terminal session: ${error48 instanceof Error ? error48.message : "unknown error"}`
+            });
+          }
+          break;
+        }
+        case "attach": {
+          if (!msg.sessionId) {
+            sendJson({ type: "error", message: "Missing sessionId" });
+            return;
+          }
+          const attached = attachToSession(msg.sessionId);
+          if (attached) {
+            sendJson({ type: "attached", sessionId: msg.sessionId });
+          }
+          break;
+        }
+        case "input": {
+          if (!currentSessionId) {
+            sendJson({ type: "error", message: "No active session" });
+            return;
+          }
+          if (!writeToSession(currentSessionId, msg.data)) {
+            sendJson({ type: "exited" });
+            cleanup();
+          }
+          break;
+        }
+        case "resize": {
+          if (!currentSessionId)
+            return;
+          if (typeof msg.cols === "number" && typeof msg.rows === "number" && msg.cols > 0 && msg.rows > 0) {
+            resizeSession(currentSessionId, msg.cols, msg.rows);
+          }
+          break;
+        }
+        case "destroy": {
+          if (currentSessionId) {
+            const sid = currentSessionId;
+            cleanup();
+            destroySession(sid);
+            sendJson({ type: "exited" });
+          }
+          break;
+        }
+        default:
+          sendJson({ type: "error", message: `Unknown message type` });
+      }
+    });
+    ws.on("close", () => {
+      const sid = currentSessionId;
+      log2.debug({ sessionId: sid }, "Terminal WebSocket closed");
+      cleanup();
+      if (sid) {
+        scheduleOrphanDestroy(sid);
+      }
+    });
+    ws.on("error", (error48) => {
+      const sid = currentSessionId;
+      log2.warn({ sessionId: sid, error: error48 }, "Terminal WebSocket error");
+      cleanup();
+      if (sid) {
+        scheduleOrphanDestroy(sid);
+      }
+    });
+  });
+  return wss;
+}
+function scheduleOrphanDestroy(sessionId) {
+  if (orphanTimers.has(sessionId))
+    return;
+  const timer = setTimeout(() => {
+    orphanTimers.delete(sessionId);
+    if (getSession(sessionId)) {
+      log2.info({ sessionId }, "Destroying orphaned PTY session after timeout");
+      destroySession(sessionId);
+    }
+  }, ORPHAN_SESSION_TIMEOUT_MS);
+  orphanTimers.set(sessionId, timer);
+}
+function cancelOrphanDestroy(sessionId) {
+  const timer = orphanTimers.get(sessionId);
+  if (timer) {
+    clearTimeout(timer);
+    orphanTimers.delete(sessionId);
+  }
+}
+function handleTerminalUpgrade(req, socket, head) {
+  const server = createTerminalWebSocketServer();
+  server.handleUpgrade(req, socket, head, (ws) => {
+    server.emit("connection", ws, req);
+  });
+}
+var log2, ORPHAN_SESSION_TIMEOUT_MS, orphanTimers, wss = null, configuredRoot = null;
+var init_terminal_ws = __esm(() => {
+  init_wrapper();
+  init_pty_session();
+  init_log();
+  log2 = logger.child({ module: "terminal-ws" });
+  ORPHAN_SESSION_TIMEOUT_MS = 5 * 60 * 1000;
+  orphanTimers = new Map;
+});
+
 // ../api/src/server/http.ts
 var exports_http = {};
 __export(exports_http, {
   startServer: () => startServer
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { createReadStream } from "node:fs";
 import { stat as stat2 } from "node:fs/promises";
-import { extname as extname2, resolve as resolve21, sep as sep6 } from "node:path";
+import { extname as extname2, resolve as resolve22, sep as sep7 } from "node:path";
 async function startServer(options2) {
   const startedAt = Date.now();
   const taskFileWatch = createTaskFileWatchService(options2.root);
@@ -123011,7 +123582,7 @@ async function startServer(options2) {
       logger.error(`tRPC request failed ${JSON.stringify(details, (_key, value) => value === undefined ? "[undefined]" : value)}`);
     }
   });
-  const hasUi = Boolean(options2.uiRoot && existsSync13(options2.uiRoot));
+  const hasUi = Boolean(options2.uiRoot && existsSync14(options2.uiRoot));
   const server = createServer2(async (req, res) => {
     const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     if (url2.pathname === "/api/health/live") {
@@ -123067,10 +123638,26 @@ async function startServer(options2) {
       res.end(`Server error: ${error48 instanceof Error ? error48.message : "unknown"}`);
     }
   });
-  const log = logger.child({ module: "api" });
+  createTerminalWebSocketServer(options2.root);
+  server.on("upgrade", (req, socket, head) => {
+    const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url2.pathname === "/api/terminal") {
+      const remoteAddr = req.socket.remoteAddress ?? "";
+      const isLocalhost2 = remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
+      if (!isLocalhost2) {
+        logger.warn({ remoteAddress: remoteAddr }, "Rejected terminal WebSocket from non-localhost address");
+        socket.destroy();
+        return;
+      }
+      handleTerminalUpgrade(req, socket, head);
+    } else {
+      socket.destroy();
+    }
+  });
+  const log3 = logger.child({ module: "api" });
   const portResolution = await listenWithPortFallback(server, options2.port);
   if (portResolution.fallbackUsed) {
-    log.warn({
+    log3.warn({
       event: "startup.port.conflict",
       requestedPort: portResolution.requestedPort,
       resolvedPort: portResolution.resolvedPort,
@@ -123078,17 +123665,23 @@ async function startServer(options2) {
     });
   }
   const apiUrl = `http://localhost:${portResolution.resolvedPort}`;
-  log.info({
+  log3.info({
     event: "startup.ready",
     apiUrl,
     hint: "Press Ctrl+C to stop"
   }, `Ready: ${apiUrl} (Ctrl+C to stop)`);
   server.on("close", () => {
     taskFileWatch.stop();
-    log.info({
-      event: "startup.closed"
-    }, "API server closed.");
+    destroyAllSessions();
+    log3.info({ event: "startup.closed" }, "API server closed.");
   });
+  const gracefulShutdown = async () => {
+    log3.info({ event: "startup.shutting_down" }, "Graceful shutdown initiated");
+    await gracefulShutdownSessions();
+    server.close();
+  };
+  process.once("SIGINT", () => void gracefulShutdown());
+  process.once("SIGTERM", () => void gracefulShutdown());
   return {
     server,
     port: portResolution.resolvedPort
@@ -123174,8 +123767,8 @@ async function serveVibemanImage(options2) {
     return;
   }
   const requested = decodedPath.replace(/^\//, "");
-  const absoluteTarget = resolve21(rootPath, requested);
-  if (!absoluteTarget.startsWith(imagesDir + sep6)) {
+  const absoluteTarget = resolve22(rootPath, requested);
+  if (!absoluteTarget.startsWith(imagesDir + sep7)) {
     res.statusCode = 404;
     res.setHeader("content-type", "text/plain; charset=utf-8");
     res.end("Not found");
@@ -123241,6 +123834,8 @@ var init_http2 = __esm(() => {
   init_task_file_watch();
   init_port_utils();
   init_health_report();
+  init_terminal_ws();
+  init_pty_session();
   import_serve_handler = __toESM(require_src3(), 1);
 });
 
@@ -123404,35 +123999,12 @@ function isNodeVersionCompatible(currentNodeVersion, requiredRange) {
 
 // ../api/src/services/config.ts
 init_zod();
+init_env_policy();
 import { existsSync as existsSync2, statSync } from "node:fs";
 import { isAbsolute, resolve as resolvePath } from "node:path";
 var LOG_LEVELS = ["error", "warn", "info", "debug", "trace"];
 var LOG_FORMATS = ["pretty", "json"];
-var startupEnvSchema = exports_external.object({
-  PORT: exports_external.string().optional(),
-  VIBEMAN_ROOT: exports_external.string().optional(),
-  UI_DIST: exports_external.string().optional(),
-  VERBOSE: exports_external.string().optional(),
-  LOG_FORMAT: exports_external.string().optional(),
-  CODEX_PATH: exports_external.string().optional(),
-  GEMINI_PATH: exports_external.string().optional(),
-  CLAUDE_CODE_PATH: exports_external.string().optional(),
-  DEBUG: exports_external.string().optional(),
-  ENABLE_VIBEMAN_CA_TESTS: exports_external.string().optional(),
-  ENABLE_VIBEMAN_CA_TESTS_CODEX: exports_external.string().optional(),
-  ENABLE_VIBEMAN_CA_TESTS_GEMINI: exports_external.string().optional(),
-  ENABLE_VIBEMAN_CA_TESTS_CLAUDE: exports_external.string().optional(),
-  VIBEMAN_WORKFLOW_RUN_ID: exports_external.string().optional(),
-  VIBEMAN_WORKFLOW_STEP_ID: exports_external.string().optional(),
-  VIBEMAN_WORKFLOW_ROOT: exports_external.string().optional(),
-  VIBEMAN_TASK_PATH: exports_external.string().optional(),
-  VIBEMAN_TASK_NAME: exports_external.string().optional(),
-  VIBEMAN_TASK_BRANCH: exports_external.string().optional(),
-  VIBEMAN_TASK_WORKTREE: exports_external.string().optional(),
-  VIBEMAN_REPO_ROOT: exports_external.string().optional(),
-  VIBEMAN_DEFAULT_BRANCH: exports_external.string().optional(),
-  NODE_ENV: exports_external.string().optional()
-}).passthrough();
+var startupEnvSchema = exports_external.object({}).catchall(exports_external.string().optional());
 
 class StartupConfigError extends Error {
   details;
@@ -123446,7 +124018,7 @@ function loadStartupConfig(input) {
   const cwd = input.cwd ?? process.cwd();
   const parsed = startupEnvSchema.parse(input.env);
   const warnings = [];
-  const rootRaw = parsed.VIBEMAN_ROOT?.trim();
+  const rootRaw = parsed[VIBEMAN_ENV_KEYS.ROOT]?.trim();
   if (!rootRaw) {
     throw new StartupConfigError("Missing required environment variable VIBEMAN_ROOT.", [
       "Set VIBEMAN_ROOT to the target project directory before starting the API."
@@ -123458,13 +124030,13 @@ function loadStartupConfig(input) {
       `Resolved path does not exist or is not a directory: ${root}`
     ]);
   }
-  const port = parsePort(parsed.PORT, warnings);
-  const uiDist = parseOptionalDirectory(parsed.UI_DIST, "UI_DIST", cwd, warnings);
-  const verbose = parseLogLevel(parsed.VERBOSE, warnings);
-  const logFormat = parseLogFormat(parsed.LOG_FORMAT, parsed.NODE_ENV, warnings);
-  const codexPath = parseOptionalCliPath(parsed.CODEX_PATH, "CODEX_PATH", warnings);
-  const geminiPath = parseOptionalCliPath(parsed.GEMINI_PATH, "GEMINI_PATH", warnings);
-  const claudeCodePath = parseOptionalCliPath(parsed.CLAUDE_CODE_PATH, "CLAUDE_CODE_PATH", warnings);
+  const port = parsePort(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.PORT), warnings);
+  const uiDist = parseOptionalDirectory(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.UI_DIST), VIBEMAN_ENV_KEYS.UI_DIST, cwd, warnings);
+  const verbose = parseLogLevel(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.VERBOSE), warnings);
+  const logFormat = parseLogFormat(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.LOG_FORMAT), parsed.NODE_ENV, warnings);
+  const codexPath = parseOptionalCliPath(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.CODEX_PATH), VIBEMAN_ENV_KEYS.CODEX_PATH, warnings);
+  const geminiPath = parseOptionalCliPath(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.GEMINI_PATH), VIBEMAN_ENV_KEYS.GEMINI_PATH, warnings);
+  const claudeCodePath = parseOptionalCliPath(readVibemanEnv(parsed, VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH), VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH, warnings);
   const debug = parseBoolean(parsed.DEBUG).value;
   const caAll = parseBoolean(parsed.ENABLE_VIBEMAN_CA_TESTS).value;
   const caCodex = parseBoolean(parsed.ENABLE_VIBEMAN_CA_TESTS_CODEX);
@@ -123522,7 +124094,7 @@ function parsePort(raw2, warnings) {
   }
   const value = Number(raw2);
   if (!Number.isInteger(value) || value < 1 || value > 65535) {
-    warnings.push(`PORT="${raw2}" is invalid; using default 6969.`);
+    warnings.push(`${VIBEMAN_ENV_KEYS.PORT}="${raw2}" is invalid; using default 6969.`);
     return 6969;
   }
   return value;
@@ -123549,7 +124121,7 @@ function parseLogLevel(raw2, warnings) {
   }
   const parsed = exports_external.enum(LOG_LEVELS).safeParse(normalized);
   if (!parsed.success) {
-    warnings.push(`VERBOSE="${raw2}" is invalid; using "info".`);
+    warnings.push(`${VIBEMAN_ENV_KEYS.VERBOSE}="${raw2}" is invalid; using "info".`);
     return "info";
   }
   return parsed.data;
@@ -123562,7 +124134,7 @@ function parseLogFormat(raw2, nodeEnv, warnings) {
   }
   const parsed = exports_external.enum(LOG_FORMATS).safeParse(normalized);
   if (!parsed.success) {
-    warnings.push(`LOG_FORMAT="${raw2}" is invalid; using "${defaultValue}".`);
+    warnings.push(`${VIBEMAN_ENV_KEYS.LOG_FORMAT}="${raw2}" is invalid; using "${defaultValue}".`);
     return defaultValue;
   }
   return parsed.data;
@@ -123609,14 +124181,14 @@ function warnInvalidBoolean(key, raw2, parsed, warnings) {
   warnings.push(`${key}="${raw2}" is invalid; treating it as false.`);
 }
 function applyConfigToEnv(config2, env) {
-  env.VIBEMAN_ROOT = config2.root;
-  env.PORT = String(config2.port);
-  env.VERBOSE = config2.verbose;
-  env.LOG_FORMAT = config2.logFormat;
-  setOptionalEnv(env, "UI_DIST", config2.uiDist);
-  setOptionalEnv(env, "CODEX_PATH", config2.codexPath);
-  setOptionalEnv(env, "GEMINI_PATH", config2.geminiPath);
-  setOptionalEnv(env, "CLAUDE_CODE_PATH", config2.claudeCodePath);
+  env[VIBEMAN_ENV_KEYS.ROOT] = config2.root;
+  env[VIBEMAN_ENV_KEYS.PORT] = String(config2.port);
+  env[VIBEMAN_ENV_KEYS.VERBOSE] = config2.verbose;
+  env[VIBEMAN_ENV_KEYS.LOG_FORMAT] = config2.logFormat;
+  setOptionalEnv(env, VIBEMAN_ENV_KEYS.UI_DIST, config2.uiDist);
+  setOptionalEnv(env, VIBEMAN_ENV_KEYS.CODEX_PATH, config2.codexPath);
+  setOptionalEnv(env, VIBEMAN_ENV_KEYS.GEMINI_PATH, config2.geminiPath);
+  setOptionalEnv(env, VIBEMAN_ENV_KEYS.CLAUDE_CODE_PATH, config2.claudeCodePath);
 }
 function setOptionalEnv(env, key, value) {
   if (value === undefined) {