@virtengine/openfleet 0.26.2 → 0.26.3

package/.env.example

@@ -1,4 +1,4 @@
-# ─── Codex Monitor — Environment Configuration ───────────────────────────────
+# ─── OpenFleet — Environment Configuration ───────────────────────────────
 # Copy this file to .env and fill in your values.
 # Or run: openfleet --setup
 # All variables are optional unless marked [REQUIRED].
@@ -788,7 +788,7 @@ COPILOT_CLOUD_DISABLED=true
 
 # ─── Git Identity (optional) ─────────────────────────────────────────────────
 # Override git author for automated commits
-# VE_GIT_AUTHOR_NAME=Codex Monitor
+# VE_GIT_AUTHOR_NAME=OpenFleet
 # VE_GIT_AUTHOR_EMAIL=bot@yoursite.com
 
 # ─── Task Planner ─────────────────────────────────────────────────────────────

package/cli.mjs

@@ -27,6 +27,11 @@ import { fileURLToPath } from "node:url";
 import { fork, spawn } from "node:child_process";
 import os from "node:os";
 import { createDaemonCrashTracker } from "./daemon-restart-policy.mjs";
+import {
+  applyAllCompatibility,
+  detectLegacySetup,
+  migrateFromLegacy,
+} from "./compat.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
@@ -381,7 +386,8 @@ function startDaemon() {
       stdio: "ignore",
       windowsHide: process.platform === "win32",
       env: { ...process.env, OPENFLEET_DAEMON: "1" },
-      cwd: process.cwd(),
+      // Use home dir so spawn never inherits a deleted CWD (e.g. old git worktree)
+      cwd: os.homedir(),
     },
   );
 
@@ -456,6 +462,9 @@ function daemonStatus() {
 }
 
 async function main() {
+  // Apply legacy CODEX_MONITOR_* → OPENFLEET_* env aliases before any config ops
+  applyAllCompatibility();
+
   // Handle --help
   if (args.includes("--help") || args.includes("-h")) {
     showHelp();
@@ -689,6 +698,23 @@ async function main() {
     console.log("\n  Setup complete! Starting openfleet...\n");
   }
 
+  // Legacy migration: if ~/codex-monitor exists with config, auto-migrate to ~/openfleet
+  const legacyInfo = detectLegacySetup();
+  if (legacyInfo.hasLegacy && !legacyInfo.alreadyMigrated) {
+    console.log(
+      `\n  📦 Detected legacy codex-monitor config at ${legacyInfo.legacyDir}`,
+    );
+    console.log(`     Auto-migrating to ${legacyInfo.newDir}...\n`);
+    const result = migrateFromLegacy(legacyInfo.legacyDir, legacyInfo.newDir);
+    if (result.migrated.length > 0) {
+      console.log(`  ✅  Migrated: ${result.migrated.join(", ")}`);
+      console.log(`\n  Config is now at ${legacyInfo.newDir}\n`);
+    }
+    for (const err of result.errors) {
+      console.log(`  ⚠️   Migration warning: ${err}`);
+    }
+  }
+
   // ── 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
@@ -731,24 +757,40 @@ async function main() {
               `\n  Tailing logs for active openfleet (PID ${monitorPid}):\n  ${logFile}\n`,
             );
             await new Promise((res) => {
+              // Spawn tail in its own process group (detached) so that
+              // Ctrl+C in this terminal only kills the tailing session,
+              // never the running daemon.
               const tail = spawn("tail", ["-f", "-n", "200", logFile], {
-                stdio: "inherit",
+                stdio: ["ignore", "inherit", "inherit"],
+                detached: true,
               });
               tail.on("exit", res);
               process.on("SIGINT", () => {
-                tail.kill();
+                try { process.kill(-tail.pid, "SIGTERM"); } catch { tail.kill(); }
                 res();
               });
             });
             process.exit(0);
+          } else {
+            console.error(
+              `\n  No log file found for active openfleet (PID ${monitorPid}).\n  Expected: ${logFile}\n`,
+            );
+            process.exit(1);
           }
         }
-      } catch {
-        // best-effort — fall through to normal start
+      } catch (e) {
+        console.error(`\n  --echo-logs: failed to read PID file — ${e.message}\n`);
+        process.exit(1);
       }
+    } else {
+      console.error(
+        "\n  --echo-logs: no active openfleet found (PID file missing).\n  Start openfleet first with: openfleet --daemon\n",
+      );
+      process.exit(1);
     }
 
-    // No active monitor found — start normally; echoLogs will be picked up by config.mjs
+    // Should not reach here — all paths above exit
+    process.exit(0);
   }
 
   // Fork monitor as a child process — enables self-restart on source changes.

package/compat.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * compat.mjs — Backward compatibility for users migrating from codex-monitor
+ *
+ * Handles:
+ *   1. Legacy env var aliasing: CODEX_MONITOR_X → OPENFLEET_X
+ *   2. Legacy config dir detection: ~/codex-monitor or $CODEX_MONITOR_DIR
+ *   3. Migration: copy old config dir to new openfleet dir
+ *
+ * This module is intentionally dependency-free (only Node built-ins) and
+ * should be imported as early as possible in the startup path.
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+// ── Legacy config file names accepted from old codex-monitor installations ───
+const LEGACY_CONFIG_NAMES = [
+  "codex-monitor.config.json",
+  "openfleet.config.json",
+  ".openfleet.json",
+  "openfleet.json",
+  ".env",
+];
+
+/**
+ * Env vars the old codex-monitor package used that have been renamed.
+ * Format: [oldName, newName]
+ * Rule: any CODEX_MONITOR_X maps to OPENFLEET_X by default, but some had
+ * different names entirely — those are listed explicitly below.
+ */
+const EXPLICIT_ALIASES = [
+  // Dir / location
+  ["CODEX_MONITOR_DIR",                      "OPENFLEET_DIR"],
+  ["CODEX_MONITOR_HOME",                     "OPENFLEET_HOME"],
+  // Runtime flags
+  ["CODEX_MONITOR_SKIP_AUTO_UPDATE",         "OPENFLEET_SKIP_AUTO_UPDATE"],
+  ["CODEX_MONITOR_SKIP_UPDATE_CHECK",        "OPENFLEET_SKIP_UPDATE_CHECK"],
+  ["CODEX_MONITOR_UPDATE_INTERVAL_MS",       "OPENFLEET_UPDATE_INTERVAL_MS"],
+  ["CODEX_MONITOR_SKIP_POSTINSTALL",         "OPENFLEET_SKIP_POSTINSTALL"],
+  ["CODEX_MONITOR_INTERACTIVE",              "OPENFLEET_INTERACTIVE"],
+  ["CODEX_MONITOR_PREFLIGHT_DISABLED",       "OPENFLEET_PREFLIGHT_DISABLED"],
+  ["CODEX_MONITOR_PREFLIGHT_RETRY_MS",       "OPENFLEET_PREFLIGHT_RETRY_MS"],
+  ["CODEX_MONITOR_MIN_FREE_GB",              "OPENFLEET_MIN_FREE_GB"],
+  ["CODEX_MONITOR_INSTANCE_ID",              "OPENFLEET_INSTANCE_ID"],
+  ["CODEX_MONITOR_MODE",                     "OPENFLEET_MODE"],
+  ["CODEX_MONITOR_SHELL",                    "OPENFLEET_SHELL"],
+  ["CODEX_MONITOR_SHELL_MODE",               "OPENFLEET_SHELL_MODE"],
+  ["CODEX_MONITOR_PROFILE",                  "OPENFLEET_PROFILE"],
+  ["CODEX_MONITOR_ENV_PROFILE",              "OPENFLEET_ENV_PROFILE"],
+  // Task
+  ["CODEX_MONITOR_TASK_LABEL",               "OPENFLEET_TASK_LABEL"],
+  ["CODEX_MONITOR_TASK_LABELS",              "OPENFLEET_TASK_LABELS"],
+  ["CODEX_MONITOR_ENFORCE_TASK_LABEL",       "OPENFLEET_ENFORCE_TASK_LABEL"],
+  ["CODEX_MONITOR_TASK_UPSTREAM",            "OPENFLEET_TASK_UPSTREAM"],
+  // Daemon
+  ["CODEX_MONITOR_DAEMON",                   "OPENFLEET_DAEMON"],
+  ["CODEX_MONITOR_DAEMON_RESTART_DELAY_MS",  "OPENFLEET_DAEMON_RESTART_DELAY_MS"],
+  ["CODEX_MONITOR_DAEMON_MAX_RESTARTS",      "OPENFLEET_DAEMON_MAX_RESTARTS"],
+  ["CODEX_MONITOR_DAEMON_INSTANT_CRASH_WINDOW_MS", "OPENFLEET_DAEMON_INSTANT_CRASH_WINDOW_MS"],
+  ["CODEX_MONITOR_DAEMON_MAX_INSTANT_RESTARTS",    "OPENFLEET_DAEMON_MAX_INSTANT_RESTARTS"],
+  // Hooks
+  ["CODEX_MONITOR_HOOK_PROFILE",             "OPENFLEET_HOOK_PROFILE"],
+  ["CODEX_MONITOR_HOOK_TARGETS",             "OPENFLEET_HOOK_TARGETS"],
+  ["CODEX_MONITOR_HOOKS_ENABLED",            "OPENFLEET_HOOKS_ENABLED"],
+  ["CODEX_MONITOR_HOOKS_OVERWRITE",          "OPENFLEET_HOOKS_OVERWRITE"],
+  ["CODEX_MONITOR_HOOK_NODE_BIN",            "OPENFLEET_HOOK_NODE_BIN"],
+  ["CODEX_MONITOR_HOOK_BRIDGE_PATH",         "OPENFLEET_HOOK_BRIDGE_PATH"],
+  ["CODEX_MONITOR_HOOK_PREPUSH",             "OPENFLEET_HOOK_PREPUSH"],
+  ["CODEX_MONITOR_HOOK_PRECOMMIT",           "OPENFLEET_HOOK_PRECOMMIT"],
+  ["CODEX_MONITOR_HOOK_TASK_COMPLETE",       "OPENFLEET_HOOK_TASK_COMPLETE"],
+  ["CODEX_MONITOR_HOOKS_BUILTINS_MODE",      "OPENFLEET_HOOKS_BUILTINS_MODE"],
+  ["CODEX_MONITOR_HOOKS_FORCE",              "OPENFLEET_HOOKS_FORCE"],
+  // Sentinel
+  ["CODEX_MONITOR_SENTINEL_AUTO_START",      "OPENFLEET_SENTINEL_AUTO_START"],
+  ["CODEX_MONITOR_SENTINEL_STRICT",          "OPENFLEET_SENTINEL_STRICT"],
+  // Prompts
+  ["CODEX_MONITOR_PROMPT_WORKSPACE",         "OPENFLEET_PROMPT_WORKSPACE"],
+  // Repo
+  ["CODEX_MONITOR_REPO",                     "OPENFLEET_REPO"],
+  ["CODEX_MONITOR_REPO_NAME",                "OPENFLEET_REPO_NAME"],
+  ["CODEX_MONITOR_REPO_ROOT",                "OPENFLEET_REPO_ROOT"],
+  // Config path
+  ["CODEX_MONITOR_CONFIG_PATH",              "OPENFLEET_CONFIG_PATH"],
+];
+
+/**
+ * Apply all legacy CODEX_MONITOR_* → OPENFLEET_* env var aliases.
+ * Also does a generic pass: any remaining CODEX_MONITOR_X that wasn't in the
+ * explicit list is aliased to OPENFLEET_X.
+ *
+ * Existing OPENFLEET_* values are never overwritten (OPENFLEET_ wins).
+ * Safe to call multiple times (idempotent).
+ */
+export function applyLegacyEnvAliases() {
+  // Explicit known renames
+  for (const [oldKey, newKey] of EXPLICIT_ALIASES) {
+    if (process.env[oldKey] !== undefined && process.env[newKey] === undefined) {
+      process.env[newKey] = process.env[oldKey];
+    }
+  }
+
+  // Generic pass: CODEX_MONITOR_X → OPENFLEET_X for anything not already mapped
+  for (const key of Object.keys(process.env)) {
+    if (!key.startsWith("CODEX_MONITOR_")) continue;
+    const suffix = key.slice("CODEX_MONITOR_".length);
+    const newKey = `OPENFLEET_${suffix}`;
+    if (process.env[newKey] === undefined) {
+      process.env[newKey] = process.env[key];
+    }
+  }
+}
+
+/**
+ * Returns the legacy codex-monitor config directory if it exists and
+ * contains config files, null otherwise.
+ *
+ * Checks in priority order:
+ *   1. $CODEX_MONITOR_DIR env var
+ *   2. ~/codex-monitor
+ *   3. ~/.codex-monitor
+ *   4. ~/.config/codex-monitor
+ */
+export function getLegacyConfigDir() {
+  const home =
+    process.env.HOME ||
+    process.env.USERPROFILE ||
+    process.env.APPDATA ||
+    null;
+
+  const candidates = [
+    process.env.CODEX_MONITOR_DIR || null,
+    home ? join(home, "codex-monitor") : null,
+    home ? join(home, ".codex-monitor") : null,
+    home ? join(home, ".config", "codex-monitor") : null,
+  ].filter(Boolean);
+
+  for (const dir of candidates) {
+    if (existsSync(dir) && hasLegacyMarkers(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+
+function hasLegacyMarkers(dir) {
+  return LEGACY_CONFIG_NAMES.some((name) => existsSync(join(dir, name)));
+}
+
+/**
+ * Returns the target openfleet config directory (where we'd migrate to).
+ * Does NOT create the directory.
+ */
+export function getNewConfigDir() {
+  const home =
+    process.env.HOME ||
+    process.env.USERPROFILE ||
+    process.env.APPDATA ||
+    process.cwd();
+
+  return (
+    process.env.OPENFLEET_DIR ||
+    join(home, "openfleet")
+  );
+}
+
+/**
+ * Detect if the user has a legacy codex-monitor setup but no openfleet setup.
+ * Returns { hasLegacy, legacyDir, newDir, alreadyMigrated }
+ */
+export function detectLegacySetup() {
+  const legacyDir = getLegacyConfigDir();
+  const newDir = getNewConfigDir();
+  const newHasConfig = hasLegacyMarkers(newDir);
+
+  return {
+    hasLegacy: legacyDir !== null,
+    legacyDir,
+    newDir,
+    alreadyMigrated: newHasConfig,
+  };
+}
+
+/**
+ * Migrate config files from old codex-monitor dir to new openfleet dir.
+ * Only copies; never deletes the old directory.
+ *
+ * Files copied:
+ *   .env                            → .env  (with CODEX_MONITOR_ → OPENFLEET_ substitution)
+ *   openfleet.config.json           → openfleet.config.json
+ *   codex-monitor.config.json       → openfleet.config.json  (rename)
+ *   .openfleet.json / openfleet.json → as-is
+ *
+ * Returns { migrated: string[], skipped: string[], errors: string[] }
+ */
+export function migrateFromLegacy(legacyDir, newDir, { overwrite = false } = {}) {
+  const result = { migrated: [], skipped: [], errors: [] };
+
+  try {
+    mkdirSync(newDir, { recursive: true });
+  } catch (e) {
+    result.errors.push(`Could not create ${newDir}: ${e.message}`);
+    return result;
+  }
+
+  // Files to migrate: [source name, dest name]
+  const filePairs = [
+    [".env",                     ".env"],
+    ["openfleet.config.json",    "openfleet.config.json"],
+    ["codex-monitor.config.json","openfleet.config.json"],
+    [".openfleet.json",          ".openfleet.json"],
+    ["openfleet.json",           "openfleet.json"],
+  ];
+
+  for (const [srcName, destName] of filePairs) {
+    const src = join(legacyDir, srcName);
+    const dest = join(newDir, destName);
+
+    if (!existsSync(src)) continue;
+    if (existsSync(dest) && !overwrite) {
+      result.skipped.push(destName);
+      continue;
+    }
+
+    try {
+      if (srcName === ".env") {
+        // Rewrite CODEX_MONITOR_ prefixes to OPENFLEET_ in .env content
+        const content = readFileSync(src, "utf8");
+        const updated = rewriteEnvContent(content);
+        writeFileSync(dest, updated, "utf8");
+      } else {
+        copyFileSync(src, dest);
+      }
+      result.migrated.push(destName);
+    } catch (e) {
+      result.errors.push(`${destName}: ${e.message}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Rewrite .env file content: replace CODEX_MONITOR_X= with OPENFLEET_X=
+ * while preserving comments and blank lines.
+ */
+function rewriteEnvContent(content) {
+  return content
+    .split("\n")
+    .map((line) => {
+      // Match both active vars and commented-out vars
+      return line.replace(/^(#?\s*)CODEX_MONITOR_/, "$1OPENFLEET_");
+    })
+    .join("\n");
+}
+
+/**
+ * If OPENFLEET_DIR is not set but CODEX_MONITOR_DIR is (or legacy dir exists),
+ * transparently set OPENFLEET_DIR to point at the legacy dir so openfleet reads
+ * from it without requiring a migration step.
+ *
+ * This is the "zero-friction" path: existing users just upgrade the package and
+ * it works. Migration is optional (improves going forward).
+ */
+export function autoApplyLegacyDir() {
+  // Already set — nothing to do
+  if (process.env.OPENFLEET_DIR) return false;
+
+  const legacyDir = getLegacyConfigDir();
+  if (!legacyDir) return false;
+
+  process.env.OPENFLEET_DIR = legacyDir;
+  console.log(
+    `[compat] Legacy codex-monitor config detected at ${legacyDir} — using it as OPENFLEET_DIR.`,
+  );
+  return true;
+}
+
+/**
+ * Run full compatibility setup: alias env vars + auto-apply legacy dir.
+ * Call this before loadConfig().
+ */
+export function applyAllCompatibility() {
+  applyLegacyEnvAliases();
+  autoApplyLegacyDir();
+}

package/config.mjs

@@ -23,6 +23,7 @@ import {
   getAgentPromptDefinitions,
   resolveAgentPrompts,
 } from "./agent-prompts.mjs";
+import { applyAllCompatibility } from "./compat.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -719,6 +720,9 @@ function loadAgentPrompts(configDir, repoRoot, configData) {
  * Returns a frozen config object used by all modules.
  */
 export function loadConfig(argv = process.argv, options = {}) {
+  // Apply legacy CODEX_MONITOR_* → OPENFLEET_* compatibility before anything else
+  applyAllCompatibility();
+
   const { reloadEnv = false } = options;
   const cli = parseArgs(argv);
 

package/kanban-adapter.mjs

@@ -2581,7 +2581,7 @@ class GitHubIssuesAdapter {
       const commentBody = `<!-- openfleet-state
 ${stateJson}
 -->
-**Codex Monitor Status**: Agent \`${agentId}\` on \`${workstationId}\` is ${normalizedState.status === "working" ? "working on" : normalizedState.status === "claimed" ? "claiming" : "stale for"} this task.
+**OpenFleet Status**: Agent \`${agentId}\` on \`${workstationId}\` is ${normalizedState.status === "working" ? "working on" : normalizedState.status === "claimed" ? "claiming" : "stale for"} this task.
 *Last heartbeat: ${normalizedState.heartbeat || normalizedState.ownerHeartbeat}*`;
 
       if (stateCommentIndex >= 0) {
@@ -2709,7 +2709,7 @@ ${stateJson}
       );
 
       // Add comment explaining why
-      const commentBody = `**Codex Monitor**: This task has been marked as ignored.
+      const commentBody = `**OpenFleet**: This task has been marked as ignored.
 
 **Reason**: ${reason}
 
@@ -3581,7 +3581,7 @@ class JiraAdapter {
     const json = JSON.stringify(normalized, null, 2);
     return (
       `<!-- openfleet-state\n${json}\n-->\n` +
-      `Codex Monitor Status: Agent ${agentId} on ${workstationId} is ${normalized?.status} this task.\n` +
+      `OpenFleet Status: Agent ${agentId} on ${workstationId} is ${normalized?.status} this task.\n` +
       `Last heartbeat: ${normalized?.heartbeat || normalized?.ownerHeartbeat || ""}`
     );
   }
@@ -4245,7 +4245,7 @@ class JiraAdapter {
    *       {
    *         "type": "paragraph",
    *         "content": [
-   *           {"type": "text", "text": "Codex Monitor: Task marked as ignored."}
+   *           {"type": "text", "text": "OpenFleet: Task marked as ignored."}
    *         ]
    *       }
    *     ]
@@ -4294,7 +4294,7 @@ class JiraAdapter {
         });
       }
       const commentBody =
-        `Codex Monitor: This task has been marked as ignored.\n\n` +
+        `OpenFleet: This task has been marked as ignored.\n\n` +
         `Reason: ${ignoreReason}\n\n` +
         `To re-enable openfleet for this task, remove the ${this._codexLabels.ignore} label.`;
       await this.addComment(key, commentBody);

package/monitor.mjs

@@ -46,6 +46,8 @@ import {
   getDigestSnapshot,
   startStatusFileWriter,
   stopStatusFileWriter,
+  initStatusBoard,
+  pushStatusBoardUpdate,
 } from "./telegram-bot.mjs";
 import { PRCleanupDaemon } from "./pr-cleanup-daemon.mjs";
 import {
@@ -1739,6 +1741,11 @@ function notifyVkError(line) {
   if (!isVkBackendActive()) {
     return;
   }
+  // If the user explicitly disabled VK spawning they know VK isn't running —
+  // spamming "unreachable" every 10 minutes is pure noise.
+  if (!vkSpawnEnabled) {
+    return;
+  }
   const key = "vibe-kanban-unavailable";
   const now = Date.now();
   const last = vkErrorNotified.get(key) || 0;
@@ -3401,6 +3408,14 @@ async function fetchTasksByStatus(status) {
   const backend = getActiveKanbanBackend();
   if (backend !== "vk") {
     try {
+      // Internal backend uses file-based storage — no project ID required.
+      if (backend === "internal") {
+        const tasks = status
+          ? getInternalTasksByStatus(status)
+          : getAllInternalTasks();
+        return Array.isArray(tasks) ? tasks : [];
+      }
+
       const projectId = getConfiguredKanbanProjectId(backend);
       if (!projectId) {
         console.warn(
@@ -7796,6 +7811,10 @@ async function sendTelegramMessage(text, options = {}) {
     }
   }
 
+  // Allow caller to explicitly override the computed priority (e.g. auto-update
+  // restart notifications should always arrive as direct messages, not digest).
+  if (options.priority !== undefined) priority = Number(options.priority);
+
   // Route through batching system — apply verbosity filter first.
   // minimal: only priority 1-2 (critical + error)
   // summary: priority 1-4 (everything except debug) — DEFAULT
@@ -8278,10 +8297,17 @@ async function startTelegramNotifier() {
   const sendUpdate = async () => {
     const summary = await readStatusSummary();
     if (summary && summary.text) {
-      await sendTelegramMessage(summary.text, {
+      // Push to the pinned status board (edits in-place) when available.
+      // Fall back to a regular new message only if the board hasn't been set up.
+      const routed = pushStatusBoardUpdate(summary.text, {
         parseMode: summary.parseMode,
-        disablePreview: true,
       });
+      if (!routed) {
+        await sendTelegramMessage(summary.text, {
+          parseMode: summary.parseMode,
+          disablePreview: true,
+        });
+      }
     }
     await flushMergeNotifications();
     await checkStatusMilestones();
@@ -11466,7 +11492,9 @@ startAutoUpdateLoop({
   onRestart: (reason) => restartSelf(reason),
   onNotify: (msg) => {
     try {
-      void sendTelegramMessage(msg);
+      // Priority 1 (critical) bypasses the live digest so the user gets a
+      // direct push notification for update-detected and restarting events.
+      void sendTelegramMessage(msg, { priority: 1, skipDedup: true });
     } catch {
       /* best-effort */
     }
@@ -12019,9 +12047,11 @@ if (telegramCommandEnabled) {
 // Restore live digest state BEFORE any messages flow — so restarts continue the
 // existing digest message instead of creating a new one.
 // Chain notifier start after restore to prevent race conditions.
+// Also initialise the pinned status board (creates/restores the persistent message).
 void restoreLiveDigest()
   .catch(() => {})
-  .then(() => startTelegramNotifier());
+  .then(() => startTelegramNotifier())
+  .then(() => initStatusBoard().catch(() => {}));
 
 // ── Start long-running devmode monitor-monitor supervisor ───────────────────
 startMonitorMonitorSupervisor();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virtengine/openfleet",
-  "version": "0.26.2",
+  "version": "0.26.3",
   "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",
@@ -62,7 +62,8 @@
     "./startup-service": "./startup-service.mjs",
     "./telegram-sentinel": "./telegram-sentinel.mjs",
     "./whatsapp-channel": "./whatsapp-channel.mjs",
-    "./container-runner": "./container-runner.mjs"
+    "./container-runner": "./container-runner.mjs",
+    "./compat": "./compat.mjs"
   },
   "bin": {
     "openfleet": "cli.mjs",
@@ -110,6 +111,7 @@
     "autofix.mjs",
     "claude-shell.mjs",
     "cli.mjs",
+    "compat.mjs",
     "codex-config.mjs",
     "openfleet.config.example.json",
     "openfleet.schema.json",

package/presence.mjs

@@ -286,7 +286,7 @@ export function formatPresenceSummary({ nowMs, ttlMs } = {}) {
     return "No active instances reported.";
   }
   const coordinator = selectCoordinator({ nowMs, ttlMs });
-  const lines = ["🛰️ Codex Monitor Presence"];
+  const lines = ["🛰️ OpenFleet Presence"];
   for (const entry of active) {
     const name = entry.instance_label || entry.instance_id;
     const role = entry.workspace_role || "workspace";

package/publish.mjs

@@ -225,9 +225,9 @@ function main() {
     if (status === 0 && !dryRun) {
       console.log(
         "\n[publish] REMINDER: deprecate the legacy npm package to redirect users:\n" +
-        "  npm deprecate codex-monitor@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n" +
+        "  npm deprecate openfleet@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n" +
         "  # If a scoped legacy package exists:\n" +
-        "  npm deprecate @virtengine/codex-monitor@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n",
+        "  npm deprecate @virtengine/openfleet@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n",
       );
     }
     process.exit(status);

package/setup.mjs

@@ -44,6 +44,7 @@ import {
   normalizeHookTargets,
   scaffoldAgentHookFiles,
 } from "./hook-profiles.mjs";
+import { detectLegacySetup, applyAllCompatibility } from "./compat.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -3904,6 +3905,14 @@ async function writeConfigFiles({ env, configJson, repoRoot, configDir }) {
  * Called from monitor.mjs before starting the main loop.
  */
 export function shouldRunSetup() {
+  // Apply legacy compat so OPENFLEET_DIR is set before resolveConfigDir is called
+  applyAllCompatibility();
+
+  // If a legacy codex-monitor setup exists and the user hasn't migrated yet,
+  // skip the setup wizard — they are already configured.
+  const legacyInfo = detectLegacySetup();
+  if (legacyInfo.hasLegacy) return false;
+
   const repoRoot = detectRepoRoot();
   const configDir = resolveConfigDir(repoRoot);
   return !hasSetupMarkers(configDir);

package/shared-state-manager.mjs

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Shared State Manager for Codex Monitor Task Coordination
+ * @fileoverview Shared State Manager for OpenFleet Task Coordination
  *
  * Manages distributed task execution state across multiple agents and workstations.
  * Provides atomic operations for claiming, updating, and releasing task ownership

package/startup-service.mjs

@@ -32,7 +32,7 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const SERVICE_LABEL = "com.openfleet.service";
-const TASK_NAME = "CodexMonitor";
+const TASK_NAME = "OpenFleet";
 const SYSTEMD_UNIT = "openfleet.service";
 
 // ── Platform Detection ───────────────────────────────────────────────────────
@@ -121,7 +121,7 @@ function generateTaskSchedulerXml({ daemon = true } = {}) {
 <Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <RegistrationInfo>
     <Description>Auto-start openfleet AI orchestrator on login</Description>
-    <Author>Codex Monitor</Author>
+    <Author>OpenFleet</Author>
     <URI>\\${TASK_NAME}</URI>
   </RegistrationInfo>
   <Triggers>