@intent-systems/nexus 2026.1.5-3

package/dist/cli/upstream-sync-cli.js

@@ -0,0 +1,2833 @@
+#!/usr/bin/env node
+/**
+ * Upstream Sync CLI
+ *
+ * Tracks upstream merge commits and dispatches Codex agents to port them to nexus.
+ *
+ * Usage:
+ *   npx tsx src/cli/upstream-sync-cli.ts [command]
+ *
+ * Commands:
+ *   (default)     - Full sync: fetch, dispatch agents, show status
+ *   status        - Just show current status
+ *   merge <pr>    - Merge a pending_review PR into main
+ *   ignore <pr>   - Mark a PR as ignored
+ *   retry <pr>    - Re-dispatch agent for a PR
+ *   show <pr>     - Show diff for a PR
+ *   pause         - Disable new agent dispatch
+ *   resume        - Re-enable agent dispatch
+ *   bundle-split  - Split a bundle into smaller ones
+ *   bundle-requeue - Reset a bundle for re-dispatch
+ *   bundle-dispatch-oldest - Dispatch oldest pending bundles
+ */
+import { execSync, spawn } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, openSync, closeSync, statSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, "../..");
+const STATE_FILE = join(PROJECT_ROOT, ".upstream-sync/state.json");
+const TMUX_SOCKET = "/tmp/upstream-sync.sock";
+const RUNS_DIR = join(PROJECT_ROOT, ".upstream-sync/runs");
+// ============================================================================
+// State Management
+// ============================================================================
+function loadState() {
+    if (!existsSync(STATE_FILE)) {
+        throw new Error(`State file not found: ${STATE_FILE}`);
+    }
+    return JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+}
+function saveState(state) {
+    const dir = dirname(STATE_FILE);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+// ============================================================================
+// Commit Bundling
+// ============================================================================
+// Normalize type to lowercase and map legacy module names to proper types
+function normalizeType(type) {
+    const lower = type.toLowerCase();
+    // Map legacy module names to appropriate types
+    const typeMap = {
+        // These are module names, not commit types - treat as misc changes
+        agents: "chore",
+        auth: "chore",
+        browser: "chore",
+        changelog: "docs",
+        config: "chore",
+        cron: "chore",
+        deps: "chore",
+        discord: "chore",
+        models: "chore",
+        slack: "chore",
+        telegram: "chore",
+        thinking: "chore",
+        tui: "chore",
+        typing: "chore",
+        wizard: "chore",
+        // Plural forms
+        chores: "chore",
+        tests: "test",
+    };
+    return typeMap[lower] || lower;
+}
+// Parse conventional commit format: type(scope)!: description
+function parseConventionalCommit(title) {
+    const match = title.match(/^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/);
+    if (match) {
+        return {
+            type: normalizeType(match[1]),
+            scope: match[2],
+            breaking: match[3] === "!",
+            description: match[4],
+        };
+    }
+    return { type: "other", breaking: false, description: title };
+}
+// Get priority for a commit type (higher = more important)
+function getTypePriority(type, breaking) {
+    if (breaking)
+        return 100; // Breaking changes are highest priority
+    const normalized = normalizeType(type);
+    switch (normalized) {
+        case "feat":
+            return 80;
+        case "fix":
+            return 60;
+        case "perf":
+            return 50;
+        case "refactor":
+            return 40;
+        case "style":
+            return 20;
+        case "docs":
+            return 15;
+        case "test":
+            return 10;
+        case "chore":
+            return 5;
+        case "ci":
+            return 3;
+        default:
+            return 30;
+    }
+}
+// Group direct commits into bundles
+function bundleDirectCommits(state) {
+    const directCommits = Object.entries(state.merges)
+        .filter(([_, e]) => e.isDirectCommit && e.status === "new" && !e.bundleId)
+        .map(([sha, e]) => ({ sha, entry: e, parsed: parseConventionalCommit(e.title) }));
+    if (directCommits.length === 0)
+        return [];
+    // Group by: date (day) + scope + type
+    const groups = new Map();
+    for (const commit of directCommits) {
+        const date = commit.entry.date.split("T")[0]; // YYYY-MM-DD
+        const scope = commit.parsed.scope || "general";
+        const type = commit.parsed.type;
+        const author = commit.entry.author || "unknown";
+        // Key: date|author|scope|type
+        const key = `${date}|${author}|${scope}|${type}`;
+        if (!groups.has(key)) {
+            groups.set(key, []);
+        }
+        groups.get(key).push(commit);
+    }
+    // Convert groups to bundles
+    const bundles = [];
+    for (const [key, commits] of groups) {
+        const [date, author, scope, type] = key.split("|");
+        const sorted = commits.sort((a, b) => new Date(a.entry.date).getTime() - new Date(b.entry.date).getTime());
+        // Calculate priority based on highest-priority commit in bundle
+        const maxPriority = Math.max(...commits.map((c) => getTypePriority(c.parsed.type, c.parsed.breaking)));
+        // Check if any commit is breaking
+        const hasBreaking = commits.some((c) => c.parsed.breaking);
+        // Generate bundle name
+        const typeName = hasBreaking ? `${type}!` : type;
+        const scopeName = scope === "general" ? "" : `(${scope})`;
+        const bundleName = commits.length === 1
+            ? commits[0].entry.title
+            : `${typeName}${scopeName}: ${commits.length} commits (${date})`;
+        // Generate description
+        const descriptions = commits.map((c) => `- ${c.entry.title}`).join("\n");
+        // Create unique bundle ID using first commit SHA
+        const firstSha = sorted[0].sha.slice(0, 8);
+        const bundle = {
+            id: `bundle-${type}-${scope}-${firstSha}`,
+            name: bundleName,
+            description: `${commits.length} ${type} commit(s) for ${scope === "general" ? "general" : scope}\n\nCommits:\n${descriptions}`,
+            commits: sorted.map((c) => c.sha),
+            author,
+            dateRange: {
+                start: sorted[0].entry.date,
+                end: sorted[sorted.length - 1].entry.date,
+            },
+            scope: scope === "general" ? undefined : scope,
+            type,
+            status: "pending",
+            priority: maxPriority,
+        };
+        bundles.push(bundle);
+    }
+    // Sort bundles by priority (highest first)
+    return bundles.sort((a, b) => b.priority - a.priority);
+}
+// Types that should ALWAYS be consolidated into daily bundles (low priority, safe to batch)
+const LOW_PRIORITY_TYPES = new Set(["fix", "docs", "test", "chore", "style", "ci", "build"]);
+const BUNDLE_STRATEGY = (process.env.NEXUS_UPSTREAM_SYNC_BUNDLE_STRATEGY ?? "aggressive");
+const MIN_BUNDLE_LINES = (() => {
+    const raw = process.env.NEXUS_UPSTREAM_SYNC_BUNDLE_MIN_LINES ?? "1000";
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1000;
+})();
+function parseNumstatLineTotal(line) {
+    const [addedRaw, deletedRaw] = line.trim().split("\t");
+    if (!addedRaw || !deletedRaw)
+        return 0;
+    if (addedRaw === "-" || deletedRaw === "-")
+        return 0;
+    const added = Number.parseInt(addedRaw, 10);
+    const deleted = Number.parseInt(deletedRaw, 10);
+    if (!Number.isFinite(added) || !Number.isFinite(deleted))
+        return 0;
+    return added + deleted;
+}
+function getCommitLineCount(upstreamPath, sha, cache) {
+    const existing = cache.get(sha);
+    if (existing != null)
+        return existing;
+    try {
+        const output = exec(`git show --numstat --format= ${sha}`, upstreamPath);
+        const total = output
+            .split("\n")
+            .map((line) => parseNumstatLineTotal(line))
+            .reduce((sum, value) => sum + value, 0);
+        cache.set(sha, total);
+        return total;
+    }
+    catch {
+        cache.set(sha, 0);
+        return 0;
+    }
+}
+function getBundleLineCount(bundle, upstreamPath, cache) {
+    return bundle.commits.reduce((sum, sha) => sum + getCommitLineCount(upstreamPath, sha, cache), 0);
+}
+// Merge bundles based on priority strategy:
+// - Breaking changes: NEVER consolidate (individual review required)
+// - Features: consolidate by scope when aggressive
+// - Refactors: consolidate BY SCOPE (e.g., all refactor(ui) together)
+// - Low priority (fix, docs, test, chore, etc.): consolidate by day (aggressive) or day+type (standard)
+function consolidateBundles(state, bundles) {
+    const consolidated = [];
+    const aggressive = BUNDLE_STRATEGY === "aggressive";
+    const upstreamPath = getUpstreamPath(state);
+    const commitSizeCache = new Map();
+    const bundleLines = (bundle) => getBundleLineCount(bundle, upstreamPath, commitSizeCache);
+    // Categorize bundles by consolidation strategy
+    const keepSeparate = []; // Breaking
+    const scopeBundles = new Map(); // Consolidate by scope
+    const toConsolidate = []; // Consolidate by day
+    const buildAggregatedBundle = (params) => {
+        const allCommits = params.bundles.flatMap((b) => b.commits);
+        const maxPriority = Math.max(...params.bundles.map((b) => b.priority));
+        const authors = [...new Set(params.bundles.map((b) => b.author))];
+        const authorStr = authors.length === 1 ? authors[0] : `${authors.length} authors`;
+        const firstSha = allCommits[0].slice(0, 8);
+        const dateStart = params.bundles.reduce((min, b) => (b.dateRange.start < min ? b.dateRange.start : min), params.bundles[0].dateRange.start);
+        const dateEnd = params.bundles.reduce((max, b) => (b.dateRange.end > max ? b.dateRange.end : max), params.bundles[0].dateRange.end);
+        const dateLabel = dateStart.split("T")[0] === dateEnd.split("T")[0]
+            ? dateStart.split("T")[0]
+            : `${dateStart.split("T")[0]} to ${dateEnd.split("T")[0]}`;
+        const partLabel = params.part > 1 ? ` (part ${params.part})` : "";
+        const totalLines = params.bundles.reduce((sum, b) => sum + bundleLines(b), 0);
+        const description = `${params.descriptionPrefix ?? "Aggregated bundle"}\n` +
+            `\n**Total lines:** ~${totalLines} (target ${MIN_BUNDLE_LINES}+)\n` +
+            `**Authors:** ${authors.join(", ")}\n\n` +
+            params.bundles.map((b) => `### ${b.name}\n${b.description}`).join("\n\n");
+        return {
+            id: `${params.idPrefix}-${firstSha}${params.part > 1 ? `-p${params.part}` : ""}`,
+            name: `${params.namePrefix}: ${allCommits.length} commits (${dateLabel})${partLabel}`,
+            description,
+            commits: allCommits,
+            author: authorStr,
+            dateRange: { start: dateStart, end: dateEnd },
+            type: params.type,
+            scope: params.scope,
+            status: "pending",
+            priority: maxPriority,
+        };
+    };
+    const packByMinLines = (params) => {
+        const sorted = [...params.bundles].sort((a, b) => a.dateRange.start.localeCompare(b.dateRange.start));
+        const results = [];
+        let current = [];
+        let currentLines = 0;
+        let part = 1;
+        const flush = () => {
+            if (current.length === 0)
+                return;
+            results.push(buildAggregatedBundle({
+                ...params,
+                bundles: current,
+                part,
+            }));
+            current = [];
+            currentLines = 0;
+            part += 1;
+        };
+        for (const bundle of sorted) {
+            const lines = bundleLines(bundle);
+            if (lines >= MIN_BUNDLE_LINES) {
+                flush();
+                results.push(bundle);
+                continue;
+            }
+            if (currentLines + lines >= MIN_BUNDLE_LINES && current.length > 0) {
+                current.push(bundle);
+                flush();
+                continue;
+            }
+            current.push(bundle);
+            currentLines += lines;
+        }
+        flush();
+        return results;
+    };
+    for (const bundle of bundles) {
+        // Breaking changes (priority >= 100) - NEVER consolidate
+        if (bundle.priority >= 100) {
+            keepSeparate.push(bundle);
+            continue;
+        }
+        if (bundle.type === "feat" && !aggressive) {
+            keepSeparate.push(bundle);
+            continue;
+        }
+        if (bundle.type === "feat" || bundle.type === "refactor") {
+            const scope = bundle.scope || "general";
+            const key = `${bundle.type}|${scope}`;
+            if (!scopeBundles.has(key)) {
+                scopeBundles.set(key, []);
+            }
+            scopeBundles.get(key).push(bundle);
+            continue;
+        }
+        if (bundle.type && LOW_PRIORITY_TYPES.has(bundle.type)) {
+            toConsolidate.push(bundle);
+            continue;
+        }
+        toConsolidate.push(bundle);
+    }
+    consolidated.push(...keepSeparate);
+    for (const [key, group] of scopeBundles) {
+        if (group.length === 1) {
+            consolidated.push(group[0]);
+            continue;
+        }
+        const [type, scope] = key.split("|");
+        const scopeLabel = scope ? `(${scope})` : "";
+        const namePrefix = type === "feat" ? `✨ feat${scopeLabel}` : `♻️ refactor${scopeLabel}`;
+        const descriptionPrefix = type === "feat"
+            ? `Aggregated feature bundle for ${scope || "general"}`
+            : `Aggregated refactor bundle for ${scope || "general"}`;
+        consolidated.push(...packByMinLines({
+            idPrefix: `bundle-${type}-${scope}`,
+            namePrefix,
+            descriptionPrefix,
+            bundles: group,
+            type,
+            scope: scope || undefined,
+        }));
+    }
+    if (aggressive) {
+        const byDate = new Map();
+        for (const bundle of toConsolidate) {
+            const date = bundle.dateRange.start.split("T")[0];
+            if (!byDate.has(date)) {
+                byDate.set(date, []);
+            }
+            byDate.get(date).push(bundle);
+        }
+        for (const [date, group] of byDate) {
+            if (group.length === 1) {
+                consolidated.push(group[0]);
+                continue;
+            }
+            const typeCounts = group.reduce((acc, b) => {
+                const t = b.type || "other";
+                acc[t] = (acc[t] || 0) + b.commits.length;
+                return acc;
+            }, {});
+            const typeSummary = Object.entries(typeCounts)
+                .map(([type, count]) => `${type}:${count}`)
+                .join(", ");
+            consolidated.push(...packByMinLines({
+                idPrefix: `bundle-daily-maintenance-${date.replace(/-/g, "")}`,
+                namePrefix: "🧰 Daily maintenance",
+                descriptionPrefix: `Daily maintenance bundle for ${date}\n\n**Types:** ${typeSummary}`,
+                bundles: group,
+                type: "maintenance",
+            }));
+        }
+        return consolidated.sort((a, b) => b.priority - a.priority);
+    }
+    // Standard strategy: group low-priority bundles by date + type
+    const byDateType = new Map();
+    for (const bundle of toConsolidate) {
+        const date = bundle.dateRange.start.split("T")[0];
+        const key = `${date}|${bundle.type}`;
+        if (!byDateType.has(key)) {
+            byDateType.set(key, []);
+        }
+        byDateType.get(key).push(bundle);
+    }
+    for (const [key, group] of byDateType) {
+        if (group.length === 1) {
+            consolidated.push(group[0]);
+        }
+        else {
+            const [date, type] = key.split("|");
+            const typeLabel = {
+                fix: "🐛 Daily fixes",
+                docs: "📚 Daily docs",
+                test: "🧪 Daily tests",
+                chore: "🔧 Daily chores",
+                style: "💅 Daily style",
+                ci: "⚙️ Daily CI",
+                build: "🏗️ Daily build",
+            }[type] || `📦 Daily ${type}`;
+            consolidated.push(...packByMinLines({
+                idPrefix: `bundle-daily-${type}-${date.replace(/-/g, "")}`,
+                namePrefix: typeLabel,
+                descriptionPrefix: `Consolidated ${type} changes from ${date}`,
+                bundles: group,
+                type,
+            }));
+        }
+    }
+    return consolidated.sort((a, b) => b.priority - a.priority);
+}
+// Print bundle summary
+function printBundles(bundles) {
+    if (bundles.length === 0) {
+        console.log("No bundles to display.");
+        return;
+    }
+    console.log("\n" + "═".repeat(60));
+    console.log("  DIRECT COMMIT BUNDLES");
+    console.log("═".repeat(60));
+    // Group by priority tier
+    const breaking = bundles.filter((b) => b.priority >= 100);
+    const features = bundles.filter((b) => b.priority >= 70 && b.priority < 100);
+    const fixes = bundles.filter((b) => b.priority >= 50 && b.priority < 70);
+    const refactors = bundles.filter((b) => b.priority >= 30 && b.priority < 50);
+    const other = bundles.filter((b) => b.priority < 30);
+    const printTier = (name, emoji, tier) => {
+        if (tier.length === 0)
+            return;
+        console.log(`\n  ${emoji} ${name} (${tier.length} bundle${tier.length > 1 ? "s" : ""}):`);
+        for (const b of tier) {
+            const commitCount = b.commits.length;
+            console.log(`     [${b.id.slice(0, 12)}] ${b.name}`);
+            console.log(`        ${commitCount} commit(s) | ${b.author} | ${b.dateRange.start.split("T")[0]}`);
+        }
+    };
+    printTier("BREAKING CHANGES", "🔥", breaking);
+    printTier("FEATURES", "✨", features);
+    printTier("FIXES", "🐛", fixes);
+    printTier("REFACTORS", "♻️", refactors);
+    printTier("OTHER", "📦", other);
+    console.log("\n" + "═".repeat(60));
+    console.log(`  Total: ${bundles.length} bundles, ${bundles.reduce((sum, b) => sum + b.commits.length, 0)} commits`);
+    console.log("═".repeat(60) + "\n");
+}
+function categorizeSplitBucket(title, type) {
+    const lower = title.toLowerCase();
+    if (lower.includes("appcast") || lower.includes("release") || lower.includes("changelog")) {
+        return "release";
+    }
+    if (type === "docs" ||
+        lower.startsWith("docs") ||
+        lower.includes("documentation") ||
+        lower.includes("faq") ||
+        lower.includes("readme")) {
+        return "docs";
+    }
+    if (type === "ci" ||
+        lower.includes("install") ||
+        lower.includes("smoke") ||
+        lower.includes("docker") ||
+        lower.includes("postinstall") ||
+        lower.includes("workflow")) {
+        return "install";
+    }
+    if (lower.includes("discord") ||
+        lower.includes("telegram") ||
+        lower.includes("slack") ||
+        lower.includes("whatsapp") ||
+        lower.includes("typing")) {
+        return "chat";
+    }
+    if (lower.includes("model") ||
+        lower.includes("gemini") ||
+        lower.includes("minimax") ||
+        lower.includes("moonshot") ||
+        lower.includes("kimi")) {
+        return "models";
+    }
+    if (lower.includes("cron") || lower.includes("gateway")) {
+        return "gateway";
+    }
+    if (lower.includes("voice") || lower.includes("plugin") || lower.includes("apply_patch")) {
+        return "voice";
+    }
+    if (type && type !== "other")
+        return type;
+    return "misc";
+}
+// ============================================================================
+// Git Operations
+// ============================================================================
+function exec(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch (e) {
+        const error = e;
+        throw new Error(error.stderr || error.message || "Command failed");
+    }
+}
+function isDispatchDisabled(state) {
+    return process.env.NEXUS_UPSTREAM_SYNC_DISABLE_DISPATCH === "1" || Boolean(state?.dispatchDisabled);
+}
+function assertDispatchEnabled(state) {
+    if (isDispatchDisabled(state)) {
+        throw new Error("Dispatch is disabled. Run 'upstream-sync resume' or unset NEXUS_UPSTREAM_SYNC_DISABLE_DISPATCH=1.");
+    }
+}
+function branchExists(branchName) {
+    try {
+        execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+            cwd: PROJECT_ROOT,
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isGitAncestor(ancestor, target, cwd) {
+    try {
+        execSync(`git merge-base --is-ancestor ${ancestor} ${target}`, { cwd, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertBranchBasedOnMain(branchName, worktreePath) {
+    const mainCommit = exec("git rev-parse main", PROJECT_ROOT);
+    if (worktreePath && existsSync(worktreePath)) {
+        if (!isGitAncestor(mainCommit, "HEAD", worktreePath)) {
+            throw new Error(`Worktree ${worktreePath} is not based on current main (${mainCommit}). Remove it and re-dispatch.`);
+        }
+        return mainCommit;
+    }
+    if (branchExists(branchName) && !isGitAncestor(mainCommit, branchName, PROJECT_ROOT)) {
+        throw new Error(`Branch ${branchName} is not based on current main (${mainCommit}). Delete/recreate before dispatch.`);
+    }
+    return mainCommit;
+}
+function ensureRunsDir() {
+    if (!existsSync(RUNS_DIR)) {
+        mkdirSync(RUNS_DIR, { recursive: true });
+    }
+}
+function getRunPaths(runId) {
+    ensureRunsDir();
+    return {
+        metaPath: join(RUNS_DIR, `${runId}.json`),
+        logPath: join(RUNS_DIR, `${runId}.log`),
+        exitPath: join(RUNS_DIR, `${runId}.exit`),
+    };
+}
+function bashSingleQuote(s) {
+    // 'foo'"'"'bar' pattern
+    return `'${s.replace(/'/g, `'\"'\"'`)}'`;
+}
+function isPidRunning(pid) {
+    try {
+        execSync(`kill -0 ${pid}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readLastLines(filePath, maxLines) {
+    try {
+        const txt = readFileSync(filePath, "utf-8");
+        const lines = txt.split("\n");
+        return lines.slice(Math.max(0, lines.length - maxLines)).join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+function isRunStalled(runLog, runStartedAt) {
+    if (!runLog || !runStartedAt)
+        return false;
+    try {
+        const st = statSync(runLog);
+        const lastLogMs = st.mtimeMs;
+        const startedMs = new Date(runStartedAt).getTime();
+        const now = Date.now();
+        // If it's been running a while but no log output recently, treat as stalled.
+        if (now - startedMs > 15 * 60 * 1000 && now - lastLogMs > 5 * 60 * 1000)
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function startDetachedAgentRun(opts) {
+    const startedAt = new Date().toISOString();
+    const { metaPath, logPath, exitPath } = getRunPaths(opts.runId);
+    // One combined log for stdout/stderr
+    const fd = openSync(logPath, "a");
+    const promptArg = bashSingleQuote(opts.prompt);
+    const commitMsgArg = bashSingleQuote(opts.commitMessage);
+    const exitPathArg = bashSingleQuote(exitPath);
+    const cmd = `rc=0; ` +
+        `echo "== upstream-sync run ${opts.runId} =="; ` +
+        `echo "startedAt=${startedAt}"; ` +
+        `echo "cwd=${opts.cwd}"; ` +
+        `echo ""; ` +
+        `npm install || rc=$?; ` +
+        `if [ $rc -eq 0 ]; then codex exec --dangerously-bypass-approvals-and-sandbox ${promptArg} || rc=$?; fi; ` +
+        `if [ $rc -eq 0 ]; then ` +
+        `  git add -A || rc=$?; ` +
+        `  git reset PORT_TASK.md package-lock.json 2>/dev/null || true; ` +
+        `  if git diff --cached --quiet; then ` +
+        `    echo "NO_CHANGES_TO_COMMIT"; rc=10; ` +
+        `  else ` +
+        `    git commit -m ${commitMsgArg} || rc=$?; ` +
+        `  fi; ` +
+        `fi; ` +
+        `echo $rc > ${exitPathArg}; ` +
+        `echo "exitCode=$rc"; ` +
+        `exit $rc;`;
+    const child = spawn("/bin/bash", ["-lc", cmd], {
+        cwd: opts.cwd,
+        detached: true,
+        stdio: ["ignore", fd, fd],
+        env: process.env,
+    });
+    try {
+        writeFileSync(metaPath, JSON.stringify({ runId: opts.runId, pid: child.pid, startedAt, cwd: opts.cwd, logPath, exitPath }, null, 2) + "\n");
+    }
+    catch {
+        // ignore
+    }
+    child.unref();
+    closeSync(fd);
+    return { pid: child.pid, logPath, exitPath, metaPath, startedAt };
+}
+function getUpstreamPath(state) {
+    return resolve(PROJECT_ROOT, state.upstream.path);
+}
+function fetchUpstream(state) {
+    const upstreamPath = getUpstreamPath(state);
+    console.log("📡 Fetching upstream...");
+    // Fetch only; avoid pull conflicts in local upstream clone.
+    exec("git fetch --prune origin", upstreamPath);
+    state.lastFetched = new Date().toISOString();
+}
+function findNewCommits(state) {
+    const upstreamPath = getUpstreamPath(state);
+    const since = state.trackingStartDate;
+    // Get ALL commits since tracking start date (both merges and direct commits)
+    // Format: SHA|subject|date|author|parent_count
+    const output = exec(`git log --format="%H|%s|%cI|%an|%P" --since="${since}" origin/main`, upstreamPath);
+    if (!output)
+        return [];
+    const commits = [];
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("|");
+        const sha = parts[0];
+        const subject = parts[1];
+        const date = parts[2];
+        const author = parts[3];
+        const parents = parts[4] || "";
+        // Skip if already tracked
+        if (state.merges[sha])
+            continue;
+        // Determine if this is a merge commit (has 2+ parents) or direct commit
+        const parentCount = parents
+            .trim()
+            .split(" ")
+            .filter((p) => p).length;
+        const isMerge = parentCount >= 2;
+        if (isMerge) {
+            // Extract PR number from "Merge pull request #XXX from user/branch"
+            const prMatch = subject.match(/Merge pull request #(\d+) from (.+)/);
+            const prNumber = prMatch ? parseInt(prMatch[1], 10) : undefined;
+            const title = prMatch ? prMatch[2] : subject;
+            commits.push({ sha, prNumber, title, date, isDirectCommit: false, author });
+        }
+        else {
+            // Check if this references a PR anywhere in the subject:
+            // 1. Squash merge: "feat: something (#123)"
+            // 2. Reference: "fix: something (thanks @user) (#123)"
+            // 3. Hash reference: "fix: related to #123"
+            const prRefMatch = subject.match(/\(#(\d+)\)/) || subject.match(/#(\d{3,})/);
+            if (prRefMatch) {
+                // References a PR - treat as a PR-related commit
+                const prNumber = parseInt(prRefMatch[1], 10);
+                // Clean title: remove (#XXX) patterns
+                const title = subject
+                    .replace(/\s*\(#\d+\)\s*/g, " ")
+                    .replace(/\s+/g, " ")
+                    .trim();
+                commits.push({ sha, prNumber, title, date, isDirectCommit: false, author });
+            }
+            else {
+                // True direct commit - no PR number reference
+                commits.push({ sha, title: subject, date, isDirectCommit: true, author });
+            }
+        }
+    }
+    return commits;
+}
+// Legacy alias for compatibility
+function findNewMerges(state) {
+    return findNewCommits(state);
+}
+// ============================================================================
+// Agent Dispatch
+// ============================================================================
+function generatePortTask(state, sha, entry) {
+    const upstreamPath = getUpstreamPath(state);
+    const baseCommit = entry.baseCommit || exec("git rev-parse main", PROJECT_ROOT);
+    // Get the diff for this commit
+    const diff = exec(`git show ${sha} --stat`, upstreamPath);
+    const commitType = entry.isDirectCommit ? "Direct Commit" : `PR #${entry.prNumber || "unknown"}`;
+    const commitLabel = entry.isDirectCommit
+        ? `⭐ DIRECT COMMIT (HIGH PRIORITY)`
+        : `PR #${entry.prNumber}`;
+    return `# Port Task: ${commitLabel} - ${entry.title}
+
+## Source
+${entry.isDirectCommit ? "⭐ **DIRECT COMMIT** - Pushed directly to main by core maintainer" : `Upstream PR #${entry.prNumber}`}
+${entry.author ? `Author: ${entry.author}` : ""}
+Commit: ${sha}
+Base branch: main @ ${baseCommit}
+
+## Files Changed
+${diff}
+
+## Full Diff
+Run: git show ${sha}
+
+## Instructions
+
+1. Review the changes in upstream at: ${upstreamPath}
+2. Apply equivalent changes to this nexus codebase
+3. Adapt imports/paths if they differ from upstream
+4. Confirm branch base: \`git merge-base --is-ancestor ${baseCommit} HEAD\`
+5. Run \`npm run build\` to verify compilation
+6. Run relevant tests if they exist
+
+## Commit Instructions
+IMPORTANT: Use git directly, NOT scripts/committer:
+
+\`\`\`bash
+git add <changed-files>
+git commit -m "feat: port ${commitType} - ${entry.title}
+
+Ported from upstream ${commitType}"
+\`\`\`
+
+## Notes
+- Don't modify CHANGELOG.md
+- If tests fail due to missing dependencies in worktree, commit anyway
+- Focus on the core functionality, skip UI-only changes if any
+- Do NOT use scripts/committer - use git add && git commit directly
+${entry.isDirectCommit ? "- ⭐ This is a DIRECT COMMIT from a core maintainer - handle with care!" : ""}
+`;
+}
+function dispatchAgent(state, sha) {
+    assertDispatchEnabled(state);
+    const entry = state.merges[sha];
+    if (!entry)
+        throw new Error(`Unknown commit: ${sha}`);
+    const identifier = entry.prNumber || sha.slice(0, 8);
+    const branchName = `port/pr-${identifier}`;
+    const worktreePath = `/tmp/nexus-port-${identifier}`;
+    const mainCommit = assertBranchBasedOnMain(branchName, worktreePath);
+    const label = entry.isDirectCommit ? `⭐ DIRECT COMMIT` : `PR #${identifier}`;
+    console.log(`🚀 Dispatching agent for ${label}: ${entry.title}`);
+    // Check if worktree already exists
+    if (existsSync(worktreePath)) {
+        console.log(`   Worktree exists at ${worktreePath}, reusing...`);
+    }
+    else {
+        // Create worktree
+        console.log(`   Creating worktree at ${worktreePath}...`);
+        try {
+            exec(`git worktree add -b ${branchName} ${worktreePath} main`, PROJECT_ROOT);
+        }
+        catch (e) {
+            // Branch might already exist
+            try {
+                exec(`git worktree add ${worktreePath} ${branchName}`, PROJECT_ROOT);
+            }
+            catch {
+                throw new Error(`Failed to create worktree: ${e}`);
+            }
+        }
+    }
+    // Generate PORT_TASK.md
+    const taskContent = generatePortTask(state, sha, entry);
+    writeFileSync(join(worktreePath, "PORT_TASK.md"), taskContent);
+    console.log(`   Generated PORT_TASK.md`);
+    // Start detached runner (no tmux control path)
+    const runId = `pr-${identifier}-${Date.now()}`;
+    const prompt = "Read PORT_TASK.md and complete the porting task. Commit your changes when done (a supervisor will also attempt to commit).";
+    const commitMessage = "feat: port upstream changes";
+    const run = startDetachedAgentRun({ runId, cwd: worktreePath, prompt, commitMessage });
+    console.log(`   Started detached runner pid=${run.pid}`);
+    // Update state
+    entry.status = "porting";
+    entry.baseCommit = mainCommit;
+    entry.portBranch = branchName;
+    entry.worktree = worktreePath;
+    entry.runId = runId;
+    entry.runPid = run.pid;
+    entry.runLog = run.logPath;
+    entry.runStartedAt = run.startedAt;
+    saveState(state);
+}
+// ============================================================================
+// Status Checking
+// ============================================================================
+function checkAgentStatus(state, sha) {
+    const entry = state.merges[sha];
+    if (!entry || entry.status !== "porting")
+        return "not_started";
+    // Prefer detached runner PID if present
+    if (typeof entry.runPid === "number") {
+        // If we already have a commit, it's done.
+        if (entry.portCommit)
+            return "done";
+        // If branch has a commit, it's done (even if process is still alive).
+        if (entry.portBranch) {
+            try {
+                const commits = exec(`git log main..${entry.portBranch} --oneline`, PROJECT_ROOT);
+                if (commits.trim()) {
+                    const latestCommit = commits.split("\n")[0].split(" ")[0];
+                    entry.portCommit = latestCommit;
+                    return "done";
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (!isPidRunning(entry.runPid)) {
+            return "failed";
+        }
+        // If the run looks stalled, treat as idle so supervisor can intervene.
+        if (isRunStalled(entry.runLog, entry.runStartedAt))
+            return "idle";
+        // If log indicates codex finished and is waiting on commit, treat as idle.
+        const tail = entry.runLog ? readLastLines(entry.runLog, 30) : "";
+        if (tail.includes("Your task is complete") || tail.includes("Run these commands NOW"))
+            return "idle";
+        return "working";
+    }
+    const sessionName = entry.tmuxSession;
+    if (!sessionName)
+        return "not_started";
+    // Check if tmux session exists
+    try {
+        exec(`tmux -S "${TMUX_SOCKET}" has-session -t ${sessionName} 2>/dev/null`);
+    }
+    catch {
+        // Session doesn't exist - check if there's a commit
+        if (entry.portBranch) {
+            try {
+                const commits = exec(`git log main..${entry.portBranch} --oneline`, PROJECT_ROOT);
+                if (commits.trim()) {
+                    // There's a commit on the branch
+                    const latestCommit = commits.split("\n")[0].split(" ")[0];
+                    entry.portCommit = latestCommit;
+                    return "done";
+                }
+            }
+            catch {
+                // Branch doesn't exist or no commits
+            }
+        }
+        return "failed";
+    }
+    // Session exists - check if agent is idle (waiting at prompt) or still working
+    try {
+        const output = exec(`tmux -S "${TMUX_SOCKET}" capture-pane -p -t ${sessionName} -S -10`);
+        // Check if codex is waiting for commit instructions
+        if (output.includes("Your task is complete") || output.includes("Run these commands NOW")) {
+            if (entry.portBranch) {
+                try {
+                    const commits = exec(`git log main..${entry.portBranch} --oneline`, PROJECT_ROOT);
+                    if (commits.trim()) {
+                        const latestCommit = commits.split("\n")[0].split(" ")[0];
+                        entry.portCommit = latestCommit;
+                        return "done";
+                    }
+                }
+                catch {
+                    // No commits yet
+                }
+            }
+            return "idle";
+        }
+        // Check if codex is at its interactive prompt (idle, waiting for input)
+        // The prompt looks like: "› " with "context left" nearby
+        if (output.includes("context left") && output.includes("›")) {
+            // Agent is idle at prompt - check if there's already a commit
+            if (entry.portBranch) {
+                try {
+                    const commits = exec(`git log main..${entry.portBranch} --oneline`, PROJECT_ROOT);
+                    if (commits.trim()) {
+                        const latestCommit = commits.split("\n")[0].split(" ")[0];
+                        entry.portCommit = latestCommit;
+                        return "done"; // Has commit, just need to close session
+                    }
+                }
+                catch {
+                    // No commits yet
+                }
+            }
+            return "idle"; // At prompt but no commit yet
+        }
+        // Check for shell prompt (agent exited but session still open)
+        if (output.includes("$ ") || output.match(/\n%\s*$/)) {
+            if (entry.portBranch) {
+                try {
+                    const commits = exec(`git log main..${entry.portBranch} --oneline`, PROJECT_ROOT);
+                    if (commits.trim()) {
+                        const latestCommit = commits.split("\n")[0].split(" ")[0];
+                        entry.portCommit = latestCommit;
+                        return "done";
+                    }
+                }
+                catch {
+                    // No commits
+                }
+            }
+            return "failed";
+        }
+        return "working";
+    }
+    catch {
+        return "working";
+    }
+}
+function nudgeIdleAgent(worktreePath, sessionName) {
+    // Commit directly from the supervisor to avoid tmux prompt issues
+    if (worktreePath) {
+        try {
+            execSync("git add -A", { cwd: worktreePath, stdio: "ignore" });
+            try {
+                execSync("git reset PORT_TASK.md package-lock.json", {
+                    cwd: worktreePath,
+                    stdio: "ignore",
+                });
+            }
+            catch {
+                // Ignore missing files
+            }
+            let hasChanges = false;
+            try {
+                execSync("git diff --cached --quiet", { cwd: worktreePath, stdio: "ignore" });
+            }
+            catch {
+                hasChanges = true;
+            }
+            if (hasChanges) {
+                execSync("git commit -m 'feat: port upstream changes'", {
+                    cwd: worktreePath,
+                    stdio: "ignore",
+                });
+            }
+            if (sessionName) {
+                killAgentSession(sessionName);
+            }
+            return;
+        }
+        catch {
+            // Fall back to tmux send-keys if direct commit fails
+        }
+    }
+    if (sessionName) {
+        try {
+            const cmd = `git add -A && ` +
+                `git reset PORT_TASK.md package-lock.json 2>/dev/null || true && ` +
+                `git diff --cached --quiet || git commit -m 'feat: port upstream changes' && exit`;
+            exec(`tmux -S "${TMUX_SOCKET}" send-keys -t ${sessionName} "${cmd}" Enter`);
+        }
+        catch {
+            // Session might not exist
+        }
+    }
+}
+function killAgentPid(pid) {
+    if (typeof pid !== "number")
+        return;
+    try {
+        execSync(`kill ${pid}`, { stdio: "ignore" });
+    }
+    catch {
+        // ignore
+    }
+}
+function killAgentSession(sessionName) {
+    try {
+        exec(`tmux -S "${TMUX_SOCKET}" kill-session -t ${sessionName} 2>/dev/null`);
+    }
+    catch {
+        // Session might not exist
+    }
+}
+function updateAllStatuses(state) {
+    // Update individual merge entries
+    for (const [sha, entry] of Object.entries(state.merges)) {
+        if (entry.bundleId)
+            continue;
+        if (entry.status === "porting") {
+            const label = entry.prNumber ? `PR #${entry.prNumber}` : `Commit ${sha.slice(0, 8)}`;
+            const status = checkAgentStatus(state, sha);
+            if (status === "done") {
+                // Agent finished and committed - close session and mark complete
+                if (entry.tmuxSession) {
+                    killAgentSession(entry.tmuxSession);
+                }
+                entry.status = "pending_review";
+                console.log(`✅ ${label} completed - ready for review`);
+            }
+            else if (status === "idle") {
+                // Agent is at prompt but hasn't committed - nudge it
+                if (entry.worktree || entry.tmuxSession) {
+                    console.log(`🔔 ${label} idle - sending commit nudge...`);
+                    nudgeIdleAgent(entry.worktree, entry.tmuxSession);
+                    // If this was a detached runner stuck at "task complete", kill it after committing
+                    if (typeof entry.runPid === "number") {
+                        killAgentPid(entry.runPid);
+                    }
+                }
+            }
+            else if (status === "failed") {
+                entry.status = "porting"; // Keep as porting with error, can retry
+                entry.error = "Agent session ended without commit";
+                console.log(`❌ ${label} failed - no commit found`);
+            }
+        }
+    }
+    // Update bundle statuses
+    if (state.bundles) {
+        for (const [bundleId, bundle] of Object.entries(state.bundles)) {
+            if (bundle.status === "porting") {
+                const status = checkBundleAgentStatus(bundleId);
+                if (status === "done") {
+                    bundle.status = "pending_review";
+                    for (const sha of bundle.commits) {
+                        const entry = state.merges[sha];
+                        if (!entry)
+                            continue;
+                        entry.status = "pending_review";
+                        delete entry.error;
+                    }
+                    console.log(`✅ Bundle ${bundleId.slice(0, 20)} completed - ready for review`);
+                }
+                else if (status === "idle") {
+                    // Nudge the bundle agent
+                    const shortId = bundleId.split("-").pop() || bundleId.slice(-8);
+                    const worktreePath = `/tmp/nexus-bundle-${shortId}`;
+                    console.log(`🔔 Bundle ${bundleId.slice(0, 20)} idle - sending commit nudge...`);
+                    nudgeIdleAgent(worktreePath, bundle.tmuxSession);
+                    if (typeof bundle.runPid === "number") {
+                        killAgentPid(bundle.runPid);
+                    }
+                }
+            }
+        }
+    }
+    saveState(state);
+}
+// Check bundle agent status by looking at the worktree
+function checkBundleAgentStatus(bundleId) {
+    const shortId = bundleId.split("-").pop() || bundleId.slice(-8);
+    const worktreePath = `/tmp/nexus-bundle-${shortId}`;
+    const sessionName = `bundle-${shortId}`;
+    // Check if worktree exists
+    try {
+        execSync(`test -d "${worktreePath}"`, { stdio: "ignore" });
+    }
+    catch {
+        return "failed"; // Worktree doesn't exist
+    }
+    // If bundle has a detached runner, trust PID/log for liveness and stall detection.
+    // (We still fall back to tmux checks for older runs.)
+    try {
+        const state = loadState();
+        const bundle = state.bundles?.[bundleId];
+        if (bundle && typeof bundle.runPid === "number") {
+            // If there's a valid port commit with real changes, we're done (or idle if process still alive).
+            try {
+                const subject = execSync(`git log --oneline -1 --format="%s"`, {
+                    cwd: worktreePath,
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "ignore"],
+                }).trim();
+                if (subject) {
+                    const files = execSync(`git show --name-only --pretty=format: -1`, {
+                        cwd: worktreePath,
+                        encoding: "utf-8",
+                        stdio: ["pipe", "pipe", "ignore"],
+                    })
+                        .split("\n")
+                        .map((line) => line.trim())
+                        .filter(Boolean)
+                        .filter((file) => file !== "PORT_TASK.md" && file !== "package-lock.json");
+                    if (files.length > 0) {
+                        if (isPidRunning(bundle.runPid))
+                            return "idle";
+                        return "done";
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            if (!isPidRunning(bundle.runPid))
+                return "failed";
+            if (isRunStalled(bundle.runLog, bundle.runStartedAt))
+                return "idle";
+            const tail = bundle.runLog ? readLastLines(bundle.runLog, 40) : "";
+            if (tail.includes("Your task is complete") || tail.includes("Run these commands NOW"))
+                return "idle";
+            return "working";
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Check if there's a port commit with real changes
+    try {
+        const log = execSync(`git log --oneline -1 --format="%s"`, {
+            cwd: worktreePath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        if (log.includes("port") ||
+            log.includes("feat:") ||
+            log.includes("fix:") ||
+            log.includes("refactor")) {
+            // Ensure the commit includes actual changes beyond PORT_TASK/package-lock
+            try {
+                const files = execSync(`git show --name-only --pretty=format: -1`, {
+                    cwd: worktreePath,
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "ignore"],
+                })
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .filter((file) => file !== "PORT_TASK.md" && file !== "package-lock.json");
+                if (files.length === 0) {
+                    return "failed";
+                }
+            }
+            catch {
+                // If we can't read files, keep going
+            }
+            // Has a port commit - check if session is still running
+            try {
+                execSync(`tmux -S ${TMUX_SOCKET} has-session -t "${sessionName}" 2>/dev/null`, {
+                    stdio: "ignore",
+                });
+                // Session still running - check if idle or working
+                const pane = execSync(`tmux -S ${TMUX_SOCKET} capture-pane -t "${sessionName}" -p 2>/dev/null`, {
+                    encoding: "utf-8",
+                });
+                if (pane.includes("Your task is complete") || pane.includes("Run these commands NOW")) {
+                    return "idle"; // Done but hasn't exited
+                }
+                return "working";
+            }
+            catch {
+                // Session ended - if we have a commit, it's done
+                return "done";
+            }
+        }
+    }
+    catch {
+        // No commit yet
+    }
+    // Check if session is still running
+    try {
+        execSync(`tmux -S ${TMUX_SOCKET} has-session -t "${sessionName}" 2>/dev/null`, {
+            stdio: "ignore",
+        });
+        return "working";
+    }
+    catch {
+        return "failed";
+    }
+}
+// ============================================================================
+// Display
+// ============================================================================
+function getBundleCategory(bundle) {
+    if (bundle.priority >= 100)
+        return "breaking";
+    if (bundle.priority >= 70)
+        return "features";
+    if (bundle.priority >= 50)
+        return "fixes";
+    if (bundle.priority >= 30)
+        return "refactors";
+    return "other";
+}
+function getBundleSessionName(bundleId) {
+    const shortId = bundleId.split("-").pop() || bundleId.slice(-8);
+    return `bundle-${shortId}`;
+}
+function getTmuxSessions() {
+    const sessions = new Map();
+    try {
+        const output = execSync(`tmux -S "${TMUX_SOCKET}" list-sessions -F "#{session_name} #{session_created}"`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        if (!output)
+            return sessions;
+        for (const line of output.split("\n")) {
+            const [name, createdStr] = line.trim().split(/\s+/);
+            const created = createdStr ? parseInt(createdStr, 10) : 0;
+            if (name)
+                sessions.set(name, { created });
+        }
+    }
+    catch {
+        // tmux may not be running
+    }
+    return sessions;
+}
+function formatDuration(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        return "unknown";
+    const mins = Math.floor(seconds / 60);
+    const hours = Math.floor(mins / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${mins % 60}m`;
+    return `${mins}m`;
+}
+function printStatus(state) {
+    const counts = { new: 0, porting: 0, pending_review: 0, shelved: 0, merged: 0, ignored: 0 };
+    const byStatus = {
+        pending_review: [],
+        shelved: [],
+        porting: [],
+        new: [],
+        merged: [],
+        ignored: [],
+    };
+    for (const [sha, entry] of Object.entries(state.merges)) {
+        const normalizedStatus = entry.status === "pending" ? "new" : entry.status;
+        const statusKey = (normalizedStatus in counts ? normalizedStatus : "new");
+        counts[statusKey]++;
+        byStatus[statusKey].push({ sha, entry });
+    }
+    console.log("\n" + "═".repeat(60));
+    console.log("  UPSTREAM SYNC STATUS");
+    console.log("═".repeat(60));
+    console.log(`  Last fetched: ${state.lastFetched}`);
+    console.log(`  Tracking since: ${state.trackingStartDate}`);
+    console.log("");
+    console.log(`  📊 Summary:`);
+    console.log(`     ✅ Merged:         ${counts.merged}`);
+    console.log(`     👀 Pending Review: ${counts.pending_review}`);
+    console.log(`     📦 Shelved:        ${counts.shelved}`);
+    console.log(`     ⚙️  Porting:        ${counts.porting}`);
+    console.log(`     🆕 New:            ${counts.new}`);
+    console.log(`     ⏭️  Ignored:        ${counts.ignored}`);
+    if (isDispatchDisabled(state)) {
+        console.log(`     ⛔ Dispatch:       paused`);
+    }
+    console.log("");
+    // Bundle summary (direct commits)
+    const bundles = Object.values(state.bundles || {});
+    const bundleCounts = {
+        pending: bundles.filter((b) => b.status === "pending").length,
+        porting: bundles.filter((b) => b.status === "porting").length,
+        pending_review: bundles.filter((b) => b.status === "pending_review").length,
+        merged: bundles.filter((b) => b.status === "merged").length,
+        ignored: bundles.filter((b) => b.status === "ignored").length,
+    };
+    const bundleOutstanding = bundleCounts.pending + bundleCounts.porting + bundleCounts.pending_review;
+    console.log("  📦 BUNDLE STATUS (Direct commits):");
+    console.log(`     Outstanding:    ${bundleOutstanding}`);
+    console.log(`     Ready Review:   ${bundleCounts.pending_review}`);
+    console.log(`     In Progress:    ${bundleCounts.porting}`);
+    console.log(`     Waiting Agents: ${bundleCounts.pending}`);
+    console.log("");
+    // Agent status for bundles in progress
+    if (bundleCounts.porting > 0) {
+        const tmuxSessions = getTmuxSessions();
+        console.log("  🧵 BUNDLE AGENTS (status + runtime):");
+        for (const bundle of bundles.filter((b) => b.status === "porting")) {
+            const sessionName = getBundleSessionName(bundle.id);
+            const agentStatus = checkBundleAgentStatus(bundle.id);
+            const session = tmuxSessions.get(sessionName);
+            const runtimeSec = session ? Math.floor(Date.now() / 1000) - session.created : 0;
+            const runtime = formatDuration(runtimeSec);
+            const statusLabel = agentStatus === "idle"
+                ? "stuck (idle)"
+                : agentStatus === "failed"
+                    ? "failed"
+                    : agentStatus === "done"
+                        ? "done"
+                        : "running";
+            console.log(`     ${bundle.name.slice(0, 60)} [${statusLabel}] (${runtime})`);
+        }
+        console.log("");
+    }
+    // Bundle grouping by priority tiers, list features
+    if (bundles.length > 0) {
+        const outstandingBundles = bundles.filter((b) => b.status !== "merged" && b.status !== "ignored");
+        const grouped = {
+            breaking: outstandingBundles.filter((b) => getBundleCategory(b) === "breaking"),
+            features: outstandingBundles.filter((b) => getBundleCategory(b) === "features"),
+            fixes: outstandingBundles.filter((b) => getBundleCategory(b) === "fixes"),
+            refactors: outstandingBundles.filter((b) => getBundleCategory(b) === "refactors"),
+            other: outstandingBundles.filter((b) => getBundleCategory(b) === "other"),
+        };
+        console.log("  📊 BUNDLES BY CATEGORY (outstanding):");
+        console.log(`     🔥 Breaking: ${grouped.breaking.length}`);
+        console.log(`     ✨ Features: ${grouped.features.length}`);
+        console.log(`     🐛 Fixes:    ${grouped.fixes.length}`);
+        console.log(`     ♻️ Refactors:${grouped.refactors.length}`);
+        console.log(`     📦 Other:    ${grouped.other.length}`);
+        console.log("");
+        if (grouped.features.length > 0) {
+            console.log("  ✨ FEATURE BUNDLES (outstanding):");
+            for (const bundle of grouped.features) {
+                console.log(`     - ${bundle.name} [${bundle.status}]`);
+            }
+            console.log("");
+        }
+    }
+    if (byStatus.pending_review.length > 0) {
+        console.log("  👀 READY FOR REVIEW (new):");
+        for (const { entry } of byStatus.pending_review) {
+            console.log(`     PR #${entry.prNumber}: ${entry.title}`);
+            console.log(`        Branch: ${entry.portBranch} | Commit: ${entry.portCommit}`);
+        }
+        console.log("");
+    }
+    if (byStatus.shelved.length > 0) {
+        console.log("  📦 SHELVED (reviewed, keeping for later):");
+        for (const { entry } of byStatus.shelved) {
+            console.log(`     PR #${entry.prNumber}: ${entry.title}`);
+            console.log(`        Branch: ${entry.portBranch}`);
+        }
+        console.log("");
+    }
+    if (byStatus.porting.length > 0) {
+        console.log("  ⚙️  IN PROGRESS:");
+        for (const { entry } of byStatus.porting) {
+            const status = entry.tmuxSession ? `tmux: ${entry.tmuxSession}` : "unknown";
+            console.log(`     PR #${entry.prNumber}: ${entry.title} [${status}]`);
+        }
+        console.log("");
+    }
+    if (byStatus.new.length > 0) {
+        // Sort: direct commits first
+        const sortedNew = [...byStatus.new].sort((a, b) => {
+            if (a.entry.isDirectCommit && !b.entry.isDirectCommit)
+                return -1;
+            if (!a.entry.isDirectCommit && b.entry.isDirectCommit)
+                return 1;
+            return new Date(b.entry.date).getTime() - new Date(a.entry.date).getTime();
+        });
+        const directCount = sortedNew.filter((x) => x.entry.isDirectCommit).length;
+        console.log(`  🆕 NEW (will dispatch agents): ${directCount} direct commits, ${byStatus.new.length - directCount} PRs`);
+        // Show direct commits first with star
+        for (const { entry } of sortedNew.filter((x) => x.entry.isDirectCommit)) {
+            console.log(`     ⭐ DIRECT: ${entry.title} (${entry.author || "unknown"})`);
+        }
+        // Then PRs
+        for (const { entry } of sortedNew.filter((x) => !x.entry.isDirectCommit).slice(0, 10)) {
+            console.log(`     PR #${entry.prNumber}: ${entry.title}`);
+        }
+        const remainingPRs = sortedNew.filter((x) => !x.entry.isDirectCommit).length - 10;
+        if (remainingPRs > 0) {
+            console.log(`     ... and ${remainingPRs} more PRs`);
+        }
+        console.log("");
+    }
+    console.log("═".repeat(60));
+    console.log("  Commands:");
+    console.log("    daemon [mins]           - Run continuously until all done (default: 2 min interval)");
+    console.log("    pause                   - Disable new agent dispatch");
+    console.log("    resume                  - Re-enable agent dispatch");
+    console.log("    review                  - Generate markdown review queue");
+    console.log("    merge <pr#> [pr#]...    - Merge PRs (with conflict check)");
+    console.log("    shelve <pr#>            - Mark as reviewed, keep for later");
+    console.log("    unshelve <pr#>          - Move back to pending review");
+    console.log("    ignore <pr#> [reason]   - Mark as ignored permanently");
+    console.log("    retry <pr#>             - Re-dispatch agent for a PR");
+    console.log("    show <pr#>              - Show diff for a PR");
+    console.log("");
+    console.log("  Bundle Commands (for direct commits):");
+    console.log("    bundles                 - Analyze and show direct commit bundles");
+    console.log("    bundle-dispatch <id>    - Dispatch agent for a specific bundle");
+    console.log("    bundle-split <id>       - Split a bundle into smaller bundles");
+    console.log("    bundle-requeue <id>     - Reset bundle for re-dispatch");
+    console.log("    bundle-dispatch-oldest  - Dispatch oldest pending bundles");
+    console.log("    bundle-ignore <id>      - Ignore a bundle");
+    console.log("    bundle-auto             - Auto-dispatch high-priority bundles");
+    console.log("═".repeat(60) + "\n");
+}
+// ============================================================================
+// Commands
+// ============================================================================
+function findMergeBySha(state, prNumOrSha) {
+    // Try PR number first
+    const prNum = parseInt(prNumOrSha, 10);
+    if (!isNaN(prNum)) {
+        for (const [sha, entry] of Object.entries(state.merges)) {
+            if (entry.prNumber === prNum) {
+                return { sha, entry };
+            }
+        }
+    }
+    // Try SHA
+    if (state.merges[prNumOrSha]) {
+        return { sha: prNumOrSha, entry: state.merges[prNumOrSha] };
+    }
+    // Try partial SHA
+    for (const [sha, entry] of Object.entries(state.merges)) {
+        if (sha.startsWith(prNumOrSha)) {
+            return { sha, entry };
+        }
+    }
+    return null;
+}
+function cmdMerge(state, prNumOrSha) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { sha, entry } = found;
+    if (entry.status !== "pending_review") {
+        console.error(`❌ PR #${entry.prNumber} is not ready for review (status: ${entry.status})`);
+        return;
+    }
+    if (!entry.portBranch) {
+        console.error(`❌ No port branch found for PR #${entry.prNumber}`);
+        return;
+    }
+    console.log(`🔀 Merging ${entry.portBranch} into main...`);
+    try {
+        exec(`git checkout main`, PROJECT_ROOT);
+        exec(`git merge ${entry.portBranch} --no-edit`, PROJECT_ROOT);
+        entry.status = "merged";
+        saveState(state);
+        console.log(`✅ PR #${entry.prNumber} merged successfully!`);
+        // Clean up worktree
+        if (entry.worktree && existsSync(entry.worktree)) {
+            console.log(`🧹 Cleaning up worktree...`);
+            exec(`git worktree remove ${entry.worktree}`, PROJECT_ROOT);
+        }
+    }
+    catch (e) {
+        console.error(`❌ Merge failed: ${e}`);
+    }
+}
+function cmdIgnore(state, prNumOrSha, reason) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { entry } = found;
+    entry.status = "ignored";
+    entry.ignoreReason = reason || "Manually ignored";
+    saveState(state);
+    console.log(`⏭️  PR #${entry.prNumber} marked as ignored`);
+}
+function cmdRetry(state, prNumOrSha) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { sha, entry } = found;
+    // Kill existing tmux session if any
+    if (entry.tmuxSession) {
+        try {
+            exec(`tmux -S "${TMUX_SOCKET}" kill-session -t ${entry.tmuxSession} 2>/dev/null`);
+        }
+        catch {
+            // Session might not exist
+        }
+    }
+    // Reset status
+    entry.status = "new";
+    delete entry.tmuxSession;
+    delete entry.error;
+    saveState(state);
+    // Dispatch again
+    dispatchAgent(state, sha);
+}
+function cmdShow(state, prNumOrSha) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { sha, entry } = found;
+    const upstreamPath = getUpstreamPath(state);
+    console.log(`\n📋 PR #${entry.prNumber}: ${entry.title}`);
+    console.log(`   Status: ${entry.status}`);
+    console.log(`   Date: ${entry.date}`);
+    console.log(`   SHA: ${sha}`);
+    if (entry.portBranch) {
+        console.log(`   Port Branch: ${entry.portBranch}`);
+    }
+    console.log("\n📝 Changes:");
+    try {
+        const diff = exec(`git show ${sha} --stat`, upstreamPath);
+        console.log(diff);
+    }
+    catch (e) {
+        console.error(`   Could not get diff: ${e}`);
+    }
+}
+function cmdShelve(state, prNumOrSha) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { entry } = found;
+    if (entry.status !== "pending_review" && entry.status !== "shelved") {
+        console.error(`❌ PR #${entry.prNumber} cannot be shelved (status: ${entry.status})`);
+        return;
+    }
+    entry.status = "shelved";
+    saveState(state);
+    console.log(`📦 PR #${entry.prNumber} shelved for later`);
+    // Clean up worktree if exists (but keep branch)
+    if (entry.worktree && existsSync(entry.worktree)) {
+        console.log(`   🧹 Cleaning up worktree (branch preserved)...`);
+        try {
+            exec(`git worktree remove ${entry.worktree}`, PROJECT_ROOT);
+            delete entry.worktree;
+            saveState(state);
+        }
+        catch {
+            console.log(`   ⚠️  Could not remove worktree`);
+        }
+    }
+}
+function cmdUnshelve(state, prNumOrSha) {
+    const found = findMergeBySha(state, prNumOrSha);
+    if (!found) {
+        console.error(`❌ PR not found: ${prNumOrSha}`);
+        return;
+    }
+    const { entry } = found;
+    if (entry.status !== "shelved") {
+        console.error(`❌ PR #${entry.prNumber} is not shelved (status: ${entry.status})`);
+        return;
+    }
+    entry.status = "pending_review";
+    saveState(state);
+    console.log(`👀 PR #${entry.prNumber} moved back to pending review`);
+}
+function generatePrDescription(state, sha, entry) {
+    const upstreamPath = getUpstreamPath(state);
+    try {
+        // Get commit message body for description
+        const commitMsg = exec(`git log -1 --format="%B" ${sha}`, upstreamPath);
+        const stat = exec(`git show ${sha} --stat --format="" | tail -5`, upstreamPath);
+        // Extract meaningful description from commit message
+        const lines = commitMsg
+            .split("\n")
+            .filter((l) => l.trim() && !l.startsWith("Merge pull request"));
+        const description = lines.slice(0, 3).join(" ").slice(0, 200) || "No description available";
+        return `${description}\n\nFiles: ${stat.split("\n").pop()?.trim() || "unknown"}`;
+    }
+    catch {
+        return "Could not fetch description";
+    }
+}
+// Visual timeline showing sync progress
+function cmdTimeline(state) {
+    const entries = Object.entries(state.merges);
+    // Group by date
+    const byDate = new Map();
+    for (const [sha, entry] of entries) {
+        const date = entry.date.split("T")[0];
+        if (!byDate.has(date)) {
+            byDate.set(date, {
+                merged: 0,
+                porting: 0,
+                pending: 0,
+                new: 0,
+                ignored: 0,
+                prs: 0,
+                direct: 0,
+            });
+        }
+        const day = byDate.get(date);
+        if (entry.status === "merged")
+            day.merged++;
+        else if (entry.status === "porting")
+            day.porting++;
+        else if (entry.status === "pending_review")
+            day.pending++;
+        else if (entry.status === "new")
+            day.new++;
+        else if (entry.status === "ignored")
+            day.ignored++;
+        if (entry.prNumber)
+            day.prs++;
+        if (entry.isDirectCommit)
+            day.direct++;
+    }
+    // Sort dates
+    const dates = [...byDate.keys()].sort();
+    // Calculate totals
+    const totals = { merged: 0, porting: 0, pending: 0, new: 0, ignored: 0, prs: 0, direct: 0 };
+    for (const day of byDate.values()) {
+        totals.merged += day.merged;
+        totals.porting += day.porting;
+        totals.pending += day.pending;
+        totals.new += day.new;
+        totals.ignored += day.ignored;
+        totals.prs += day.prs;
+        totals.direct += day.direct;
+    }
+    const totalCommits = totals.merged + totals.porting + totals.pending + totals.new + totals.ignored;
+    const ported = totals.merged + totals.porting + totals.pending;
+    const portedPct = Math.round((ported / totalCommits) * 100);
+    // Header
+    console.log("\n" + "═".repeat(80));
+    console.log("  📊 NEXUS ← UPSTREAM SYNC TIMELINE");
+    console.log("═".repeat(80));
+    console.log(`  Tracking since: ${state.trackingStartDate}`);
+    console.log(`  Last fetched:   ${state.lastFetched}`);
+    console.log("");
+    // Overall progress bar
+    const barWidth = 50;
+    const mergedBar = Math.round((totals.merged / totalCommits) * barWidth);
+    const portingBar = Math.round((totals.porting / totalCommits) * barWidth);
+    const pendingBar = Math.round((totals.pending / totalCommits) * barWidth);
+    const newBar = barWidth - mergedBar - portingBar - pendingBar;
+    console.log("  OVERALL PROGRESS:");
+    console.log(`  ${"█".repeat(mergedBar)}${"▓".repeat(portingBar)}${"░".repeat(pendingBar)}${"·".repeat(Math.max(0, newBar))} ${portedPct}%`);
+    console.log(`  ${"█"} merged (${totals.merged})  ${"▓"} porting (${totals.porting})  ${"░"} pending (${totals.pending})  ${"·"} new (${totals.new})`);
+    console.log("");
+    // Summary stats
+    console.log("  COMMIT BREAKDOWN:");
+    console.log(`  ┌─────────────────┬────────────┬────────────┐`);
+    console.log(`  │                 │    PRs     │   Direct   │`);
+    console.log(`  ├─────────────────┼────────────┼────────────┤`);
+    console.log(`  │ Total tracked   │ ${String(totals.prs).padStart(10)} │ ${String(totals.direct).padStart(10)} │`);
+    console.log(`  └─────────────────┴────────────┴────────────┘`);
+    console.log("");
+    // Daily timeline
+    console.log("  DAILY TIMELINE:");
+    console.log("  " + "─".repeat(76));
+    console.log("  Date       │ Total │ Merged │ Porting │ Pending │ New   │ Progress");
+    console.log("  " + "─".repeat(76));
+    for (const date of dates) {
+        const day = byDate.get(date);
+        const dayTotal = day.merged + day.porting + day.pending + day.new + day.ignored;
+        const dayPorted = day.merged + day.porting + day.pending;
+        const dayPct = dayTotal > 0 ? Math.round((dayPorted / dayTotal) * 100) : 0;
+        // Mini progress bar
+        const miniWidth = 20;
+        const miniMerged = Math.round((day.merged / dayTotal) * miniWidth);
+        const miniPorting = Math.round((day.porting / dayTotal) * miniWidth);
+        const miniPending = Math.round((day.pending / dayTotal) * miniWidth);
+        const miniNew = miniWidth - miniMerged - miniPorting - miniPending;
+        const miniBar = "█".repeat(miniMerged) +
+            "▓".repeat(miniPorting) +
+            "░".repeat(miniPending) +
+            "·".repeat(Math.max(0, miniNew));
+        console.log(`  ${date} │ ${String(dayTotal).padStart(5)} │ ${String(day.merged).padStart(6)} │ ${String(day.porting).padStart(7)} │ ${String(day.pending).padStart(7)} │ ${String(day.new).padStart(5)} │ ${miniBar} ${dayPct}%`);
+    }
+    console.log("  " + "─".repeat(76));
+    console.log(`  TOTAL      │ ${String(totalCommits).padStart(5)} │ ${String(totals.merged).padStart(6)} │ ${String(totals.porting).padStart(7)} │ ${String(totals.pending).padStart(7)} │ ${String(totals.new).padStart(5)} │`);
+    console.log("");
+    // Bundle summary
+    const bundles = Object.values(state.bundles || {});
+    const bundlePending = bundles.filter((b) => b.status === "pending").length;
+    const bundlePorting = bundles.filter((b) => b.status === "porting").length;
+    const bundleMerged = bundles.filter((b) => b.status === "merged").length;
+    console.log("  BUNDLE STATUS (Direct Commits):");
+    console.log(`  ┌───────────────┬───────┐`);
+    console.log(`  │ Pending       │ ${String(bundlePending).padStart(5)} │  ← Ready to dispatch`);
+    console.log(`  │ Porting       │ ${String(bundlePorting).padStart(5)} │  ← Agents working`);
+    console.log(`  │ Merged        │ ${String(bundleMerged).padStart(5)} │  ← Done`);
+    console.log(`  └───────────────┴───────┘`);
+    console.log("");
+    // What's being worked on
+    const portingEntries = entries.filter(([_, e]) => e.status === "porting");
+    if (portingEntries.length > 0) {
+        console.log("  🔧 CURRENTLY PORTING:");
+        for (const [sha, entry] of portingEntries.slice(0, 8)) {
+            const type = entry.isDirectCommit ? "DIRECT" : `PR #${entry.prNumber}`;
+            const session = entry.tmuxSession ? ` [${entry.tmuxSession}]` : "";
+            console.log(`     ${type}: ${entry.title.slice(0, 50)}...${session}`);
+        }
+        if (portingEntries.length > 8) {
+            console.log(`     ... and ${portingEntries.length - 8} more`);
+        }
+        console.log("");
+    }
+    // What's next
+    console.log("  📋 WHAT'S NEXT:");
+    const newPRs = entries.filter(([_, e]) => e.status === "new" && e.prNumber);
+    const newDirect = entries.filter(([_, e]) => e.status === "new" && e.isDirectCommit);
+    console.log(`     • ${newPRs.length} PRs still need porting`);
+    console.log(`     • ${newDirect.length} direct commits (in ${bundlePending} bundles) need porting`);
+    console.log(`     • ${totals.pending} commits ready for your review`);
+    console.log("");
+    // Key insight
+    console.log("  💡 KEY INSIGHT:");
+    console.log(`     You've merged ${totals.merged} PR-based commits (mostly from overnight run).`);
+    console.log(`     But Peter pushes ${totals.direct} commits directly to main (no PRs).`);
+    console.log(`     We just discovered these today - that's why there's so much "new" work.`);
+    console.log("");
+    console.log("═".repeat(80) + "\n");
+}
+function cmdReview(state) {
+    const reviewable = Object.entries(state.merges)
+        .filter(([_, e]) => e.status === "pending_review" || e.status === "shelved")
+        .sort((a, b) => {
+        // pending_review first, then shelved, then by date
+        if (a[1].status !== b[1].status) {
+            return a[1].status === "pending_review" ? -1 : 1;
+        }
+        return new Date(b[1].date).getTime() - new Date(a[1].date).getTime();
+    });
+    if (reviewable.length === 0) {
+        console.log("No PRs ready for review.");
+        return;
+    }
+    const pendingCount = reviewable.filter(([_, e]) => e.status === "pending_review").length;
+    const shelvedCount = reviewable.filter(([_, e]) => e.status === "shelved").length;
+    console.log(`# Upstream Port Review Queue\n`);
+    console.log(`**${pendingCount} new** | **${shelvedCount} shelved**\n`);
+    console.log(`---\n`);
+    // Group by status
+    const pending = reviewable.filter(([_, e]) => e.status === "pending_review");
+    const shelved = reviewable.filter(([_, e]) => e.status === "shelved");
+    if (pending.length > 0) {
+        // Sort: direct commits first
+        const sortedPending = [...pending].sort((a, b) => {
+            if (a[1].isDirectCommit && !b[1].isDirectCommit)
+                return -1;
+            if (!a[1].isDirectCommit && b[1].isDirectCommit)
+                return 1;
+            return new Date(b[1].date).getTime() - new Date(a[1].date).getTime();
+        });
+        console.log(`## 👀 New (Pending Review)\n`);
+        for (const [sha, entry] of sortedPending) {
+            const desc = generatePrDescription(state, sha, entry);
+            const label = entry.isDirectCommit
+                ? `⭐ DIRECT: ${entry.title}`
+                : `PR #${entry.prNumber}: ${entry.title}`;
+            console.log(`### ${label}\n`);
+            if (entry.isDirectCommit && entry.author) {
+                console.log(`**Author:** ${entry.author}\n`);
+            }
+            console.log(`${desc}\n`);
+            console.log(`- **Branch:** \`${entry.portBranch}\``);
+            console.log(`- **Commit:** \`${entry.portCommit}\``);
+            console.log(`- **Date:** ${entry.date}\n`);
+            console.log(`---\n`);
+        }
+    }
+    if (shelved.length > 0) {
+        console.log(`## 📦 Shelved (Reviewed, Keeping for Later)\n`);
+        for (const [sha, entry] of shelved) {
+            const desc = generatePrDescription(state, sha, entry);
+            console.log(`### PR #${entry.prNumber}: ${entry.title}\n`);
+            console.log(`${desc}\n`);
+            console.log(`- **Branch:** \`${entry.portBranch}\``);
+            console.log(`- **Date:** ${entry.date}\n`);
+            console.log(`---\n`);
+        }
+    }
+    console.log(`## Commands\n`);
+    console.log(`\`\`\`bash`);
+    console.log(`# Merge specific PRs (checks for conflicts first)`);
+    console.log(`npx tsx src/cli/upstream-sync-cli.ts merge 832 722 583`);
+    console.log(``);
+    console.log(`# Shelve a PR for later`);
+    console.log(`npx tsx src/cli/upstream-sync-cli.ts shelve 740`);
+    console.log(``);
+    console.log(`# Unshelve a PR back to pending`);
+    console.log(`npx tsx src/cli/upstream-sync-cli.ts unshelve 740`);
+    console.log(``);
+    console.log(`# Ignore a PR permanently`);
+    console.log(`npx tsx src/cli/upstream-sync-cli.ts ignore 748 "Not applicable to fork"`);
+    console.log(`\`\`\``);
+}
+// ============================================================================
+// Bundle Commands
+// ============================================================================
+function cmdBundles(state) {
+    console.log("🔍 Analyzing direct commits...\n");
+    // Generate bundles
+    const rawBundles = bundleDirectCommits(state);
+    const bundles = consolidateBundles(state, rawBundles);
+    // Save bundles to state
+    state.bundles = state.bundles || {};
+    for (const bundle of bundles) {
+        if (!state.bundles[bundle.id]) {
+            state.bundles[bundle.id] = bundle;
+            // Mark commits as bundled
+            for (const sha of bundle.commits) {
+                if (state.merges[sha]) {
+                    state.merges[sha].bundleId = bundle.id;
+                }
+            }
+        }
+    }
+    saveState(state);
+    // Print summary
+    printBundles(bundles);
+    // Show quick stats
+    const directCount = Object.values(state.merges).filter((e) => e.isDirectCommit && e.status === "new").length;
+    const prCount = Object.values(state.merges).filter((e) => !e.isDirectCommit && e.status === "new").length;
+    console.log("Summary:");
+    console.log(`  📦 ${bundles.length} bundles created from ${directCount} direct commits`);
+    console.log(`  📋 ${prCount} PR-based commits (handled separately)`);
+    console.log("");
+    console.log("Next steps:");
+    console.log("  - Review bundles above");
+    console.log("  - Run 'bundle-dispatch <id>' for high-priority bundles");
+    console.log("  - Run 'bundle-auto' to dispatch all BREAKING/FEATURE bundles");
+    console.log("  - Run 'bundle-ignore <id>' to skip low-priority bundles");
+}
+// Reset and rebuild all bundles with current consolidation logic
+function cmdRebundle(state) {
+    console.log("🔄 Rebuilding bundles with new consolidation logic...\n");
+    // Count existing bundles before cleanup
+    const existingBundles = Object.keys(state.bundles || {}).length;
+    const portingBundles = Object.values(state.bundles || {}).filter((b) => b.status === "porting");
+    if (portingBundles.length > 0) {
+        console.log(`⚠️  Warning: ${portingBundles.length} bundle(s) are currently being ported.`);
+        console.log("   These will be preserved. Stop their agents first if you want to rebundle them.\n");
+    }
+    // 1. Clear bundleIds from all "new" direct commits (not porting ones)
+    let clearedCommits = 0;
+    for (const [sha, entry] of Object.entries(state.merges)) {
+        if (entry.isDirectCommit && entry.bundleId && entry.status === "new") {
+            delete entry.bundleId;
+            clearedCommits++;
+        }
+    }
+    console.log(`   Cleared bundleIds from ${clearedCommits} commits`);
+    // 2. Remove all pending bundles (keep porting/merged/ignored)
+    let removedBundles = 0;
+    if (state.bundles) {
+        for (const [id, bundle] of Object.entries(state.bundles)) {
+            if (bundle.status === "pending") {
+                delete state.bundles[id];
+                removedBundles++;
+            }
+        }
+    }
+    console.log(`   Removed ${removedBundles} pending bundles`);
+    // 3. Regenerate bundles
+    const rawBundles = bundleDirectCommits(state);
+    const bundles = consolidateBundles(state, rawBundles);
+    // 4. Save new bundles
+    state.bundles = state.bundles || {};
+    for (const bundle of bundles) {
+        state.bundles[bundle.id] = bundle;
+        // Mark commits as bundled
+        for (const sha of bundle.commits) {
+            if (state.merges[sha]) {
+                state.merges[sha].bundleId = bundle.id;
+            }
+        }
+    }
+    saveState(state);
+    console.log(`   Created ${bundles.length} new bundles\n`);
+    // Print summary
+    printBundles(bundles);
+    // Stats
+    const totalBundles = Object.keys(state.bundles).length;
+    const totalCommits = bundles.reduce((sum, b) => sum + b.commits.length, 0);
+    console.log("Rebundle complete:");
+    console.log(`   Before: ${existingBundles} bundles`);
+    console.log(`   After:  ${totalBundles} bundles (${bundles.length} pending, ${portingBundles.length} porting)`);
+    console.log(`   Commits covered: ${totalCommits}`);
+}
+function generateBundlePortTask(state, bundle) {
+    const upstreamPath = getUpstreamPath(state);
+    const baseCommit = bundle.baseCommit || exec("git rev-parse main", PROJECT_ROOT);
+    // Get combined diff stats for all commits
+    const commitDiffs = [];
+    for (const sha of bundle.commits) {
+        try {
+            const stat = exec(`git show ${sha} --stat --format="Commit: %h - %s"`, upstreamPath);
+            commitDiffs.push(stat);
+        }
+        catch {
+            commitDiffs.push(`Commit ${sha.slice(0, 8)}: [could not get diff]`);
+        }
+    }
+    const priorityLabel = bundle.priority >= 100
+        ? "🔥 BREAKING CHANGE"
+        : bundle.priority >= 70
+            ? "✨ FEATURE"
+            : bundle.priority >= 50
+                ? "🐛 FIX"
+                : bundle.priority >= 30
+                    ? "♻️ REFACTOR"
+                    : "📦 OTHER";
+    return `# Port Bundle: ${bundle.name}
+
+## Priority: ${priorityLabel}
+
+## Bundle Info
+- **ID:** ${bundle.id}
+- **Author:** ${bundle.author}
+- **Date Range:** ${bundle.dateRange.start.split("T")[0]} to ${bundle.dateRange.end.split("T")[0]}
+- **Commits:** ${bundle.commits.length}
+- **Base branch:** main @ ${baseCommit}
+
+## Description
+${bundle.description}
+
+## All Commits (in order)
+${commitDiffs.join("\n\n")}
+
+## Instructions
+
+1. Review ALL ${bundle.commits.length} commits in upstream at: ${upstreamPath}
+2. Apply the changes as ONE cohesive update to nexus
+3. Don't port commit-by-commit - understand the full change first
+4. Confirm branch base: \`git merge-base --is-ancestor ${baseCommit} HEAD\`
+5. Adapt imports/paths if they differ from upstream
+6. Run \`npm run build\` to verify compilation
+7. Run relevant tests if they exist
+
+## Commit Instructions
+Create a SINGLE commit that encompasses all changes:
+
+\`\`\`bash
+git add <changed-files>
+git commit -m "feat: port ${bundle.name}
+
+Ported from upstream bundle: ${bundle.id}
+Includes ${bundle.commits.length} commits from ${bundle.author}"
+\`\`\`
+
+## Notes
+- This is a BUNDLED port - multiple upstream commits as one
+- Focus on the end result, not intermediate states
+- If the bundle includes breaking changes, note them in the commit message
+- Do NOT use scripts/committer - use git add && git commit directly
+`;
+}
+function dispatchBundleAgent(state, bundleId) {
+    assertDispatchEnabled(state);
+    if (!state.bundles || !state.bundles[bundleId]) {
+        throw new Error(`Bundle not found: ${bundleId}`);
+    }
+    const bundle = state.bundles[bundleId];
+    if (bundle.status !== "pending" && bundle.status !== "ready") {
+        throw new Error(`Bundle ${bundleId} is not ready for dispatch (status: ${bundle.status})`);
+    }
+    // Use last part of bundle ID (the commit SHA) for uniqueness
+    const parts = bundleId.split("-");
+    const shortId = parts[parts.length - 1]; // Get the SHA part
+    const branchName = `port/bundle-${shortId}`;
+    const worktreePath = `/tmp/nexus-bundle-${shortId}`;
+    const mainCommit = assertBranchBasedOnMain(branchName, worktreePath);
+    console.log(`🚀 Dispatching agent for bundle: ${bundle.name}`);
+    console.log(`   ${bundle.commits.length} commits | ${bundle.author} | Priority: ${bundle.priority}`);
+    // Check if worktree already exists
+    if (existsSync(worktreePath)) {
+        console.log(`   Worktree exists at ${worktreePath}, reusing...`);
+    }
+    else {
+        // Create worktree
+        console.log(`   Creating worktree at ${worktreePath}...`);
+        try {
+            exec(`git worktree add -b ${branchName} ${worktreePath} main`, PROJECT_ROOT);
+        }
+        catch (e) {
+            try {
+                exec(`git worktree add ${worktreePath} ${branchName}`, PROJECT_ROOT);
+            }
+            catch {
+                throw new Error(`Failed to create worktree: ${e}`);
+            }
+        }
+    }
+    // Generate PORT_TASK.md for the bundle
+    const taskContent = generateBundlePortTask(state, bundle);
+    writeFileSync(join(worktreePath, "PORT_TASK.md"), taskContent);
+    console.log(`   Generated PORT_TASK.md`);
+    // Start detached runner (no tmux control path)
+    const runId = `bundle-${shortId}-${Date.now()}`;
+    const prompt = "Read PORT_TASK.md and complete the porting task. This is a BUNDLED port - apply all changes as one cohesive update. Commit your changes when done (a supervisor will also attempt to commit).";
+    const commitMessage = `feat: port ${bundle.name}`;
+    const run = startDetachedAgentRun({ runId, cwd: worktreePath, prompt, commitMessage });
+    console.log(`   Started detached runner pid=${run.pid}`);
+    // Update bundle status
+    bundle.status = "porting";
+    bundle.baseCommit = mainCommit;
+    bundle.runId = runId;
+    bundle.runPid = run.pid;
+    bundle.runLog = run.logPath;
+    bundle.runStartedAt = run.startedAt;
+    // Mark all commits in bundle as part of this dispatch
+    for (const sha of bundle.commits) {
+        if (state.merges[sha]) {
+            state.merges[sha].status = "porting";
+            state.merges[sha].portBranch = branchName;
+            state.merges[sha].worktree = worktreePath;
+            state.merges[sha].runId = runId;
+            state.merges[sha].runPid = run.pid;
+            state.merges[sha].runLog = run.logPath;
+            state.merges[sha].runStartedAt = run.startedAt;
+        }
+    }
+    saveState(state);
+    console.log(`   ✅ Agent dispatched!`);
+}
+function cmdBundleDispatch(state, bundleId) {
+    // Find bundle by ID or partial ID
+    if (!state.bundles) {
+        console.error("❌ No bundles found. Run 'bundles' first to analyze commits.");
+        return;
+    }
+    let found;
+    for (const id of Object.keys(state.bundles)) {
+        if (id === bundleId || id.includes(bundleId)) {
+            found = id;
+            break;
+        }
+    }
+    if (!found) {
+        console.error(`❌ Bundle not found: ${bundleId}`);
+        return;
+    }
+    try {
+        dispatchBundleAgent(state, found);
+    }
+    catch (e) {
+        console.error(`❌ Failed to dispatch: ${e}`);
+    }
+}
+function cmdBundleIgnore(state, bundleId, reason) {
+    if (!state.bundles) {
+        console.error("❌ No bundles found. Run 'bundles' first to analyze commits.");
+        return;
+    }
+    let found;
+    for (const id of Object.keys(state.bundles)) {
+        if (id === bundleId || id.includes(bundleId)) {
+            found = id;
+            break;
+        }
+    }
+    if (!found) {
+        console.error(`❌ Bundle not found: ${bundleId}`);
+        return;
+    }
+    const bundle = state.bundles[found];
+    bundle.status = "ignored";
+    // Mark all commits in bundle as ignored
+    for (const sha of bundle.commits) {
+        if (state.merges[sha]) {
+            state.merges[sha].status = "ignored";
+            state.merges[sha].ignoreReason = reason || "Bundle ignored";
+        }
+    }
+    saveState(state);
+    console.log(`⏭️  Bundle ignored: ${bundle.name} (${bundle.commits.length} commits)`);
+}
+function cmdBundleSplit(state, bundleId) {
+    if (!state.bundles) {
+        console.error("❌ No bundles found. Run 'bundles' first to analyze commits.");
+        return;
+    }
+    let found;
+    for (const id of Object.keys(state.bundles)) {
+        if (id === bundleId || id.includes(bundleId)) {
+            found = id;
+            break;
+        }
+    }
+    if (!found) {
+        console.error(`❌ Bundle not found: ${bundleId}`);
+        return;
+    }
+    const bundle = state.bundles[found];
+    if (bundle.status === "porting") {
+        console.error(`❌ Bundle ${bundle.id} is currently porting. Stop it before splitting.`);
+        return;
+    }
+    if (bundle.status === "merged" || bundle.status === "ignored") {
+        console.error(`❌ Bundle ${bundle.id} is ${bundle.status} and cannot be split.`);
+        return;
+    }
+    const buckets = new Map();
+    for (const sha of bundle.commits) {
+        const entry = state.merges[sha];
+        if (!entry)
+            continue;
+        const parsed = parseConventionalCommit(entry.title);
+        const bucket = categorizeSplitBucket(entry.title, parsed.type);
+        const items = buckets.get(bucket) ?? [];
+        items.push({ sha, entry, parsed });
+        buckets.set(bucket, items);
+    }
+    if (buckets.size <= 1) {
+        console.error(`❌ Bundle ${bundle.id} did not split into multiple buckets.`);
+        return;
+    }
+    delete state.bundles[found];
+    const newBundles = [];
+    for (const [bucket, items] of buckets.entries()) {
+        const sorted = items;
+        const firstEntry = sorted[0]?.entry;
+        const lastEntry = sorted[sorted.length - 1]?.entry;
+        const commitTitles = sorted.map((c) => `- ${c.entry.title}`).join("\n");
+        const maxPriority = Math.max(...sorted.map((c) => getTypePriority(c.parsed.type, c.parsed.breaking)));
+        const firstSha = sorted[0]?.sha?.slice(0, 8) || `${Date.now()}`;
+        let id = `bundle-${bucket}-${firstSha}`;
+        let suffix = 1;
+        while (state.bundles[id]) {
+            id = `bundle-${bucket}-${firstSha}-${suffix}`;
+            suffix += 1;
+        }
+        const types = new Set(sorted.map((c) => c.parsed.type));
+        const scopes = new Set(sorted.map((c) => c.parsed.scope).filter(Boolean));
+        const authors = new Set(sorted.map((c) => c.entry.author).filter(Boolean));
+        const author = authors.size === 1 ? Array.from(authors)[0] : bundle.author || "multiple";
+        const dateLabel = firstEntry?.date?.split("T")[0] ?? "unknown";
+        const name = sorted.length === 1
+            ? sorted[0]?.entry.title
+            : `${bucket}: ${sorted.length} commits (${dateLabel})`;
+        newBundles.push({
+            id,
+            name,
+            description: `${sorted.length} commit(s) split from ${bundle.id}\n\nCommits:\n${commitTitles}`,
+            commits: sorted.map((c) => c.sha),
+            author,
+            dateRange: {
+                start: firstEntry?.date ?? bundle.dateRange.start,
+                end: lastEntry?.date ?? bundle.dateRange.end,
+            },
+            scope: scopes.size === 1 ? Array.from(scopes)[0] : undefined,
+            type: types.size === 1 ? Array.from(types)[0] : undefined,
+            status: bundle.status,
+            priority: maxPriority,
+            baseCommit: bundle.baseCommit,
+        });
+    }
+    for (const next of newBundles) {
+        state.bundles[next.id] = next;
+        for (const sha of next.commits) {
+            if (state.merges[sha]) {
+                state.merges[sha].bundleId = next.id;
+            }
+        }
+    }
+    saveState(state);
+    console.log(`✅ Split bundle ${bundle.id} into ${newBundles.length} bundle(s):`);
+    for (const next of newBundles) {
+        console.log(`   - ${next.id}: ${next.name}`);
+    }
+}
+function cmdBundleRequeue(state, bundleId) {
+    if (!state.bundles) {
+        console.error("❌ No bundles found. Run 'bundles' first to analyze commits.");
+        return;
+    }
+    let found;
+    for (const id of Object.keys(state.bundles)) {
+        if (id === bundleId || id.includes(bundleId)) {
+            found = id;
+            break;
+        }
+    }
+    if (!found) {
+        console.error(`❌ Bundle not found: ${bundleId}`);
+        return;
+    }
+    const bundle = state.bundles[found];
+    if (bundle.status === "porting") {
+        console.error(`❌ Bundle ${bundle.id} is currently porting. Stop it before requeueing.`);
+        return;
+    }
+    bundle.status = "pending";
+    delete bundle.portBranch;
+    delete bundle.portCommit;
+    delete bundle.tmuxSession;
+    delete bundle.worktree;
+    delete bundle.runId;
+    delete bundle.runPid;
+    delete bundle.runLog;
+    delete bundle.runStartedAt;
+    delete bundle.error;
+    for (const sha of bundle.commits) {
+        const entry = state.merges[sha];
+        if (!entry)
+            continue;
+        entry.status = "new";
+        delete entry.portBranch;
+        delete entry.portCommit;
+        delete entry.tmuxSession;
+        delete entry.worktree;
+        delete entry.runId;
+        delete entry.runPid;
+        delete entry.runLog;
+        delete entry.runStartedAt;
+        delete entry.error;
+    }
+    saveState(state);
+    console.log(`🔁 Bundle requeued: ${bundle.id} (${bundle.commits.length} commits)`);
+}
+function cmdBundleAuto(state, minPriority = 70) {
+    if (!state.bundles) {
+        console.log("🔍 Analyzing direct commits first...\n");
+        cmdBundles(state);
+    }
+    const pending = Object.values(state.bundles)
+        .filter((b) => b.status === "pending" && b.priority >= minPriority)
+        .sort((a, b) => b.priority - a.priority);
+    if (pending.length === 0) {
+        console.log("✨ No high-priority bundles to dispatch.");
+        return;
+    }
+    // Check how many agents are already running
+    const currentlyRunning = Object.values(state.bundles).filter((b) => b.status === "porting").length;
+    const maxConcurrent = 6;
+    const canDispatch = Math.max(0, maxConcurrent - currentlyRunning);
+    if (canDispatch === 0) {
+        console.log(`⏳ Max agents (${maxConcurrent}) already running. Wait for some to complete.`);
+        return;
+    }
+    const toDispatch = pending.slice(0, canDispatch);
+    console.log(`🚀 Auto-dispatching ${toDispatch.length} high-priority bundle(s)...\n`);
+    for (const bundle of toDispatch) {
+        const priorityLabel = bundle.priority >= 100 ? "🔥 BREAKING" : bundle.priority >= 70 ? "✨ FEATURE" : "🐛 FIX";
+        console.log(`\n${priorityLabel} ${bundle.name}`);
+        try {
+            dispatchBundleAgent(state, bundle.id);
+        }
+        catch (e) {
+            console.error(`   ❌ Failed: ${e}`);
+        }
+    }
+    console.log(`\n✅ Dispatched ${toDispatch.length} bundle(s).`);
+    if (pending.length > toDispatch.length) {
+        console.log(`   ${pending.length - toDispatch.length} more pending (run again after agents complete).`);
+    }
+}
+function cmdBundleDispatchOldest(state, requested) {
+    if (!state.bundles) {
+        console.log("🔍 Analyzing direct commits first...\n");
+        cmdBundles(state);
+    }
+    if (isDispatchDisabled(state)) {
+        console.log("⛔ Dispatch paused; skipping bundle dispatch.");
+        return;
+    }
+    const portingBundles = state.bundles
+        ? Object.values(state.bundles).filter((b) => b.status === "porting").length
+        : 0;
+    const portingIndividual = Object.values(state.merges).filter((e) => e.status === "porting" && !e.bundleId).length;
+    const currentlyPorting = portingBundles + portingIndividual;
+    const maxConcurrent = 6;
+    const available = Math.max(0, maxConcurrent - currentlyPorting);
+    if (available === 0) {
+        console.log(`⏳ All ${maxConcurrent} slots occupied. Wait for current bundles to finish.`);
+        return;
+    }
+    const pending = Object.values(state.bundles)
+        .filter((b) => b.status === "pending")
+        .sort((a, b) => {
+        const dateDiff = a.dateRange.start.localeCompare(b.dateRange.start);
+        if (dateDiff !== 0)
+            return dateDiff;
+        return b.priority - a.priority;
+    });
+    if (pending.length === 0) {
+        console.log("✨ No pending bundles to dispatch.");
+        return;
+    }
+    const limit = typeof requested === "number" && Number.isFinite(requested) && requested > 0
+        ? Math.min(requested, available)
+        : available;
+    const toDispatch = pending.slice(0, limit);
+    console.log(`🚀 Dispatching ${toDispatch.length} oldest pending bundle(s)...`);
+    for (const bundle of toDispatch) {
+        try {
+            dispatchBundleAgent(state, bundle.id);
+            console.log(`   ✓ ${bundle.name} (${bundle.commits.length} commits)`);
+        }
+        catch (e) {
+            console.error(`   ✗ ${bundle.id}: ${e}`);
+        }
+    }
+}
+function checkMergeConflicts(state, prNums) {
+    const conflicts = [];
+    // Create a temporary branch to test merges
+    const testBranch = `test-merge-${Date.now()}`;
+    try {
+        exec(`git checkout -b ${testBranch} main`, PROJECT_ROOT);
+        for (const prNum of prNums) {
+            const found = findMergeBySha(state, String(prNum));
+            if (!found || !found.entry.portBranch)
+                continue;
+            try {
+                exec(`git merge --no-commit --no-ff ${found.entry.portBranch}`, PROJECT_ROOT);
+                exec(`git reset --hard HEAD`, PROJECT_ROOT);
+            }
+            catch (e) {
+                // Get conflicting files
+                try {
+                    const conflictFiles = exec(`git diff --name-only --diff-filter=U`, PROJECT_ROOT);
+                    conflicts.push({
+                        pr: prNum,
+                        files: conflictFiles.split("\n").filter((f) => f.trim()),
+                    });
+                }
+                catch {
+                    conflicts.push({ pr: prNum, files: ["unknown"] });
+                }
+                exec(`git merge --abort`, PROJECT_ROOT);
+            }
+        }
+    }
+    finally {
+        // Clean up
+        exec(`git checkout main`, PROJECT_ROOT);
+        try {
+            exec(`git branch -D ${testBranch}`, PROJECT_ROOT);
+        }
+        catch {
+            // Branch might not exist
+        }
+    }
+    return { canMerge: conflicts.length === 0, conflicts };
+}
+function cmdMergeMultiple(state, prNums) {
+    const nums = prNums.map((p) => parseInt(p, 10)).filter((n) => !isNaN(n));
+    if (nums.length === 0) {
+        console.error("Usage: upstream-sync merge <pr#> [pr#] [pr#]...");
+        return;
+    }
+    // Validate all PRs exist and are mergeable
+    const toMerge = [];
+    for (const prNum of nums) {
+        const found = findMergeBySha(state, String(prNum));
+        if (!found) {
+            console.error(`❌ PR #${prNum} not found`);
+            return;
+        }
+        if (found.entry.status !== "pending_review" && found.entry.status !== "shelved") {
+            console.error(`❌ PR #${prNum} is not ready for merge (status: ${found.entry.status})`);
+            return;
+        }
+        if (!found.entry.portBranch) {
+            console.error(`❌ PR #${prNum} has no port branch`);
+            return;
+        }
+        toMerge.push({ ...found, prNum });
+    }
+    console.log(`\n🔍 Checking for conflicts among ${toMerge.length} PRs...`);
+    // Check for conflicts
+    const { canMerge, conflicts } = checkMergeConflicts(state, nums);
+    if (!canMerge) {
+        console.log(`\n⚠️  CONFLICTS DETECTED:\n`);
+        for (const c of conflicts) {
+            console.log(`   PR #${c.pr} conflicts in:`);
+            for (const f of c.files) {
+                console.log(`      - ${f}`);
+            }
+        }
+        console.log(`\nPlease resolve these conflicts before merging, or merge PRs individually.`);
+        return;
+    }
+    console.log(`✅ No conflicts detected!\n`);
+    // Merge one at a time
+    for (const { entry, prNum } of toMerge) {
+        console.log(`🔀 Merging PR #${prNum}: ${entry.title}...`);
+        try {
+            exec(`git checkout main`, PROJECT_ROOT);
+            exec(`git merge ${entry.portBranch} --no-edit`, PROJECT_ROOT);
+            entry.status = "merged";
+            saveState(state);
+            console.log(`   ✅ Merged successfully!`);
+            // Clean up worktree if exists
+            if (entry.worktree && existsSync(entry.worktree)) {
+                try {
+                    exec(`git worktree remove ${entry.worktree}`, PROJECT_ROOT);
+                    delete entry.worktree;
+                    saveState(state);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+        catch (e) {
+            console.error(`   ❌ Merge failed: ${e}`);
+            console.log(`   Stopping merge sequence. Please resolve manually.`);
+            return;
+        }
+    }
+    console.log(`\n🎉 All ${toMerge.length} PRs merged successfully!`);
+}
+// ============================================================================
+// Daemon Mode
+// ============================================================================
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runDaemon(state, intervalMinutes = 2) {
+    console.log("🤖 UPSTREAM SYNC DAEMON STARTED");
+    console.log(`   Interval: ${intervalMinutes} minute(s)`);
+    console.log(`   Max concurrent agents: 6`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    console.log("═".repeat(60) + "\n");
+    let iteration = 0;
+    while (true) {
+        iteration++;
+        const timestamp = new Date().toLocaleTimeString();
+        console.log(`\n⏰ [${timestamp}] Iteration ${iteration}`);
+        console.log("─".repeat(40));
+        // Reload state (in case of external changes)
+        try {
+            state = loadState();
+        }
+        catch (e) {
+            console.error(`   ❌ Failed to load state: ${e}`);
+            await sleep(intervalMinutes * 60 * 1000);
+            continue;
+        }
+        // 1. Fetch latest from upstream
+        try {
+            fetchUpstream(state);
+        }
+        catch (e) {
+            console.error(`   ⚠️ Fetch failed: ${e}`);
+        }
+        // 2. Find new commits (both merges and direct commits)
+        const newCommits = findNewCommits(state);
+        if (newCommits.length > 0) {
+            const directCount = newCommits.filter((c) => c.isDirectCommit).length;
+            const mergeCount = newCommits.length - directCount;
+            console.log(`   📦 Found ${newCommits.length} new commit(s): ${directCount} direct, ${mergeCount} PRs`);
+            for (const commit of newCommits) {
+                state.merges[commit.sha] = {
+                    status: "new",
+                    prNumber: commit.prNumber,
+                    title: commit.title,
+                    date: commit.date,
+                    isDirectCommit: commit.isDirectCommit,
+                    author: commit.author,
+                };
+                if (commit.isDirectCommit) {
+                    console.log(`      ⭐ DIRECT: ${commit.title} (${commit.author})`);
+                }
+            }
+            saveState(state);
+        }
+        // 3. Update statuses of in-progress agents
+        console.log(`   🔍 Checking agent statuses...`);
+        const beforePending = Object.values(state.merges).filter((e) => e.status === "pending_review").length;
+        updateAllStatuses(state);
+        const afterPending = Object.values(state.merges).filter((e) => e.status === "pending_review").length;
+        if (afterPending > beforePending) {
+            console.log(`   🎉 ${afterPending - beforePending} agent(s) completed!`);
+        }
+        // 4. Count current state (including bundles)
+        const mergeCounts = {
+            new: 0,
+            pending: 0,
+            porting: 0,
+            pending_review: 0,
+            shelved: 0,
+            merged: 0,
+            ignored: 0,
+        };
+        for (const entry of Object.values(state.merges)) {
+            mergeCounts[entry.status]++;
+        }
+        const bundleCounts = { pending: 0, porting: 0, pending_review: 0, merged: 0, ignored: 0 };
+        if (state.bundles) {
+            for (const bundle of Object.values(state.bundles)) {
+                if (bundle.status in bundleCounts) {
+                    bundleCounts[bundle.status]++;
+                }
+            }
+        }
+        const totalPorting = bundleCounts.porting +
+            Object.values(state.merges).filter((e) => e.status === "porting" && !e.bundleId).length;
+        const totalReady = bundleCounts.pending_review + mergeCounts.pending_review;
+        const totalQueued = bundleCounts.pending +
+            Object.values(state.merges).filter((e) => e.status === "new" && !e.bundleId && !e.isDirectCommit).length;
+        console.log(`   📊 Status: ${totalPorting} porting | ${totalReady} ready | ${totalQueued} queued (${bundleCounts.pending} bundles + ${totalQueued - bundleCounts.pending} PRs)`);
+        // 5. Check if we're done
+        if (totalQueued === 0 && totalPorting === 0) {
+            console.log("\n" + "═".repeat(60));
+            console.log("🎉 ALL DONE! No more work to process.");
+            console.log(`   ✅ Merged: ${mergeCounts.merged}`);
+            console.log(`   👀 Ready for review: ${totalReady}`);
+            console.log(`   📦 Shelved: ${mergeCounts.shelved}`);
+            console.log(`   ⏭️  Ignored: ${mergeCounts.ignored}`);
+            console.log("═".repeat(60) + "\n");
+            console.log("Daemon exiting. Run 'upstream-sync review' to see pending PRs.");
+            break;
+        }
+        // 6. Dispatch agents for new work (up to max concurrent)
+        // Handle both bundles (for direct commits) and individual PRs
+        const maxConcurrent = 6;
+        // Count currently porting (both bundle and individual)
+        const portingBundles = state.bundles
+            ? Object.values(state.bundles).filter((b) => b.status === "porting").length
+            : 0;
+        const portingIndividual = Object.values(state.merges).filter((e) => e.status === "porting" && !e.bundleId).length;
+        const currentlyPorting = portingBundles + portingIndividual;
+        const canDispatch = Math.max(0, maxConcurrent - currentlyPorting);
+        if (canDispatch > 0 && !isDispatchDisabled(state)) {
+            let dispatched = 0;
+            // First: dispatch pending bundles (direct commits) - OLDEST FIRST
+            if (state.bundles) {
+                const allBundles = Object.entries(state.bundles);
+                const breakingActive = allBundles.some(([_, b]) => getBundleCategory(b) === "breaking" &&
+                    (b.status === "porting" || b.status === "pending_review"));
+                let pendingBundles = allBundles
+                    .filter(([_, b]) => b.status === "pending")
+                    .sort((a, b) => {
+                    // Oldest first, then higher priority
+                    const dateDiff = new Date(a[1].dateRange.start).getTime() - new Date(b[1].dateRange.start).getTime();
+                    if (dateDiff !== 0)
+                        return dateDiff;
+                    return b[1].priority - a[1].priority;
+                });
+                if (breakingActive) {
+                    // Hold other bundles until breaking change is merged
+                    const breakingPending = pendingBundles.filter(([_, b]) => getBundleCategory(b) === "breaking");
+                    if (breakingPending.length === 0) {
+                        console.log("   ⏸️ Holding new bundles until breaking change is merged");
+                        pendingBundles = [];
+                    }
+                    else {
+                        pendingBundles = breakingPending;
+                    }
+                }
+                for (const [bundleId] of pendingBundles) {
+                    if (dispatched >= canDispatch)
+                        break;
+                    try {
+                        dispatchBundleAgent(state, bundleId);
+                        const bundle = state.bundles[bundleId];
+                        console.log(`      ✓ 📦 Bundle: ${bundle.name.slice(0, 50)}`);
+                        dispatched++;
+                    }
+                    catch (e) {
+                        console.error(`      ✗ Bundle ${bundleId}: ${e}`);
+                    }
+                }
+            }
+            // Second: dispatch new PR merges (non-bundled commits) - OLDEST FIRST
+            if (dispatched < canDispatch) {
+                const newPRs = Object.entries(state.merges)
+                    .filter(([_, e]) => e.status === "new" && !e.isDirectCommit && !e.bundleId)
+                    .sort((a, b) => {
+                    // Oldest first
+                    return new Date(a[1].date).getTime() - new Date(b[1].date).getTime();
+                });
+                for (const [sha, entry] of newPRs) {
+                    if (dispatched >= canDispatch)
+                        break;
+                    try {
+                        dispatchAgent(state, sha);
+                        console.log(`      ✓ PR #${entry.prNumber}: ${entry.title.slice(0, 40)}`);
+                        dispatched++;
+                    }
+                    catch (e) {
+                        console.error(`      ✗ PR #${entry.prNumber}: ${e}`);
+                    }
+                }
+            }
+            if (dispatched > 0) {
+                console.log(`   🚀 Dispatched ${dispatched} agent(s)`);
+            }
+            else {
+                console.log(`   ⏸️ No new work to dispatch`);
+            }
+        }
+        else if (isDispatchDisabled(state)) {
+            console.log(`   ⛔ Dispatch paused; skipping new agents`);
+        }
+        else {
+            console.log(`   ⏳ All ${maxConcurrent} slots occupied`);
+        }
+        // 7. Sleep before next iteration
+        console.log(`   💤 Sleeping ${intervalMinutes} minute(s)...`);
+        await sleep(intervalMinutes * 60 * 1000);
+    }
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || "sync";
+    let state;
+    try {
+        state = loadState();
+    }
+    catch (e) {
+        console.error(`❌ ${e}`);
+        process.exit(1);
+    }
+    switch (command) {
+        case "daemon": {
+            // Parse interval from args (default 2 minutes)
+            const interval = args[1] ? parseInt(args[1], 10) : 2;
+            await runDaemon(state, interval);
+            break;
+        }
+        case "status":
+            updateAllStatuses(state);
+            printStatus(state);
+            break;
+        case "timeline":
+            cmdTimeline(state);
+            break;
+        case "merge":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync merge <pr#> [pr#] [pr#]...");
+                process.exit(1);
+            }
+            cmdMergeMultiple(state, args.slice(1));
+            break;
+        case "review":
+            cmdReview(state);
+            break;
+        case "shelve":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync shelve <pr#>");
+                process.exit(1);
+            }
+            cmdShelve(state, args[1]);
+            break;
+        case "unshelve":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync unshelve <pr#>");
+                process.exit(1);
+            }
+            cmdUnshelve(state, args[1]);
+            break;
+        case "ignore":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync ignore <pr#> [reason]");
+                process.exit(1);
+            }
+            cmdIgnore(state, args[1], args.slice(2).join(" "));
+            break;
+        case "retry":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync retry <pr#>");
+                process.exit(1);
+            }
+            cmdRetry(state, args[1]);
+            break;
+        case "show":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync show <pr#>");
+                process.exit(1);
+            }
+            cmdShow(state, args[1]);
+            break;
+        case "bundles":
+            cmdBundles(state);
+            break;
+        case "rebundle":
+            cmdRebundle(state);
+            break;
+        case "bundle-dispatch":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync bundle-dispatch <bundle-id>");
+                process.exit(1);
+            }
+            cmdBundleDispatch(state, args[1]);
+            break;
+        case "bundle-ignore":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync bundle-ignore <bundle-id> [reason]");
+                process.exit(1);
+            }
+            cmdBundleIgnore(state, args[1], args.slice(2).join(" "));
+            break;
+        case "bundle-split":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync bundle-split <bundle-id>");
+                process.exit(1);
+            }
+            cmdBundleSplit(state, args[1]);
+            break;
+        case "bundle-requeue":
+            if (!args[1]) {
+                console.error("Usage: upstream-sync bundle-requeue <bundle-id>");
+                process.exit(1);
+            }
+            cmdBundleRequeue(state, args[1]);
+            break;
+        case "bundle-dispatch-oldest": {
+            const rawCount = args[1] ? parseInt(args[1], 10) : undefined;
+            cmdBundleDispatchOldest(state, Number.isFinite(rawCount) ? rawCount : undefined);
+            break;
+        }
+        case "bundle-auto":
+            // Optional: specify minimum priority (default 70 = features+)
+            const minPriority = args[1] ? parseInt(args[1], 10) : 70;
+            cmdBundleAuto(state, minPriority);
+            break;
+        case "pause":
+            state.dispatchDisabled = true;
+            saveState(state);
+            console.log("⛔ Dispatch paused. New agents will not be started.");
+            break;
+        case "resume":
+            state.dispatchDisabled = false;
+            saveState(state);
+            console.log("✅ Dispatch resumed. New agents can be started.");
+            break;
+        case "sync":
+        default:
+            // Full sync flow
+            console.log("🔄 UPSTREAM SYNC\n");
+            // 1. Fetch
+            fetchUpstream(state);
+            // 2. Find new commits (both merges and direct commits)
+            const newCommits = findNewCommits(state);
+            if (newCommits.length > 0) {
+                const directCommits = newCommits.filter((c) => c.isDirectCommit);
+                const prCommits = newCommits.filter((c) => !c.isDirectCommit);
+                console.log(`\n📦 Found ${newCommits.length} new commit(s):`);
+                // Show direct commits first (more important)
+                if (directCommits.length > 0) {
+                    console.log(`\n   ⭐ DIRECT COMMITS (${directCommits.length}) - PRIORITY:`);
+                    for (const commit of directCommits) {
+                        console.log(`      ${commit.title}`);
+                        console.log(`         Author: ${commit.author} | Date: ${commit.date}`);
+                        state.merges[commit.sha] = {
+                            status: "new",
+                            title: commit.title,
+                            date: commit.date,
+                            isDirectCommit: true,
+                            author: commit.author,
+                        };
+                    }
+                }
+                // Then PR merges
+                if (prCommits.length > 0) {
+                    console.log(`\n   📋 PR MERGES (${prCommits.length}):`);
+                    for (const commit of prCommits) {
+                        console.log(`      PR #${commit.prNumber}: ${commit.title}`);
+                        state.merges[commit.sha] = {
+                            status: "new",
+                            prNumber: commit.prNumber,
+                            title: commit.title,
+                            date: commit.date,
+                            isDirectCommit: false,
+                            author: commit.author,
+                        };
+                    }
+                }
+                saveState(state);
+            }
+            else {
+                console.log("\n✨ No new commits found");
+            }
+            // 3. Update statuses of in-progress agents
+            console.log("\n🔍 Checking agent statuses...");
+            updateAllStatuses(state);
+            // 4. Dispatch agents - PRIORITIZE direct commits
+            const currentlyPorting = Object.values(state.merges).filter((e) => e.status === "porting").length;
+            const maxConcurrentSync = 6;
+            const canDispatchSync = Math.max(0, maxConcurrentSync - currentlyPorting);
+            // Sort: direct commits first, then by date
+            const newEntries = Object.entries(state.merges)
+                .filter(([_, e]) => e.status === "new")
+                .sort((a, b) => {
+                if (a[1].isDirectCommit && !b[1].isDirectCommit)
+                    return -1;
+                if (!a[1].isDirectCommit && b[1].isDirectCommit)
+                    return 1;
+                return new Date(b[1].date).getTime() - new Date(a[1].date).getTime();
+            });
+            const toDispatchSync = newEntries.slice(0, canDispatchSync);
+            if (toDispatchSync.length > 0 && !isDispatchDisabled(state)) {
+                console.log(`\n🚀 Dispatching ${toDispatchSync.length} agent(s)...`);
+                for (const [sha, entry] of toDispatchSync) {
+                    try {
+                        dispatchAgent(state, sha);
+                        const label = entry.isDirectCommit ? "⭐ DIRECT" : `PR #${entry.prNumber}`;
+                        console.log(`   ✓ ${label}: ${entry.title}`);
+                    }
+                    catch (e) {
+                        console.error(`   Failed to dispatch: ${e}`);
+                    }
+                }
+            }
+            else if (isDispatchDisabled(state) && toDispatchSync.length > 0) {
+                console.log(`\n⛔ Dispatch paused; ${toDispatchSync.length} agent(s) queued`);
+            }
+            // 5. Show status
+            printStatus(state);
+            break;
+    }
+}
+main().catch((e) => {
+    console.error("Fatal error:", e);
+    process.exit(1);
+});