vibeman 0.0.12 → 0.0.13

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) {
@@ -44249,8 +44316,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 +45407,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 +45484,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 +45757,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 +45777,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 +45803,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 +45829,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 +45840,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 +101179,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 +101286,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 +101295,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 +101986,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 +102833,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 +102868,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 +102978,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 +102992,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 +103285,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 +103293,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 +103305,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 +103368,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 +103816,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 +103825,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 +104037,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 +104857,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 +104892,7 @@ async function autoCommitTaskStatusUpdate(input) {
     if (isNothingToCommitError(message)) {
       return;
     }
-    logger.warn({
+    safeLog5("warn", {
       module: "workflow",
       runId: input.runId,
       nodeKey: input.nodeKey,
@@ -104798,7 +104905,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 +107593,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 +107661,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 +107681,7 @@ var init_system2 = __esm(() => {
   init_dist4();
   init_zod();
   init_trpc();
+  init_env_policy();
   init_remote_access();
   appCategories = ["terminal", "editor"];
   appCatalog = [
@@ -108307,6 +108429,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 +108480,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);
@@ -123404,35 +123527,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 +123546,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 +123558,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 +123622,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 +123649,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 +123662,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 +123709,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) {