@teammates/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -7,21 +7,37 @@
  *   teammates --adapter codex     Use a specific agent adapter
  *   teammates --dir <path>        Override .teammates/ location
  */
+import { spawn as cpSpawn, exec as execCb, execSync, } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import { Writable } from "node:stream";
-import { resolve, join } from "node:path";
-import { stat, mkdir, readdir } from "node:fs/promises";
-import { execSync, exec as execCb } from "node:child_process";
-import { statSync, readdirSync } from "node:fs";
 import { promisify } from "node:util";
 const execAsync = promisify(execCb);
+import { App, ChatView, Control, concat, esc, Interview, pen, renderMarkdown, StyledText, stripAnsi, } from "@teammates/consolonia";
 import chalk from "chalk";
 import ora from "ora";
-import { Orchestrator } from "./orchestrator.js";
-import { EchoAdapter } from "./adapters/echo.js";
 import { CliProxyAdapter, PRESETS } from "./adapters/cli-proxy.js";
-import { Dropdown } from "./dropdown.js";
-import { getOnboardingPrompt, copyTemplateFiles } from "./onboard.js";
+import { CopilotAdapter } from "./adapters/copilot.js";
+import { EchoAdapter } from "./adapters/echo.js";
+import { findAtMention, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
+import { compactEpisodic } from "./compact.js";
+import { PromptInput } from "./console/prompt-input.js";
+import { buildTitle } from "./console/startup.js";
+import { buildAdaptationPrompt, copyTemplateFiles, getOnboardingPrompt, importTeammates, } from "./onboard.js";
+import { Orchestrator } from "./orchestrator.js";
+import { colorToHex, theme } from "./theme.js";
+// ─── Version ─────────────────────────────────────────────────────────
+const PKG_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
 // ─── Argument parsing ────────────────────────────────────────────────
 const args = process.argv.slice(2);
 function getFlag(name) {
@@ -61,7 +77,9 @@ async function findTeammatesDir() {
             if (s.isDirectory())
                 return candidate;
         }
-        catch { /* keep looking */ }
+        catch {
+            /* keep looking */
+        }
         const parent = resolve(dir, "..");
         if (parent === dir)
             break;
@@ -72,6 +90,12 @@ async function findTeammatesDir() {
 function resolveAdapter(name) {
     if (name === "echo")
         return new EchoAdapter();
+    // GitHub Copilot SDK adapter
+    if (name === "copilot") {
+        return new CopilotAdapter({
+            model: modelOverride,
+        });
+    }
     // All other adapters go through the CLI proxy
     if (PRESETS[name]) {
         return new CliProxyAdapter({
@@ -80,22 +104,11 @@ function resolveAdapter(name) {
             extraFlags: agentPassthrough,
         });
     }
-    const available = ["echo", ...Object.keys(PRESETS)].join(", ");
+    const available = ["echo", "copilot", ...Object.keys(PRESETS)].join(", ");
     console.error(chalk.red(`Unknown adapter: ${name}`));
     console.error(`Available adapters: ${available}`);
     process.exit(1);
 }
-function relativeTime(date) {
-    const diff = Date.now() - date.getTime();
-    const secs = Math.floor(diff / 1000);
-    if (secs < 60)
-        return `${secs}s ago`;
-    const mins = Math.floor(secs / 60);
-    if (mins < 60)
-        return `${mins}m ago`;
-    const hrs = Math.floor(mins / 60);
-    return `${hrs}h ago`;
-}
 const SERVICE_REGISTRY = {
     recall: {
         package: "@teammates/recall",
@@ -108,18 +121,306 @@ const SERVICE_REGISTRY = {
             "",
             "1. Verify `teammates-recall --help` works. If it does, great. If not, figure out the correct path to the binary (check recall/package.json bin field) and note it.",
             "2. Read .teammates/PROTOCOL.md and .teammates/CROSS-TEAM.md.",
-            "3. If recall is not already documented there, add a short section explaining that `teammates-recall` is now available for semantic memory search, with basic usage (e.g. `teammates-recall search \"query\"`).",
+            '3. If recall is not already documented there, add a short section explaining that `teammates-recall` is now available for semantic memory search, with basic usage (e.g. `teammates-recall search "query"`).',
             "4. Check each teammate's SOUL.md (under .teammates/*/SOUL.md). If a teammate's role involves memory or search, note in their SOUL.md that recall is installed and available.",
             "5. Do NOT modify code files — only update .teammates/ markdown files.",
         ].join("\n"),
     },
 };
+// WordwheelItem is now DropdownItem from @teammates/consolonia
+// ── Themed pen shortcuts ────────────────────────────────────────────
+//
+// Thin wrappers that read from the active theme() at call time, so
+// every styled span picks up the current palette automatically.
+const tp = {
+    accent: (s) => pen.fg(theme().accent)(s),
+    accentBright: (s) => pen.fg(theme().accentBright)(s),
+    accentDim: (s) => pen.fg(theme().accentDim)(s),
+    text: (s) => pen.fg(theme().text)(s),
+    muted: (s) => pen.fg(theme().textMuted)(s),
+    dim: (s) => pen.fg(theme().textDim)(s),
+    success: (s) => pen.fg(theme().success)(s),
+    warning: (s) => pen.fg(theme().warning)(s),
+    error: (s) => pen.fg(theme().error)(s),
+    info: (s) => pen.fg(theme().info)(s),
+    bold: (s) => pen.bold.fg(theme().text)(s),
+};
+/**
+ * Custom banner widget that plays a reveal animation inside the
+ * consolonia rendering loop (alternate screen already active).
+ *
+ * Phases:
+ *  1. Reveal "teammates" letter by letter in block font
+ *  2. Collapse to "TM" + stats panel
+ *  3. Fade in teammate roster
+ *  4. Fade in command reference
+ */
+class AnimatedBanner extends Control {
+    _lines = [];
+    _info;
+    _phase = "idle";
+    _inner;
+    _timer = null;
+    _onDirty = null;
+    // Spelling state
+    _word = "teammates";
+    _charIndex = 0;
+    _builtTop = "";
+    _builtBot = "";
+    _versionStr = ` v${PKG_VERSION}`;
+    _versionIndex = 0;
+    // Roster/command reveal state
+    _revealIndex = 0;
+    /** When true, the animation pauses after roster reveal (before commands). */
+    _held = false;
+    // The final lines (built once, revealed progressively)
+    _finalLines = [];
+    // Line index where roster starts and commands start
+    _rosterStart = 0;
+    _commandsStart = 0;
+    static GLYPHS = {
+        t: ["▀█▀", " █ "],
+        e: ["█▀▀", "██▄"],
+        a: ["▄▀█", "█▀█"],
+        m: ["█▀▄▀█", "█ ▀ █"],
+        s: ["█▀", "▄█"],
+    };
+    constructor(info) {
+        super();
+        this._info = info;
+        this._inner = new StyledText({ lines: [], wrap: true });
+        this.addChild(this._inner);
+        this._buildFinalLines();
+    }
+    /** Set a callback that fires when the banner needs a re-render. */
+    set onDirty(fn) {
+        this._onDirty = fn;
+    }
+    /** Start the animation sequence. */
+    start() {
+        this._phase = "spelling";
+        this._charIndex = 0;
+        this._builtTop = "";
+        this._builtBot = "";
+        this._tick();
+    }
+    _buildFinalLines() {
+        const info = this._info;
+        const [tmTop, tmBot] = buildTitle("tm");
+        const tmPad = " ".repeat(tmTop.length);
+        const gap = "   ";
+        const lines = [];
+        // TM logo row 1 + adapter info
+        lines.push(concat(tp.accent(tmTop), tp.text(gap + info.adapterName), tp.muted(` · ${info.teammateCount} teammate${info.teammateCount === 1 ? "" : "s"}`), tp.muted(` · v${PKG_VERSION}`)));
+        // TM logo row 2 + cwd
+        lines.push(concat(tp.accent(tmBot), tp.muted(gap + info.cwd)));
+        // Recall status (indented to align with info above)
+        lines.push(info.recallInstalled
+            ? concat(tp.text(tmPad + gap), tp.success("● "), tp.success("recall"), tp.muted(" installed"))
+            : concat(tp.text(tmPad + gap), tp.warning("○ "), tp.warning("recall"), tp.muted(" not installed")));
+        // blank
+        lines.push("");
+        this._rosterStart = lines.length;
+        // Teammate roster
+        for (const t of info.teammates) {
+            lines.push(concat(tp.accent("  ● "), tp.accent(`@${t.name}`.padEnd(14)), tp.muted(t.role)));
+        }
+        // blank
+        lines.push("");
+        this._commandsStart = lines.length;
+        // Command reference (must match printBanner normal-mode layout)
+        const col1 = [
+            ["@mention", "assign to teammate"],
+            ["text", "auto-route task"],
+            ["[image]", "drag & drop images"],
+        ];
+        const col2 = [
+            ["/status", "teammates & queue"],
+            ["/compact", "compact memory"],
+            ["/retro", "run retrospective"],
+        ];
+        const col3 = [
+            [
+                info.recallInstalled ? "/copy" : "/install",
+                info.recallInstalled ? "copy session text" : "add a service",
+            ],
+            ["/help", "all commands"],
+            ["/exit", "exit session"],
+        ];
+        for (let i = 0; i < col1.length; i++) {
+            lines.push(concat(tp.accent(`  ${col1[i][0].padEnd(12)}`), tp.muted(col1[i][1].padEnd(22)), tp.accent(col2[i][0].padEnd(12)), tp.muted(col2[i][1].padEnd(22)), tp.accent(col3[i][0].padEnd(12)), tp.muted(col3[i][1])));
+        }
+        this._finalLines = lines;
+    }
+    _tick() {
+        switch (this._phase) {
+            case "spelling": {
+                const ch = this._word[this._charIndex];
+                const g = AnimatedBanner.GLYPHS[ch];
+                if (g) {
+                    if (this._builtTop.length > 0) {
+                        this._builtTop += " ";
+                        this._builtBot += " ";
+                    }
+                    this._builtTop += g[0];
+                    this._builtBot += g[1];
+                }
+                this._lines = [
+                    concat(tp.accent(this._builtTop)),
+                    concat(tp.accent(this._builtBot)),
+                ];
+                this._apply();
+                this._charIndex++;
+                if (this._charIndex >= this._word.length) {
+                    this._phase = "version";
+                    this._versionIndex = 0;
+                    this._schedule(60);
+                }
+                else {
+                    this._schedule(60);
+                }
+                break;
+            }
+            case "version": {
+                // Type out version string character by character on the bottom row
+                this._versionIndex++;
+                const partial = this._versionStr.slice(0, this._versionIndex);
+                this._lines = [
+                    concat(tp.accent(this._builtTop)),
+                    concat(tp.accent(this._builtBot), tp.muted(partial)),
+                ];
+                this._apply();
+                if (this._versionIndex >= this._versionStr.length) {
+                    this._phase = "pause";
+                    this._schedule(600);
+                }
+                else {
+                    this._schedule(60);
+                }
+                break;
+            }
+            case "pause": {
+                // Brief pause before transitioning to compact view
+                this._phase = "compact";
+                this._schedule(800);
+                break;
+            }
+            case "compact": {
+                // Switch to TM + stats — show first 4 lines of final
+                this._lines = this._finalLines.slice(0, 4);
+                this._apply();
+                this._phase = "roster";
+                this._revealIndex = 0;
+                this._schedule(80);
+                break;
+            }
+            case "roster": {
+                // Reveal roster lines one at a time
+                const end = this._rosterStart + this._revealIndex + 1;
+                this._lines = [
+                    ...this._finalLines.slice(0, this._rosterStart),
+                    ...this._finalLines.slice(this._rosterStart, end),
+                ];
+                this._apply();
+                this._revealIndex++;
+                const rosterCount = this._commandsStart - 1 - this._rosterStart; // -1 for blank line
+                if (this._revealIndex >= rosterCount) {
+                    if (this._held) {
+                        // Pause here until releaseHold() is called
+                        this._phase = "roster-held";
+                    }
+                    else {
+                        this._phase = "commands";
+                        this._revealIndex = 0;
+                        this._schedule(80);
+                    }
+                }
+                else {
+                    this._schedule(40);
+                }
+                break;
+            }
+            case "commands": {
+                // Add the blank line between roster and commands, then reveal commands
+                const rosterEnd = this._commandsStart; // includes the blank line
+                const cmdEnd = this._commandsStart + this._revealIndex + 1;
+                this._lines = [
+                    ...this._finalLines.slice(0, rosterEnd),
+                    ...this._finalLines.slice(this._commandsStart, cmdEnd),
+                ];
+                this._apply();
+                this._revealIndex++;
+                const cmdCount = this._finalLines.length - this._commandsStart;
+                if (this._revealIndex >= cmdCount) {
+                    this._phase = "done";
+                }
+                else {
+                    this._schedule(30);
+                }
+                break;
+            }
+        }
+    }
+    _apply() {
+        this._inner.lines = this._lines;
+        this.invalidate();
+        if (this._onDirty)
+            this._onDirty();
+    }
+    _schedule(ms) {
+        this._timer = setTimeout(() => {
+            this._timer = null;
+            this._tick();
+        }, ms);
+    }
+    /**
+     * Hold the animation — it will pause after the roster phase and
+     * not reveal the command reference until releaseHold() is called.
+     */
+    hold() {
+        this._held = true;
+    }
+    /**
+     * Release the hold and continue to the commands phase.
+     * If the animation already reached the hold point, it resumes immediately.
+     */
+    releaseHold() {
+        this._held = false;
+        // If we're waiting at the hold point, resume
+        if (this._phase === "roster-held") {
+            this._phase = "commands";
+            this._revealIndex = 0;
+            this._schedule(80);
+        }
+    }
+    /** Cancel any pending animation timer. */
+    dispose() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+    // ── Layout delegation ───────────────────────────────────────────
+    measure(constraint) {
+        const size = this._inner.measure(constraint);
+        this.desiredSize = size;
+        return size;
+    }
+    arrange(rect) {
+        this.bounds = rect;
+        this._inner.arrange(rect);
+    }
+    render(ctx) {
+        this._inner.render(ctx);
+    }
+}
 // ─── REPL ────────────────────────────────────────────────────────────
 class TeammatesREPL {
     orchestrator;
     adapter;
-    rl;
-    spinner = null;
+    input;
+    chatView;
+    app;
     commands = new Map();
     lastResult = null;
     lastResults = new Map();
@@ -145,199 +446,1242 @@ class TeammatesREPL {
     }
     adapterName;
     teammatesDir;
+    recallWatchProcess = null;
     taskQueue = [];
-    queueActive = null;
-    queueDraining = false;
-    /** Mutex to prevent concurrent drainQueue invocations. Resolves when drain finishes. */
-    drainLock = null;
-    /** True while a task is being dispatched — prevents concurrent dispatches from pasted text. */
-    dispatching = false;
+    /** Per-agent active tasks — one per agent running in parallel. */
+    agentActive = new Map();
+    /** Per-agent drain locks — prevents double-draining a single agent. */
+    agentDrainLocks = new Map();
     /** Stored pasted text keyed by paste number, expanded on Enter. */
     pastedTexts = new Map();
-    dropdown;
+    pasteCounter = 0;
     wordwheelItems = [];
     wordwheelIndex = -1; // -1 = no selection, 0+ = highlighted row
+    escPending = false; // true after first ESC, waiting for second
+    escTimer = null;
+    ctrlcPending = false; // true after first Ctrl+C, waiting for second
+    ctrlcTimer = null;
+    lastCleanedOutput = ""; // last teammate output for clipboard copy
+    dispatching = false;
+    autoApproveHandoffs = false;
+    /** Pending handoffs awaiting user approval. */
+    pendingHandoffs = [];
+    /** Pending retro proposals awaiting user approval. */
+    pendingRetroProposals = [];
+    /** Maps reply action IDs to their context (teammate + message). */
+    _replyContexts = new Map();
+    /** Quoted reply text to expand on next submit. */
+    _pendingQuotedReply = null;
+    defaultFooter = null; // cached default footer content
+    // ── Animated status tracker ─────────────────────────────────────
+    activeTasks = new Map();
+    statusTimer = null;
+    statusFrame = 0;
+    statusRotateIndex = 0;
+    statusRotateTimer = null;
+    static SPINNER = [
+        "⠋",
+        "⠙",
+        "⠹",
+        "⠸",
+        "⠼",
+        "⠴",
+        "⠦",
+        "⠧",
+        "⠇",
+        "⠏",
+    ];
     constructor(adapterName) {
         this.adapterName = adapterName;
     }
-    // ─── Onboarding ───────────────────────────────────────────────────
-    /**
-     * Interactive prompt when no .teammates/ directory is found.
-     * Returns the new .teammates/ path, or null if user chose to exit.
-     */
-    async promptOnboarding(adapter) {
-        const cwd = process.cwd();
-        const teammatesDir = join(cwd, ".teammates");
-        const termWidth = process.stdout.columns || 100;
-        console.log();
-        this.printLogo([
-            chalk.bold("Teammates") + chalk.gray(" v0.1.0"),
-            chalk.yellow("No .teammates/ directory found"),
-            chalk.gray(cwd),
-        ]);
-        console.log();
-        console.log(chalk.gray("─".repeat(termWidth)));
-        console.log();
-        console.log(chalk.white("  Set up teammates for this project?\n"));
-        console.log(chalk.cyan("  1") + chalk.gray(") ") +
-            chalk.white("Run onboarding") +
-            chalk.gray(" — analyze this codebase and create .teammates/"));
-        console.log(chalk.cyan("  2") + chalk.gray(") ") +
-            chalk.white("Solo mode") +
-            chalk.gray(` — use ${this.adapterName} without teammates`));
-        console.log(chalk.cyan("  3") + chalk.gray(") ") +
-            chalk.white("Exit"));
-        console.log();
-        const choice = await this.askChoice("Pick an option (1/2/3): ", ["1", "2", "3"]);
-        if (choice === "3") {
-            console.log(chalk.gray("  Goodbye."));
-            return null;
+    /** Show the prompt with the fenced border. */
+    showPrompt() {
+        if (this.chatView) {
+            // ChatView is always visible — just refresh
+            this.app.refresh();
         }
-        if (choice === "2") {
-            await mkdir(teammatesDir, { recursive: true });
-            console.log();
-            console.log(chalk.green("  ✔") + chalk.gray(` Created ${teammatesDir}`));
-            console.log(chalk.gray(`  Running in solo mode — all tasks go to ${this.adapterName}.`));
-            console.log(chalk.gray("  Run /init later to set up teammates."));
-            console.log();
-            return teammatesDir;
+        else {
+            this.input.activate();
         }
-        // choice === "1": Run onboarding via the agent
-        await mkdir(teammatesDir, { recursive: true });
-        await this.runOnboardingAgent(adapter, cwd);
-        return teammatesDir;
     }
-    /**
-     * Run the onboarding agent to analyze the codebase and create teammates.
-     * Used by both promptOnboarding (pre-orchestrator) and cmdInit (post-orchestrator).
-     */
-    async runOnboardingAgent(adapter, projectDir) {
-        console.log();
-        console.log(chalk.blue("  Starting onboarding...") +
-            chalk.gray(` ${this.adapterName} will analyze your codebase and create .teammates/`));
-        console.log();
-        // Copy framework files from bundled template
-        const teammatesDir = join(projectDir, ".teammates");
-        const copied = await copyTemplateFiles(teammatesDir);
-        if (copied.length > 0) {
-            console.log(chalk.green("  ✔") + chalk.gray(` Copied template files: ${copied.join(", ")}`));
-            console.log();
-        }
-        const onboardingPrompt = await getOnboardingPrompt(projectDir);
-        const tempConfig = {
-            name: this.adapterName,
-            role: "Onboarding agent",
-            soul: "",
-            memories: "",
-            dailyLogs: [],
-            ownership: { primary: [], secondary: [] },
-        };
-        const sessionId = await adapter.startSession(tempConfig);
-        const spinner = ora({
-            text: chalk.blue(this.adapterName) + chalk.gray(" is analyzing your codebase..."),
-            spinner: "dots",
-        }).start();
-        try {
-            const result = await adapter.executeTask(sessionId, tempConfig, onboardingPrompt);
-            spinner.stop();
-            this.printAgentOutput(result.rawOutput);
-            if (result.success) {
-                console.log(chalk.green("  ✔ Onboarding complete!"));
-            }
-            else {
-                console.log(chalk.yellow("  ⚠ Onboarding finished with issues: " + result.summary));
+    /** Start or update the animated status tracker above the prompt. */
+    startStatusAnimation() {
+        if (this.statusTimer)
+            return; // already running
+        this.statusFrame = 0;
+        this.statusRotateIndex = 0;
+        this.renderStatusFrame();
+        // Animate spinner at ~80ms
+        this.statusTimer = setInterval(() => {
+            this.statusFrame++;
+            this.renderStatusFrame();
+        }, 80);
+        // Rotate through teammates every 3 seconds
+        this.statusRotateTimer = setInterval(() => {
+            if (this.activeTasks.size > 1) {
+                this.statusRotateIndex =
+                    (this.statusRotateIndex + 1) % this.activeTasks.size;
             }
+        }, 3000);
+    }
+    /** Stop the status animation and clear the status line. */
+    stopStatusAnimation() {
+        if (this.statusTimer) {
+            clearInterval(this.statusTimer);
+            this.statusTimer = null;
         }
-        catch (err) {
-            spinner.fail(chalk.red("Onboarding failed: " + err.message));
+        if (this.statusRotateTimer) {
+            clearInterval(this.statusRotateTimer);
+            this.statusRotateTimer = null;
         }
-        if (adapter.destroySession) {
-            await adapter.destroySession(sessionId);
+        if (this.chatView) {
+            this.chatView.setProgress(null);
+            this.app.refresh();
         }
-        // Verify .teammates/ now has content
-        try {
-            const entries = await readdir(teammatesDir);
-            if (!entries.some(e => !e.startsWith("."))) {
-                console.log(chalk.yellow("  ⚠ .teammates/ was created but appears empty."));
-                console.log(chalk.gray("  You may need to run the onboarding agent again or set up manually."));
-            }
+        else {
+            this.input.setStatus(null);
+        }
+    }
+    /** Render one frame of the status animation. */
+    renderStatusFrame() {
+        if (this.activeTasks.size === 0)
+            return;
+        const entries = Array.from(this.activeTasks.values());
+        const idx = this.statusRotateIndex % entries.length;
+        const { teammate, task } = entries[idx];
+        const spinChar = TeammatesREPL.SPINNER[this.statusFrame % TeammatesREPL.SPINNER.length];
+        const taskPreview = task.length > 50 ? `${task.slice(0, 47)}...` : task;
+        const queueInfo = this.activeTasks.size > 1 ? ` (${idx + 1}/${this.activeTasks.size})` : "";
+        if (this.chatView) {
+            // Strip newlines and truncate task text for single-line display
+            const cleanTask = task.replace(/[\r\n]+/g, " ").trim();
+            const maxLen = Math.max(20, (process.stdout.columns || 80) - teammate.length - 10);
+            const taskText = cleanTask.length > maxLen
+                ? `${cleanTask.slice(0, maxLen - 1)}…`
+                : cleanTask;
+            const queueTag = this.activeTasks.size > 1
+                ? ` (${idx + 1}/${this.activeTasks.size})`
+                : "";
+            this.chatView.setProgress(concat(tp.accent(`${spinChar} ${teammate}… `), tp.muted(taskText + queueTag)));
+            this.app.refresh();
+        }
+        else {
+            // Mostly bright blue, periodically flicker to dark blue
+            const spinColor = this.statusFrame % 8 === 0 ? chalk.blue : chalk.blueBright;
+            const line = `  ${spinColor(spinChar)} ` +
+                chalk.bold(teammate) +
+                chalk.gray(`… ${taskPreview}`) +
+                (queueInfo ? chalk.gray(queueInfo) : "");
+            this.input.setStatus(line);
         }
-        catch { /* dir might not exist if onboarding failed badly */ }
-        console.log();
     }
     /**
-     * Simple blocking prompt — reads one line from stdin and validates.
+     * Print the user's message as an inverted block in the feed.
+     * White text on dark background, right-aligned indicator.
      */
-    askChoice(prompt, valid) {
-        return new Promise((resolve) => {
-            const rl = createInterface({ input: process.stdin, output: process.stdout });
-            const ask = () => {
-                rl.question(chalk.cyan("  ") + prompt, (answer) => {
-                    const trimmed = answer.trim();
-                    if (valid.includes(trimmed)) {
-                        rl.close();
-                        resolve(trimmed);
+    _userBg = { r: 25, g: 25, b: 25, a: 255 };
+    /** Feed a line with the user message background, padded to full width. */
+    feedUserLine(spans) {
+        if (!this.chatView)
+            return;
+        const termW = (process.stdout.columns || 80) - 1; // -1 for scrollbar
+        // Calculate visible length of spans
+        let len = 0;
+        for (const seg of spans)
+            len += seg.text.length;
+        const pad = Math.max(0, termW - len);
+        const padded = concat(spans, pen.fg(this._userBg).bg(this._userBg)(" ".repeat(pad)));
+        this.chatView.appendStyledToFeed(padded);
+    }
+    /** Word-wrap text to maxWidth, breaking at spaces. */
+    wrapLine(text, maxWidth) {
+        return wrapLine(text, maxWidth);
+    }
+    printUserMessage(text) {
+        if (this.chatView) {
+            const bg = this._userBg;
+            const t = theme();
+            const termW = (process.stdout.columns || 80) - 1; // -1 for scrollbar
+            const allLines = text.split("\n");
+            // Separate non-quote lines from blockquote lines (> prefix)
+            // Find contiguous blockquote regions and fence them with empty lines
+            const rendered = [];
+            let inQuote = false;
+            for (const line of allLines) {
+                const isQuote = line.startsWith("> ") || line === ">";
+                if (isQuote && !inQuote) {
+                    rendered.push({ type: "text", content: "" }); // empty line before quotes
+                    inQuote = true;
+                }
+                else if (!isQuote && inQuote) {
+                    rendered.push({ type: "text", content: "" }); // empty line after quotes
+                    inQuote = false;
+                }
+                if (isQuote) {
+                    rendered.push({
+                        type: "quote",
+                        content: line.startsWith("> ") ? line.slice(2) : "",
+                    });
+                }
+                else {
+                    rendered.push({ type: "text", content: line });
+                }
+            }
+            // Render first line with "User: " label
+            const label = "user: ";
+            const first = rendered.shift();
+            if (first) {
+                if (first.type === "text") {
+                    const firstWrapW = termW - label.length;
+                    const firstWrapped = this.wrapLine(first.content, firstWrapW);
+                    // First wrapped segment gets the label
+                    const seg0 = firstWrapped.shift() ?? "";
+                    const pad0 = Math.max(0, termW - label.length - seg0.length);
+                    this.chatView.appendStyledToFeed(concat(pen.fg(t.accent).bg(bg)(label), pen.fg(t.text).bg(bg)(seg0 + " ".repeat(pad0))));
+                    // Remaining wrapped segments are indented to align with content
+                    for (const wl of firstWrapped) {
+                        this.feedUserLine(concat(pen.fg(t.text).bg(bg)(wl)));
                     }
-                    else {
-                        ask();
+                }
+                else {
+                    // First line is a quote (unusual but handle it)
+                    const pad = Math.max(0, termW - label.length);
+                    this.chatView.appendStyledToFeed(concat(pen.fg(t.accent).bg(bg)(label + " ".repeat(pad))));
+                    // Re-add to render as quote
+                    rendered.unshift(first);
+                }
+            }
+            // Render remaining lines
+            for (const entry of rendered) {
+                if (entry.type === "quote") {
+                    const prefix = "│ ";
+                    const wrapWidth = termW - prefix.length;
+                    const wrapped = this.wrapLine(entry.content, wrapWidth);
+                    for (const wl of wrapped) {
+                        const pad = Math.max(0, termW - prefix.length - wl.length);
+                        this.chatView.appendStyledToFeed(concat(pen.fg(t.textDim).bg(bg)(prefix), pen.fg(t.textMuted).bg(bg)(wl + " ".repeat(pad))));
                     }
-                });
-            };
-            ask();
-        });
+                }
+                else {
+                    const wrapWidth = termW;
+                    const wrapped = this.wrapLine(entry.content, wrapWidth);
+                    for (const wl of wrapped) {
+                        this.feedUserLine(concat(pen.fg(t.text).bg(bg)(wl)));
+                    }
+                }
+            }
+            this.app.refresh();
+            return;
+        }
+        const termWidth = process.stdout.columns || 100;
+        const maxWidth = Math.min(termWidth - 4, 80);
+        const lines = text.split("\n");
+        console.log();
+        for (const line of lines) {
+            // Truncate long lines
+            const display = line.length > maxWidth ? `${line.slice(0, maxWidth - 1)}…` : line;
+            const padded = display + " ".repeat(Math.max(0, maxWidth - stripAnsi(display).length));
+            console.log(`  ${chalk.bgGray.white(` ${padded} `)}`);
+        }
+        console.log();
     }
-    // ─── Display helpers ──────────────────────────────────────────────
     /**
-     * Render the box logo with up to 4 info lines on the right side.
+     * Route text input to the right teammate and queue it for execution.
+     * Returns immediately — the task runs in the background via drainQueue.
      */
-    printLogo(infoLines) {
-        const pad = (i) => infoLines[i] ? "   " + infoLines[i] : "";
-        console.log(chalk.cyan(" ▐▛▀▀▀▀▀▀▜▌") + pad(0));
-        console.log(chalk.cyan(" ▐▌") + "      " + chalk.cyan("▐▌") + pad(1));
-        console.log(chalk.cyan(" ▐▌") + "  🧬  " + chalk.cyan("▐▌") + pad(2));
-        console.log(chalk.cyan(" ▐▌") + "      " + chalk.cyan("▐▌") + pad(3));
-        console.log(chalk.cyan(" ▐▙▄▄▄▄▄▄▟▌"));
-    }
     /**
-     * Print agent raw output, stripping the trailing JSON protocol block.
+     * Write a line to the chat feed.
+     * Accepts a plain string or a StyledSpan for colored output.
      */
-    printAgentOutput(rawOutput) {
-        const raw = rawOutput ?? "";
-        if (!raw)
+    feedLine(text = "") {
+        if (this.chatView) {
+            if (typeof text === "string") {
+                this.chatView.appendToFeed(text);
+            }
+            else {
+                this.chatView.appendStyledToFeed(text);
+            }
             return;
-        const cleaned = raw.replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/, "").trim();
-        if (cleaned) {
-            console.log(cleaned);
         }
-        console.log();
+        // Fallback: convert StyledSpan to plain text for console
+        if (typeof text !== "string") {
+            console.log(text.map((s) => s.text).join(""));
+        }
+        else {
+            console.log(text);
+        }
     }
-    // ─── Wordwheel ─────────────────────────────────────────────────────
-    getUniqueCommands() {
-        const seen = new Set();
-        const result = [];
-        for (const [, cmd] of this.commands) {
-            if (seen.has(cmd.name))
-                continue;
-            seen.add(cmd.name);
-            result.push(cmd);
+    /** Render markdown text to the feed using the consolonia markdown widget. */
+    feedMarkdown(source) {
+        const t = theme();
+        const width = process.stdout.columns || 80;
+        const lines = renderMarkdown(source, {
+            width: width - 3, // -2 for indent, -1 for scrollbar
+            indent: "  ",
+            theme: {
+                text: { fg: t.textMuted },
+                bold: { fg: t.text, bold: true },
+                italic: { fg: t.textMuted, italic: true },
+                boldItalic: { fg: t.text, bold: true, italic: true },
+                code: { fg: t.accentDim },
+                h1: { fg: t.accent, bold: true },
+                h2: { fg: t.accent, bold: true },
+                h3: { fg: t.accent },
+                codeBlockChrome: { fg: t.textDim },
+                codeBlock: { fg: t.success },
+                blockquote: { fg: t.textMuted, italic: true },
+                listMarker: { fg: t.accent },
+                tableBorder: { fg: t.textDim },
+                tableHeader: { fg: t.text, bold: true },
+                hr: { fg: t.textDim },
+                link: { fg: t.accent, underline: true },
+                linkUrl: { fg: t.textMuted },
+                strikethrough: { fg: t.textMuted, strikethrough: true },
+                checkbox: { fg: t.accent },
+            },
+        });
+        for (const line of lines) {
+            // Convert markdown Line (Seg[]) to StyledSpan, preserving all style flags
+            const styledSpan = line.map((seg) => ({
+                text: seg.text,
+                style: seg.style,
+            }));
+            styledSpan.__brand = "StyledSpan";
+            this.feedLine(styledSpan);
         }
-        return result;
     }
-    clearWordwheel() {
-        this.dropdown.clear();
+    /** Render handoff blocks with approve/reject actions. */
+    /** Helper to create a branded StyledSpan from segments. */
+    makeSpan(...segs) {
+        const s = segs;
+        s.__brand = "StyledSpan";
+        return s;
     }
-    writeWordwheel(lines) {
-        this.dropdown.render(lines);
+    /** Word-wrap a string to fit within maxWidth. */
+    wordWrap(text, maxWidth) {
+        const words = text.split(" ");
+        const lines = [];
+        let current = "";
+        for (const word of words) {
+            if (current.length === 0) {
+                current = word;
+            }
+            else if (current.length + 1 + word.length <= maxWidth) {
+                current += ` ${word}`;
+            }
+            else {
+                lines.push(current);
+                current = word;
+            }
+        }
+        if (current)
+            lines.push(current);
+        return lines.length > 0 ? lines : [""];
     }
-    /**
-     * Which argument positions are teammate-name completable per command.
-     * Key = command name, value = set of 0-based arg positions that take a teammate.
-     */
-    static TEAMMATE_ARG_POSITIONS = {
-        assign: new Set([0]),
-        handoff: new Set([0, 1]),
-        log: new Set([0]),
-    };
+    renderHandoffs(_from, handoffs) {
+        const t = theme();
+        const names = this.orchestrator.listTeammates();
+        const avail = (process.stdout.columns || 80) - 4; // -4 for "  │ " + " │"
+        const boxW = Math.max(40, Math.round(avail * 0.6));
+        const innerW = boxW - 4; // space inside │ _ content _ │
+        for (let i = 0; i < handoffs.length; i++) {
+            const h = handoffs[i];
+            const isValid = names.includes(h.to);
+            const handoffId = `handoff-${Date.now()}-${i}`;
+            const chrome = isValid ? t.accentDim : t.error;
+            // Top border with label
+            this.feedLine();
+            const label = ` handoff → @${h.to} `;
+            const topFill = Math.max(0, boxW - 2 - label.length);
+            this.feedLine(this.makeSpan({
+                text: `  ┌${label}${"─".repeat(topFill)}┐`,
+                style: { fg: chrome },
+            }));
+            // Task body — word-wrap each paragraph line
+            for (const rawLine of h.task.split("\n")) {
+                const wrapped = rawLine.length === 0 ? [""] : this.wordWrap(rawLine, innerW);
+                for (const wl of wrapped) {
+                    const pad = Math.max(0, innerW - wl.length);
+                    this.feedLine(this.makeSpan({ text: "  │ ", style: { fg: chrome } }, { text: wl + " ".repeat(pad), style: { fg: t.textMuted } }, { text: " │", style: { fg: chrome } }));
+                }
+            }
+            // Bottom border
+            this.feedLine(this.makeSpan({
+                text: `  └${"─".repeat(Math.max(0, boxW - 2))}┘`,
+                style: { fg: chrome },
+            }));
+            if (!isValid) {
+                this.feedLine(tp.error(`  ✖ Unknown teammate: @${h.to}`));
+            }
+            else if (this.autoApproveHandoffs) {
+                this.taskQueue.push({ type: "agent", teammate: h.to, task: h.task });
+                this.feedLine(tp.muted("  automatically approved"));
+                this.kickDrain();
+            }
+            else if (this.chatView) {
+                const actionIdx = this.chatView.feedLineCount;
+                this.chatView.appendActionList([
+                    {
+                        id: `approve-${handoffId}`,
+                        normalStyle: this.makeSpan({
+                            text: "  [approve]",
+                            style: { fg: t.textDim },
+                        }),
+                        hoverStyle: this.makeSpan({
+                            text: "  [approve]",
+                            style: { fg: t.accent },
+                        }),
+                    },
+                    {
+                        id: `reject-${handoffId}`,
+                        normalStyle: this.makeSpan({
+                            text: " [reject]",
+                            style: { fg: t.textDim },
+                        }),
+                        hoverStyle: this.makeSpan({
+                            text: " [reject]",
+                            style: { fg: t.accent },
+                        }),
+                    },
+                ]);
+                this.pendingHandoffs.push({
+                    id: handoffId,
+                    envelope: h,
+                    approveIdx: actionIdx,
+                    rejectIdx: actionIdx,
+                });
+            }
+        }
+        // Show global approval options as dropdown when there are pending handoffs
+        this.showHandoffDropdown();
+        this.refreshView();
+    }
+    /** Show/hide the handoff approval dropdown based on pending handoffs. */
+    showHandoffDropdown() {
+        if (!this.chatView)
+            return;
+        if (this.pendingHandoffs.length > 0) {
+            const items = [];
+            if (this.pendingHandoffs.length === 1) {
+                items.push({
+                    label: "approve",
+                    description: `approve handoff to @${this.pendingHandoffs[0].envelope.to}`,
+                    completion: "/approve",
+                });
+            }
+            else {
+                items.push({
+                    label: "approve",
+                    description: `approve ${this.pendingHandoffs.length} handoffs`,
+                    completion: "/approve",
+                });
+            }
+            items.push({
+                label: "always approve",
+                description: "auto-approve future handoffs",
+                completion: "/always-approve",
+            });
+            if (this.pendingHandoffs.length === 1) {
+                items.push({
+                    label: "reject",
+                    description: `reject handoff to @${this.pendingHandoffs[0].envelope.to}`,
+                    completion: "/reject",
+                });
+            }
+            else {
+                items.push({
+                    label: "reject",
+                    description: `reject ${this.pendingHandoffs.length} handoffs`,
+                    completion: "/reject",
+                });
+            }
+            this.chatView.showDropdown(items);
+        }
+        else {
+            this.chatView.hideDropdown();
+        }
+        this.refreshView();
+    }
+    /** Handle handoff approve/reject actions. */
+    handleHandoffAction(actionId) {
+        const approveMatch = actionId.match(/^approve-(.+)$/);
+        if (approveMatch) {
+            const hId = approveMatch[1];
+            const idx = this.pendingHandoffs.findIndex((h) => h.id === hId);
+            if (idx >= 0 && this.chatView) {
+                const h = this.pendingHandoffs.splice(idx, 1)[0];
+                this.taskQueue.push({
+                    type: "agent",
+                    teammate: h.envelope.to,
+                    task: h.envelope.task,
+                });
+                this.chatView.updateFeedLine(h.approveIdx, this.makeSpan({ text: "  approved", style: { fg: theme().success } }));
+                this.kickDrain();
+                this.showHandoffDropdown();
+            }
+            return;
+        }
+        const rejectMatch = actionId.match(/^reject-(.+)$/);
+        if (rejectMatch) {
+            const hId = rejectMatch[1];
+            const idx = this.pendingHandoffs.findIndex((h) => h.id === hId);
+            if (idx >= 0 && this.chatView) {
+                const h = this.pendingHandoffs.splice(idx, 1)[0];
+                this.chatView.updateFeedLine(h.approveIdx, this.makeSpan({ text: "  rejected", style: { fg: theme().error } }));
+                this.showHandoffDropdown();
+            }
+            return;
+        }
+    }
+    /** Handle bulk handoff actions. */
+    handleBulkHandoff(action) {
+        if (!this.chatView)
+            return;
+        const t = theme();
+        const isApprove = action === "Approve all" || action === "Always approve";
+        if (action === "Always approve") {
+            this.autoApproveHandoffs = true;
+        }
+        for (const h of this.pendingHandoffs) {
+            if (isApprove) {
+                this.taskQueue.push({
+                    type: "agent",
+                    teammate: h.envelope.to,
+                    task: h.envelope.task,
+                });
+                const label = action === "Always approve"
+                    ? "  automatically approved"
+                    : "  approved";
+                this.chatView.updateFeedLine(h.approveIdx, this.makeSpan({ text: label, style: { fg: t.success } }));
+            }
+            else {
+                this.chatView.updateFeedLine(h.approveIdx, this.makeSpan({ text: "  rejected", style: { fg: t.error } }));
+            }
+        }
+        this.pendingHandoffs = [];
+        if (isApprove)
+            this.kickDrain();
+        this.showHandoffDropdown();
+    }
+    // ─── Retro Phase 2: proposal approval ─────────────────────────
+    /** Parse retro proposals from agent output and render approval UI. */
+    handleRetroResult(result) {
+        const raw = result.rawOutput ?? "";
+        const proposals = this.parseRetroProposals(raw);
+        if (proposals.length === 0)
+            return;
+        const t = theme();
+        const teammate = result.teammate;
+        const retroId = `retro-${Date.now()}`;
+        this.feedLine();
+        this.feedLine(concat(tp.accent(`  ${proposals.length} SOUL.md proposal${proposals.length > 1 ? "s" : ""}`), tp.muted(" — approve or reject each:")));
+        for (let i = 0; i < proposals.length; i++) {
+            const p = proposals[i];
+            const pId = `${retroId}-${i}`;
+            this.feedLine();
+            this.feedLine(tp.text(`  Proposal ${i + 1}: ${p.title}`));
+            this.feedLine(tp.muted(`    Section: ${p.section}`));
+            if (p.before === "(new entry)") {
+                this.feedLine(tp.muted("    Before: (new entry)"));
+            }
+            else {
+                this.feedLine(tp.muted(`    Before: ${p.before}`));
+            }
+            this.feedLine(concat(tp.muted("    After: "), tp.text(p.after)));
+            this.feedLine(tp.muted(`    Why: ${p.why}`));
+            if (this.chatView) {
+                const actionIdx = this.chatView.feedLineCount;
+                this.chatView.appendActionList([
+                    {
+                        id: `retro-approve-${pId}`,
+                        normalStyle: this.makeSpan({
+                            text: "    [approve]",
+                            style: { fg: t.textDim },
+                        }),
+                        hoverStyle: this.makeSpan({
+                            text: "    [approve]",
+                            style: { fg: t.accent },
+                        }),
+                    },
+                    {
+                        id: `retro-reject-${pId}`,
+                        normalStyle: this.makeSpan({
+                            text: " [reject]",
+                            style: { fg: t.textDim },
+                        }),
+                        hoverStyle: this.makeSpan({
+                            text: " [reject]",
+                            style: { fg: t.accent },
+                        }),
+                    },
+                ]);
+                this.pendingRetroProposals.push({
+                    id: pId,
+                    teammate,
+                    index: i + 1,
+                    title: p.title,
+                    section: p.section,
+                    before: p.before,
+                    after: p.after,
+                    why: p.why,
+                    actionIdx,
+                });
+            }
+        }
+        this.feedLine();
+        this.showRetroDropdown();
+        this.refreshView();
+    }
+    /** Parse Proposal N blocks from retro output. */
+    parseRetroProposals(text) {
+        const proposals = [];
+        // Match **Proposal N: title** blocks
+        const proposalPattern = /\*\*Proposal\s+\d+[:.]\s*(.+?)\*\*/gi;
+        let match;
+        const positions = [];
+        while ((match = proposalPattern.exec(text)) !== null) {
+            positions.push({ title: match[1].trim(), start: match.index });
+        }
+        for (let i = 0; i < positions.length; i++) {
+            const end = i + 1 < positions.length ? positions[i + 1].start : text.length;
+            const block = text.slice(positions[i].start, end);
+            const section = this.extractField(block, "Section") || "Unknown";
+            const before = this.extractField(block, "Before") || "(new entry)";
+            const after = this.extractField(block, "After") || "";
+            const why = this.extractField(block, "Why") || "";
+            if (after) {
+                proposals.push({
+                    title: positions[i].title,
+                    section,
+                    before,
+                    after,
+                    why,
+                });
+            }
+        }
+        return proposals;
+    }
+    /** Extract a **Field:** value from a proposal block. */
+    extractField(block, field) {
+        // Match "- **Field:** value" or "**Field:** value" across potential line breaks
+        const pattern = new RegExp(`\\*\\*${field}:\\*\\*\\s*(.+?)(?=\\n\\s*[-*]\\s*\\*\\*|\\n\\s*\\n|$)`, "is");
+        const m = block.match(pattern);
+        if (!m)
+            return "";
+        // Clean up: remove backticks and trim
+        return m[1].trim().replace(/^`+|`+$/g, "");
+    }
+    /** Show/hide the retro approval dropdown based on pending proposals. */
+    showRetroDropdown() {
+        if (!this.chatView)
+            return;
+        if (this.pendingRetroProposals.length > 0 &&
+            this.pendingHandoffs.length === 0) {
+            const n = this.pendingRetroProposals.length;
+            const items = [];
+            items.push({
+                label: "approve all",
+                description: `approve ${n} SOUL.md proposal${n > 1 ? "s" : ""}`,
+                completion: "/approve-retro",
+            });
+            items.push({
+                label: "reject all",
+                description: `reject ${n} SOUL.md proposal${n > 1 ? "s" : ""}`,
+                completion: "/reject-retro",
+            });
+            this.chatView.showDropdown(items);
+        }
+        else if (this.pendingHandoffs.length === 0) {
+            this.chatView.hideDropdown();
+        }
+        this.refreshView();
+    }
+    /** Handle retro approve/reject actions (individual clicks). */
+    handleRetroAction(actionId) {
+        const approveMatch = actionId.match(/^retro-approve-(.+)$/);
+        if (approveMatch) {
+            const pId = approveMatch[1];
+            const idx = this.pendingRetroProposals.findIndex((p) => p.id === pId);
+            if (idx >= 0 && this.chatView) {
+                const p = this.pendingRetroProposals.splice(idx, 1)[0];
+                this.chatView.updateFeedLine(p.actionIdx, this.makeSpan({
+                    text: "    approved",
+                    style: { fg: theme().success },
+                }));
+                this.queueRetroApply(p.teammate, [p]);
+                this.showRetroDropdown();
+            }
+            return;
+        }
+        const rejectMatch = actionId.match(/^retro-reject-(.+)$/);
+        if (rejectMatch) {
+            const pId = rejectMatch[1];
+            const idx = this.pendingRetroProposals.findIndex((p) => p.id === pId);
+            if (idx >= 0 && this.chatView) {
+                const p = this.pendingRetroProposals.splice(idx, 1)[0];
+                this.chatView.updateFeedLine(p.actionIdx, this.makeSpan({ text: "    rejected", style: { fg: theme().error } }));
+                this.showRetroDropdown();
+            }
+            return;
+        }
+    }
+    /** Handle bulk retro approve/reject. */
+    handleBulkRetro(action) {
+        if (!this.chatView)
+            return;
+        const t = theme();
+        const isApprove = action === "Approve all";
+        const grouped = new Map();
+        for (const p of this.pendingRetroProposals) {
+            if (isApprove) {
+                this.chatView.updateFeedLine(p.actionIdx, this.makeSpan({ text: "    approved", style: { fg: t.success } }));
+                const list = grouped.get(p.teammate) || [];
+                list.push(p);
+                grouped.set(p.teammate, list);
+            }
+            else {
+                this.chatView.updateFeedLine(p.actionIdx, this.makeSpan({ text: "    rejected", style: { fg: t.error } }));
+            }
+        }
+        if (isApprove) {
+            for (const [teammate, proposals] of grouped) {
+                this.queueRetroApply(teammate, proposals);
+            }
+        }
+        this.pendingRetroProposals = [];
+        this.showRetroDropdown();
+    }
+    /** Queue a follow-up task for the teammate to apply approved SOUL.md changes. */
+    queueRetroApply(teammate, proposals) {
+        const changes = proposals
+            .map((p) => `- **Proposal ${p.index}: ${p.title}**\n  - Section: ${p.section}\n  - Before: ${p.before}\n  - After: ${p.after}`)
+            .join("\n\n");
+        const applyPrompt = `The user approved the following SOUL.md changes from your retrospective. Apply them now.
+
+**Edit your SOUL.md file** (\`.teammates/${teammate}/SOUL.md\`) to incorporate these changes:
+
+${changes}
+
+After editing SOUL.md, record a brief summary of the retro outcome in your daily log: which proposals were approved and what changed.
+
+Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily log.`;
+        this.taskQueue.push({ type: "agent", teammate, task: applyPrompt });
+        this.feedLine(concat(tp.muted("  Queued SOUL.md update for "), tp.accent(`@${teammate}`)));
+        this.refreshView();
+        this.kickDrain();
+    }
+    /** Refresh the ChatView app if active. */
+    refreshView() {
+        if (this.app)
+            this.app.refresh();
+    }
+    queueTask(input) {
+        const allNames = this.orchestrator.listTeammates();
+        // Check for @everyone — queue to all teammates except the coding agent
+        const everyoneMatch = input.match(/^@everyone\s+([\s\S]+)$/i);
+        if (everyoneMatch) {
+            const task = everyoneMatch[1];
+            const names = allNames.filter((n) => n !== this.adapterName);
+            for (const teammate of names) {
+                this.taskQueue.push({ type: "agent", teammate, task });
+            }
+            const bg = this._userBg;
+            const t = theme();
+            this.feedUserLine(concat(pen.fg(t.textMuted).bg(bg)("  → "), pen.fg(t.accent).bg(bg)(names.map((n) => `@${n}`).join(", "))));
+            this.feedLine();
+            this.refreshView();
+            this.kickDrain();
+            return;
+        }
+        // Collect all @mentioned teammates anywhere in the input
+        const mentionRegex = /@(\S+)/g;
+        let m;
+        const mentioned = [];
+        while ((m = mentionRegex.exec(input)) !== null) {
+            const name = m[1];
+            if (allNames.includes(name) && !mentioned.includes(name)) {
+                mentioned.push(name);
+            }
+        }
+        if (mentioned.length > 0) {
+            // Queue a copy of the full message to every mentioned teammate
+            for (const teammate of mentioned) {
+                this.taskQueue.push({ type: "agent", teammate, task: input });
+            }
+            const bg = this._userBg;
+            const t = theme();
+            this.feedUserLine(concat(pen.fg(t.textMuted).bg(bg)("  → "), pen.fg(t.accent).bg(bg)(mentioned.map((n) => `@${n}`).join(", "))));
+            this.feedLine();
+            this.refreshView();
+            this.kickDrain();
+            return;
+        }
+        // No mentions — auto-route: resolve teammate synchronously if possible, else use default
+        let match = this.orchestrator.route(input);
+        if (!match) {
+            // Fall back to adapter name — avoid blocking for agent routing
+            match = this.adapterName;
+        }
+        {
+            const bg = this._userBg;
+            const t = theme();
+            this.feedUserLine(concat(pen.fg(t.textMuted).bg(bg)("  → "), pen.fg(t.accent).bg(bg)(`@${match}`)));
+        }
+        this.feedLine();
+        this.refreshView();
+        this.taskQueue.push({ type: "agent", teammate: match, task: input });
+        this.kickDrain();
+    }
+    /** Start draining per-agent queues in parallel. Each agent gets its own drain loop. */
+    kickDrain() {
+        // Find agents that have queued tasks but no active drain
+        const agentsWithWork = new Set();
+        for (const entry of this.taskQueue) {
+            agentsWithWork.add(entry.teammate);
+        }
+        for (const agent of agentsWithWork) {
+            if (!this.agentDrainLocks.has(agent)) {
+                const lock = this.drainAgentQueue(agent).finally(() => {
+                    this.agentDrainLocks.delete(agent);
+                });
+                this.agentDrainLocks.set(agent, lock);
+            }
+        }
+    }
+    // ─── Onboarding ───────────────────────────────────────────────────
+    /**
+     * Interactive prompt when no .teammates/ directory is found.
+     * Returns the new .teammates/ path, or null if user chose to exit.
+     */
+    async promptOnboarding(adapter) {
+        const cwd = process.cwd();
+        const teammatesDir = join(cwd, ".teammates");
+        const termWidth = process.stdout.columns || 100;
+        console.log();
+        this.printLogo([
+            chalk.bold("Teammates") + chalk.gray(` v${PKG_VERSION}`),
+            chalk.yellow("No .teammates/ directory found"),
+            chalk.gray(cwd),
+        ]);
+        console.log();
+        console.log(chalk.gray("─".repeat(termWidth)));
+        console.log();
+        console.log(chalk.white("  Set up teammates for this project?\n"));
+        console.log(chalk.cyan("  1") +
+            chalk.gray(") ") +
+            chalk.white("New team") +
+            chalk.gray(" — analyze this codebase and create teammates from scratch"));
+        console.log(chalk.cyan("  2") +
+            chalk.gray(") ") +
+            chalk.white("Import team") +
+            chalk.gray(" — copy teammates from another project"));
+        console.log(chalk.cyan("  3") +
+            chalk.gray(") ") +
+            chalk.white("Solo mode") +
+            chalk.gray(` — use ${this.adapterName} without teammates`));
+        console.log(chalk.cyan("  4") + chalk.gray(") ") + chalk.white("Exit"));
+        console.log();
+        const choice = await this.askChoice("Pick an option (1/2/3/4): ", [
+            "1",
+            "2",
+            "3",
+            "4",
+        ]);
+        if (choice === "4") {
+            console.log(chalk.gray("  Goodbye."));
+            return null;
+        }
+        if (choice === "3") {
+            await mkdir(teammatesDir, { recursive: true });
+            console.log();
+            console.log(chalk.green("  ✔") + chalk.gray(` Created ${teammatesDir}`));
+            console.log(chalk.gray(`  Running in solo mode — all tasks go to ${this.adapterName}.`));
+            console.log(chalk.gray("  Run /init later to set up teammates."));
+            console.log();
+            return teammatesDir;
+        }
+        if (choice === "2") {
+            // Import from another project
+            await mkdir(teammatesDir, { recursive: true });
+            await this.runImport(cwd);
+            return teammatesDir;
+        }
+        // choice === "1": Run onboarding via the agent
+        await mkdir(teammatesDir, { recursive: true });
+        await this.runOnboardingAgent(adapter, cwd);
+        return teammatesDir;
+    }
+    /**
+     * Run the onboarding agent to analyze the codebase and create teammates.
+     * Used by both promptOnboarding (pre-orchestrator) and cmdInit (post-orchestrator).
+     */
+    async runOnboardingAgent(adapter, projectDir) {
+        console.log();
+        console.log(chalk.blue("  Starting onboarding...") +
+            chalk.gray(` ${this.adapterName} will analyze your codebase and create .teammates/`));
+        console.log();
+        // Copy framework files from bundled template
+        const teammatesDir = join(projectDir, ".teammates");
+        const copied = await copyTemplateFiles(teammatesDir);
+        if (copied.length > 0) {
+            console.log(chalk.green("  ✔") +
+                chalk.gray(` Copied template files: ${copied.join(", ")}`));
+            console.log();
+        }
+        const onboardingPrompt = await getOnboardingPrompt(projectDir);
+        const tempConfig = {
+            name: this.adapterName,
+            role: "Onboarding agent",
+            soul: "",
+            wisdom: "",
+            dailyLogs: [],
+            weeklyLogs: [],
+            ownership: { primary: [], secondary: [] },
+            routingKeywords: [],
+        };
+        const sessionId = await adapter.startSession(tempConfig);
+        const spinner = ora({
+            text: chalk.blue(this.adapterName) +
+                chalk.gray(" is analyzing your codebase..."),
+            spinner: "dots",
+        }).start();
+        try {
+            const result = await adapter.executeTask(sessionId, tempConfig, onboardingPrompt);
+            spinner.stop();
+            this.printAgentOutput(result.rawOutput);
+            if (result.success) {
+                console.log(chalk.green("  ✔ Onboarding complete!"));
+            }
+            else {
+                console.log(chalk.yellow(`  ⚠ Onboarding finished with issues: ${result.summary}`));
+            }
+        }
+        catch (err) {
+            spinner.fail(chalk.red(`Onboarding failed: ${err.message}`));
+        }
+        if (adapter.destroySession) {
+            await adapter.destroySession(sessionId);
+        }
+        // Verify .teammates/ now has content
+        try {
+            const entries = await readdir(teammatesDir);
+            if (!entries.some((e) => !e.startsWith("."))) {
+                console.log(chalk.yellow("  ⚠ .teammates/ was created but appears empty."));
+                console.log(chalk.gray("  You may need to run the onboarding agent again or set up manually."));
+            }
+        }
+        catch {
+            /* dir might not exist if onboarding failed badly */
+        }
+        console.log();
+    }
+    /**
+     * Import teammates from another project's .teammates/ directory.
+     * Prompts for a path, copies teammate folders + framework files,
+     * then optionally runs the agent to adapt ownership for this codebase.
+     */
+    async runImport(projectDir) {
+        console.log();
+        console.log(chalk.white("  Enter the path to another project") +
+            chalk.gray(" (the project root or its .teammates/ directory):"));
+        console.log();
+        const rawPath = await this.askInput("Path: ");
+        if (!rawPath) {
+            console.log(chalk.yellow("  No path provided. Aborting import."));
+            return;
+        }
+        // Resolve the source — accept either project root or .teammates/ directly
+        const resolved = resolve(rawPath);
+        let sourceDir;
+        try {
+            const s = await stat(join(resolved, ".teammates"));
+            if (s.isDirectory()) {
+                sourceDir = join(resolved, ".teammates");
+            }
+            else {
+                sourceDir = resolved;
+            }
+        }
+        catch {
+            sourceDir = resolved;
+        }
+        const teammatesDir = join(projectDir, ".teammates");
+        console.log();
+        try {
+            const { teammates, files } = await importTeammates(sourceDir, teammatesDir);
+            if (teammates.length === 0) {
+                console.log(chalk.yellow("  No teammates found at ") + chalk.white(sourceDir));
+                console.log(chalk.gray("  The directory should contain teammate folders (each with a SOUL.md)."));
+                return;
+            }
+            console.log(chalk.green("  ✔") +
+                chalk.white(` Imported ${teammates.length} teammate${teammates.length > 1 ? "s" : ""}: `) +
+                chalk.cyan(teammates.join(", ")));
+            console.log(chalk.gray(`    (${files.length} files copied)`));
+            console.log();
+            // Ask if user wants the agent to adapt teammates to this codebase
+            console.log(chalk.white("  Adapt teammates to this codebase?"));
+            console.log(chalk.gray("  The agent will update ownership patterns, file paths, and boundaries."));
+            console.log(chalk.gray("  You can also do this later with /init."));
+            console.log();
+            const adapt = await this.askChoice("Adapt now? (y/n): ", ["y", "n"]);
+            if (adapt === "y") {
+                await this.runAdaptationAgent(this.adapter, projectDir, teammates);
+            }
+            else {
+                console.log(chalk.gray("  Skipped adaptation. Run /init to adapt later."));
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`  Import failed: ${err.message}`));
+        }
+        console.log();
+    }
+    /**
+     * Run the agent to adapt imported teammates' ownership/boundaries
+     * to the current codebase. Queues one task per teammate so the user
+     * can review and approve each adaptation individually.
+     */
+    async runAdaptationAgent(adapter, projectDir, teammateNames) {
+        const teammatesDir = join(projectDir, ".teammates");
+        console.log();
+        console.log(chalk.blue("  Queuing adaptation tasks...") +
+            chalk.gray(` ${this.adapterName} will adapt each teammate individually`));
+        console.log();
+        for (const name of teammateNames) {
+            const prompt = await buildAdaptationPrompt(teammatesDir, name);
+            const tempConfig = {
+                name: this.adapterName,
+                role: "Adaptation agent",
+                soul: "",
+                wisdom: "",
+                dailyLogs: [],
+                weeklyLogs: [],
+                ownership: { primary: [], secondary: [] },
+                routingKeywords: [],
+            };
+            const sessionId = await adapter.startSession(tempConfig);
+            const spinner = ora({
+                text: chalk.blue(this.adapterName) +
+                    chalk.gray(` is adapting @${name} to this codebase...`),
+                spinner: "dots",
+            }).start();
+            try {
+                const result = await adapter.executeTask(sessionId, tempConfig, prompt);
+                spinner.stop();
+                this.printAgentOutput(result.rawOutput);
+                if (result.success) {
+                    console.log(chalk.green(`  ✔ @${name} adaptation complete!`));
+                }
+                else {
+                    console.log(chalk.yellow(`  ⚠ @${name} adaptation finished with issues: ${result.summary}`));
+                }
+            }
+            catch (err) {
+                spinner.fail(chalk.red(`@${name} adaptation failed: ${err.message}`));
+            }
+            if (adapter.destroySession) {
+                await adapter.destroySession(sessionId);
+            }
+            console.log();
+        }
+    }
+    /**
+     * Simple blocking prompt — reads one line from stdin and validates.
+     */
+    askChoice(prompt, valid) {
+        return new Promise((resolve) => {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const ask = () => {
+                rl.question(chalk.cyan("  ") + prompt, (answer) => {
+                    const trimmed = answer.trim();
+                    if (valid.includes(trimmed)) {
+                        rl.close();
+                        resolve(trimmed);
+                    }
+                    else {
+                        ask();
+                    }
+                });
+            };
+            ask();
+        });
+    }
+    askInput(prompt) {
+        return new Promise((resolve) => {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(chalk.cyan("  ") + prompt, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    /**
+     * Check whether USER.md needs to be created or is still template placeholders.
+     */
+    needsUserSetup(teammatesDir) {
+        const userMdPath = join(teammatesDir, "USER.md");
+        try {
+            const content = readFileSync(userMdPath, "utf-8");
+            // Template placeholders contain "<your name>" — treat as not set up
+            return !content.trim() || content.includes("<your name>");
+        }
+        catch {
+            // File doesn't exist
+            return true;
+        }
+    }
+    /**
+     * Run the user interview inside the ChatView using the Interview widget.
+     * Hides the normal input prompt until the interview completes.
+     */
+    startUserInterview(teammatesDir, bannerWidget) {
+        if (!this.chatView)
+            return;
+        const t = theme();
+        const interview = new Interview({
+            title: "Quick intro — helps teammates tailor their work to you.",
+            subtitle: "(press Enter to skip any question)",
+            questions: [
+                { key: "name", prompt: "Your name" },
+                {
+                    key: "role",
+                    prompt: "Your role",
+                    placeholder: "e.g., senior backend engineer",
+                },
+                {
+                    key: "experience",
+                    prompt: "Relevant experience",
+                    placeholder: "e.g., 10 years Go, new to React",
+                },
+                {
+                    key: "preferences",
+                    prompt: "How you like to work",
+                    placeholder: "e.g., terse responses, explain reasoning",
+                },
+                {
+                    key: "context",
+                    prompt: "Anything else",
+                    placeholder: "e.g., solo dev, working on a rewrite",
+                },
+            ],
+            titleStyle: { fg: t.text },
+            subtitleStyle: { fg: t.textDim, italic: true },
+            promptStyle: { fg: t.accent },
+            answeredStyle: { fg: t.textMuted, italic: true },
+            inputStyle: { fg: t.text },
+            cursorStyle: { fg: t.cursorFg, bg: t.cursorBg },
+            placeholderStyle: { fg: t.textDim, italic: true },
+        });
+        this.chatView.setInputOverride(interview);
+        if (this.app)
+            this.app.refresh();
+        interview.on("complete", (answers) => {
+            // Write USER.md
+            const userMdPath = join(teammatesDir, "USER.md");
+            const lines = ["# User\n"];
+            lines.push(`- **Name:** ${answers.name || "_not provided_"}`);
+            lines.push(`- **Role:** ${answers.role || "_not provided_"}`);
+            lines.push(`- **Experience:** ${answers.experience || "_not provided_"}`);
+            lines.push(`- **Preferences:** ${answers.preferences || "_not provided_"}`);
+            lines.push(`- **Context:** ${answers.context || "_not provided_"}`);
+            writeFileSync(userMdPath, `${lines.join("\n")}\n`, "utf-8");
+            // Remove override and restore normal input
+            if (this.chatView) {
+                this.chatView.setInputOverride(null);
+                this.chatView.appendStyledToFeed(concat(tp.success("  ✔ "), tp.dim("Saved USER.md — update anytime with /user")));
+            }
+            // Release the banner hold so commands animate in
+            if (bannerWidget)
+                bannerWidget.releaseHold();
+            if (this.app)
+                this.app.refresh();
+        });
+    }
+    // ─── Display helpers ──────────────────────────────────────────────
+    /**
+     * Render the box logo with up to 4 info lines on the right side.
+     */
+    printLogo(infoLines) {
+        const [top, bot] = buildTitle("teammates");
+        console.log(`  ${chalk.cyan(top)}`);
+        console.log(`  ${chalk.cyan(bot)}`);
+        if (infoLines.length > 0) {
+            console.log();
+            for (const line of infoLines) {
+                console.log(`  ${line}`);
+            }
+        }
+    }
+    /**
+     * Print agent raw output, stripping the trailing JSON protocol block.
+     */
+    printAgentOutput(rawOutput) {
+        const raw = rawOutput ?? "";
+        if (!raw)
+            return;
+        const cleaned = raw
+            .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/, "")
+            .trim();
+        if (cleaned) {
+            this.feedMarkdown(cleaned);
+        }
+        this.feedLine();
+    }
+    // ─── Wordwheel ─────────────────────────────────────────────────────
+    getUniqueCommands() {
+        const seen = new Set();
+        const result = [];
+        for (const [, cmd] of this.commands) {
+            if (seen.has(cmd.name))
+                continue;
+            seen.add(cmd.name);
+            result.push(cmd);
+        }
+        return result;
+    }
+    clearWordwheel() {
+        if (this.chatView) {
+            this.chatView.hideDropdown();
+            // Don't refreshView here — caller will either showDropdown + refresh,
+            // or the next App render pass will pick up the cleared state.
+        }
+        else {
+            this.input.clearDropdown();
+        }
+    }
+    writeWordwheel(lines) {
+        if (this.chatView) {
+            // Lines are pre-formatted for PromptInput — convert to DropdownItems
+            // This path is used for static usage hints; wordwheel items use showDropdown directly
+            this.chatView.showDropdown(lines.map((l) => ({
+                label: stripAnsi(l).trim(),
+                description: "",
+                completion: "",
+            })));
+            this.refreshView();
+        }
+        else {
+            this.input.setDropdown(lines);
+        }
+    }
+    /**
+     * Which argument positions are teammate-name completable per command.
+     * Key = command name, value = set of 0-based arg positions that take a teammate.
+     */
+    static TEAMMATE_ARG_POSITIONS = {
+        assign: new Set([0]),
+        handoff: new Set([0, 1]),
+        compact: new Set([0]),
+        debug: new Set([0]),
+        retro: new Set([0]),
+    };
     /** Build param-completion items for the current line, if any. */
     getParamItems(cmdName, argsBefore, partial) {
         // Service-name completions for /install
@@ -348,70 +1692,117 @@ class TeammatesREPL {
                 .map(([name, svc]) => ({
                 label: name,
                 description: svc.description,
-                completion: "/install " + name + " ",
+                completion: `/install ${name} `,
             }));
         }
         const positions = TeammatesREPL.TEAMMATE_ARG_POSITIONS[cmdName];
         if (!positions)
             return [];
         // Count how many complete args precede the current partial
-        const completedArgs = argsBefore.trim() ? argsBefore.trim().split(/\s+/).length : 0;
+        const completedArgs = argsBefore.trim()
+            ? argsBefore.trim().split(/\s+/).length
+            : 0;
         if (!positions.has(completedArgs))
             return [];
         const teammates = this.orchestrator.listTeammates();
         const lower = partial.toLowerCase();
-        return teammates
-            .filter((n) => n.toLowerCase().startsWith(lower))
-            .map((name) => {
+        const items = [];
+        // Add "everyone" option at the top (only for first arg position)
+        if (completedArgs === 0 && "everyone".startsWith(lower)) {
+            const linePrefix = `/${cmdName} ${argsBefore ? argsBefore : ""}`;
+            items.push({
+                label: "everyone",
+                description: "all teammates",
+                completion: `${linePrefix}everyone `,
+            });
+        }
+        for (const name of teammates) {
+            if (!name.toLowerCase().startsWith(lower))
+                continue;
             const t = this.orchestrator.getRegistry().get(name);
-            const linePrefix = "/" + cmdName + " " + (argsBefore ? argsBefore : "");
-            return {
+            const linePrefix = `/${cmdName} ${argsBefore ? argsBefore : ""}`;
+            items.push({
                 label: name,
                 description: t?.role ?? "",
-                completion: linePrefix + name + " ",
-            };
-        });
+                completion: `${linePrefix + name} `,
+            });
+        }
+        return items;
     }
     /**
-     * Find the @mention token the cursor is currently inside, if any.
-     * Returns { before, partial, atPos } or null.
+     * Return dim placeholder hint text for the current input value.
+     * e.g. typing "/log" shows " <teammate>", typing "/log b" shows nothing.
      */
-    findAtMention(line, cursor) {
-        // Walk backward from cursor to find the nearest unescaped '@'
-        const left = line.slice(0, cursor);
-        const atPos = left.lastIndexOf("@");
-        if (atPos < 0)
+    getCommandHint(value) {
+        const trimmed = value.trimStart();
+        if (!trimmed.startsWith("/"))
             return null;
-        // '@' must be at start of line or preceded by whitespace
-        if (atPos > 0 && !/\s/.test(line[atPos - 1]))
+        // Extract command name and what's been typed after it
+        const spaceIdx = trimmed.indexOf(" ");
+        const cmdName = spaceIdx < 0 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+        const cmd = this.commands.get(cmdName);
+        if (!cmd)
             return null;
-        const partial = left.slice(atPos + 1);
-        // Partial must be a single token (no spaces)
-        if (/\s/.test(partial))
+        // Extract placeholder tokens from usage (e.g. "/log [teammate]" → ["[teammate]"])
+        const usageParts = cmd.usage.split(/\s+/).slice(1); // drop the "/command" part
+        if (usageParts.length === 0)
             return null;
-        return { before: line.slice(0, atPos), partial, atPos };
+        // Count how many args the user has typed after the command
+        const afterCmd = spaceIdx < 0 ? "" : trimmed.slice(spaceIdx + 1);
+        const typedArgs = afterCmd
+            .trim()
+            .split(/\s+/)
+            .filter((s) => s.length > 0);
+        // Show remaining placeholders
+        const remaining = usageParts.slice(typedArgs.length);
+        if (remaining.length === 0)
+            return null;
+        // Add a leading space if the value doesn't already end with one
+        const pad = value.endsWith(" ") ? "" : " ";
+        return pad + remaining.join(" ");
+    }
+    /**
+     * Find the @mention token the cursor is currently inside, if any.
+     * Returns { before, partial, atPos } or null.
+     */
+    findAtMention(line, cursor) {
+        return findAtMention(line, cursor);
     }
     /** Build @mention teammate completion items. */
     getAtMentionItems(line, before, partial, atPos) {
         const teammates = this.orchestrator.listTeammates();
         const lower = partial.toLowerCase();
         const after = line.slice(atPos + 1 + partial.length);
-        return teammates
-            .filter((n) => n.toLowerCase().startsWith(lower))
-            .map((name) => {
-            const t = this.orchestrator.getRegistry().get(name);
-            return {
-                label: "@" + name,
-                description: t?.role ?? "",
-                completion: before + "@" + name + " " + after.replace(/^\s+/, ""),
-            };
-        });
+        const items = [];
+        // @everyone alias
+        if ("everyone".startsWith(lower)) {
+            items.push({
+                label: "@everyone",
+                description: "Send to all teammates",
+                completion: `${before}@everyone ${after.replace(/^\s+/, "")}`,
+            });
+        }
+        for (const name of teammates) {
+            if (name.toLowerCase().startsWith(lower)) {
+                const t = this.orchestrator.getRegistry().get(name);
+                items.push({
+                    label: `@${name}`,
+                    description: t?.role ?? "",
+                    completion: `${before}@${name} ${after.replace(/^\s+/, "")}`,
+                });
+            }
+        }
+        return items;
     }
     /** Recompute matches and draw the wordwheel. */
     updateWordwheel() {
         this.clearWordwheel();
-        const line = this.rl.line ?? "";
-        const cursor = this.rl.cursor ?? line.length;
+        const line = this.chatView
+            ? this.chatView.inputValue
+            : this.input.line;
+        const cursor = this.chatView
+            ? this.chatView.inputValue.length
+            : this.input.cursor;
         // ── @mention anywhere in the line ──────────────────────────────
         const mention = this.findAtMention(line, cursor);
         if (mention) {
@@ -453,12 +1844,9 @@ class TeammatesREPL {
                 this.renderItems();
             }
             else {
-                // No param completions — show static usage hint
+                // No param completions — hide dropdown
+                this.wordwheelItems = [];
                 this.wordwheelIndex = -1;
-                this.writeWordwheel([
-                    `  ${chalk.cyan(cmd.usage)}`,
-                    `  ${chalk.gray(cmd.description)}`,
-                ]);
             }
             return;
         }
@@ -467,11 +1855,14 @@ class TeammatesREPL {
         this.wordwheelItems = this.getUniqueCommands()
             .filter((c) => c.name.startsWith(partial) ||
             c.aliases.some((a) => a.startsWith(partial)))
-            .map((c) => ({
-            label: "/" + c.name,
-            description: c.description,
-            completion: "/" + c.name + " ",
-        }));
+            .map((c) => {
+            const hasParams = /^\/\S+\s+.+$/.test(c.usage);
+            return {
+                label: `/${c.name}`,
+                description: c.description,
+                completion: hasParams ? `/${c.name} ` : `/${c.name}`,
+            };
+        });
         if (this.wordwheelItems.length === 0) {
             this.wordwheelIndex = -1;
             return;
@@ -483,14 +1874,30 @@ class TeammatesREPL {
     }
     /** Render the current wordwheelItems list with selection highlight. */
     renderItems() {
-        this.writeWordwheel(this.wordwheelItems.map((item, i) => {
-            const prefix = i === this.wordwheelIndex ? chalk.cyan("▸ ") : "  ";
-            const label = item.label.padEnd(14);
-            if (i === this.wordwheelIndex) {
-                return prefix + chalk.cyanBright.bold(label) + " " + chalk.white(item.description);
+        if (this.chatView) {
+            this.chatView.showDropdown(this.wordwheelItems);
+            // Sync selection index
+            if (this.wordwheelIndex >= 0) {
+                while (this.chatView.dropdownIndex < this.wordwheelIndex)
+                    this.chatView.dropdownDown();
+                while (this.chatView.dropdownIndex > this.wordwheelIndex)
+                    this.chatView.dropdownUp();
             }
-            return prefix + chalk.cyan(label) + " " + chalk.gray(item.description);
-        }));
+            this.refreshView();
+        }
+        else {
+            this.writeWordwheel(this.wordwheelItems.map((item, i) => {
+                const prefix = i === this.wordwheelIndex ? chalk.cyan("▸ ") : "  ";
+                const label = item.label.padEnd(14);
+                if (i === this.wordwheelIndex) {
+                    return (prefix +
+                        chalk.cyanBright.bold(label) +
+                        " " +
+                        chalk.white(item.description));
+                }
+                return `${prefix + chalk.cyan(label)} ${chalk.gray(item.description)}`;
+            }));
+        }
     }
     /** Accept the currently highlighted item into the input line. */
     acceptWordwheelSelection() {
@@ -498,9 +1905,12 @@ class TeammatesREPL {
         if (!item)
             return;
         this.clearWordwheel();
-        this.rl.line = item.completion;
-        this.rl.cursor = item.completion.length;
-        this.rl._refreshLine();
+        if (this.chatView) {
+            this.chatView.inputValue = item.completion;
+        }
+        else {
+            this.input.setLine(item.completion);
+        }
         this.wordwheelItems = [];
         this.wordwheelIndex = -1;
         // Re-render for next param or usage hint
@@ -517,6 +1927,9 @@ class TeammatesREPL {
             if (!teammatesDir)
                 return; // user chose to exit
         }
+        // Check if USER.md needs setup — we'll run the interview inside the
+        // ChatView after the UI loads (not before).
+        const pendingUserInterview = this.needsUserSetup(teammatesDir);
         // Init orchestrator
         this.teammatesDir = teammatesDir;
         this.orchestrator = new Orchestrator({
@@ -531,37 +1944,30 @@ class TeammatesREPL {
             name: this.adapterName,
             role: `General-purpose coding agent (${this.adapterName})`,
             soul: "",
-            memories: "",
+            wisdom: "",
             dailyLogs: [],
+            weeklyLogs: [],
             ownership: { primary: [], secondary: [] },
+            routingKeywords: [],
         });
         // Add status entry (init() already ran, so we add it manually)
         this.orchestrator.getAllStatuses().set(this.adapterName, { state: "idle" });
         // Populate roster on the adapter so prompts include team info
         if ("roster" in this.adapter) {
             const registry = this.orchestrator.getRegistry();
-            this.adapter.roster = this.orchestrator.listTeammates().map((name) => {
+            this.adapter.roster = this.orchestrator
+                .listTeammates()
+                .map((name) => {
                 const t = registry.get(name);
                 return { name: t.name, role: t.role, ownership: t.ownership };
             });
         }
-        // Detect installed services and tell the adapter
+        // Detect installed services from services.json and tell the adapter
         if ("services" in this.adapter) {
             const services = [];
-            // Check if any teammate has a .index/ directory (recall is indexed)
             try {
-                const entries = readdirSync(this.teammatesDir, { withFileTypes: true });
-                const hasIndex = entries.some((e) => {
-                    if (!e.isDirectory() || e.name.startsWith("."))
-                        return false;
-                    try {
-                        return statSync(join(this.teammatesDir, e.name, ".index")).isDirectory();
-                    }
-                    catch {
-                        return false;
-                    }
-                });
-                if (hasIndex) {
+                const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+                if (svcJson && "recall" in svcJson) {
                     services.push({
                         name: "recall",
                         description: "Local semantic search across teammate memories and daily logs. Use this to find relevant context before starting a task.",
@@ -569,311 +1975,542 @@ class TeammatesREPL {
                     });
                 }
             }
-            catch { /* can't read teammates dir */ }
+            catch {
+                /* no services.json or invalid */
+            }
             this.adapter.services = services;
         }
+        // Start recall watch mode if recall is installed
+        this.startRecallWatch();
+        // Background maintenance: compact stale dailies + sync recall indexes
+        this.startupMaintenance().catch(() => { });
         // Register commands
         this.registerCommands();
-        // Create readline with a mutable output stream so we can mute
-        // echo during paste detection.
-        let outputMuted = false;
-        const mutableOutput = new Writable({
-            write(chunk, _encoding, callback) {
-                if (!outputMuted)
-                    process.stdout.write(chunk);
-                callback();
+        // Create PromptInput — consolonia-based replacement for readline.
+        // Uses raw stdin + InputProcessor for proper escape/paste/mouse parsing.
+        // Kept as a fallback for pre-onboarding prompts; the main REPL uses ChatView.
+        this.input = new PromptInput({
+            prompt: chalk.gray("> "),
+            borderStyle: (s) => chalk.gray(s),
+            colorize: (value) => {
+                const validNames = new Set([
+                    ...this.orchestrator.listTeammates(),
+                    this.adapterName,
+                ]);
+                return value
+                    .replace(/@(\w+)/g, (match, name) => validNames.has(name) ? chalk.blue(match) : match)
+                    .replace(/^\/\w+/, (m) => chalk.blue(m));
             },
-        });
-        // Trick readline into thinking it's a real TTY
-        mutableOutput.columns = process.stdout.columns;
-        mutableOutput.rows = process.stdout.rows;
-        mutableOutput.isTTY = true;
-        mutableOutput.cursorTo = process.stdout.cursorTo?.bind(process.stdout);
-        mutableOutput.clearLine = process.stdout.clearLine?.bind(process.stdout);
-        mutableOutput.moveCursor = process.stdout.moveCursor?.bind(process.stdout);
-        mutableOutput.getWindowSize = () => [process.stdout.columns ?? 80, process.stdout.rows ?? 24];
-        process.stdout.on("resize", () => {
-            mutableOutput.columns = process.stdout.columns;
-            mutableOutput.rows = process.stdout.rows;
-            mutableOutput.emit("resize");
-        });
-        this.rl = createInterface({
-            input: process.stdin,
-            output: mutableOutput,
-            prompt: chalk.cyan("teammates") + chalk.gray("> "),
-            terminal: true,
-        });
-        this.dropdown = new Dropdown(this.rl);
-        // Pre-mute: if stdin delivers a chunk with multiple newlines (paste),
-        // mute output immediately BEFORE readline echoes anything.
-        process.stdin.prependListener("data", (chunk) => {
-            const str = chunk.toString();
-            if (str.includes("\n") && str.indexOf("\n") < str.length - 1) {
-                // Multiple lines in one chunk — it's a paste, mute now
-                outputMuted = true;
-            }
-        });
-        // Intercept all keypress via _ttyWrite so we can capture
-        // arrow-down / arrow-up / Tab for wordwheel navigation.
-        // Also used for paste prefix detection via timing heuristic.
-        let lastKeystrokeTime = 0;
-        const origTtyWrite = this.rl._ttyWrite.bind(this.rl);
-        this.rl._ttyWrite = (s, key) => {
-            // Timing-based paste prefix detection: if >50ms since last keystroke,
-            // this is a new input burst. Snapshot rl.line BEFORE readline processes
-            // this character — during a paste burst, characters arrive <5ms apart
-            // so the snapshot stays at the pre-paste value.
-            const now = Date.now();
-            if (now - lastKeystrokeTime > 50) {
-                prePastePrefix = this.rl.line ?? "";
-            }
-            lastKeystrokeTime = now;
-            const hasWheel = this.wordwheelItems.length > 0;
-            if (hasWheel && key) {
-                if (key.name === "down") {
-                    this.wordwheelIndex = Math.min(this.wordwheelIndex + 1, this.wordwheelItems.length - 1);
-                    this.renderItems(); // calls dropdown.render() → _refreshLine()
-                    return;
-                }
-                if (key.name === "up") {
+            hint: (value) => this.getCommandHint(value),
+            onUpDown: (dir) => {
+                if (this.wordwheelItems.length === 0)
+                    return false;
+                if (dir === "up") {
                     this.wordwheelIndex = Math.max(this.wordwheelIndex - 1, -1);
-                    this.renderItems(); // calls dropdown.render() → _refreshLine()
-                    return;
                 }
-                if (key.name === "tab" && this.wordwheelIndex >= 0) {
-                    this.acceptWordwheelSelection();
-                    return;
+                else {
+                    this.wordwheelIndex = Math.min(this.wordwheelIndex + 1, this.wordwheelItems.length - 1);
                 }
-            }
-            // Enter/return — if a wordwheel item is highlighted, accept it into the
-            // input line first.  For no-arg commands this means a single Enter both
-            // populates and executes (e.g. arrow-down to /exit → Enter → exits).
-            if (key && key.name === "return") {
-                if (hasWheel && this.wordwheelIndex >= 0) {
+                this.renderItems();
+                return true;
+            },
+            beforeSubmit: (currentValue) => {
+                if (this.wordwheelItems.length > 0 && this.wordwheelIndex >= 0) {
                     const item = this.wordwheelItems[this.wordwheelIndex];
                     if (item) {
-                        this.rl.line = item.completion;
-                        this.rl.cursor = item.completion.length;
+                        this.clearWordwheel();
+                        this.wordwheelItems = [];
+                        this.wordwheelIndex = -1;
+                        return item.completion;
                     }
                 }
-                this.dropdown.clear();
+                this.clearWordwheel();
                 this.wordwheelItems = [];
                 this.wordwheelIndex = -1;
-                // Force a refresh to erase dropdown, then let readline process Enter
-                this.rl._refreshLine();
-                origTtyWrite(s, key);
-                return;
+                return currentValue;
+            },
+        });
+        // ── Build animated banner for ChatView ─────────────────────────────
+        const names = this.orchestrator.listTeammates();
+        const reg = this.orchestrator.getRegistry();
+        let hasRecall = false;
+        try {
+            const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+            hasRecall = !!(svcJson && "recall" in svcJson);
+        }
+        catch {
+            /* no services.json */
+        }
+        const bannerWidget = new AnimatedBanner({
+            adapterName: this.adapterName,
+            teammateCount: names.length,
+            cwd: process.cwd(),
+            recallInstalled: hasRecall,
+            teammates: names.map((name) => {
+                const t = reg.get(name);
+                return { name, role: t?.role ?? "" };
+            }),
+        });
+        // ── Create ChatView and Consolonia App ────────────────────────────
+        const t = theme();
+        this.chatView = new ChatView({
+            bannerWidget,
+            prompt: "> ",
+            promptStyle: { fg: t.prompt },
+            inputStyle: { fg: t.textMuted },
+            cursorStyle: { fg: t.cursorFg, bg: t.cursorBg },
+            placeholder: " @mention or type a task...",
+            placeholderStyle: { fg: t.textDim, italic: true },
+            inputColorize: (value) => {
+                const styles = new Array(value.length).fill(null);
+                const accentStyle = { fg: theme().accent };
+                const dimStyle = { fg: theme().textDim };
+                // Colorize /commands (only at start of input)
+                const cmdPattern = /^\/[\w-]+/;
+                let m = cmdPattern.exec(value);
+                if (m) {
+                    for (let i = m.index; i < m.index + m[0].length; i++) {
+                        styles[i] = accentStyle;
+                    }
+                }
+                // Colorize @mentions only if they reference a valid teammate or the coding agent
+                const validNames = new Set([
+                    ...this.orchestrator.listTeammates(),
+                    this.adapterName,
+                ]);
+                const mentionPattern = /@(\w+)/g;
+                while ((m = mentionPattern.exec(value)) !== null) {
+                    if (validNames.has(m[1])) {
+                        for (let i = m.index; i < m.index + m[0].length; i++) {
+                            styles[i] = accentStyle;
+                        }
+                    }
+                }
+                // Colorize [placeholder] blocks as dim
+                const placeholders = /\[[^[\]]+\]/g;
+                while ((m = placeholders.exec(value)) !== null) {
+                    for (let i = m.index; i < m.index + m[0].length; i++) {
+                        styles[i] = dimStyle;
+                    }
+                }
+                return styles;
+            },
+            inputDeleteSize: (value, cursor, direction) => {
+                // Delete entire [placeholder] blocks as a unit (paste placeholders, quoted reply, etc.)
+                const placeholder = /\[[^[\]]+\]/g;
+                let m;
+                while ((m = placeholder.exec(value)) !== null) {
+                    const start = m.index;
+                    const end = start + m[0].length;
+                    if (direction === "backward" && cursor > start && cursor <= end) {
+                        return cursor - start;
+                    }
+                    if (direction === "forward" && cursor >= start && cursor < end) {
+                        return end - cursor;
+                    }
+                }
+                return 1;
+            },
+            inputHint: (value) => this.getCommandHint(value),
+            inputHintStyle: { fg: t.textDim },
+            maxInputHeight: 5,
+            separatorStyle: { fg: t.separator },
+            progressStyle: { fg: t.progress, italic: true },
+            dropdownHighlightStyle: { fg: t.accent },
+            dropdownStyle: { fg: t.textMuted },
+            footer: concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`)),
+            footerStyle: { fg: t.textDim },
+        });
+        this.defaultFooter = concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`));
+        // Wire ChatView events for input handling
+        this.chatView.on("submit", (rawLine) => {
+            this.handleSubmit(rawLine).catch((err) => {
+                this.feedLine(tp.error(`Unhandled error: ${err.message}`));
+                this.refreshView();
+            });
+        });
+        this.chatView.on("change", () => {
+            // Clear quoted reply if user backspaced over the placeholder
+            if (this._pendingQuotedReply &&
+                this.chatView &&
+                !this.chatView.inputValue.includes("[quoted reply]")) {
+                this._pendingQuotedReply = null;
             }
-            // Any other key — clear dropdown, let readline handle keystroke,
-            // then recompute and render the new dropdown.
-            this.dropdown.clear();
             this.wordwheelItems = [];
             this.wordwheelIndex = -1;
-            origTtyWrite(s, key);
-            // origTtyWrite called _refreshLine which cleared old dropdown.
-            // Now compute new items and render (calls _refreshLine again with new suffix).
             this.updateWordwheel();
-        };
-        // Banner
-        this.printBanner(this.orchestrator.listTeammates());
-        // REPL loop
-        this.rl.prompt();
-        // ── Paste detection ──────────────────────────────────────────────
-        // Strategy: the first `line` event echoes normally. We immediately
-        // mute output so subsequent pasted lines are invisible. After 30ms
-        // of quiet, we check: if only 1 line arrived it was normal typing
-        // (already echoed, good). If multiple lines arrived, we erase the
-        // one echoed line and show a placeholder instead.
-        let pasteBuffer = [];
-        let pasteTimer = null;
-        let pasteCount = 0;
-        let prePastePrefix = ""; // text user typed before paste started
-        const processPaste = async () => {
-            pasteTimer = null;
-            outputMuted = false;
-            const lines = pasteBuffer;
-            pasteBuffer = [];
-            if (lines.length === 0)
-                return;
-            if (lines.length > 1) {
-                // Multi-line paste — the first line was echoed, the rest were muted.
-                // Erase the first echoed line (move up 1, clear).
-                process.stdout.write("\x1b[A\x1b[2K");
-                pasteCount++;
-                const combined = lines.join("\n");
-                const sizeKB = Buffer.byteLength(combined, "utf-8") / 1024;
-                const tag = `[Pasted text #${pasteCount} +${lines.length} lines, ${sizeKB.toFixed(1)}KB] `;
-                // Store the pasted text — expanded when the user presses Enter.
-                this.pastedTexts.set(pasteCount, combined);
-                // Restore what the user typed before the paste, plus the placeholder.
-                const newLine = prePastePrefix + tag;
-                prePastePrefix = ""; // reset for next paste
-                this.rl.line = newLine;
-                this.rl.cursor = newLine.length;
-                this.rl.prompt(true);
-                return;
-            }
-            // Expand paste placeholders with actual content
-            const rawLine = lines[0];
-            const hasPaste = /\[Pasted text #\d+/.test(rawLine);
-            let input = rawLine.replace(/\[Pasted text #(\d+) \+\d+ lines, [\d.]+KB\]\s*/g, (_match, num) => {
-                const n = parseInt(num, 10);
-                const text = this.pastedTexts.get(n);
-                if (text) {
-                    this.pastedTexts.delete(n);
-                    return text + "\n";
+            // Reset ESC / Ctrl+C pending state on any text change
+            if (this.escPending) {
+                this.escPending = false;
+                if (this.escTimer) {
+                    clearTimeout(this.escTimer);
+                    this.escTimer = null;
                 }
-                return "";
-            }).trim();
-            // Show the expanded pasted content on Enter
-            if (hasPaste && input) {
-                const sizeKB = Buffer.byteLength(input, "utf-8") / 1024;
-                const lineCount = input.split("\n").length;
-                console.log();
-                console.log(chalk.gray(`  ┌ Expanded paste (${lineCount} lines, ${sizeKB.toFixed(1)}KB)`));
-                // Show first few lines as preview
-                const previewLines = input.split("\n").slice(0, 5);
-                for (const l of previewLines) {
-                    console.log(chalk.gray(`  │ `) + l.slice(0, 120));
+                this.chatView.setFooter(this.defaultFooter);
+                this.refreshView();
+            }
+            if (this.ctrlcPending) {
+                this.ctrlcPending = false;
+                if (this.ctrlcTimer) {
+                    clearTimeout(this.ctrlcTimer);
+                    this.ctrlcTimer = null;
                 }
-                if (lineCount > 5) {
-                    console.log(chalk.gray(`  │ ... ${lineCount - 5} more lines`));
+                this.chatView.setFooter(this.defaultFooter);
+                this.refreshView();
+            }
+        });
+        this.chatView.on("tab", () => {
+            if (this.wordwheelItems.length > 0) {
+                if (this.wordwheelIndex < 0)
+                    this.wordwheelIndex = 0;
+                this.acceptWordwheelSelection();
+            }
+        });
+        this.chatView.on("cancel", () => {
+            this.clearWordwheel();
+            this.wordwheelItems = [];
+            this.wordwheelIndex = -1;
+            if (this.escPending) {
+                // Second ESC — clear input and restore footer
+                this.escPending = false;
+                if (this.escTimer) {
+                    clearTimeout(this.escTimer);
+                    this.escTimer = null;
                 }
-                console.log(chalk.gray(`  └`));
+                this.chatView.inputValue = "";
+                this.chatView.setFooter(this.defaultFooter);
+                this.pastedTexts.clear();
+                this.refreshView();
             }
-            if (!input || this.dispatching) {
-                this.rl.prompt();
+            else if (this.chatView.inputValue.length > 0) {
+                // First ESC with text — show hint in footer, auto-expire after 2s
+                this.escPending = true;
+                const termW = process.stdout.columns || 80;
+                const hint = "ESC again to clear";
+                const pad = Math.max(0, termW - hint.length - 1);
+                this.chatView.setFooter(concat(tp.dim(" ".repeat(pad)), tp.muted(hint)));
+                this.refreshView();
+                this.escTimer = setTimeout(() => {
+                    this.escTimer = null;
+                    if (this.escPending) {
+                        this.escPending = false;
+                        this.chatView.setFooter(this.defaultFooter);
+                        this.refreshView();
+                    }
+                }, 2000);
+            }
+        });
+        this.chatView.on("paste", (text) => {
+            this.handlePaste(text);
+        });
+        this.chatView.on("ctrlc", () => {
+            if (this.ctrlcPending) {
+                // Second Ctrl+C — exit
+                this.ctrlcPending = false;
+                if (this.ctrlcTimer) {
+                    clearTimeout(this.ctrlcTimer);
+                    this.ctrlcTimer = null;
+                }
+                this.chatView.setFooter(this.defaultFooter);
+                this.stopRecallWatch();
+                if (this.app)
+                    this.app.stop();
+                this.orchestrator.shutdown().then(() => process.exit(0));
                 return;
             }
-            if (!input.startsWith("/")) {
-                this.conversationHistory.push({ role: "user", text: input });
+            // First Ctrl+C — show hint in footer, auto-expire after 2s
+            this.ctrlcPending = true;
+            const termW = process.stdout.columns || 80;
+            const hint = "Ctrl+C again to exit";
+            const pad = Math.max(0, termW - hint.length - 1);
+            this.chatView.setFooter(concat(tp.dim(" ".repeat(pad)), tp.muted(hint)));
+            this.refreshView();
+            this.ctrlcTimer = setTimeout(() => {
+                this.ctrlcTimer = null;
+                if (this.ctrlcPending) {
+                    this.ctrlcPending = false;
+                    this.chatView.setFooter(this.defaultFooter);
+                    this.refreshView();
+                }
+            }, 2000);
+        });
+        this.chatView.on("action", (id) => {
+            if (id === "copy") {
+                this.doCopy(this.lastCleanedOutput || undefined);
+            }
+            else if (id.startsWith("retro-approve-") ||
+                id.startsWith("retro-reject-")) {
+                this.handleRetroAction(id);
+            }
+            else if (id.startsWith("approve-") || id.startsWith("reject-")) {
+                this.handleHandoffAction(id);
+            }
+            else if (id.startsWith("reply-")) {
+                const ctx = this._replyContexts.get(id);
+                if (ctx && this.chatView) {
+                    this.chatView.inputValue = `@${ctx.teammate} [quoted reply] `;
+                    this._pendingQuotedReply = ctx.message;
+                    this.refreshView();
+                }
+            }
+        });
+        this.chatView.on("link", (url) => {
+            const cmd = process.platform === "darwin"
+                ? "open"
+                : process.platform === "win32"
+                    ? "start"
+                    : "xdg-open";
+            execCb(`${cmd} ${JSON.stringify(url)}`);
+        });
+        this.app = new App({
+            root: this.chatView,
+            alternateScreen: true,
+            mouse: true,
+        });
+        // Run the app — this takes over the terminal.
+        // Start the banner animation after the first frame renders.
+        bannerWidget.onDirty = () => this.app?.refresh();
+        const runPromise = this.app.run();
+        // Hold the banner animation before commands if we need to run the interview
+        if (pendingUserInterview) {
+            bannerWidget.hold();
+        }
+        bannerWidget.start();
+        // Run user interview inside the ChatView if USER.md needs setup
+        if (pendingUserInterview) {
+            this.startUserInterview(teammatesDir, bannerWidget);
+        }
+        await runPromise;
+    }
+    /**
+     * Handle paste events from ChatView.
+     * For multi-line or large pastes, store the text and replace
+     * the input with a compact placeholder that gets expanded on submit.
+     */
+    /** Image extensions for drag & drop detection. */
+    // IMAGE_EXTS is now imported from ./cli-utils.js
+    handlePaste(text) {
+        if (!this.chatView)
+            return;
+        // Check if the pasted text is a file path to an image (drag & drop)
+        const trimmed = text.trim().replace(/^["']|["']$/g, ""); // strip quotes from drag & drop paths
+        if (this.isImagePath(trimmed)) {
+            const current = this.chatView.inputValue;
+            const clean = text.replace(/[\r\n]/g, "");
+            const idx = current.indexOf(clean);
+            if (idx >= 0) {
+                const fileName = trimmed.split(/[/\\]/).pop() || trimmed;
+                const n = ++this.pasteCounter;
+                this.pastedTexts.set(n, `[Image: source: ${trimmed}]`);
+                const placeholder = `[Image ${fileName}]`;
+                const newVal = current.slice(0, idx) +
+                    placeholder +
+                    current.slice(idx + clean.length);
+                this.chatView.inputValue = newVal;
+                this.refreshView();
+            }
+            return;
+        }
+        const lines = text.split(/\r?\n/).length;
+        const sizeKB = (text.length / 1024).toFixed(1);
+        // Only use placeholder for multi-line or large pastes
+        if (lines <= 1 && text.length < 200)
+            return;
+        const n = ++this.pasteCounter;
+        this.pastedTexts.set(n, text);
+        // Replace the pasted text in the input with a placeholder.
+        // The paste was already inserted by TextInput, so we need to
+        // remove it and insert the placeholder instead.
+        const current = this.chatView.inputValue;
+        // The pasted text (with newlines stripped) was inserted at the cursor.
+        // Find it and replace with placeholder.
+        const clean = text.replace(/[\r\n]/g, "");
+        const idx = current.indexOf(clean);
+        if (idx >= 0) {
+            const placeholder = `[Pasted text #${n} +${lines} lines, ${sizeKB}KB]`;
+            const newVal = current.slice(0, idx) + placeholder + current.slice(idx + clean.length);
+            this.chatView.inputValue = newVal;
+        }
+        this.refreshView();
+    }
+    /** Check if a string looks like a path to an image file. */
+    isImagePath(text) {
+        return isImagePath(text);
+    }
+    /** Handle line submission from ChatView. */
+    async handleSubmit(rawLine) {
+        this.clearWordwheel();
+        this.wordwheelItems = [];
+        this.wordwheelIndex = -1;
+        // Expand paste placeholders with actual content
+        let input = rawLine.replace(/\[Pasted text #(\d+) \+\d+ lines, [\d.]+KB\]\s*/g, (_match, num) => {
+            const n = parseInt(num, 10);
+            const text = this.pastedTexts.get(n);
+            if (text) {
+                this.pastedTexts.delete(n);
+                return `${text}\n`;
+            }
+            return "";
+        });
+        // Expand [Image filename] placeholders with stored image source paths
+        input = input
+            .replace(/\[Image [^\]]+\]/g, (match) => {
+            // Find the matching pastedText entry by checking stored values
+            for (const [n, stored] of this.pastedTexts) {
+                if (stored.startsWith("[Image: source:")) {
+                    this.pastedTexts.delete(n);
+                    return stored;
+                }
             }
+            return match;
+        })
+            .trim();
+        // Expand [quoted reply] placeholder with blockquoted message
+        if (this._pendingQuotedReply && input.includes("[quoted reply]")) {
+            const quoted = this._pendingQuotedReply
+                .split("\n")
+                .map((l) => `> ${l}`)
+                .join("\n");
+            const before = input.slice(0, input.indexOf("[quoted reply]")).trimEnd();
+            const after = input
+                .slice(input.indexOf("[quoted reply]") + "[quoted reply]".length)
+                .trimStart();
+            const parts = [before, quoted];
+            if (after)
+                parts.push(after);
+            input = parts.join("\n");
+            this._pendingQuotedReply = null;
+        }
+        else {
+            this._pendingQuotedReply = null;
+        }
+        if (!input)
+            return;
+        // Handoff actions
+        if (input === "/approve") {
+            this.handleBulkHandoff("Approve all");
+            return;
+        }
+        if (input === "/always-approve") {
+            this.handleBulkHandoff("Always approve");
+            return;
+        }
+        if (input === "/reject") {
+            this.handleBulkHandoff("Reject all");
+            return;
+        }
+        if (input === "/approve-retro") {
+            this.handleBulkRetro("Approve all");
+            return;
+        }
+        if (input === "/reject-retro") {
+            this.handleBulkRetro("Reject all");
+            return;
+        }
+        // Slash commands
+        if (input.startsWith("/")) {
             this.dispatching = true;
             try {
                 await this.dispatch(input);
             }
             catch (err) {
-                console.log(chalk.red(`Error: ${err.message}`));
+                this.feedLine(tp.error(`Error: ${err.message}`));
             }
             finally {
                 this.dispatching = false;
             }
-            this.rl.prompt();
-        };
-        this.rl.on("line", (line) => {
-            this.dropdown.clear();
-            this.wordwheelItems = [];
-            this.wordwheelIndex = -1;
-            pasteBuffer.push(line);
-            // After the first line, mute readline output so subsequent
-            // pasted lines don't echo to the terminal.
-            if (pasteBuffer.length === 1) {
-                outputMuted = true;
-            }
-            if (pasteTimer)
-                clearTimeout(pasteTimer);
-            pasteTimer = setTimeout(processPaste, 30);
-        });
-        this.rl.on("close", async () => {
-            this.clearWordwheel();
-            console.log(chalk.gray("\nShutting down..."));
-            await this.orchestrator.shutdown();
-            process.exit(0);
-        });
+            this.refreshView();
+            return;
+        }
+        // Everything else gets queued
+        this.conversationHistory.push({ role: "user", text: input });
+        this.printUserMessage(input);
+        this.queueTask(input);
+        this.refreshView();
     }
     printBanner(teammates) {
         const registry = this.orchestrator.getRegistry();
         const termWidth = process.stdout.columns || 100;
-        const divider = chalk.gray("─".repeat(termWidth));
-        // Detect recall — check for .index/ inside any teammate folder
+        // Detect recall from services.json
         let recallInstalled = false;
         try {
-            const entries = readdirSync(this.teammatesDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory() || entry.name.startsWith("."))
-                    continue;
-                try {
-                    const s = statSync(join(this.teammatesDir, entry.name, ".index"));
-                    if (s.isDirectory()) {
-                        recallInstalled = true;
-                        break;
-                    }
-                }
-                catch { /* no index for this teammate */ }
-            }
+            const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+            recallInstalled = !!(svcJson && "recall" in svcJson);
         }
-        catch { /* can't read teammates dir */ }
-        console.log();
-        this.printLogo([
-            chalk.bold("Teammates") + chalk.gray(" v0.1.0"),
-            chalk.white(this.adapterName) +
-                chalk.gray(` · ${teammates.length} teammate${teammates.length === 1 ? "" : "s"}`),
-            chalk.gray(process.cwd()),
-            recallInstalled
-                ? chalk.green("● recall") + chalk.gray(" installed")
-                : chalk.yellow("○ recall") + chalk.gray(" not installed"),
-        ]);
+        catch {
+            /* no services.json or invalid */
+        }
+        this.feedLine();
+        this.feedLine(concat(tp.bold("  Teammates"), tp.muted(` v${PKG_VERSION}`)));
+        this.feedLine(concat(tp.text(`  ${this.adapterName}`), tp.muted(` · ${teammates.length} teammate${teammates.length === 1 ? "" : "s"}`)));
+        this.feedLine(`  ${process.cwd()}`);
+        this.feedLine(recallInstalled
+            ? tp.success("  ● recall installed")
+            : tp.warning("  ○ recall not installed"));
         // Roster
-        console.log();
+        this.feedLine();
         for (const name of teammates) {
             const t = registry.get(name);
             if (t) {
-                console.log(chalk.gray(" ") +
-                    chalk.cyan("●") +
-                    chalk.cyan(` @${name}`.padEnd(14)) +
-                    chalk.gray(t.role));
+                this.feedLine(concat(tp.muted("  "), tp.accent(`● @${name.padEnd(14)}`), tp.muted(t.role)));
             }
         }
-        console.log();
-        console.log(divider);
-        // Quick reference — 3 columns
-        const col1 = [
-            ["@mention", "assign to teammate"],
-            ["text", "auto-route task"],
-            ["/queue", "queue tasks"],
-        ];
-        const col2 = [
-            ["/status", "session overview"],
-            ["/debug", "raw agent output"],
-            ["/log", "last task output"],
-        ];
-        const col3 = [
-            ["/install", "add a service"],
-            ["/help", "all commands"],
-            ["/exit", "exit session"],
-        ];
+        this.feedLine();
+        this.feedLine(tp.muted("─".repeat(termWidth)));
+        // Quick reference — 3 columns (different set for first run vs normal)
+        let col1;
+        let col2;
+        let col3;
+        if (teammates.length === 0) {
+            // First run — no teammates yet
+            col1 = [
+                ["/init", "set up teammates"],
+                ["/install", "add a service"],
+            ];
+            col2 = [
+                ["/help", "all commands"],
+                ["/exit", "exit session"],
+            ];
+            col3 = [
+                ["", ""],
+                ["", ""],
+            ];
+        }
+        else {
+            col1 = [
+                ["@mention", "assign to teammate"],
+                ["text", "auto-route task"],
+                ["[image]", "drag & drop images"],
+            ];
+            col2 = [
+                ["/status", "teammates & queue"],
+                ["/compact", "compact memory"],
+                ["/retro", "run retrospective"],
+            ];
+            col3 = [
+                [
+                    recallInstalled ? "/copy" : "/install",
+                    recallInstalled ? "copy session text" : "add a service",
+                ],
+                ["/help", "all commands"],
+                ["/exit", "exit session"],
+            ];
+        }
         for (let i = 0; i < col1.length; i++) {
-            const c1 = chalk.cyan(col1[i][0].padEnd(12)) + chalk.gray(col1[i][1].padEnd(22));
-            const c2 = chalk.cyan(col2[i][0].padEnd(12)) + chalk.gray(col2[i][1].padEnd(22));
-            const c3 = chalk.cyan(col3[i][0].padEnd(12)) + chalk.gray(col3[i][1]);
-            console.log(`  ${c1}${c2}${c3}`);
+            this.feedLine(concat(tp.accent(`  ${col1[i][0]}`.padEnd(12)), tp.muted(col1[i][1].padEnd(22)), tp.accent(col2[i][0].padEnd(12)), tp.muted(col2[i][1].padEnd(22)), tp.accent(col3[i][0].padEnd(12)), tp.muted(col3[i][1])));
         }
-        console.log();
-        console.log(divider);
+        this.feedLine();
+        this.refreshView();
     }
     registerCommands() {
         const cmds = [
             {
                 name: "status",
-                aliases: ["s"],
+                aliases: ["s", "queue", "qu"],
                 usage: "/status",
-                description: "Show teammate roster and session status",
+                description: "Show teammates, active tasks, and queue",
                 run: () => this.cmdStatus(),
             },
-            {
-                name: "teammates",
-                aliases: ["team", "t"],
-                usage: "/teammates",
-                description: "List all teammates and their roles",
-                run: () => this.cmdTeammates(),
-            },
-            {
-                name: "log",
-                aliases: ["l"],
-                usage: "/log [teammate]",
-                description: "Show the last task result for a teammate",
-                run: (args) => this.cmdLog(args),
-            },
             {
                 name: "help",
                 aliases: ["h", "?"],
@@ -888,26 +2525,19 @@ class TeammatesREPL {
                 description: "Show raw agent output from the last task",
                 run: (args) => this.cmdDebug(args),
             },
-            {
-                name: "queue",
-                aliases: ["qu"],
-                usage: "/queue [@teammate] [task]",
-                description: "Add to queue, or show queue if no args",
-                run: (args) => this.cmdQueue(args),
-            },
             {
                 name: "cancel",
                 aliases: [],
-                usage: "/cancel <n>",
+                usage: "/cancel [n]",
                 description: "Cancel a queued task by number",
                 run: (args) => this.cmdCancel(args),
             },
             {
                 name: "init",
                 aliases: ["onboard", "setup"],
-                usage: "/init",
-                description: "Run onboarding to set up teammates for this project",
-                run: () => this.cmdInit(),
+                usage: "/init [from-path]",
+                description: "Set up teammates (or import from another project)",
+                run: (args) => this.cmdInit(args),
             },
             {
                 name: "clear",
@@ -919,17 +2549,62 @@ class TeammatesREPL {
             {
                 name: "install",
                 aliases: [],
-                usage: "/install <service>",
+                usage: "/install [service]",
                 description: "Install a teammates service (e.g. recall)",
                 run: (args) => this.cmdInstall(args),
             },
+            {
+                name: "compact",
+                aliases: [],
+                usage: "/compact [teammate]",
+                description: "Compact daily logs into weekly/monthly summaries",
+                run: (args) => this.cmdCompact(args),
+            },
+            {
+                name: "retro",
+                aliases: [],
+                usage: "/retro [teammate]",
+                description: "Run a structured self-retrospective for a teammate",
+                run: (args) => this.cmdRetro(args),
+            },
+            {
+                name: "copy",
+                aliases: ["cp"],
+                usage: "/copy",
+                description: "Copy session text to clipboard",
+                run: () => this.cmdCopy(),
+            },
+            {
+                name: "user",
+                aliases: [],
+                usage: "/user [change]",
+                description: "View or update USER.md",
+                run: (args) => this.cmdUser(args),
+            },
+            {
+                name: "btw",
+                aliases: [],
+                usage: "/btw [question]",
+                description: "Ask a quick side question without interrupting the main conversation",
+                run: (args) => this.cmdBtw(args),
+            },
+            {
+                name: "theme",
+                aliases: [],
+                usage: "/theme",
+                description: "Show current theme colors",
+                run: () => this.cmdTheme(),
+            },
             {
                 name: "exit",
                 aliases: ["q", "quit"],
                 usage: "/exit",
                 description: "Exit the session",
                 run: async () => {
-                    console.log(chalk.gray("Shutting down..."));
+                    this.feedLine(tp.muted("Shutting down..."));
+                    this.stopRecallWatch();
+                    if (this.app)
+                        this.app.stop();
                     await this.orchestrator.shutdown();
                     process.exit(0);
                 },
@@ -943,471 +2618,395 @@ class TeammatesREPL {
         }
     }
     async dispatch(input) {
-        // Handle pending handoff menu (1/2/3)
-        if (this.orchestrator.getPendingHandoff()) {
-            const handled = await this.handleHandoffChoice(input);
-            if (handled)
-                return;
-        }
-        if (input.startsWith("/")) {
-            const spaceIdx = input.indexOf(" ");
-            const cmdName = spaceIdx > 0 ? input.slice(1, spaceIdx) : input.slice(1);
-            const cmdArgs = spaceIdx > 0 ? input.slice(spaceIdx + 1).trim() : "";
-            const cmd = this.commands.get(cmdName);
-            if (cmd) {
-                await cmd.run(cmdArgs);
-            }
-            else {
-                console.log(chalk.yellow(`Unknown command: /${cmdName}`));
-                console.log(chalk.gray("Type /help for available commands"));
-            }
+        // Dispatch only handles slash commands — text input is queued via queueTask()
+        const spaceIdx = input.indexOf(" ");
+        const cmdName = spaceIdx > 0 ? input.slice(1, spaceIdx) : input.slice(1);
+        const cmdArgs = spaceIdx > 0 ? input.slice(spaceIdx + 1).trim() : "";
+        const cmd = this.commands.get(cmdName);
+        if (cmd) {
+            await cmd.run(cmdArgs);
         }
         else {
-            // Check for @mention — extract teammate and treat rest as task
-            const mentionMatch = input.match(/^@(\S+)\s+([\s\S]+)$/);
-            if (mentionMatch) {
-                const [, teammate, task] = mentionMatch;
-                const names = this.orchestrator.listTeammates();
-                if (names.includes(teammate)) {
-                    await this.cmdAssign(`${teammate} ${task}`);
-                    return;
-                }
-            }
-            // Also handle @mentions inline: strip @names and route to them
-            const inlineMention = input.match(/@(\S+)/);
-            if (inlineMention) {
-                const teammate = inlineMention[1];
-                const names = this.orchestrator.listTeammates();
-                if (names.includes(teammate)) {
-                    const task = input.replace(/@\S+\s*/, "").trim();
-                    if (task) {
-                        await this.cmdAssign(`${teammate} ${task}`);
-                        return;
-                    }
-                }
-            }
-            // Bare text — auto-route
-            await this.cmdRoute(input);
+            this.feedLine(tp.warning(`Unknown command: /${cmdName}`));
+            this.feedLine(tp.muted("Type /help for available commands"));
         }
     }
     // ─── Event handler ───────────────────────────────────────────────
     handleEvent(event) {
-        // When queue is draining in background, never use spinner — it blocks the prompt
-        const useSpinner = !this.queueDraining;
         switch (event.type) {
-            case "task_assigned":
-                if (useSpinner) {
-                    this.spinner = ora({
-                        text: chalk.blue(`${event.assignment.teammate}`) +
-                            chalk.gray(` is working on: ${event.assignment.task.slice(0, 60)}...`),
-                        spinner: "dots",
-                    }).start();
-                }
-                else if (!this.queueDraining) {
-                    console.log(chalk.blue(`  ${event.assignment.teammate}`) +
-                        chalk.gray(` is working on: ${event.assignment.task.slice(0, 60)}...`));
-                }
+            case "task_assigned": {
+                // Track this task and start the animated status bar
+                const key = event.assignment.teammate;
+                this.activeTasks.set(key, {
+                    teammate: event.assignment.teammate,
+                    task: event.assignment.task,
+                });
+                this.startStatusAnimation();
                 break;
-            case "task_completed":
-                {
-                    if (this.spinner) {
-                        this.spinner.stop();
-                        this.spinner = null;
-                    }
-                    const raw = event.result.rawOutput ?? "";
-                    const cleaned = raw.replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/, "").trim();
-                    const sizeKB = cleaned ? Buffer.byteLength(cleaned, "utf-8") / 1024 : 0;
-                    console.log();
-                    if (sizeKB > 5) {
-                        console.log(chalk.gray("  ─".repeat(40)));
-                        console.log(chalk.yellow(`  ⚠ Response is ${sizeKB.toFixed(1)}KB — use /debug ${event.result.teammate} to view full output`));
-                        console.log(chalk.gray("  ─".repeat(40)));
-                    }
-                    else if (cleaned) {
-                        console.log(cleaned);
-                    }
-                    console.log();
-                    console.log(chalk.green(`  ✔ ${event.result.teammate}`) +
-                        chalk.gray(": ") +
-                        event.result.summary);
+            }
+            case "task_completed": {
+                // Remove from active tasks
+                this.activeTasks.delete(event.result.teammate);
+                // Stop animation if no more active tasks
+                if (this.activeTasks.size === 0) {
+                    this.stopStatusAnimation();
                 }
-                break;
-            case "handoff_initiated":
-                if (this.spinner) {
-                    this.spinner.info(chalk.yellow("Handoff: ") +
-                        chalk.bold(event.envelope.from) +
-                        chalk.yellow(" → ") +
-                        chalk.bold(event.envelope.to));
-                    this.spinner = null;
+                if (!this.chatView)
+                    this.input.deactivateAndErase();
+                const raw = event.result.rawOutput ?? "";
+                // Strip protocol artifacts
+                const cleaned = raw
+                    .replace(/^TO:\s*\S+\s*\n/im, "")
+                    .replace(/^#\s+.+\n*/m, "")
+                    .replace(/```handoff\s*\n@\w+\s*\n[\s\S]*?```/g, "")
+                    .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/g, "")
+                    .trim();
+                const sizeKB = cleaned ? Buffer.byteLength(cleaned, "utf-8") / 1024 : 0;
+                // Header: "teammate: subject"
+                const subject = event.result.summary || "Task completed";
+                this.feedLine(concat(tp.accent(`${event.result.teammate}: `), tp.text(subject)));
+                this.lastCleanedOutput = cleaned;
+                if (sizeKB > 5) {
+                    const tmpFile = join(tmpdir(), `teammates-${event.result.teammate}-${Date.now()}.md`);
+                    writeFileSync(tmpFile, cleaned, "utf-8");
+                    this.feedLine(tp.muted(`  ${"─".repeat(40)}`));
+                    this.feedLine(tp.warning(`  ⚠ Response is ${sizeKB.toFixed(1)}KB — saved to temp file:`));
+                    this.feedLine(tp.muted(`  ${tmpFile}`));
+                    this.feedLine(tp.muted(`  ${"─".repeat(40)}`));
                 }
-                this.printHandoffDetails(event.envelope);
-                break;
-            case "handoff_completed":
-                // Already handled via task_completed
-                break;
-            case "error":
-                if (this.spinner) {
-                    this.spinner.fail(chalk.red(event.teammate) + chalk.gray(": ") + event.error);
-                    this.spinner = null;
+                else if (cleaned) {
+                    this.feedMarkdown(cleaned);
                 }
                 else {
-                    console.log(chalk.red(`  ${event.teammate}: ${event.error}`));
+                    this.feedLine(tp.muted("  (no response text — the agent may have only performed tool actions)"));
+                    this.feedLine(tp.muted(`  Use /debug ${event.result.teammate} to view full output`));
                 }
+                // Render handoffs
+                const handoffs = event.result.handoffs;
+                if (handoffs.length > 0) {
+                    this.renderHandoffs(event.result.teammate, handoffs);
+                }
+                // Clickable [reply] [copy] actions after the response
+                if (this.chatView && cleaned) {
+                    const t = theme();
+                    const teammate = event.result.teammate;
+                    const replyId = `reply-${teammate}-${Date.now()}`;
+                    this._replyContexts.set(replyId, { teammate, message: cleaned });
+                    this.chatView.appendActionList([
+                        {
+                            id: replyId,
+                            normalStyle: this.makeSpan({
+                                text: "  [reply]",
+                                style: { fg: t.textDim },
+                            }),
+                            hoverStyle: this.makeSpan({
+                                text: "  [reply]",
+                                style: { fg: t.accent },
+                            }),
+                        },
+                        {
+                            id: "copy",
+                            normalStyle: this.makeSpan({
+                                text: " [copy]",
+                                style: { fg: t.textDim },
+                            }),
+                            hoverStyle: this.makeSpan({
+                                text: " [copy]",
+                                style: { fg: t.accent },
+                            }),
+                        },
+                    ]);
+                }
+                this.feedLine();
+                // Auto-detect new teammates added during this task
+                this.refreshTeammates();
+                this.showPrompt();
                 break;
-        }
-    }
-    printHandoffDetails(envelope) {
-        console.log(chalk.gray("  ┌─────────────────────────────────────"));
-        console.log(chalk.gray("  │ ") +
-            chalk.white("Task: ") +
-            envelope.task);
-        if (envelope.changedFiles?.length) {
-            console.log(chalk.gray("  │ ") +
-                chalk.white("Files: ") +
-                envelope.changedFiles.join(", "));
-        }
-        if (envelope.acceptanceCriteria?.length) {
-            console.log(chalk.gray("  │ ") + chalk.white("Criteria:"));
-            for (const c of envelope.acceptanceCriteria) {
-                console.log(chalk.gray("  │   ") + chalk.gray("• ") + c);
-            }
-        }
-        if (envelope.openQuestions?.length) {
-            console.log(chalk.gray("  │ ") + chalk.white("Questions:"));
-            for (const q of envelope.openQuestions) {
-                console.log(chalk.gray("  │   ") + chalk.gray("? ") + q);
-            }
-        }
-        console.log(chalk.gray("  └─────────────────────────────────────"));
-        console.log();
-        console.log(chalk.cyan("  1") + chalk.gray(") Approve"));
-        console.log(chalk.cyan("  2") + chalk.gray(") Always approve handoffs"));
-        console.log(chalk.cyan("  3") + chalk.gray(") Reject"));
-        console.log();
-    }
-    /** Handle the numbered handoff menu choice. */
-    async handleHandoffChoice(choice) {
-        const pending = this.orchestrator.getPendingHandoff();
-        if (!pending)
-            return false;
-        switch (choice) {
-            case "1": {
-                this.orchestrator.clearPendingHandoff(pending.from);
-                const result = await this.orchestrator.assign({
-                    teammate: pending.to,
-                    task: pending.task,
-                    handoff: pending,
-                });
-                this.storeResult(result);
-                return true;
-            }
-            case "2": {
-                this.orchestrator.requireApproval = false;
-                this.orchestrator.clearPendingHandoff(pending.from);
-                console.log(chalk.gray("  Auto-approving all future handoffs."));
-                const result = await this.orchestrator.assign({
-                    teammate: pending.to,
-                    task: pending.task,
-                    handoff: pending,
-                });
-                this.storeResult(result);
-                return true;
-            }
-            case "3": {
-                this.orchestrator.clearPendingHandoff(pending.from);
-                console.log(chalk.gray(`  Rejected handoff from `) +
-                    chalk.bold(pending.from) +
-                    chalk.gray(" to ") +
-                    chalk.bold(pending.to));
-                return true;
             }
-            default:
-                return false;
-        }
-    }
-    // ─── Commands ────────────────────────────────────────────────────
-    async cmdAssign(argsStr) {
-        const parts = argsStr.match(/^(\S+)\s+(.+)$/);
-        if (!parts) {
-            console.log(chalk.yellow("Usage: /assign <teammate> <task...>"));
-            return;
-        }
-        const [, teammate, task] = parts;
-        // Pause readline so streamed agent output isn't garbled by the prompt
-        const extraContext = this.buildConversationContext();
-        const result = await this.orchestrator.assign({ teammate, task, extraContext: extraContext || undefined });
-        this.storeResult(result);
-        if (result.handoff && this.orchestrator.requireApproval) {
-            // Handoff is pending — user was already prompted
-        }
-    }
-    async cmdRoute(argsStr) {
-        let match = this.orchestrator.route(argsStr);
-        if (!match) {
-            // Keyword routing didn't find a strong match — ask the agent
-            match = await this.orchestrator.agentRoute(argsStr);
+            case "error":
+                this.activeTasks.delete(event.teammate);
+                if (this.activeTasks.size === 0)
+                    this.stopStatusAnimation();
+                if (!this.chatView)
+                    this.input.deactivateAndErase();
+                this.feedLine(tp.error(`  ✖ ${event.teammate}: ${event.error}`));
+                this.showPrompt();
+                break;
         }
-        match = match ?? this.adapterName;
-        console.log(chalk.gray(`  Routed to: ${chalk.bold(match)}`));
-        const extraContext = this.buildConversationContext();
-        const result = await this.orchestrator.assign({ teammate: match, task: argsStr, extraContext: extraContext || undefined });
-        this.storeResult(result);
     }
     async cmdStatus() {
         const statuses = this.orchestrator.getAllStatuses();
         const registry = this.orchestrator.getRegistry();
-        console.log();
-        console.log(chalk.bold("  Status"));
-        console.log(chalk.gray("  " + "─".repeat(60)));
+        this.feedLine();
+        this.feedLine(tp.bold("  Status"));
+        this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
         for (const [name, status] of statuses) {
-            const teammate = registry.get(name);
-            const stateColor = status.state === "idle"
-                ? chalk.gray
-                : status.state === "working"
-                    ? chalk.blue
-                    : chalk.yellow;
-            const stateLabel = stateColor(status.state.padEnd(16));
-            const nameLabel = chalk.bold(name.padEnd(14));
-            let detail = chalk.gray("—");
-            if (status.lastSummary) {
-                const time = status.lastTimestamp ? chalk.gray(` (${relativeTime(status.lastTimestamp)})`) : "";
-                detail = chalk.white(status.lastSummary.slice(0, 50)) + time;
-            }
-            if (status.state === "pending-handoff" && status.pendingHandoff) {
-                detail = chalk.yellow(`→ ${status.pendingHandoff.to}: ${status.pendingHandoff.task.slice(0, 40)}`);
-            }
-            console.log(`  ${nameLabel} ${stateLabel} ${detail}`);
-        }
-        console.log();
-    }
-    async cmdTeammates() {
-        const names = this.orchestrator.listTeammates();
-        const registry = this.orchestrator.getRegistry();
-        console.log();
-        for (const name of names) {
             const t = registry.get(name);
-            console.log(chalk.cyan(`  @${name}`.padEnd(16)) +
-                chalk.gray(t.role));
-            if (t.ownership.primary.length > 0) {
-                console.log(chalk.gray("                ") +
-                    chalk.gray("owns: ") +
-                    chalk.white(t.ownership.primary.join(", ")));
+            const active = this.agentActive.get(name);
+            const queued = this.taskQueue.filter((e) => e.teammate === name);
+            // Teammate name + state
+            const stateLabel = active ? "working" : status.state;
+            const stateColor = stateLabel === "working"
+                ? tp.info(` (${stateLabel})`)
+                : tp.muted(` (${stateLabel})`);
+            this.feedLine(concat(tp.accent(`  @${name}`), stateColor));
+            // Role
+            if (t) {
+                this.feedLine(tp.muted(`    ${t.role}`));
+            }
+            // Active task
+            if (active) {
+                const taskText = active.task.length > 60
+                    ? `${active.task.slice(0, 57)}…`
+                    : active.task;
+                this.feedLine(concat(tp.info("    ▸ "), tp.text(taskText)));
+            }
+            // Queued tasks
+            for (let i = 0; i < queued.length; i++) {
+                const taskText = queued[i].task.length > 60
+                    ? `${queued[i].task.slice(0, 57)}…`
+                    : queued[i].task;
+                this.feedLine(concat(tp.muted(`    ${i + 1}. `), tp.muted(taskText)));
+            }
+            // Last result
+            if (!active && status.lastSummary) {
+                const time = status.lastTimestamp
+                    ? ` ${relativeTime(status.lastTimestamp)}`
+                    : "";
+                this.feedLine(tp.muted(`    last: ${status.lastSummary.slice(0, 50)}${time}`));
             }
+            this.feedLine();
         }
-        console.log();
+        this.refreshView();
     }
-    async cmdLog(argsStr) {
-        const teammate = argsStr.trim();
-        if (teammate) {
-            // Show specific teammate's last result
-            const status = this.orchestrator.getStatus(teammate);
-            if (!status) {
-                console.log(chalk.yellow(`Unknown teammate: ${teammate}`));
+    async cmdDebug(argsStr) {
+        const arg = argsStr.trim().replace(/^@/, "");
+        // Resolve targets
+        let targets;
+        if (arg === "everyone") {
+            targets = [];
+            for (const [name, result] of this.lastResults) {
+                if (name !== this.adapterName && result.rawOutput) {
+                    targets.push({ name, result });
+                }
+            }
+            if (targets.length === 0) {
+                this.feedLine(tp.muted("  No raw output available from any teammate."));
+                this.refreshView();
                 return;
             }
-            this.printTeammateLog(teammate, status);
-        }
-        else if (this.lastResult) {
-            // Show last result globally
-            const status = this.orchestrator.getStatus(this.lastResult.teammate);
-            if (status)
-                this.printTeammateLog(this.lastResult.teammate, status);
         }
         else {
-            console.log(chalk.gray("No task results yet."));
-        }
-    }
-    printTeammateLog(name, status) {
-        console.log();
-        console.log(chalk.bold(`  ${name}`));
-        if (status.lastSummary) {
-            console.log(chalk.white(`  Summary: `) + status.lastSummary);
-        }
-        if (status.lastChangedFiles?.length) {
-            console.log(chalk.white(`  Changed:`));
-            for (const f of status.lastChangedFiles) {
-                console.log(chalk.gray(`    • `) + f);
+            const result = arg ? this.lastResults.get(arg) : this.lastResult;
+            if (!result?.rawOutput) {
+                this.feedLine(tp.muted("  No raw output available." +
+                    (arg ? "" : " Try: /debug <teammate>")));
+                this.refreshView();
+                return;
             }
+            targets = [{ name: result.teammate, result }];
         }
-        if (status.lastTimestamp) {
-            console.log(chalk.gray(`  Time: ${relativeTime(status.lastTimestamp)}`));
-        }
-        if (!status.lastSummary) {
-            console.log(chalk.gray("  No task results yet."));
+        for (const { name, result } of targets) {
+            this.feedLine();
+            this.feedLine(tp.muted(`  ── raw output from ${name} ──`));
+            this.feedLine();
+            this.feedMarkdown(result.rawOutput);
+            this.feedLine();
+            this.feedLine(tp.muted("  ── end raw output ──"));
         }
-        console.log();
-    }
-    async cmdDebug(argsStr) {
-        const teammate = argsStr.trim();
-        const result = teammate
-            ? this.lastResults.get(teammate)
-            : this.lastResult;
-        if (!result?.rawOutput) {
-            console.log(chalk.gray("  No raw output available." + (teammate ? "" : " Try: /debug <teammate>")));
-            return;
+        // [copy] action for the debug output
+        if (this.chatView) {
+            const t = theme();
+            this.lastCleanedOutput = targets
+                .map((t) => t.result.rawOutput)
+                .join("\n\n");
+            this.chatView.appendActionList([
+                {
+                    id: "copy",
+                    normalStyle: this.makeSpan({
+                        text: "  [copy]",
+                        style: { fg: t.textDim },
+                    }),
+                    hoverStyle: this.makeSpan({
+                        text: "  [copy]",
+                        style: { fg: t.accent },
+                    }),
+                },
+            ]);
         }
-        console.log();
-        console.log(chalk.gray(`  ── raw output from ${result.teammate} ──`));
-        console.log();
-        console.log(result.rawOutput);
-        console.log();
-        console.log(chalk.gray(`  ── end raw output ──`));
-        console.log();
+        this.feedLine();
+        this.refreshView();
     }
     async cmdCancel(argsStr) {
         const n = parseInt(argsStr.trim(), 10);
-        if (isNaN(n) || n < 1 || n > this.taskQueue.length) {
+        if (Number.isNaN(n) || n < 1 || n > this.taskQueue.length) {
             if (this.taskQueue.length === 0) {
-                console.log(chalk.gray("  Queue is empty."));
+                this.feedLine(tp.muted("  Queue is empty."));
             }
             else {
-                console.log(chalk.yellow(`  Usage: /cancel <1-${this.taskQueue.length}>`));
+                this.feedLine(tp.warning(`  Usage: /cancel <1-${this.taskQueue.length}>`));
             }
+            this.refreshView();
             return;
         }
         const removed = this.taskQueue.splice(n - 1, 1)[0];
-        console.log(chalk.gray("  Cancelled: ") +
-            chalk.cyan(`@${removed.teammate}`) +
-            chalk.gray(" — ") +
-            chalk.white(removed.task.slice(0, 60)));
-    }
-    async cmdQueue(argsStr) {
-        if (!argsStr) {
-            // Show queue
-            if (this.taskQueue.length === 0 && !this.queueDraining) {
-                console.log(chalk.gray("  Queue is empty."));
-                return;
+        this.feedLine(concat(tp.muted("  Cancelled: "), tp.accent(`@${removed.teammate}`), tp.muted(" — "), tp.text(removed.task.slice(0, 60))));
+        this.refreshView();
+    }
+    /** Drain tasks for a single agent — runs in parallel with other agents. */
+    async drainAgentQueue(agent) {
+        while (true) {
+            const idx = this.taskQueue.findIndex((e) => e.teammate === agent);
+            if (idx < 0)
+                break;
+            const entry = this.taskQueue.splice(idx, 1)[0];
+            this.agentActive.set(agent, entry);
+            try {
+                if (entry.type === "compact") {
+                    await this.runCompact(entry.teammate);
+                }
+                else {
+                    // btw tasks skip conversation context (side question, not part of main thread)
+                    const extraContext = entry.type === "btw" ? "" : this.buildConversationContext();
+                    const result = await this.orchestrator.assign({
+                        teammate: entry.teammate,
+                        task: entry.task,
+                        extraContext: extraContext || undefined,
+                    });
+                    // btw results are not stored in conversation history
+                    if (entry.type !== "btw") {
+                        this.storeResult(result);
+                    }
+                    if (entry.type === "retro") {
+                        this.handleRetroResult(result);
+                    }
+                }
             }
-            console.log();
-            console.log(chalk.bold("  Task Queue") +
-                (this.queueDraining ? chalk.blue("  (draining)") : ""));
-            console.log(chalk.gray("  " + "─".repeat(50)));
-            if (this.queueActive) {
-                console.log(chalk.blue("  ▸ ") +
-                    chalk.cyan(`@${this.queueActive.teammate}`) +
-                    chalk.gray(" — ") +
-                    chalk.white(this.queueActive.task.length > 60 ? this.queueActive.task.slice(0, 57) + "..." : this.queueActive.task) +
-                    chalk.blue("  (running)"));
-            }
-            for (let i = 0; i < this.taskQueue.length; i++) {
-                const entry = this.taskQueue[i];
-                console.log(chalk.gray(`  ${i + 1}. `) +
-                    chalk.cyan(`@${entry.teammate}`) +
-                    chalk.gray(" — ") +
-                    chalk.white(entry.task.length > 60 ? entry.task.slice(0, 57) + "..." : entry.task));
-            }
-            if (this.taskQueue.length > 0) {
-                console.log(chalk.gray("  /cancel <n> to remove a task"));
+            catch (err) {
+                // Handle spawn failures, network errors, etc. gracefully
+                this.activeTasks.delete(agent);
+                if (this.activeTasks.size === 0)
+                    this.stopStatusAnimation();
+                const msg = err?.message ?? String(err);
+                this.feedLine(tp.error(`  ✖ @${agent}: ${msg}`));
+                this.refreshView();
             }
-            console.log();
-            return;
-        }
-        // Parse: @teammate task or teammate task
-        const match = argsStr.match(/^@?(\S+)(?:\s+([\s\S]+))?$/);
-        if (!match) {
-            console.log(chalk.yellow("  Usage: /queue @teammate <task...>"));
-            return;
-        }
-        const [, teammate, task] = match;
-        const names = this.orchestrator.listTeammates();
-        if (!names.includes(teammate)) {
-            console.log(chalk.yellow(`  Unknown teammate: ${teammate}`));
-            return;
-        }
-        if (!task?.trim()) {
-            console.log(chalk.yellow(`  Missing task. Usage: /queue @${teammate} <task...>`));
-            return;
-        }
-        this.taskQueue.push({ teammate, task: task.trim() });
-        console.log();
-        console.log(chalk.gray("  Queued: ") +
-            chalk.cyan(`@${teammate}`) +
-            chalk.gray(" — ") +
-            chalk.white(task.trim().slice(0, 60)) +
-            chalk.gray(` (${this.taskQueue.length} in queue)`));
-        console.log(chalk.blue(`  ${teammate}`) +
-            chalk.gray(` is working on: ${task.trim().slice(0, 60)}...`));
-        console.log();
-        // Start draining if not already (mutex-protected)
-        if (!this.drainLock) {
-            this.drainLock = this.drainQueue().finally(() => { this.drainLock = null; });
+            this.agentActive.delete(agent);
         }
     }
-    /** Drain the queue in the background — REPL stays responsive. Mutex via drainLock. */
-    async drainQueue() {
-        this.queueDraining = true;
-        try {
-            while (this.taskQueue.length > 0) {
-                // If a handoff is pending, pause until it's resolved
-                if (this.orchestrator.getPendingHandoff()) {
-                    await new Promise((resolve) => {
-                        const check = () => {
-                            if (!this.orchestrator.getPendingHandoff()) {
-                                resolve();
-                            }
-                            else {
-                                setTimeout(check, 500);
-                            }
-                        };
-                        setTimeout(check, 500);
+    async cmdInit(argsStr) {
+        const cwd = process.cwd();
+        const teammatesDir = join(cwd, ".teammates");
+        await mkdir(teammatesDir, { recursive: true });
+        const fromPath = argsStr.trim();
+        if (fromPath) {
+            // Import mode: /init <path-to-another-project>
+            const resolved = resolve(fromPath);
+            let sourceDir;
+            try {
+                const s = await stat(join(resolved, ".teammates"));
+                if (s.isDirectory()) {
+                    sourceDir = join(resolved, ".teammates");
+                }
+                else {
+                    sourceDir = resolved;
+                }
+            }
+            catch {
+                sourceDir = resolved;
+            }
+            try {
+                const { teammates, files } = await importTeammates(sourceDir, teammatesDir);
+                if (teammates.length === 0) {
+                    this.feedLine(tp.warning(`  No teammates found at ${sourceDir}`));
+                    this.refreshView();
+                    return;
+                }
+                this.feedLine(tp.success(`  Imported ${teammates.length} teammate${teammates.length > 1 ? "s" : ""}: ${teammates.join(", ")} (${files.length} files)`));
+                // Queue one adaptation task per teammate
+                this.feedLine(tp.muted(`  Queuing ${this.adapterName} to adapt each teammate individually...`));
+                for (const name of teammates) {
+                    const prompt = await buildAdaptationPrompt(teammatesDir, name);
+                    this.taskQueue.push({
+                        type: "agent",
+                        teammate: this.adapterName,
+                        task: prompt,
                     });
-                    continue;
                 }
-                const entry = this.taskQueue.shift();
-                this.queueActive = entry;
-                const extraContext = this.buildConversationContext();
-                const result = await this.orchestrator.assign({
-                    teammate: entry.teammate,
-                    task: entry.task,
-                    extraContext: extraContext || undefined,
-                });
-                this.queueActive = null;
-                this.storeResult(result);
+                this.kickDrain();
+            }
+            catch (err) {
+                this.feedLine(tp.error(`  Import failed: ${err.message}`));
             }
-            console.log(chalk.green("  ✔ Queue complete."));
-            this.rl.prompt();
         }
-        finally {
-            this.queueDraining = false;
+        else {
+            // Normal onboarding
+            await this.runOnboardingAgent(this.adapter, cwd);
         }
-    }
-    async cmdInit() {
-        const cwd = process.cwd();
-        await mkdir(join(cwd, ".teammates"), { recursive: true });
-        await this.runOnboardingAgent(this.adapter, cwd);
         // Reload the registry to pick up newly created teammates
-        await this.orchestrator.init();
-        console.log(chalk.gray("  Run /teammates to see the roster."));
+        const added = await this.orchestrator.refresh();
+        if (added.length > 0) {
+            const registry = this.orchestrator.getRegistry();
+            if ("roster" in this.adapter) {
+                this.adapter.roster = this.orchestrator
+                    .listTeammates()
+                    .map((name) => {
+                    const t = registry.get(name);
+                    return { name: t.name, role: t.role, ownership: t.ownership };
+                });
+            }
+        }
+        this.feedLine(tp.muted("  Run /status to see the roster."));
+        this.refreshView();
     }
     async cmdInstall(argsStr) {
         const serviceName = argsStr.trim().toLowerCase();
         if (!serviceName) {
-            console.log(chalk.bold("\n  Available services:"));
+            this.feedLine(tp.bold("\n  Available services:"));
             for (const [name, svc] of Object.entries(SERVICE_REGISTRY)) {
-                console.log(`  ${chalk.cyan(name.padEnd(16))}${chalk.gray(svc.description)}`);
+                this.feedLine(concat(tp.accent(name.padEnd(16)), tp.muted(svc.description)));
             }
-            console.log();
+            this.feedLine();
+            this.refreshView();
             return;
         }
         const service = SERVICE_REGISTRY[serviceName];
         if (!service) {
-            console.log(chalk.red(`  Unknown service: ${serviceName}`));
-            console.log(chalk.gray(`  Available: ${Object.keys(SERVICE_REGISTRY).join(", ")}`));
+            this.feedLine(tp.warning(`  Unknown service: ${serviceName}`));
+            this.feedLine(tp.muted(`  Available: ${Object.keys(SERVICE_REGISTRY).join(", ")}`));
+            this.refreshView();
             return;
         }
         // Install the package globally
-        const spinner = ora({
-            text: chalk.blue(serviceName) + chalk.gray(` installing ${service.package}...`),
-            spinner: "dots",
-        }).start();
+        if (this.chatView) {
+            this.chatView.setProgress(`Installing ${service.package}...`);
+            this.refreshView();
+        }
+        let installSpinner = null;
+        if (!this.chatView) {
+            installSpinner = ora({
+                text: chalk.blue(serviceName) +
+                    chalk.gray(` installing ${service.package}...`),
+                spinner: "dots",
+            }).start();
+        }
         try {
             await execAsync(`npm install -g ${service.package}`, {
                 timeout: 5 * 60 * 1000,
             });
-            spinner.stop();
+            if (installSpinner)
+                installSpinner.stop();
+            if (this.chatView)
+                this.chatView.setProgress(null);
         }
         catch (err) {
-            spinner.fail(chalk.red(`Install failed: ${err.message}`));
+            if (installSpinner)
+                installSpinner.fail(chalk.red(`Install failed: ${err.message}`));
+            if (this.chatView) {
+                this.chatView.setProgress(null);
+                this.feedLine(tp.error(`  ✖ Install failed: ${err.message}`));
+                this.refreshView();
+            }
             return;
         }
         // Verify the binary works
@@ -1416,57 +3015,499 @@ class TeammatesREPL {
             execSync(checkCmdStr, { stdio: "ignore" });
         }
         catch {
-            console.log(chalk.green(`  ✔ ${serviceName}`) + chalk.gray(" installed"));
-            console.log(chalk.yellow(`  ⚠ Restart your terminal to add ${service.checkCmd[0]} to your PATH, then run /install ${serviceName} again to build the index.`));
+            this.feedLine(tp.success(`  ✔ ${serviceName} installed`));
+            this.feedLine(tp.warning(`  ⚠ Restart your terminal to add ${service.checkCmd[0]} to your PATH, then run /install ${serviceName} again to build the index.`));
+            this.refreshView();
             return;
         }
-        console.log(chalk.green(`  ✔ ${serviceName}`) + chalk.gray(" installed successfully"));
+        this.feedLine(tp.success(`  ✔ ${serviceName} installed successfully`));
+        // Register in services.json
+        const svcPath = join(this.teammatesDir, "services.json");
+        let svcJson = {};
+        try {
+            svcJson = JSON.parse(readFileSync(svcPath, "utf-8"));
+        }
+        catch {
+            /* new file */
+        }
+        if (!(serviceName in svcJson)) {
+            svcJson[serviceName] = {};
+            writeFileSync(svcPath, `${JSON.stringify(svcJson, null, 2)}\n`);
+            this.feedLine(tp.muted(`  Registered in services.json`));
+        }
         // Build initial index if this service supports it
         if (service.indexCmd) {
-            const indexSpinner = ora({
-                text: chalk.blue(serviceName) + chalk.gray(` building index...`),
-                spinner: "dots",
-            }).start();
+            if (this.chatView) {
+                this.chatView.setProgress(`Building ${serviceName} index...`);
+                this.refreshView();
+            }
+            let idxSpinner = null;
+            if (!this.chatView) {
+                idxSpinner = ora({
+                    text: chalk.blue(serviceName) + chalk.gray(` building index...`),
+                    spinner: "dots",
+                }).start();
+            }
             const indexCmdStr = service.indexCmd.join(" ");
             try {
                 await execAsync(indexCmdStr, {
                     cwd: resolve(this.teammatesDir, ".."),
                     timeout: 5 * 60 * 1000,
                 });
-                indexSpinner.succeed(chalk.blue(serviceName) + chalk.gray(" index built"));
+                if (idxSpinner)
+                    idxSpinner.succeed(chalk.blue(serviceName) + chalk.gray(" index built"));
+                if (this.chatView) {
+                    this.chatView.setProgress(null);
+                    this.feedLine(tp.success(`  ✔ ${serviceName} index built`));
+                }
             }
             catch (err) {
-                indexSpinner.warn(chalk.yellow(`Index build failed: ${err.message}`));
+                if (idxSpinner)
+                    idxSpinner.warn(chalk.yellow(`Index build failed: ${err.message}`));
+                if (this.chatView) {
+                    this.chatView.setProgress(null);
+                    this.feedLine(tp.warning(`  ⚠ Index build failed: ${err.message}`));
+                }
             }
         }
         // Ask the coding agent to wire the service into the project
         if (service.wireupTask) {
-            console.log();
-            console.log(chalk.gray(`  Wiring up ${serviceName}...`));
+            this.feedLine();
+            this.feedLine(tp.muted(`  Wiring up ${serviceName}...`));
+            this.refreshView();
             const result = await this.orchestrator.assign({
                 teammate: this.adapterName,
                 task: service.wireupTask,
             });
             this.storeResult(result);
         }
+        this.refreshView();
     }
     async cmdClear() {
-        // Reset all session state
         this.conversationHistory.length = 0;
         this.lastResult = null;
         this.lastResults.clear();
         this.taskQueue.length = 0;
-        this.queueActive = null;
+        this.agentActive.clear();
         this.pastedTexts.clear();
+        this.pendingRetroProposals = [];
         await this.orchestrator.reset();
-        // Clear terminal and reprint banner
-        process.stdout.write("\x1b[2J\x1b[H");
-        this.printBanner(this.orchestrator.listTeammates());
+        if (this.chatView) {
+            this.chatView.clear();
+            this.refreshView();
+        }
+        else {
+            process.stdout.write(esc.clearScreen + esc.moveTo(0, 0));
+            this.printBanner(this.orchestrator.listTeammates());
+        }
+    }
+    /**
+     * Reload the registry from disk. If new teammates appeared,
+     * announce them, update the adapter roster, and refresh statuses.
+     */
+    refreshTeammates() {
+        this.orchestrator
+            .refresh()
+            .then((added) => {
+            if (added.length === 0)
+                return;
+            const registry = this.orchestrator.getRegistry();
+            // Update adapter roster so prompts include the new teammates
+            if ("roster" in this.adapter) {
+                this.adapter.roster = this.orchestrator
+                    .listTeammates()
+                    .map((name) => {
+                    const t = registry.get(name);
+                    return { name: t.name, role: t.role, ownership: t.ownership };
+                });
+            }
+            // Announce
+            for (const name of added) {
+                const config = registry.get(name);
+                const role = config?.role ?? "teammate";
+                this.feedLine(concat(tp.success(`  ✦ New teammate joined: `), tp.bold(name), tp.muted(` — ${role}`)));
+            }
+            this.refreshView();
+        })
+            .catch(() => { });
+    }
+    startRecallWatch() {
+        // Only start if recall is installed (check services.json)
+        try {
+            const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+            if (!svcJson || !("recall" in svcJson))
+                return;
+        }
+        catch {
+            return; // No services.json — recall not installed
+        }
+        try {
+            this.recallWatchProcess = cpSpawn("teammates-recall", ["watch", "--dir", this.teammatesDir, "--json"], {
+                stdio: ["ignore", "ignore", "ignore"],
+                detached: false,
+            });
+            this.recallWatchProcess.on("error", () => {
+                // Recall binary not found — silently ignore
+                this.recallWatchProcess = null;
+            });
+            this.recallWatchProcess.on("exit", () => {
+                this.recallWatchProcess = null;
+            });
+        }
+        catch {
+            this.recallWatchProcess = null;
+        }
+    }
+    stopRecallWatch() {
+        if (this.recallWatchProcess) {
+            this.recallWatchProcess.kill("SIGTERM");
+            this.recallWatchProcess = null;
+        }
+    }
+    async cmdCompact(argsStr) {
+        const arg = argsStr.trim();
+        const allTeammates = this.orchestrator
+            .listTeammates()
+            .filter((n) => n !== this.adapterName);
+        const names = !arg || arg === "everyone" ? allTeammates : [arg];
+        // Validate all names first
+        const valid = [];
+        for (const name of names) {
+            const teammateDir = join(this.teammatesDir, name);
+            try {
+                const s = await stat(teammateDir);
+                if (!s.isDirectory()) {
+                    this.feedLine(tp.warning(`  ${name}: not a directory, skipping`));
+                    continue;
+                }
+                valid.push(name);
+            }
+            catch {
+                this.feedLine(tp.warning(`  ${name}: no directory found, skipping`));
+            }
+        }
+        if (valid.length === 0)
+            return;
+        // Queue a compact task for each teammate
+        for (const name of valid) {
+            this.taskQueue.push({
+                type: "compact",
+                teammate: name,
+                task: "compact + index update",
+            });
+        }
+        this.feedLine();
+        this.feedLine(concat(tp.muted("  Queued compaction for "), tp.accent(valid.map((n) => `@${n}`).join(", ")), tp.muted(` (${valid.length} task${valid.length === 1 ? "" : "s"})`)));
+        this.feedLine();
+        this.refreshView();
+        // Start draining
+        this.kickDrain();
+    }
+    /** Run compaction + recall index update for a single teammate. */
+    async runCompact(name) {
+        const teammateDir = join(this.teammatesDir, name);
+        if (this.chatView) {
+            this.chatView.setProgress(`Compacting ${name}...`);
+            this.refreshView();
+        }
+        let spinner = null;
+        if (!this.chatView) {
+            spinner = ora({ text: `Compacting ${name}...`, color: "cyan" }).start();
+        }
+        try {
+            const result = await compactEpisodic(teammateDir, name);
+            const parts = [];
+            if (result.weekliesCreated.length > 0) {
+                parts.push(`${result.weekliesCreated.length} weekly summaries created`);
+            }
+            if (result.monthliesCreated.length > 0) {
+                parts.push(`${result.monthliesCreated.length} monthly summaries created`);
+            }
+            if (result.dailiesRemoved.length > 0) {
+                parts.push(`${result.dailiesRemoved.length} daily logs compacted`);
+            }
+            if (result.weekliesRemoved.length > 0) {
+                parts.push(`${result.weekliesRemoved.length} old weekly summaries archived`);
+            }
+            if (parts.length === 0) {
+                if (spinner)
+                    spinner.info(`${name}: nothing to compact`);
+                if (this.chatView)
+                    this.feedLine(tp.muted(`  ℹ ${name}: nothing to compact`));
+            }
+            else {
+                if (spinner)
+                    spinner.succeed(`${name}: ${parts.join(", ")}`);
+                if (this.chatView)
+                    this.feedLine(tp.success(`  ✔ ${name}: ${parts.join(", ")}`));
+            }
+            if (this.chatView)
+                this.chatView.setProgress(null);
+            // Trigger recall sync if installed
+            try {
+                const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+                if (svcJson && "recall" in svcJson) {
+                    if (this.chatView) {
+                        this.chatView.setProgress(`Syncing ${name} index...`);
+                        this.refreshView();
+                    }
+                    let syncSpinner = null;
+                    if (!this.chatView) {
+                        syncSpinner = ora({
+                            text: `Syncing ${name} index...`,
+                            color: "cyan",
+                        }).start();
+                    }
+                    await execAsync(`teammates-recall sync --dir "${this.teammatesDir}"`);
+                    if (syncSpinner)
+                        syncSpinner.succeed(`${name}: index synced`);
+                    if (this.chatView) {
+                        this.chatView.setProgress(null);
+                        this.feedLine(tp.success(`  ✔ ${name}: index synced`));
+                    }
+                }
+            }
+            catch {
+                /* recall not installed or sync failed — non-fatal */
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (spinner)
+                spinner.fail(`${name}: ${msg}`);
+            if (this.chatView) {
+                this.chatView.setProgress(null);
+                this.feedLine(tp.error(`  ✖ ${name}: ${msg}`));
+            }
+        }
+        this.refreshView();
+    }
+    async cmdRetro(argsStr) {
+        const arg = argsStr.trim().replace(/^@/, "");
+        // Resolve target list
+        const allTeammates = this.orchestrator
+            .listTeammates()
+            .filter((n) => n !== this.adapterName);
+        let targets;
+        if (arg === "everyone") {
+            targets = allTeammates;
+        }
+        else if (arg) {
+            // Validate teammate exists
+            const names = this.orchestrator.listTeammates();
+            if (!names.includes(arg)) {
+                this.feedLine(tp.warning(`  Unknown teammate: @${arg}`));
+                this.refreshView();
+                return;
+            }
+            targets = [arg];
+        }
+        else if (this.lastResult) {
+            targets = [this.lastResult.teammate];
+        }
+        else {
+            this.feedLine(tp.warning("  No teammate specified and no recent task to infer from."));
+            this.feedLine(tp.muted("  Usage: /retro <teammate>"));
+            this.refreshView();
+            return;
+        }
+        const retroPrompt = `Run a structured self-retrospective. Review your SOUL.md, WISDOM.md, your last 2-3 weekly summaries (or last 7 daily logs if no weeklies exist), and any typed memories in your memory/ folder.
+
+Produce a response with these four sections:
+
+## 1. What's Working
+Things you do well, based on evidence from recent work. Patterns worth reinforcing or codifying into wisdom. Cite specific examples from daily logs or memories.
+
+## 2. What's Not Working
+Friction, recurring issues, or patterns that aren't serving the project. Be specific — cite examples from daily logs or memories if possible.
+
+## 3. Proposed SOUL.md Changes
+The core output. Each proposal is a **specific edit** to your SOUL.md. Use this exact format for each proposal:
+
+**Proposal N: <short title>**
+- **Section:** <which SOUL.md section to change, e.g. Boundaries, Core Principles, Ownership>
+- **Before:** <the current text to replace, or "(new entry)" if adding>
+- **After:** <the exact replacement text>
+- **Why:** <evidence from recent work justifying the change>
+
+Only propose changes to your own SOUL.md. If a change affects shared files, note that it needs a handoff.
+
+## 4. Questions for the Team
+Issues that can't be resolved unilaterally — they need input from other teammates or the user.
+
+**Rules:**
+- This is a self-review of YOUR work. Do not evaluate other teammates.
+- Evidence over opinion — cite specific examples.
+- No busywork — if everything is working well, say "all good, no changes." That's a valid outcome.
+- Number each proposal (Proposal 1, Proposal 2, etc.) so the user can approve or reject individually.`;
+        const label = targets.length > 1
+            ? targets.map((n) => `@${n}`).join(", ")
+            : `@${targets[0]}`;
+        this.feedLine();
+        this.feedLine(concat(tp.muted("  Queued retro for "), tp.accent(label)));
+        this.feedLine();
+        this.refreshView();
+        for (const name of targets) {
+            this.taskQueue.push({ type: "retro", teammate: name, task: retroPrompt });
+        }
+        this.kickDrain();
+    }
+    /**
+     * Background startup maintenance:
+     * 1. Scan all teammates for daily logs older than a week → compact them
+     * 2. Sync recall indexes if recall is installed
+     */
+    /** Recursively delete files/directories older than maxAgeMs. Removes empty parent dirs. */
+    async cleanOldTempFiles(dir, maxAgeMs) {
+        const now = Date.now();
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await this.cleanOldTempFiles(fullPath, maxAgeMs);
+                // Remove dir if now empty
+                const remaining = await readdir(fullPath).catch(() => [""]);
+                if (remaining.length === 0)
+                    await rm(fullPath, { recursive: true }).catch(() => { });
+            }
+            else {
+                const info = await stat(fullPath).catch(() => null);
+                if (info && now - info.mtimeMs > maxAgeMs) {
+                    await unlink(fullPath).catch(() => { });
+                }
+            }
+        }
+    }
+    async startupMaintenance() {
+        // Clean up .teammates/.tmp files older than 1 week
+        const tmpDir = join(this.teammatesDir, ".tmp");
+        try {
+            await this.cleanOldTempFiles(tmpDir, 7 * 24 * 60 * 60 * 1000);
+        }
+        catch {
+            /* .tmp dir may not exist yet — non-fatal */
+        }
+        const teammates = this.orchestrator
+            .listTeammates()
+            .filter((n) => n !== this.adapterName);
+        if (teammates.length === 0)
+            return;
+        // Check if recall is installed
+        let recallInstalled = false;
+        try {
+            const svcJson = JSON.parse(readFileSync(join(this.teammatesDir, "services.json"), "utf-8"));
+            recallInstalled = !!(svcJson && "recall" in svcJson);
+        }
+        catch {
+            /* no services.json */
+        }
+        // 1. Check each teammate for stale daily logs (older than 7 days)
+        const oneWeekAgo = new Date();
+        oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+        const cutoff = oneWeekAgo.toISOString().slice(0, 10); // YYYY-MM-DD
+        const needsCompact = [];
+        for (const name of teammates) {
+            const memoryDir = join(this.teammatesDir, name, "memory");
+            try {
+                const entries = await readdir(memoryDir);
+                const hasStale = entries.some((e) => {
+                    if (!e.endsWith(".md"))
+                        return false;
+                    const stem = e.replace(".md", "");
+                    return /^\d{4}-\d{2}-\d{2}$/.test(stem) && stem < cutoff;
+                });
+                if (hasStale)
+                    needsCompact.push(name);
+            }
+            catch {
+                /* no memory dir */
+            }
+        }
+        if (needsCompact.length > 0) {
+            this.feedLine(concat(tp.muted("  Compacting stale logs for "), tp.accent(needsCompact.map((n) => `@${n}`).join(", ")), tp.muted("...")));
+            this.refreshView();
+            for (const name of needsCompact) {
+                await this.runCompact(name);
+            }
+        }
+        // 2. Sync recall indexes if installed
+        if (recallInstalled) {
+            try {
+                await execAsync(`teammates-recall sync --dir "${this.teammatesDir}"`);
+            }
+            catch {
+                /* sync failed — non-fatal */
+            }
+        }
+    }
+    async cmdCopy() {
+        this.doCopy(); // copies entire session
+    }
+    /** Build the full chat session as a markdown document. */
+    buildSessionMarkdown() {
+        if (this.conversationHistory.length === 0)
+            return "";
+        const lines = [];
+        lines.push(`# Chat Session\n`);
+        for (const entry of this.conversationHistory) {
+            if (entry.role === "user") {
+                lines.push(`**User:** ${entry.text}\n`);
+            }
+            else {
+                // Strip protocol artifacts from the raw output
+                const cleaned = entry.text
+                    .replace(/^TO:\s*\S+\s*\n/im, "")
+                    .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/g, "")
+                    .trim();
+                lines.push(`**${entry.role}:**\n\n${cleaned}\n`);
+            }
+            lines.push("---\n");
+        }
+        return lines.join("\n");
+    }
+    doCopy(content) {
+        // Build content: if none specified, export the entire chat session as markdown
+        const text = content ?? this.buildSessionMarkdown();
+        if (!text) {
+            this.feedLine(tp.muted("  Nothing to copy."));
+            this.refreshView();
+            return;
+        }
+        try {
+            const isWin = process.platform === "win32";
+            const cmd = isWin
+                ? "clip"
+                : process.platform === "darwin"
+                    ? "pbcopy"
+                    : "xclip -selection clipboard";
+            const child = execCb(cmd, () => { });
+            child.stdin?.write(text);
+            child.stdin?.end();
+            // Show brief "Copied" message in the progress area
+            if (this.chatView) {
+                this.chatView.setProgress(concat(tp.success("✔ "), tp.muted("Copied to clipboard")));
+                this.refreshView();
+                setTimeout(() => {
+                    this.chatView.setProgress(null);
+                    this.refreshView();
+                }, 1500);
+            }
+        }
+        catch {
+            if (this.chatView) {
+                this.chatView.setProgress(concat(tp.error("✖ "), tp.muted("Failed to copy")));
+                this.refreshView();
+                setTimeout(() => {
+                    this.chatView.setProgress(null);
+                    this.refreshView();
+                }, 1500);
+            }
+        }
     }
     async cmdHelp() {
-        console.log();
-        console.log(chalk.bold("  Commands"));
-        console.log(chalk.gray("  " + "─".repeat(50)));
+        this.feedLine();
+        this.feedLine(tp.bold("  Commands"));
+        this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
         // De-duplicate (aliases map to same command)
         const seen = new Set();
         for (const [, cmd] of this.commands) {
@@ -1474,44 +3515,202 @@ class TeammatesREPL {
                 continue;
             seen.add(cmd.name);
             const aliases = cmd.aliases.length > 0
-                ? chalk.gray(` (${cmd.aliases.map((a) => "/" + a).join(", ")})`)
+                ? ` (${cmd.aliases.map((a) => `/${a}`).join(", ")})`
                 : "";
-            console.log(`  ${chalk.cyan(cmd.usage.padEnd(36))}${cmd.description}${aliases}`);
+            this.feedLine(concat(tp.accent(`  ${cmd.usage}`.padEnd(36)), pen(cmd.description), tp.muted(aliases)));
         }
-        console.log();
-        console.log(chalk.gray("  Tip: ") +
-            chalk.white("Type text without / to auto-route to the best teammate"));
-        console.log(chalk.gray("  Tip: ") +
-            chalk.white("Press Tab to autocomplete commands and teammate names"));
-        console.log();
+        this.feedLine();
+        this.feedLine(concat(tp.muted("  Tip: "), tp.text("Type text without / to auto-route to the best teammate")));
+        this.feedLine(concat(tp.muted("  Tip: "), tp.text("Press Tab to autocomplete commands and teammate names")));
+        this.feedLine();
+        this.refreshView();
+    }
+    async cmdUser(argsStr) {
+        const userMdPath = join(this.teammatesDir, "USER.md");
+        const change = argsStr.trim();
+        if (!change) {
+            // No args — print current USER.md
+            let content;
+            try {
+                content = readFileSync(userMdPath, "utf-8");
+            }
+            catch {
+                this.feedLine(tp.muted("  USER.md not found."));
+                this.feedLine(tp.muted("  Run /init or create .teammates/USER.md manually."));
+                this.refreshView();
+                return;
+            }
+            if (!content.trim()) {
+                this.feedLine(tp.muted("  USER.md is empty."));
+                this.refreshView();
+                return;
+            }
+            this.feedLine();
+            this.feedLine(tp.muted("  ── USER.md ──"));
+            this.feedLine();
+            this.feedMarkdown(content);
+            this.feedLine();
+            this.feedLine(tp.muted("  ── end ──"));
+            this.feedLine();
+            this.refreshView();
+            return;
+        }
+        // Has args — queue a task to the coding agent to apply the change
+        const task = `Update the file ${userMdPath} with the following change:\n\n${change}\n\nKeep the existing content intact unless the change explicitly replaces something. This is the user's profile — be concise and accurate.`;
+        this.taskQueue.push({ type: "agent", teammate: this.adapterName, task });
+        this.feedLine(concat(tp.muted("  Queued USER.md update → "), tp.accent(`@${this.adapterName}`)));
+        this.feedLine();
+        this.refreshView();
+        this.kickDrain();
+    }
+    async cmdBtw(argsStr) {
+        const question = argsStr.trim();
+        if (!question) {
+            this.feedLine(tp.muted("  Usage: /btw <question>"));
+            this.refreshView();
+            return;
+        }
+        this.taskQueue.push({
+            type: "btw",
+            teammate: this.adapterName,
+            task: question,
+        });
+        this.feedLine(concat(tp.muted("  Side question → "), tp.accent(`@${this.adapterName}`)));
+        this.feedLine();
+        this.refreshView();
+        this.kickDrain();
+    }
+    async cmdTheme() {
+        const t = theme();
+        this.feedLine();
+        this.feedLine(tp.bold("  Theme"));
+        this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
+        this.feedLine();
+        // Helper: show a swatch + variable name + hex + example text
+        const row = (name, c, example) => {
+            const hex = colorToHex(c);
+            this.feedLine(concat(pen.fg(c)("  ██"), tp.text(`  ${name}`.padEnd(24)), tp.muted(hex.padEnd(12)), pen.fg(c)(example)));
+        };
+        this.feedLine(tp.muted("       Variable                Hex         Example"));
+        this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
+        // Brand / accent
+        row("accent", t.accent, "@beacon  /status  ● teammate");
+        row("accentBright", t.accentBright, "▸ highlighted item");
+        row("accentDim", t.accentDim, "┌─── border ───┐");
+        this.feedLine();
+        // Foreground
+        row("text", t.text, "Primary text content");
+        row("textMuted", t.textMuted, "Description or secondary info");
+        row("textDim", t.textDim, "─── separator ───");
+        this.feedLine();
+        // Status
+        row("success", t.success, "✔ Task completed");
+        row("warning", t.warning, "⚠ Pending handoff");
+        row("error", t.error, "✖ Something went wrong");
+        row("info", t.info, "⠋ Working on task...");
+        this.feedLine();
+        // Interactive
+        row("prompt", t.prompt, "> ");
+        row("input", t.input, "user typed text");
+        row("separator", t.separator, "────────────────");
+        row("progress", t.progress, "analyzing codebase...");
+        row("dropdown", t.dropdown, "/status  session overview");
+        row("dropdownHighlight", t.dropdownHighlight, "▸ /help   all commands");
+        this.feedLine();
+        // Cursor
+        this.feedLine(concat(pen.fg(t.cursorFg).bg(t.cursorBg)("  ██"), tp.text("  cursorFg/cursorBg".padEnd(24)), tp.muted(`${colorToHex(t.cursorFg)}/${colorToHex(t.cursorBg)}`.padEnd(12)), pen.fg(t.cursorFg).bg(t.cursorBg)(" block cursor ")));
+        this.feedLine();
+        this.feedLine(tp.muted("  Base accent: #3A96DD"));
+        this.feedLine();
+        // ── Markdown preview ──────────────────────────────────────
+        this.feedLine(tp.bold("  Markdown Preview"));
+        this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
+        this.feedLine();
+        const mdSample = [
+            "# Heading 1",
+            "",
+            "## Heading 2",
+            "",
+            "### Heading 3",
+            "",
+            "Regular text with **bold**, *italic*, and `inline code`.",
+            "A [link](https://example.com) and ~~strikethrough~~.",
+            "",
+            "- Bullet item one",
+            "- Bullet item with **bold**",
+            "  - Nested item",
+            "",
+            "1. Ordered first",
+            "2. Ordered second",
+            "",
+            "> Blockquote text",
+            "> across multiple lines",
+            "",
+            "```js",
+            'const greeting = "hello";',
+            "async function main() {",
+            '  await fetch("/api");',
+            "  return 42;",
+            "}",
+            "```",
+            "",
+            "```python",
+            "def greet(name: str) -> None:",
+            '    print(f"Hello, {name}")',
+            "```",
+            "",
+            "```bash",
+            'echo "$HOME" | grep --color user',
+            "if [ -f .env ]; then source .env; fi",
+            "```",
+            "",
+            "```json",
+            "{",
+            '  "name": "teammates",',
+            '  "version": "0.1.0",',
+            '  "active": true',
+            "}",
+            "```",
+            "",
+            "| Language   | Status  |",
+            "|------------|---------|",
+            "| JavaScript | ✔ Ready |",
+            "| Python     | ✔ Ready |",
+            "| C#         | ✔ Ready |",
+            "",
+            "---",
+        ].join("\n");
+        this.feedMarkdown(mdSample);
+        this.feedLine();
+        this.refreshView();
     }
 }
 // ─── Usage (non-interactive) ─────────────────────────────────────────
 function printUsage() {
-    console.log(`
-${chalk.bold("@teammates/cli")} — Agent-agnostic teammate orchestrator
-
-${chalk.bold("Usage:")}
-  teammates <agent>          Launch session with an agent
-  teammates claude           Use Claude Code
-  teammates codex            Use OpenAI Codex
-  teammates aider            Use Aider
-
-${chalk.bold("Options:")}
-  --model <model>            Override the agent model
-  --dir <path>               Override .teammates/ location
-
-${chalk.bold("Agents:")}
-  claude     Claude Code CLI (requires 'claude' on PATH)
-  codex      OpenAI Codex CLI (requires 'codex' on PATH)
-  aider      Aider CLI (requires 'aider' on PATH)
-  echo       Test adapter — echoes prompts (no external agent)
-
-${chalk.bold("In-session:")}
-  @teammate <task>           Assign directly via @mention
-  <text>                     Auto-route to the best teammate
-  /status                    Session overview
-  /help                      All commands
+    console.log(`
+${chalk.bold("@teammates/cli")} — Agent-agnostic teammate orchestrator
+
+${chalk.bold("Usage:")}
+  teammates <agent>          Launch session with an agent
+  teammates claude           Use Claude Code
+  teammates codex            Use OpenAI Codex
+  teammates aider            Use Aider
+
+${chalk.bold("Options:")}
+  --model <model>            Override the agent model
+  --dir <path>               Override .teammates/ location
+
+${chalk.bold("Agents:")}
+  claude     Claude Code CLI (requires 'claude' on PATH)
+  codex      OpenAI Codex CLI (requires 'codex' on PATH)
+  aider      Aider CLI (requires 'aider' on PATH)
+  echo       Test adapter — echoes prompts (no external agent)
+
+${chalk.bold("In-session:")}
+  @teammate <task>           Assign directly via @mention
+  <text>                     Auto-route to the best teammate
+  /status                    Session overview
+  /help                      All commands
 `.trim());
 }
 // ─── Main ────────────────────────────────────────────────────────────