@virtengine/openfleet 0.25.0 → 0.26.2

package/.env.example

@@ -109,7 +109,7 @@ TELEGRAM_MINIAPP_ENABLED=false
 # Keep Telegram command availability even when openfleet is down.
 # Sentinel can auto-restart monitor, detect crash loops, and run repair-agent.
 # Auto-start sentinel whenever openfleet starts (default: disabled)
-# CODEX_MONITOR_SENTINEL_AUTO_START=true
+# OPENFLEET_SENTINEL_AUTO_START=true
 # Auto-restart monitor when sentinel detects monitor down/crash (default: 1)
 # SENTINEL_AUTO_RESTART_MONITOR=true
 # Crash-loop threshold within rolling window (default: 3)
@@ -322,9 +322,9 @@ TELEGRAM_MINIAPP_ENABLED=false
 # Auto-assign task creator/login when creating issues (default: true)
 # GITHUB_AUTO_ASSIGN_CREATOR=true
 # Codex task scoping label policy (only matching labels are picked by openfleet)
-# CODEX_MONITOR_TASK_LABEL=openfleet
-# CODEX_MONITOR_TASK_LABELS=openfleet,codex-mointor
-# CODEX_MONITOR_ENFORCE_TASK_LABEL=true
+# OPENFLEET_TASK_LABEL=openfleet
+# OPENFLEET_TASK_LABELS=openfleet,codex-mointor
+# OPENFLEET_ENFORCE_TASK_LABEL=true
 # Optional issue fetch cap per sync/poll cycle (default: 1000)
 # GITHUB_ISSUES_LIST_LIMIT=1000
 
@@ -427,12 +427,12 @@ TELEGRAM_MINIAPP_ENABLED=false
 # PID file: .cache/openfleet.pid
 # Logs: logs/daemon.log
 # Daemon crash supervision (monitor child):
-# CODEX_MONITOR_DAEMON_RESTART_DELAY_MS=5000
-# CODEX_MONITOR_DAEMON_MAX_RESTARTS=0   # 0 = unlimited
+# OPENFLEET_DAEMON_RESTART_DELAY_MS=5000
+# OPENFLEET_DAEMON_MAX_RESTARTS=0   # 0 = unlimited
 # Consider any crash within this window as an instant startup failure (default: 15000)
-# CODEX_MONITOR_DAEMON_INSTANT_CRASH_WINDOW_MS=15000
+# OPENFLEET_DAEMON_INSTANT_CRASH_WINDOW_MS=15000
 # Stop auto-restarts after this many instant failures in a row (default: 3)
-# CODEX_MONITOR_DAEMON_MAX_INSTANT_RESTARTS=3
+# OPENFLEET_DAEMON_MAX_INSTANT_RESTARTS=3
 
 # ─── Vibe-Kanban ──────────────────────────────────────────────────────────────
 # Base URL for the Vibe-Kanban API (default: http://127.0.0.1:54089)
@@ -492,7 +492,7 @@ VK_RECOVERY_PORT=54089
 # Target branch for PR checks/merge (default: origin/main)
 # VK_TARGET_BRANCH=origin/main
 # Default upstream/base branch for openfleet tasks (overrides VK_TARGET_BRANCH)
-# CODEX_MONITOR_TASK_UPSTREAM=origin/ve/openfleet-generic
+# OPENFLEET_TASK_UPSTREAM=origin/ve/openfleet-generic
 
 # ─── Codex / AI Provider ─────────────────────────────────────────────────────
 # The Codex SDK uses OpenAI-compatible configuration that has been setup in ~/.codex/config.toml -
@@ -544,39 +544,39 @@ VK_RECOVERY_PORT=54089
 #
 # Hook profile for setup/non-interactive runs:
 #   strict | balanced | lightweight | none
-# CODEX_MONITOR_HOOK_PROFILE=strict
+# OPENFLEET_HOOK_PROFILE=strict
 #
 # Which agents should receive generated hook files (comma-separated):
 #   codex,claude,copilot
-# CODEX_MONITOR_HOOK_TARGETS=codex,claude,copilot
+# OPENFLEET_HOOK_TARGETS=codex,claude,copilot
 #
 # Set to false to skip hook scaffolding during setup.
-# CODEX_MONITOR_HOOKS_ENABLED=true
+# OPENFLEET_HOOKS_ENABLED=true
 # Set to true to overwrite existing generated hook files.
-# CODEX_MONITOR_HOOKS_OVERWRITE=false
+# OPENFLEET_HOOKS_OVERWRITE=false
 # Optional overrides for generated bridge command tokens.
 # Defaults are portable across workstations:
 #   node scripts/openfleet/agent-hook-bridge.mjs
-# CODEX_MONITOR_HOOK_NODE_BIN=node
-# CODEX_MONITOR_HOOK_BRIDGE_PATH=scripts/openfleet/agent-hook-bridge.mjs
+# OPENFLEET_HOOK_NODE_BIN=node
+# OPENFLEET_HOOK_BRIDGE_PATH=scripts/openfleet/agent-hook-bridge.mjs
 #
 # Optional per-event command overrides (separate multiple commands with ';;').
 # Use value 'none' to disable that event in generated .codex/hooks.json.
-# CODEX_MONITOR_HOOK_PREPUSH=go vet ./...;;go build ./...
-# CODEX_MONITOR_HOOK_PRECOMMIT=gofmt -l .
-# CODEX_MONITOR_HOOK_TASK_COMPLETE=echo \"task completed\"
-# CODEX_MONITOR_HOOK_SESSION_START=echo \"session start\"
-# CODEX_MONITOR_HOOK_SESSION_STOP=echo \"session stop\"
+# OPENFLEET_HOOK_PREPUSH=go vet ./...;;go build ./...
+# OPENFLEET_HOOK_PRECOMMIT=gofmt -l .
+# OPENFLEET_HOOK_TASK_COMPLETE=echo \"task completed\"
+# OPENFLEET_HOOK_SESSION_START=echo \"session start\"
+# OPENFLEET_HOOK_SESSION_STOP=echo \"session stop\"
 #
 # Built-in hook behavior inside openfleet runtime:
 #   force (default), auto, off
-# CODEX_MONITOR_HOOKS_BUILTINS_MODE=force
-# CODEX_MONITOR_HOOKS_DISABLE_PREPUSH=false
-# CODEX_MONITOR_HOOKS_DISABLE_TASK_COMPLETE=false
-# CODEX_MONITOR_HOOKS_DISABLE_HEALTH_CHECK=false
+# OPENFLEET_HOOKS_BUILTINS_MODE=force
+# OPENFLEET_HOOKS_DISABLE_PREPUSH=false
+# OPENFLEET_HOOKS_DISABLE_TASK_COMPLETE=false
+# OPENFLEET_HOOKS_DISABLE_HEALTH_CHECK=false
 
 # Force hooks to fire even for non-managed sessions (debug only):
-# CODEX_MONITOR_HOOKS_FORCE=false
+# OPENFLEET_HOOKS_FORCE=false
 
 # VE_MANAGED is auto-set by openfleet at startup. Agent hook bridge
 # scripts check for this and exit silently if not present, preventing
@@ -735,11 +735,15 @@ COMPLEXITY_ROUTING_ENABLED=true
 # COMPLEXITY_ROUTING_CODEX_LOW_REASONING=low
 # COMPLEXITY_ROUTING_CODEX_MEDIUM_MODEL=gpt-5.2-codex
 # COMPLEXITY_ROUTING_CODEX_MEDIUM_VARIANT=DEFAULT
+# COMPLEXITY_ROUTING_CODEX_MEDIUM_REASONING=medium
 # COMPLEXITY_ROUTING_CODEX_HIGH_MODEL=gpt-5.1-codex-max
 # COMPLEXITY_ROUTING_CODEX_HIGH_VARIANT=GPT51_CODEX_MAX
-# COMPLEXITY_ROUTING_COPILOT_LOW_MODEL=haiku-4.5
-# COMPLEXITY_ROUTING_COPILOT_MEDIUM_MODEL=sonnet-4.5
-# COMPLEXITY_ROUTING_COPILOT_HIGH_MODEL=opus-4.6
+# COMPLEXITY_ROUTING_CODEX_HIGH_REASONING=high
+# COMPLEXITY_ROUTING_COPILOT_LOW_MODEL=claude-haiku-4.5
+# COMPLEXITY_ROUTING_COPILOT_MEDIUM_MODEL=claude-sonnet-4.5
+# COMPLEXITY_ROUTING_COPILOT_MEDIUM_REASONING=medium
+# COMPLEXITY_ROUTING_COPILOT_HIGH_MODEL=claude-opus-4.6
+# COMPLEXITY_ROUTING_COPILOT_HIGH_REASONING=high
 
 # ─── Shared Cloud Workspaces ────────────────────────────────────────────────
 # Registry file for shared workspace leasing (default: .cache/openfleet/shared-workspaces.json)
@@ -812,11 +816,11 @@ COPILOT_CLOUD_DISABLED=true
 #   .openfleet/agents/*.md
 # Files in that folder are loaded automatically and are intended for per-project customization.
 # You can also override any prompt path explicitly with env vars:
-# CODEX_MONITOR_PROMPT_PLANNER=.openfleet/agents/task-planner.md
-# CODEX_MONITOR_PROMPT_MONITOR_MONITOR=.openfleet/agents/monitor-monitor.md
-# CODEX_MONITOR_PROMPT_TASK_EXECUTOR=.openfleet/agents/task-executor.md
-# CODEX_MONITOR_PROMPT_REVIEWER=.openfleet/agents/reviewer.md
-# CODEX_MONITOR_PROMPT_SDK_CONFLICT_RESOLVER=.openfleet/agents/sdk-conflict-resolver.md
+# OPENFLEET_PROMPT_PLANNER=.openfleet/agents/task-planner.md
+# OPENFLEET_PROMPT_MONITOR_MONITOR=.openfleet/agents/monitor-monitor.md
+# OPENFLEET_PROMPT_TASK_EXECUTOR=.openfleet/agents/task-executor.md
+# OPENFLEET_PROMPT_REVIEWER=.openfleet/agents/reviewer.md
+# OPENFLEET_PROMPT_SDK_CONFLICT_RESOLVER=.openfleet/agents/sdk-conflict-resolver.md
 
 # ─── Dependabot / Bot PR Auto-Merge ───────────────────────────────────────────
 # Auto-merge Dependabot (and other bot) PRs after all CI checks pass.
@@ -860,7 +864,7 @@ COPILOT_CLOUD_DISABLED=true
 
 # ─── Advanced ─────────────────────────────────────────────────────────────────
 # Override openfleet config directory (where .env and config live)
-# CODEX_MONITOR_DIR=/path/to/scripts/openfleet
+# OPENFLEET_DIR=/path/to/scripts/openfleet
 # Max orchestrator restarts (0 = unlimited)
 # MAX_RESTARTS=0
 # Restart delay in milliseconds

package/agent-hook-bridge.mjs

@@ -166,7 +166,7 @@ async function run() {
   // openfleet sets VE_MANAGED=1 in all spawned agent environments.
   // If this env var is missing, we're running inside a standalone agent session
   // that just happens to have the hook files in its config — exit silently.
-  if (!process.env.VE_MANAGED && !process.env.CODEX_MONITOR_HOOKS_FORCE) {
+  if (!process.env.VE_MANAGED && !process.env.OPENFLEET_HOOKS_FORCE) {
     process.exit(0);
   }
 

package/agent-hooks.mjs

@@ -617,7 +617,7 @@ export async function executeBlockingHooks(event, context = {}) {
 export function registerBuiltinHooks(options = {}) {
   const modeRaw =
     options.mode ??
-    process.env.CODEX_MONITOR_HOOKS_BUILTINS_MODE ??
+    process.env.OPENFLEET_HOOKS_BUILTINS_MODE ??
     process.env.VE_HOOK_BUILTINS_MODE ??
     "force";
   const mode = String(modeRaw).trim().toLowerCase();
@@ -633,12 +633,12 @@ export function registerBuiltinHooks(options = {}) {
     (hook) => !hook.builtin,
   );
   const skipPrePush =
-    envFlag("CODEX_MONITOR_HOOKS_DISABLE_PREPUSH", false) ||
+    envFlag("OPENFLEET_HOOKS_DISABLE_PREPUSH", false) ||
     envFlag("VE_HOOK_DISABLE_PREPUSH", false) ||
     (mode === "auto" && hasCustomPrePush);
   const skipTaskComplete =
-    envFlag("CODEX_MONITOR_HOOKS_DISABLE_TASK_COMPLETE", false) ||
-    envFlag("CODEX_MONITOR_HOOKS_DISABLE_VALIDATION", false) ||
+    envFlag("OPENFLEET_HOOKS_DISABLE_TASK_COMPLETE", false) ||
+    envFlag("OPENFLEET_HOOKS_DISABLE_VALIDATION", false) ||
     envFlag("VE_HOOK_DISABLE_TASK_COMPLETE", false) ||
     (mode === "auto" && hasCustomTaskComplete);
 
@@ -680,7 +680,7 @@ export function registerBuiltinHooks(options = {}) {
   // ── SessionStart: worktree health check ──
   // Verifies the worktree directory exists, is a valid git repo,
   // and the expected branch is checked out. Retryable for transient git issues.
-  const skipHealthCheck = envFlag("CODEX_MONITOR_HOOKS_DISABLE_HEALTH_CHECK", false);
+  const skipHealthCheck = envFlag("OPENFLEET_HOOKS_DISABLE_HEALTH_CHECK", false);
   if (!skipHealthCheck) {
     const healthCmd = IS_WINDOWS
       ? 'powershell -NoProfile -Command "if (-not (Test-Path .git)) { if (-not (git rev-parse --git-dir 2>$null)) { Write-Error \'Not a git repository\'; exit 1 } }; git status --porcelain 2>&1 | Out-Null; if ($LASTEXITCODE -ne 0) { Write-Error \'git status failed\'; exit 1 }; Write-Host \'OK: worktree healthy\'"'

package/agent-prompts.mjs

@@ -119,7 +119,7 @@ export const AGENT_PROMPT_DEFINITIONS = Object.freeze(
   PROMPT_DEFS.map((item) =>
     Object.freeze({
       ...item,
-      envVar: `CODEX_MONITOR_PROMPT_${toEnvSuffix(item.key)}`,
+      envVar: `OPENFLEET_PROMPT_${toEnvSuffix(item.key)}`,
       defaultRelativePath: `${PROMPT_WORKSPACE_DIR}/${item.filename}`,
     }),
   ),
@@ -562,7 +562,7 @@ export function getAgentPromptDefinitions() {
 
 export function getDefaultPromptWorkspace(repoRoot) {
   const override = String(
-    process.env.CODEX_MONITOR_PROMPT_WORKSPACE || "",
+    process.env.OPENFLEET_PROMPT_WORKSPACE || "",
   ).trim();
   if (override) {
     return isAbsolute(override)
@@ -607,13 +607,13 @@ export function ensureAgentPromptWorkspace(repoRoot) {
     mkdirSync(workspaceDir, { recursive: true });
   } catch (err) {
     const fallbackRoot = resolve(
-      process.env.CODEX_MONITOR_HOME ||
+      process.env.OPENFLEET_HOME ||
         process.env.HOME ||
         process.env.USERPROFILE ||
         homedir(),
     );
     const fallbackDir = resolve(fallbackRoot, PROMPT_WORKSPACE_DIR);
-    process.env.CODEX_MONITOR_PROMPT_WORKSPACE = fallbackDir;
+    process.env.OPENFLEET_PROMPT_WORKSPACE = fallbackDir;
     workspaceDir = fallbackDir;
     mkdirSync(workspaceDir, { recursive: true });
     console.warn(

package/cli.mjs

@@ -140,9 +140,9 @@ function showHelp() {
     5. Built-in defaults
 
     Auto-update environment variables:
-      CODEX_MONITOR_SKIP_UPDATE_CHECK=1     Disable startup version check
-      CODEX_MONITOR_SKIP_AUTO_UPDATE=1      Disable background polling
-      CODEX_MONITOR_UPDATE_INTERVAL_MS=N    Override poll interval (default: 600000)
+      OPENFLEET_SKIP_UPDATE_CHECK=1     Disable startup version check
+      OPENFLEET_SKIP_AUTO_UPDATE=1      Disable background polling
+      OPENFLEET_UPDATE_INTERVAL_MS=N    Override poll interval (default: 600000)
 
     See .env.example for all environment variables.
 
@@ -199,23 +199,23 @@ const SENTINEL_SCRIPT_PATH = fileURLToPath(
   new URL("./telegram-sentinel.mjs", import.meta.url),
 );
 const IS_DAEMON_CHILD =
-  args.includes("--daemon-child") || process.env.CODEX_MONITOR_DAEMON === "1";
+  args.includes("--daemon-child") || process.env.OPENFLEET_DAEMON === "1";
 const DAEMON_RESTART_DELAY_MS = Math.max(
   1000,
-  Number(process.env.CODEX_MONITOR_DAEMON_RESTART_DELAY_MS || 5000) || 5000,
+  Number(process.env.OPENFLEET_DAEMON_RESTART_DELAY_MS || 5000) || 5000,
 );
 const DAEMON_MAX_RESTARTS = Math.max(
   0,
-  Number(process.env.CODEX_MONITOR_DAEMON_MAX_RESTARTS || 0) || 0,
+  Number(process.env.OPENFLEET_DAEMON_MAX_RESTARTS || 0) || 0,
 );
 const DAEMON_INSTANT_CRASH_WINDOW_MS = Math.max(
   1000,
-  Number(process.env.CODEX_MONITOR_DAEMON_INSTANT_CRASH_WINDOW_MS || 15000) ||
+  Number(process.env.OPENFLEET_DAEMON_INSTANT_CRASH_WINDOW_MS || 15000) ||
     15000,
 );
 const DAEMON_MAX_INSTANT_RESTARTS = Math.max(
   1,
-  Number(process.env.CODEX_MONITOR_DAEMON_MAX_INSTANT_RESTARTS || 3) || 3,
+  Number(process.env.OPENFLEET_DAEMON_MAX_INSTANT_RESTARTS || 3) || 3,
 );
 let daemonRestartCount = 0;
 const daemonCrashTracker = createDaemonCrashTracker({
@@ -283,7 +283,7 @@ async function ensureSentinelRunning(options = {}) {
     windowsHide: process.platform === "win32",
     env: {
       ...process.env,
-      CODEX_MONITOR_SENTINEL_COMPANION: "1",
+      OPENFLEET_SENTINEL_COMPANION: "1",
     },
     cwd: process.cwd(),
   });
@@ -380,7 +380,7 @@ function startDaemon() {
       detached: true,
       stdio: "ignore",
       windowsHide: process.platform === "win32",
-      env: { ...process.env, CODEX_MONITOR_DAEMON: "1" },
+      env: { ...process.env, OPENFLEET_DAEMON: "1" },
       cwd: process.cwd(),
     },
   );
@@ -510,7 +510,7 @@ async function main() {
   // Write PID file if running as daemon child
   if (
     args.includes("--daemon-child") ||
-    process.env.CODEX_MONITOR_DAEMON === "1"
+    process.env.OPENFLEET_DAEMON === "1"
   ) {
     writePidFile(process.pid);
     // Redirect console to log file on daemon child
@@ -556,15 +556,15 @@ async function main() {
 
   const sentinelRequested =
     args.includes("--sentinel") ||
-    parseBoolEnv(process.env.CODEX_MONITOR_SENTINEL_AUTO_START, false);
+    parseBoolEnv(process.env.OPENFLEET_SENTINEL_AUTO_START, false);
   if (sentinelRequested) {
     const sentinel = await ensureSentinelRunning({ quiet: false });
     if (!sentinel.ok) {
       const mode = args.includes("--sentinel")
         ? "requested by --sentinel"
-        : "requested by CODEX_MONITOR_SENTINEL_AUTO_START";
+        : "requested by OPENFLEET_SENTINEL_AUTO_START";
       const strictSentinel = parseBoolEnv(
-        process.env.CODEX_MONITOR_SENTINEL_STRICT,
+        process.env.OPENFLEET_SENTINEL_STRICT,
         false,
       );
       const prefix = strictSentinel ? "✖" : "⚠";
@@ -649,7 +649,7 @@ async function main() {
 
   // Propagate --no-auto-update to env for monitor.mjs to pick up
   if (args.includes("--no-auto-update")) {
-    process.env.CODEX_MONITOR_SKIP_AUTO_UPDATE = "1";
+    process.env.OPENFLEET_SKIP_AUTO_UPDATE = "1";
   }
 
   // Mark all child processes as openfleet managed.
@@ -661,7 +661,7 @@ async function main() {
   if (args.includes("--setup") || args.includes("setup")) {
     const configDirArg = getArgValue("--config-dir");
     if (configDirArg) {
-      process.env.CODEX_MONITOR_DIR = configDirArg;
+      process.env.OPENFLEET_DIR = configDirArg;
     }
     const { runSetup } = await import("./setup.mjs");
     await runSetup();
@@ -682,13 +682,75 @@ async function main() {
     console.log("\n  🚀 First run detected — launching setup wizard...\n");
     const configDirArg = getArgValue("--config-dir");
     if (configDirArg) {
-      process.env.CODEX_MONITOR_DIR = configDirArg;
+      process.env.OPENFLEET_DIR = configDirArg;
     }
     const { runSetup } = await import("./setup.mjs");
     await runSetup();
     console.log("\n  Setup complete! Starting openfleet...\n");
   }
 
+  // ── Handle --echo-logs: tail the active monitor's log instead of spawning a new instance ──
+  if (args.includes("--echo-logs")) {
+    // Search for the monitor PID file in common cache locations
+    const candidatePidFiles = [
+      process.env.OPENFLEET_DIR
+        ? resolve(process.env.OPENFLEET_DIR, ".cache", "openfleet.pid")
+        : null,
+      resolve(__dirname, "..", ".cache", "openfleet.pid"),
+      resolve(process.cwd(), ".cache", "openfleet.pid"),
+    ].filter(Boolean);
+
+    let activePidFile = null;
+    for (const f of candidatePidFiles) {
+      if (existsSync(f)) {
+        activePidFile = f;
+        break;
+      }
+    }
+
+    if (activePidFile) {
+      try {
+        const pidData = JSON.parse(readFileSync(activePidFile, "utf8"));
+        const monitorPid = Number(pidData.pid);
+        const monitorPath = (pidData.argv || [])[1] || "";
+
+        let isAlive = false;
+        try {
+          process.kill(monitorPid, 0);
+          isAlive = true;
+        } catch {}
+
+        if (isAlive && monitorPath) {
+          const logDir = resolve(dirname(monitorPath), "logs");
+          const daemonLog = resolve(logDir, "daemon.log");
+          const monitorLog = resolve(logDir, "monitor.log");
+          const logFile = existsSync(daemonLog) ? daemonLog : monitorLog;
+
+          if (existsSync(logFile)) {
+            console.log(
+              `\n  Tailing logs for active openfleet (PID ${monitorPid}):\n  ${logFile}\n`,
+            );
+            await new Promise((res) => {
+              const tail = spawn("tail", ["-f", "-n", "200", logFile], {
+                stdio: "inherit",
+              });
+              tail.on("exit", res);
+              process.on("SIGINT", () => {
+                tail.kill();
+                res();
+              });
+            });
+            process.exit(0);
+          }
+        }
+      } catch {
+        // best-effort — fall through to normal start
+      }
+    }
+
+    // No active monitor found — start normally; echoLogs will be picked up by config.mjs
+  }
+
   // Fork monitor as a child process — enables self-restart on source changes.
   // When monitor exits with code 75, cli re-forks with a fresh ESM module cache.
   await runMonitor();

package/config-doctor.mjs

@@ -82,7 +82,7 @@ function isWslInteropRuntime() {
 }
 
 function resolveConfigDir(repoRoot) {
-  const explicit = process.env.CODEX_MONITOR_DIR;
+  const explicit = process.env.OPENFLEET_DIR;
   if (explicit) return resolve(explicit);
 
   const repoPath = resolve(repoRoot || process.cwd());

package/config.mjs

@@ -726,7 +726,7 @@ export function loadConfig(argv = process.argv, options = {}) {
   // Determine config directory (where openfleet stores its config)
   const configDir =
     cli["config-dir"] ||
-    process.env.CODEX_MONITOR_DIR ||
+    process.env.OPENFLEET_DIR ||
     resolveConfigDir(repoRootForConfig);
 
   const configFile = loadConfigFile(configDir);
@@ -740,8 +740,8 @@ export function loadConfig(argv = process.argv, options = {}) {
   const repoSelection =
     cli["repo-name"] ||
     cli.repository ||
-    process.env.CODEX_MONITOR_REPO ||
-    process.env.CODEX_MONITOR_REPO_NAME ||
+    process.env.OPENFLEET_REPO ||
+    process.env.OPENFLEET_REPO_NAME ||
     process.env.REPO_NAME ||
     configData.defaultRepository ||
     configData.defaultRepo ||
@@ -774,8 +774,8 @@ export function loadConfig(argv = process.argv, options = {}) {
     (profiles.default ? "default" : "");
   const profileName =
     cli.profile ||
-    process.env.CODEX_MONITOR_PROFILE ||
-    process.env.CODEX_MONITOR_ENV_PROFILE ||
+    process.env.OPENFLEET_PROFILE ||
+    process.env.OPENFLEET_ENV_PROFILE ||
     selectedRepository?.profile ||
     selectedRepository?.envProfile ||
     defaultProfile ||
@@ -838,7 +838,7 @@ export function loadConfig(argv = process.argv, options = {}) {
   const mode =
     (
       cli.mode ||
-      process.env.CODEX_MONITOR_MODE ||
+      process.env.OPENFLEET_MODE ||
       configData.mode ||
       selectedRepository?.mode ||
       ""
@@ -943,20 +943,20 @@ export function loadConfig(argv = process.argv, options = {}) {
   const interactiveShellEnabled =
     flags.has("shell") ||
     flags.has("interactive") ||
-    isEnvEnabled(process.env.CODEX_MONITOR_SHELL, false) ||
-    isEnvEnabled(process.env.CODEX_MONITOR_INTERACTIVE, false) ||
+    isEnvEnabled(process.env.OPENFLEET_SHELL, false) ||
+    isEnvEnabled(process.env.OPENFLEET_INTERACTIVE, false) ||
     configData.interactiveShellEnabled === true ||
     configData.shellEnabled === true;
   const preflightEnabled = flags.has("no-preflight")
     ? false
     : configData.preflightEnabled !== undefined
       ? configData.preflightEnabled
-      : isEnvEnabled(process.env.CODEX_MONITOR_PREFLIGHT_DISABLED, false)
+      : isEnvEnabled(process.env.OPENFLEET_PREFLIGHT_DISABLED, false)
         ? false
         : true;
   const preflightRetryMs = Number(
     cli["preflight-retry"] ||
-      process.env.CODEX_MONITOR_PREFLIGHT_RETRY_MS ||
+      process.env.OPENFLEET_PREFLIGHT_RETRY_MS ||
       configData.preflightRetryMs ||
       "300000",
   );
@@ -1656,7 +1656,7 @@ function detectProjectName(configDir, repoRoot) {
 }
 
 function findOrchestratorScript(configDir, repoRoot) {
-  const shellModeEnv = String(process.env.CODEX_MONITOR_SHELL_MODE || "")
+  const shellModeEnv = String(process.env.OPENFLEET_SHELL_MODE || "")
     .trim()
     .toLowerCase();
   const shellModeRequested = ["1", "true", "yes", "on"].includes(shellModeEnv);

package/hook-profiles.mjs

@@ -11,13 +11,13 @@ const LEGACY_BRIDGE_SNIPPET = "scripts/openfleet/agent-hook-bridge.mjs";
 const DEFAULT_BRIDGE_SCRIPT_PATH = resolve(__dirname, "agent-hook-bridge.mjs");
 
 function getHookNodeBinary() {
-  const configured = String(process.env.CODEX_MONITOR_HOOK_NODE_BIN || "").trim();
+  const configured = String(process.env.OPENFLEET_HOOK_NODE_BIN || "").trim();
   return configured || "node";
 }
 
 function getHookBridgeScriptPath() {
   const configured = String(
-    process.env.CODEX_MONITOR_HOOK_BRIDGE_PATH || "",
+    process.env.OPENFLEET_HOOK_BRIDGE_PATH || "",
   ).trim();
   return configured || DEFAULT_BRIDGE_SCRIPT_PATH;
 }
@@ -242,23 +242,23 @@ export function normalizeHookTargets(value) {
 }
 
 export function buildHookScaffoldOptionsFromEnv(env = process.env) {
-  const profile = normalizeProfile(env.CODEX_MONITOR_HOOK_PROFILE);
+  const profile = normalizeProfile(env.OPENFLEET_HOOK_PROFILE);
   return {
-    enabled: parseBoolean(env.CODEX_MONITOR_HOOKS_ENABLED, true),
+    enabled: parseBoolean(env.OPENFLEET_HOOKS_ENABLED, true),
     profile,
-    targets: normalizeHookTargets(env.CODEX_MONITOR_HOOK_TARGETS),
-    overwriteExisting: parseBoolean(env.CODEX_MONITOR_HOOKS_OVERWRITE, false),
+    targets: normalizeHookTargets(env.OPENFLEET_HOOK_TARGETS),
+    overwriteExisting: parseBoolean(env.OPENFLEET_HOOKS_OVERWRITE, false),
     commands: {
       SessionStart: normalizeOverrideCommands(
-        env.CODEX_MONITOR_HOOK_SESSION_START,
+        env.OPENFLEET_HOOK_SESSION_START,
       ),
       SessionStop: normalizeOverrideCommands(
-        env.CODEX_MONITOR_HOOK_SESSION_STOP,
+        env.OPENFLEET_HOOK_SESSION_STOP,
       ),
-      PrePush: normalizeOverrideCommands(env.CODEX_MONITOR_HOOK_PREPUSH),
-      PreCommit: normalizeOverrideCommands(env.CODEX_MONITOR_HOOK_PRECOMMIT),
+      PrePush: normalizeOverrideCommands(env.OPENFLEET_HOOK_PREPUSH),
+      PreCommit: normalizeOverrideCommands(env.OPENFLEET_HOOK_PRECOMMIT),
       TaskComplete: normalizeOverrideCommands(
-        env.CODEX_MONITOR_HOOK_TASK_COMPLETE,
+        env.OPENFLEET_HOOK_TASK_COMPLETE,
       ),
     },
   };
@@ -545,10 +545,10 @@ function buildDisableEnv(hookConfig) {
   const hasTaskComplete = Array.isArray(hookConfig.hooks?.TaskComplete);
 
   return {
-    CODEX_MONITOR_HOOKS_BUILTINS_MODE:
+    OPENFLEET_HOOKS_BUILTINS_MODE:
       hasPrePush || hasTaskComplete ? "auto" : "off",
-    CODEX_MONITOR_HOOKS_DISABLE_PREPUSH: hasPrePush ? "0" : "1",
-    CODEX_MONITOR_HOOKS_DISABLE_TASK_COMPLETE: hasTaskComplete ? "0" : "1",
+    OPENFLEET_HOOKS_DISABLE_PREPUSH: hasPrePush ? "0" : "1",
+    OPENFLEET_HOOKS_DISABLE_TASK_COMPLETE: hasTaskComplete ? "0" : "1",
   };
 }
 
@@ -571,9 +571,9 @@ export function scaffoldAgentHookFiles(repoRoot, options = {}) {
 
   if (!enabled) {
     result.env = {
-      CODEX_MONITOR_HOOKS_BUILTINS_MODE: "off",
-      CODEX_MONITOR_HOOKS_DISABLE_PREPUSH: "1",
-      CODEX_MONITOR_HOOKS_DISABLE_TASK_COMPLETE: "1",
+      OPENFLEET_HOOKS_BUILTINS_MODE: "off",
+      OPENFLEET_HOOKS_DISABLE_PREPUSH: "1",
+      OPENFLEET_HOOKS_DISABLE_TASK_COMPLETE: "1",
     };
     return result;
   }

package/kanban-adapter.mjs

@@ -862,13 +862,13 @@ class GitHubIssuesAdapter {
     };
 
     this._canonicalTaskLabel =
-      process.env.CODEX_MONITOR_TASK_LABEL || "openfleet";
+      process.env.OPENFLEET_TASK_LABEL || "openfleet";
     this._taskScopeLabels = normalizeLabels(
-      process.env.CODEX_MONITOR_TASK_LABELS ||
+      process.env.OPENFLEET_TASK_LABELS ||
         `${this._canonicalTaskLabel},codex-mointor`,
     );
     this._enforceTaskLabel = parseBooleanEnv(
-      process.env.CODEX_MONITOR_ENFORCE_TASK_LABEL,
+      process.env.OPENFLEET_ENFORCE_TASK_LABEL,
       true,
     );
 
@@ -3010,17 +3010,17 @@ class JiraAdapter {
       process.env.JIRA_SUBTASK_PARENT_KEY || "",
     ).trim();
     this._canonicalTaskLabel = String(
-      process.env.CODEX_MONITOR_TASK_LABEL || "openfleet",
+      process.env.OPENFLEET_TASK_LABEL || "openfleet",
     )
       .trim()
       .toLowerCase();
     this._taskScopeLabels = normalizeLabels(
       process.env.JIRA_TASK_LABELS ||
-        process.env.CODEX_MONITOR_TASK_LABELS ||
+        process.env.OPENFLEET_TASK_LABELS ||
         `${this._canonicalTaskLabel},openfleet`,
     ).map((label) => this._sanitizeJiraLabel(label));
     this._enforceTaskLabel = parseBooleanEnv(
-      process.env.JIRA_ENFORCE_TASK_LABEL ?? process.env.CODEX_MONITOR_ENFORCE_TASK_LABEL,
+      process.env.JIRA_ENFORCE_TASK_LABEL ?? process.env.OPENFLEET_ENFORCE_TASK_LABEL,
       true,
     );
     this._codexLabels = {

package/monitor.mjs

@@ -6109,9 +6109,9 @@ async function actOnAssessment(ctx, decision) {
 // Use config-driven branch routing instead of hardcoded defaults
 const DEFAULT_TARGET_BRANCH =
   branchRouting?.defaultBranch || process.env.VK_TARGET_BRANCH || "origin/main";
-const DEFAULT_CODEX_MONITOR_UPSTREAM =
+const DEFAULT_OPENFLEET_UPSTREAM =
   branchRouting?.scopeMap?.["openfleet"] ||
-  process.env.CODEX_MONITOR_TASK_UPSTREAM ||
+  process.env.OPENFLEET_TASK_UPSTREAM ||
   "origin/ve/openfleet-generic";
 
 /**
@@ -6303,7 +6303,7 @@ function resolveUpstreamFromTask(task) {
     text.includes("@virtengine/openfleet") ||
     text.includes("scripts/openfleet")
   ) {
-    return DEFAULT_CODEX_MONITOR_UPSTREAM;
+    return DEFAULT_OPENFLEET_UPSTREAM;
   }
 
   return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virtengine/openfleet",
-  "version": "0.25.0",
+  "version": "0.26.2",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",
@@ -92,7 +92,11 @@
     "prepush:check": "npm run syntax:check && npm test",
     "prepublishOnly": "node prepublish-check.mjs",
     "publish:env": "node publish.mjs",
-    "publish:dry-run": "node publish.mjs --dry-run"
+    "publish:dry-run": "node publish.mjs --dry-run",
+    "publish:minor": "node publish.mjs --bump minor",
+    "publish:major": "node publish.mjs --bump major",
+    "publish:minor:dry": "node publish.mjs --bump minor --dry-run",
+    "publish:major:dry": "node publish.mjs --bump major --dry-run"
   },
   "files": [
     ".env.example",

package/postinstall.mjs

@@ -103,7 +103,7 @@ const RECOMMENDED = [
 
 function main() {
   // Skip in CI environments
-  if (process.env.CI || process.env.CODEX_MONITOR_SKIP_POSTINSTALL) {
+  if (process.env.CI || process.env.OPENFLEET_SKIP_POSTINSTALL) {
     return;
   }
 

package/preflight.mjs

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import os from "node:os";
 
 const isWindows = process.platform === "win32";
-const MIN_FREE_GB = Number(process.env.CODEX_MONITOR_MIN_FREE_GB || "10");
+const MIN_FREE_GB = Number(process.env.OPENFLEET_MIN_FREE_GB || "10");
 const MIN_FREE_BYTES = MIN_FREE_GB * 1024 * 1024 * 1024;
 
 function runCommand(command, args, options = {}) {
@@ -167,7 +167,7 @@ function isShellModeRequested() {
     .toLowerCase();
   if (script.endsWith(".sh")) return true;
   if (script.endsWith(".ps1")) return false;
-  if (parseEnvBool(process.env.CODEX_MONITOR_SHELL_MODE, false)) return true;
+  if (parseEnvBool(process.env.OPENFLEET_SHELL_MODE, false)) return true;
   return !isWindows;
 }
 

package/publish.mjs

@@ -1,7 +1,22 @@
 #!/usr/bin/env node
+//
+// Usage:
+//   node publish.mjs                  # publish at current version (prompts login if no token)
+//   node publish.mjs --bump minor      # 0.25.0 → 0.25.1  (patch digit)
+//   node publish.mjs --bump major      # 0.25.0 → 0.26.0  (minor digit)
+//   node publish.mjs --bump minor --dry-run
+//
+// To set an automation token (Linux/macOS bash — NOT setx/PowerShell):
+//   export NPM_ACCESS_TOKEN=npm_xxxx && node publish.mjs --bump minor
+//   # or inline:
+//   NPM_ACCESS_TOKEN=npm_xxxx npm run publish:minor
+//
+// Terminology matches the openfleet convention (not semver):
+//   minor = last digit (semver patch)
+//   major = middle digit (semver minor)
 
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -64,8 +79,82 @@ function runCheck(label, command, args, env) {
 
 const NPM_BIN = "npm";
 
+/**
+ * Bump the version in package.json and sync package-lock.json.
+ * type: "minor" → patch digit (0.25.0 → 0.25.1)
+ *       "major" → middle digit (0.25.0 → 0.26.0)
+ * Returns the new version string.
+ */
+function bumpVersion(type, dryRun) {
+  const pkgPath = resolve(SCRIPT_DIR, "package.json");
+  const lockPath = resolve(SCRIPT_DIR, "package-lock.json");
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const [maj, mid, pat] = pkg.version.split(".").map(Number);
+
+  let newVersion;
+  if (type === "minor") {
+    // minor = patch digit (last number)
+    newVersion = `${maj}.${mid}.${pat + 1}`;
+  } else if (type === "major") {
+    // major = middle digit, reset patch
+    newVersion = `${maj}.${mid + 1}.0`;
+  } else {
+    console.error(
+      `[publish] Unknown bump type "${type}". Use "minor" (0.25.0→0.25.1) or "major" (0.25.0→0.26.0).`,
+    );
+    process.exit(1);
+  }
+
+  console.log(`[publish] Bumping version: ${pkg.version} → ${newVersion}`);
+
+  if (!dryRun) {
+    pkg.version = newVersion;
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+
+    // Update package-lock.json in-place
+    try {
+      const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+      lock.version = newVersion;
+      if (lock.packages?.[""] != null) {
+        lock.packages[""].version = newVersion;
+      }
+      writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf8");
+      console.log(
+        `[publish] package.json + package-lock.json updated to ${newVersion}`,
+      );
+    } catch {
+      console.warn(
+        "[publish] Could not update package-lock.json — regenerating...",
+      );
+      spawnSync(NPM_BIN, ["install", "--package-lock-only", "--ignore-scripts"], {
+        stdio: "inherit",
+        cwd: SCRIPT_DIR,
+        shell: true,
+      });
+    }
+  } else {
+    console.log(
+      `[publish] dry-run: would write version ${newVersion} to package.json & package-lock.json`,
+    );
+  }
+
+  return newVersion;
+}
+
+function getBumpArg() {
+  const idx = process.argv.indexOf("--bump");
+  if (idx !== -1 && process.argv[idx + 1]) return process.argv[idx + 1];
+  const flag = process.argv.find((a) => a.startsWith("--bump="));
+  if (flag) return flag.slice(7);
+  return null;
+}
+
 function main() {
+  const bumpType = getBumpArg();
   const dryRun = hasArg("--dry-run");
+  if (bumpType) bumpVersion(bumpType, dryRun);
+
   const tag = process.env.NPM_PUBLISH_TAG || "latest";
   const otp = process.env.NPM_OTP || "";
   const access = process.env.NPM_PUBLISH_ACCESS || "public";
@@ -73,10 +162,11 @@ function main() {
   const token = process.env.NPM_ACCESS_TOKEN || process.env.NODE_AUTH_TOKEN || "";
 
   if (!dryRun && !token) {
-    console.error(
-      "[publish] Missing token. Set NPM_ACCESS_TOKEN (or NODE_AUTH_TOKEN) in environment. - use a 2FA Permissionless token",
+    console.log(
+      "[publish] No NPM_ACCESS_TOKEN found — npm will prompt for login.",
     );
-    process.exit(1);
+  } else if (!dryRun && token) {
+    console.log("[publish] Token found — using NPM_ACCESS_TOKEN for auth.");
   }
 
   console.log(
@@ -105,7 +195,7 @@ function main() {
   let tempConfig = null;
   try {
     const env = { ...process.env };
-    if (!dryRun) {
+    if (!dryRun && token) {
       tempConfig = createEphemeralNpmrc(registry, token);
       env.NPM_CONFIG_USERCONFIG = tempConfig.npmrcPath;
       env.NODE_AUTH_TOKEN = token;

package/setup.mjs

@@ -97,7 +97,7 @@ function isPathInside(parent, child) {
 }
 
 function resolveConfigDir(repoRoot) {
-  const explicit = process.env.CODEX_MONITOR_DIR;
+  const explicit = process.env.OPENFLEET_DIR;
   if (explicit) return resolve(explicit);
   const repoPath = resolve(repoRoot || process.cwd());
   const packageDir = resolve(__dirname);
@@ -2488,7 +2488,7 @@ async function main() {
 
       const canonicalLabel = "openfleet";
       const existingScopeLabels = String(
-        process.env.CODEX_MONITOR_TASK_LABELS || "",
+        process.env.OPENFLEET_TASK_LABELS || "",
       )
         .split(",")
         .map((entry) => entry.trim().toLowerCase())
@@ -2499,9 +2499,9 @@ async function main() {
       if (!existingScopeLabels.includes("codex-mointor")) {
         existingScopeLabels.push("codex-mointor");
       }
-      env.CODEX_MONITOR_TASK_LABEL = canonicalLabel;
-      env.CODEX_MONITOR_TASK_LABELS = existingScopeLabels.join(",");
-      env.CODEX_MONITOR_ENFORCE_TASK_LABEL = "true";
+      env.OPENFLEET_TASK_LABEL = canonicalLabel;
+      env.OPENFLEET_TASK_LABELS = existingScopeLabels.join(",");
+      env.OPENFLEET_ENFORCE_TASK_LABEL = "true";
 
       if (githubTaskMode === "kanban") {
         env.GITHUB_PROJECT_OWNER =
@@ -2546,7 +2546,7 @@ async function main() {
           projectTitle: env.GITHUB_PROJECT_TITLE || "OpenFleet",
           projectOwner: env.GITHUB_PROJECT_OWNER || env.GITHUB_REPO_OWNER || "",
           projectNumber: env.GITHUB_PROJECT_NUMBER || "",
-          taskLabel: env.CODEX_MONITOR_TASK_LABEL || "openfleet",
+          taskLabel: env.OPENFLEET_TASK_LABEL || "openfleet",
         },
       };
       info(
@@ -2789,7 +2789,7 @@ async function main() {
       const canonicalLabel = "openfleet";
       const jiraScopeLabels = String(
         process.env.JIRA_TASK_LABELS ||
-          process.env.CODEX_MONITOR_TASK_LABELS ||
+          process.env.OPENFLEET_TASK_LABELS ||
           "",
       )
         .split(",")
@@ -2801,10 +2801,10 @@ async function main() {
       if (!jiraScopeLabels.includes("codex-mointor")) {
         jiraScopeLabels.push("codex-mointor");
       }
-      env.CODEX_MONITOR_TASK_LABEL = canonicalLabel;
-      env.CODEX_MONITOR_TASK_LABELS = jiraScopeLabels.join(",");
-      env.CODEX_MONITOR_ENFORCE_TASK_LABEL = "true";
-      env.JIRA_TASK_LABELS = env.CODEX_MONITOR_TASK_LABELS;
+      env.OPENFLEET_TASK_LABEL = canonicalLabel;
+      env.OPENFLEET_TASK_LABELS = jiraScopeLabels.join(",");
+      env.OPENFLEET_ENFORCE_TASK_LABEL = "true";
+      env.JIRA_TASK_LABELS = env.OPENFLEET_TASK_LABELS;
       env.JIRA_ENFORCE_TASK_LABEL = "true";
 
       if (hasJiraCreds) {
@@ -3244,9 +3244,9 @@ async function main() {
       const profileMap = ["strict", "balanced", "lightweight", "none"];
       let profile = "balanced";
       let targets = ["codex", "claude", "copilot"];
-      let prePushRaw = process.env.CODEX_MONITOR_HOOK_PREPUSH || "";
-      let preCommitRaw = process.env.CODEX_MONITOR_HOOK_PRECOMMIT || "";
-      let taskCompleteRaw = process.env.CODEX_MONITOR_HOOK_TASK_COMPLETE || "";
+      let prePushRaw = process.env.OPENFLEET_HOOK_PREPUSH || "";
+      let preCommitRaw = process.env.OPENFLEET_HOOK_PRECOMMIT || "";
+      let taskCompleteRaw = process.env.OPENFLEET_HOOK_TASK_COMPLETE || "";
       let overwriteHooks = false;
 
       if (isAdvancedSetup) {
@@ -3294,15 +3294,15 @@ async function main() {
 
         prePushRaw = await prompt.ask(
           "Pre-push command override",
-          process.env.CODEX_MONITOR_HOOK_PREPUSH || "",
+          process.env.OPENFLEET_HOOK_PREPUSH || "",
         );
         preCommitRaw = await prompt.ask(
           "Pre-commit command override",
-          process.env.CODEX_MONITOR_HOOK_PRECOMMIT || "",
+          process.env.OPENFLEET_HOOK_PRECOMMIT || "",
         );
         taskCompleteRaw = await prompt.ask(
           "Task-complete command override",
-          process.env.CODEX_MONITOR_HOOK_TASK_COMPLETE || "",
+          process.env.OPENFLEET_HOOK_TASK_COMPLETE || "",
         );
 
         overwriteHooks = await prompt.confirm(

package/task-executor.mjs

@@ -97,7 +97,7 @@ const NO_COMMIT_MAX_COOLDOWN_MS = 2 * 60 * 60 * 1000;
 const CLAIM_CONFLICT_COMMENT_COOLDOWN_MS = 30 * 60 * 1000; // 30 minutes
 const CODEX_TASK_LABELS = (() => {
   const raw = String(
-    process.env.CODEX_MONITOR_TASK_LABELS || "openfleet,codex-mointor",
+    process.env.OPENFLEET_TASK_LABELS || "openfleet,codex-mointor",
   );
   const labels = raw
     .split(",")
@@ -1010,11 +1010,11 @@ class TaskExecutor {
     this._claimConflictNotifiedAt = new Map();
     this._instanceIdExplicit =
       String(process.env.VE_INSTANCE_ID || "").trim() !== "" ||
-      String(process.env.CODEX_MONITOR_INSTANCE_ID || "").trim() !== "";
+      String(process.env.OPENFLEET_INSTANCE_ID || "").trim() !== "";
     this._instanceId =
       String(
         process.env.VE_INSTANCE_ID ||
-          process.env.CODEX_MONITOR_INSTANCE_ID ||
+          process.env.OPENFLEET_INSTANCE_ID ||
           `${os.hostname() || "host"}-${process.pid}`,
       ).trim() || `executor-${process.pid}`;
     this.taskClaimOwnerStaleTtlMs = Math.max(

package/telegram-bot.mjs

@@ -2614,7 +2614,7 @@ async function clearWebAppMenuButton() {
   }
 }
 
-const MENU_BUTTON_REFRESH_MS = 5 * 60 * 1000; // 5 minutes
+const MENU_BUTTON_REFRESH_MS = 60 * 1000; // 1 minute — re-sync after tunnel URL rotates
 
 async function refreshMenuButton() {
   const { uiUrl: currentUiUrl, webAppUrl: currentUrl } = syncUiUrlsFromServer();

package/telegram-sentinel.mjs

@@ -1365,7 +1365,7 @@ async function startAndWaitForMonitor(reason) {
     {
       detached: true,
       stdio: "ignore",
-      env: { ...process.env, CODEX_MONITOR_DAEMON: "1" },
+      env: { ...process.env, OPENFLEET_DAEMON: "1" },
       cwd: repoRoot,
     },
   );

package/ui/modules/settings-schema.js

@@ -104,12 +104,12 @@ export const SETTINGS_SCHEMA = [
   // ── Kanban / Tasks ─────────────────────────────────────────
   { key: "KANBAN_BACKEND",                 label: "Kanban Backend",             category: "kanban", type: "select", defaultVal: "internal", options: ["internal", "vk", "github", "jira"], description: "Task management backend. 'internal' uses built-in store, 'github' syncs with GitHub Issues/Projects." },
   { key: "KANBAN_SYNC_POLICY",             label: "Sync Policy",                category: "kanban", type: "select", defaultVal: "internal-primary", options: ["internal-primary", "bidirectional"], description: "How tasks sync between internal store and external backend." },
-  { key: "CODEX_MONITOR_TASK_LABEL",       label: "Task Label",                 category: "kanban", type: "string", defaultVal: "openfleet", description: "GitHub label used to scope which issues are managed by Codex Monitor." },
-  { key: "CODEX_MONITOR_ENFORCE_TASK_LABEL", label: "Enforce Task Label",       category: "kanban", type: "boolean", defaultVal: true, description: "Only pick up issues that have the task label. Prevents processing unrelated issues." },
+  { key: "OPENFLEET_TASK_LABEL",       label: "Task Label",                 category: "kanban", type: "string", defaultVal: "openfleet", description: "GitHub label used to scope which issues are managed by Codex Monitor." },
+  { key: "OPENFLEET_ENFORCE_TASK_LABEL", label: "Enforce Task Label",       category: "kanban", type: "boolean", defaultVal: true, description: "Only pick up issues that have the task label. Prevents processing unrelated issues." },
   { key: "STALE_TASK_AGE_HOURS",           label: "Stale Task Age",             category: "kanban", type: "number", defaultVal: 3, min: 1, max: 168, unit: "hours", description: "Hours before an in-progress task with no activity is considered stale and eligible for recovery." },
   { key: "TASK_PLANNER_MODE",              label: "Task Planner Mode",          category: "kanban", type: "select", defaultVal: "kanban", options: ["kanban", "codex-sdk", "disabled"], description: "How the autonomous task planner operates. 'disabled' turns off automatic task generation." },
   { key: "TASK_PLANNER_DEDUP_HOURS",       label: "Planner Dedup Window",       category: "kanban", type: "number", defaultVal: 6, min: 1, max: 72, unit: "hours", description: "Hours to look back for duplicate task detection.", advanced: true },
-  { key: "CODEX_MONITOR_PROMPT_PLANNER",  label: "Planner Prompt Path",         category: "advanced", type: "string", description: "Override the task planner prompt file path.", advanced: true },
+  { key: "OPENFLEET_PROMPT_PLANNER",  label: "Planner Prompt Path",         category: "advanced", type: "string", description: "Override the task planner prompt file path.", advanced: true },
 
   // ── GitHub / Git ─────────────────────────────────────────
   { key: "GITHUB_TOKEN",                   label: "GitHub Token",               category: "github", type: "secret", sensitive: true, description: "Personal access token or fine-grained token for GitHub API. Required for GitHub kanban backend." },
@@ -157,7 +157,7 @@ export const SETTINGS_SCHEMA = [
   { key: "CONTAINER_CPU_LIMIT",            label: "CPU Limit",                  category: "security", type: "string", description: "Container CPU limit (e.g., '2', '1.5'). Leave empty for no limit.", validate: "^\\d+\\.?\\d*$" },
 
   // ── Sentinel / Reliability ─────────────────────────────────
-  { key: "CODEX_MONITOR_SENTINEL_AUTO_START", label: "Auto-Start Sentinel",     category: "sentinel", type: "boolean", defaultVal: false, description: "Automatically start the sentinel watchdog on boot." },
+  { key: "OPENFLEET_SENTINEL_AUTO_START", label: "Auto-Start Sentinel",     category: "sentinel", type: "boolean", defaultVal: false, description: "Automatically start the sentinel watchdog on boot." },
   { key: "SENTINEL_AUTO_RESTART_MONITOR",  label: "Auto-Restart on Crash",      category: "sentinel", type: "boolean", defaultVal: true, description: "Automatically restart the monitor process if it crashes." },
   { key: "SENTINEL_CRASH_LOOP_THRESHOLD",  label: "Crash Loop Threshold",       category: "sentinel", type: "number", defaultVal: 3, min: 2, max: 20, description: "Number of crashes within the window before declaring a crash loop." },
   { key: "SENTINEL_CRASH_LOOP_WINDOW_MIN", label: "Crash Loop Window",          category: "sentinel", type: "number", defaultVal: 10, min: 2, max: 60, unit: "min", description: "Rolling time window for crash loop detection." },
@@ -165,11 +165,11 @@ export const SETTINGS_SCHEMA = [
   { key: "SENTINEL_REPAIR_TIMEOUT_MIN",    label: "Repair Timeout",             category: "sentinel", type: "number", defaultVal: 20, min: 5, max: 120, unit: "min", description: "Maximum time the repair agent can run." },
 
   // ── Agent Hooks ────────────────────────────────────────────
-  { key: "CODEX_MONITOR_HOOK_PROFILE",     label: "Hook Profile",               category: "hooks", type: "select", defaultVal: "strict", options: ["strict", "balanced", "lightweight", "none"], description: "Pre-configured hook intensity. 'strict' runs all checks, 'none' disables hooks." },
-  { key: "CODEX_MONITOR_HOOK_TARGETS",     label: "Hook Targets",               category: "hooks", type: "string", defaultVal: "codex,claude,copilot", description: "Comma-separated list of agent SDKs to install hooks for.", validate: "^[a-z,]+$" },
-  { key: "CODEX_MONITOR_HOOKS_ENABLED",    label: "Enable Hooks",               category: "hooks", type: "boolean", defaultVal: true, description: "Enable agent lifecycle hook scaffolding." },
-  { key: "CODEX_MONITOR_HOOKS_OVERWRITE",  label: "Overwrite Existing",         category: "hooks", type: "boolean", defaultVal: false, description: "Overwrite existing hook files when installing. Use with caution." },
-  { key: "CODEX_MONITOR_HOOKS_BUILTINS_MODE", label: "Built-ins Mode",          category: "hooks", type: "select", defaultVal: "force", options: ["force", "auto", "off"], description: "How built-in hooks are managed. 'force' always installs, 'auto' only if missing." },
+  { key: "OPENFLEET_HOOK_PROFILE",     label: "Hook Profile",               category: "hooks", type: "select", defaultVal: "strict", options: ["strict", "balanced", "lightweight", "none"], description: "Pre-configured hook intensity. 'strict' runs all checks, 'none' disables hooks." },
+  { key: "OPENFLEET_HOOK_TARGETS",     label: "Hook Targets",               category: "hooks", type: "string", defaultVal: "codex,claude,copilot", description: "Comma-separated list of agent SDKs to install hooks for.", validate: "^[a-z,]+$" },
+  { key: "OPENFLEET_HOOKS_ENABLED",    label: "Enable Hooks",               category: "hooks", type: "boolean", defaultVal: true, description: "Enable agent lifecycle hook scaffolding." },
+  { key: "OPENFLEET_HOOKS_OVERWRITE",  label: "Overwrite Existing",         category: "hooks", type: "boolean", defaultVal: false, description: "Overwrite existing hook files when installing. Use with caution." },
+  { key: "OPENFLEET_HOOKS_BUILTINS_MODE", label: "Built-ins Mode",          category: "hooks", type: "select", defaultVal: "force", options: ["force", "auto", "off"], description: "How built-in hooks are managed. 'force' always installs, 'auto' only if missing." },
 
   // ── Logging / Monitoring ────────────────────────────────────
   { key: "AGENT_WORK_LOGGING_ENABLED",     label: "Work Logging",               category: "logging", type: "boolean", defaultVal: true, description: "Enable structured agent work logging with transcripts." },
@@ -213,7 +213,7 @@ export function getGroupedSettings(includeAdvanced = false) {
  */
 export function validateSetting(def, value) {
   if (value === "" || value == null) return { valid: true };
-  if (def.key === "CODEX_MONITOR_HOOK_TARGETS") {
+  if (def.key === "OPENFLEET_HOOK_TARGETS") {
     const targets = String(value || "")
       .split(",")
       .map((entry) => entry.trim().toLowerCase())

package/ui-server.mjs

@@ -75,8 +75,8 @@ let _configSchema = null;
 let _configValidator = null;
 
 function resolveConfigPath() {
-  return process.env.CODEX_MONITOR_CONFIG_PATH
-    ? resolve(process.env.CODEX_MONITOR_CONFIG_PATH)
+  return process.env.OPENFLEET_CONFIG_PATH
+    ? resolve(process.env.OPENFLEET_CONFIG_PATH)
     : resolve(__dirname, "openfleet.config.json");
 }
 
@@ -165,7 +165,7 @@ function coerceSettingValue(def, value, propSchema) {
       .split(",")
       .map((part) => part.trim())
       .filter(Boolean);
-    if (def?.key === "CODEX_MONITOR_HOOK_TARGETS") {
+    if (def?.key === "OPENFLEET_HOOK_TARGETS") {
       parts = parts.map((part) => part.toLowerCase());
       if (parts.includes("all")) {
         const allowed = Array.isArray(propSchema?.items?.enum)
@@ -213,7 +213,7 @@ function getSchemaProperty(schema, pathParts) {
 
 const ROOT_SKIP_ENV_KEYS = new Set([]);
 const ROOT_OVERRIDE_MAP = {
-  CODEX_MONITOR_MODE: "mode",
+  OPENFLEET_MODE: "mode",
   TASK_PLANNER_MODE: "plannerMode",
   EXECUTOR_DISTRIBUTION: "distribution",
 };
@@ -274,8 +274,8 @@ function mapEnvKeyToConfigPath(key, schema) {
     const sub = toCamelCaseFromEnv(rest);
     if (schema.properties.failover.properties[sub]) return buildConfigPath(["failover", sub]);
   }
-  if (envKey.startsWith("CODEX_MONITOR_PROMPT_") && schema.properties.agentPrompts?.properties) {
-    const rest = envKey.slice("CODEX_MONITOR_PROMPT_".length);
+  if (envKey.startsWith("OPENFLEET_PROMPT_") && schema.properties.agentPrompts?.properties) {
+    const rest = envKey.slice("OPENFLEET_PROMPT_".length);
     const sub = toCamelCaseFromEnv(rest);
     if (schema.properties.agentPrompts.properties[sub]) {
       return buildConfigPath(["agentPrompts", sub]);
@@ -293,10 +293,10 @@ function mapEnvKeyToConfigPath(key, schema) {
     }
   }
   const hookProfileMap = {
-    CODEX_MONITOR_HOOK_PROFILE: ["hookProfiles", "profile"],
-    CODEX_MONITOR_HOOK_TARGETS: ["hookProfiles", "targets"],
-    CODEX_MONITOR_HOOKS_ENABLED: ["hookProfiles", "enabled"],
-    CODEX_MONITOR_HOOKS_OVERWRITE: ["hookProfiles", "overwriteExisting"],
+    OPENFLEET_HOOK_PROFILE: ["hookProfiles", "profile"],
+    OPENFLEET_HOOK_TARGETS: ["hookProfiles", "targets"],
+    OPENFLEET_HOOKS_ENABLED: ["hookProfiles", "enabled"],
+    OPENFLEET_HOOKS_OVERWRITE: ["hookProfiles", "overwriteExisting"],
   };
   if (hookProfileMap[envKey]) {
     const pathParts = hookProfileMap[envKey];
@@ -470,10 +470,10 @@ const SETTINGS_KNOWN_KEYS = [
   "CODEX_MODEL_PROFILE_M_PROVIDER", "CODEX_MODEL_PROFILE_M_MODEL", "CODEX_MODEL_PROFILE_M_BASE_URL", "CODEX_MODEL_PROFILE_M_API_KEY",
   "CODEX_SUBAGENT_MODEL", "ANTHROPIC_API_KEY", "CLAUDE_MODEL",
   "COPILOT_MODEL", "COPILOT_CLI_TOKEN",
-  "KANBAN_BACKEND", "KANBAN_SYNC_POLICY", "CODEX_MONITOR_TASK_LABEL",
-  "CODEX_MONITOR_ENFORCE_TASK_LABEL", "STALE_TASK_AGE_HOURS",
+  "KANBAN_BACKEND", "KANBAN_SYNC_POLICY", "OPENFLEET_TASK_LABEL",
+  "OPENFLEET_ENFORCE_TASK_LABEL", "STALE_TASK_AGE_HOURS",
   "TASK_PLANNER_MODE", "TASK_PLANNER_DEDUP_HOURS",
-  "CODEX_MONITOR_PROMPT_PLANNER",
+  "OPENFLEET_PROMPT_PLANNER",
   "GITHUB_TOKEN", "GITHUB_REPOSITORY", "GITHUB_PROJECT_MODE",
   "GITHUB_PROJECT_NUMBER", "GITHUB_DEFAULT_ASSIGNEE", "GITHUB_AUTO_ASSIGN_CREATOR",
   "GITHUB_PROJECT_WEBHOOK_PATH", "GITHUB_PROJECT_WEBHOOK_SECRET", "GITHUB_PROJECT_WEBHOOK_REQUIRE_SIGNATURE",
@@ -488,12 +488,12 @@ const SETTINGS_KNOWN_KEYS = [
   "CODEX_SANDBOX", "CODEX_FEATURES_BWRAP", "CODEX_SANDBOX_PERMISSIONS", "CODEX_SANDBOX_WRITABLE_ROOTS",
   "CONTAINER_ENABLED", "CONTAINER_RUNTIME", "CONTAINER_IMAGE",
   "CONTAINER_TIMEOUT_MS", "MAX_CONCURRENT_CONTAINERS", "CONTAINER_MEMORY_LIMIT", "CONTAINER_CPU_LIMIT",
-  "CODEX_MONITOR_SENTINEL_AUTO_START", "SENTINEL_AUTO_RESTART_MONITOR",
+  "OPENFLEET_SENTINEL_AUTO_START", "SENTINEL_AUTO_RESTART_MONITOR",
   "SENTINEL_CRASH_LOOP_THRESHOLD", "SENTINEL_CRASH_LOOP_WINDOW_MIN",
   "SENTINEL_REPAIR_AGENT_ENABLED", "SENTINEL_REPAIR_TIMEOUT_MIN",
-  "CODEX_MONITOR_HOOK_PROFILE", "CODEX_MONITOR_HOOK_TARGETS",
-  "CODEX_MONITOR_HOOKS_ENABLED", "CODEX_MONITOR_HOOKS_OVERWRITE",
-  "CODEX_MONITOR_HOOKS_BUILTINS_MODE",
+  "OPENFLEET_HOOK_PROFILE", "OPENFLEET_HOOK_TARGETS",
+  "OPENFLEET_HOOKS_ENABLED", "OPENFLEET_HOOKS_OVERWRITE",
+  "OPENFLEET_HOOKS_BUILTINS_MODE",
   "AGENT_WORK_LOGGING_ENABLED", "AGENT_WORK_ANALYZER_ENABLED",
   "AGENT_SESSION_LOG_RETENTION", "AGENT_ERROR_LOOP_THRESHOLD",
   "AGENT_STUCK_THRESHOLD_MS", "LOG_MAX_SIZE_MB",

package/update-check.mjs

@@ -8,9 +8,9 @@
  *       auto-installs updates and restarts the process. Zero user interaction.
  *
  * Respects:
- *   - CODEX_MONITOR_SKIP_UPDATE_CHECK=1 — disable startup check
- *   - CODEX_MONITOR_SKIP_AUTO_UPDATE=1 — disable polling auto-update
- *   - CODEX_MONITOR_UPDATE_INTERVAL_MS — override poll interval (default 10 min)
+ *   - OPENFLEET_SKIP_UPDATE_CHECK=1 — disable startup check
+ *   - OPENFLEET_SKIP_AUTO_UPDATE=1 — disable polling auto-update
+ *   - OPENFLEET_UPDATE_INTERVAL_MS — override poll interval (default 10 min)
  *   - Caches the last check timestamp so we don't query npm too aggressively
  */
 
@@ -124,7 +124,7 @@ async function fetchLatestVersion() {
  * Called on startup — must never throw or delay the main process.
  */
 export async function checkForUpdate(currentVersion) {
-  if (process.env.CODEX_MONITOR_SKIP_UPDATE_CHECK) return;
+  if (process.env.OPENFLEET_SKIP_UPDATE_CHECK) return;
 
   try {
     // Rate-limit: at most once per hour
@@ -240,13 +240,13 @@ let cleanupHandlersRegistered = false;
  * @param {number}   [opts.parentPid]  - Parent process PID to monitor (default: process.ppid)
  */
 export function startAutoUpdateLoop(opts = {}) {
-  if (process.env.CODEX_MONITOR_SKIP_AUTO_UPDATE === "1") {
-    console.log("[auto-update] Disabled via CODEX_MONITOR_SKIP_AUTO_UPDATE=1");
+  if (process.env.OPENFLEET_SKIP_AUTO_UPDATE === "1") {
+    console.log("[auto-update] Disabled via OPENFLEET_SKIP_AUTO_UPDATE=1");
     return;
   }
 
   const intervalMs =
-    Number(process.env.CODEX_MONITOR_UPDATE_INTERVAL_MS) ||
+    Number(process.env.OPENFLEET_UPDATE_INTERVAL_MS) ||
     opts.intervalMs ||
     AUTO_UPDATE_INTERVAL_MS;
   const onRestart = opts.onRestart || (() => process.exit(0));

package/ve-orchestrator.ps1

@@ -969,7 +969,7 @@ function Initialize-CISweepConfig {
     $script:CopilotCloudDisableOnRateLimit = Get-EnvBool -Name "COPILOT_CLOUD_DISABLE_ON_RATE_LIMIT" -Default $true
     $envCopilotLocalResolution = Get-EnvFallback -Name "COPILOT_LOCAL_RESOLUTION"
     $script:CopilotLocalResolution = if ($envCopilotLocalResolution) { $envCopilotLocalResolution } else { "agent" }
-    $script:CodexMonitorTaskUpstream = Get-EnvString -Name "CODEX_MONITOR_TASK_UPSTREAM" -Default "origin/ve/openfleet-generic"
+    $script:CodexMonitorTaskUpstream = Get-EnvString -Name "OPENFLEET_TASK_UPSTREAM" -Default "origin/ve/openfleet-generic"
 
     # Branch routing scope map (v0.8) — maps conventional commit scopes to upstream branches
     $script:BranchRoutingScopeMap = @{}

package/worktree-manager.mjs

@@ -177,7 +177,7 @@ function detectGitTopLevel(candidatePath) {
  * Resolve the best repository root for singleton initialization.
  * Priority:
  *   1) explicit repoRoot arg
- *   2) VE_REPO_ROOT / CODEX_MONITOR_REPO_ROOT env
+ *   2) VE_REPO_ROOT / OPENFLEET_REPO_ROOT env
  *   3) current working directory's git top-level
  *   4) module-relative git top-level (useful for local dev)
  *   5) process.cwd() fallback
@@ -189,7 +189,7 @@ function resolveDefaultRepoRoot(repoRoot) {
   if (repoRoot) return resolve(repoRoot);
 
   const envRoot =
-    process.env.VE_REPO_ROOT || process.env.CODEX_MONITOR_REPO_ROOT || "";
+    process.env.VE_REPO_ROOT || process.env.OPENFLEET_REPO_ROOT || "";
   const fromEnv = detectGitTopLevel(envRoot) || (envRoot ? resolve(envRoot) : null);
   if (fromEnv) return fromEnv;