@teammates/cli 0.5.1 → 0.5.3

package/README.md

@@ -7,18 +7,17 @@ Agent-agnostic CLI orchestrator for teammates. Routes tasks to teammates, manage
 ## Quick Start
 
 ```bash
-cd cli
+cd packages/cli
 npm install
 npm run build
 ```
 
-Then launch a session with your preferred agent:
+Then launch a session:
 
 ```bash
-teammates claude       # Claude Code
-teammates codex        # OpenAI Codex
-teammates aider        # Aider
-teammates echo         # Test adapter (no external agent)
+teammates               # Uses default adapter (claude)
+teammates --model sonnet # Override the agent model
+teammates echo           # Use the test adapter (no external agent)
 ```
 
 The CLI auto-discovers your `.teammates/` directory by walking up from the current working directory.
@@ -26,7 +25,7 @@ The CLI auto-discovers your `.teammates/` directory by walking up from the curre
 ## Usage
 
 ```
-teammates <agent> [options] [-- agent-flags...]
+teammates [options] [-- agent-flags...]
 ```
 
 ### Options
@@ -37,7 +36,7 @@ teammates <agent> [options] [-- agent-flags...]
 | `--dir <path>` | Override `.teammates/` directory location |
 | `--help` | Show usage information |
 
-Any arguments after the agent name are passed through to the underlying agent CLI.
+Any arguments after `--` are passed through to the underlying agent CLI.
 
 ## In-Session Commands
 
@@ -55,16 +54,18 @@ Once inside the REPL, you can interact with teammates using `@mentions`, `/comma
 
 | Command | Aliases | Description |
 |---|---|---|
-| `/status` | `/s`, `/queue`, `/qu` | Show teammates, active tasks, and queue |
-| `/log [teammate]` | `/l` | Show the last task result (optionally for a specific teammate) |
-| `/debug [teammate]` | `/raw` | Show raw agent output from the last task |
-| `/cancel <n>` | | Cancel a queued task by number |
-| `/init` | `/onboard`, `/setup` | Run onboarding to set up teammates for this project |
-| `/install <service>` | | Install a teammates service (e.g. `recall`) |
+| `/status` | `/s`, `/queue` | Show teammates, active tasks, and queue |
+| `/debug [teammate] [focus]` | | Analyze the last agent task with optional focus text |
+| `/cancel [n]` | | Cancel a queued task by number |
+| `/init` | `/onboard`, `/setup` | Run onboarding to set up teammates |
+| `/init pick` | | Pick teammates from persona templates (in-TUI) |
 | `/compact [teammate]` | | Compact daily logs into weekly/monthly summaries |
 | `/retro [teammate]` | | Run a structured self-retrospective for a teammate |
+| `/user [change]` | | View or update USER.md |
+| `/btw [question]` | | Ask a quick side question without interrupting |
 | `/copy` | `/cp` | Copy the last response to clipboard |
 | `/theme` | | Show current theme colors |
+| `/configure [service]` | `/config` | Configure external services (e.g. GitHub) |
 | `/clear` | `/cls`, `/reset` | Clear history and reset the session |
 | `/help` | `/h`, `/?` | Show available commands |
 | `/exit` | `/q`, `/quit` | Exit the session |
@@ -121,21 +122,24 @@ The CLI uses a generic adapter interface to support any coding agent. Each adapt
 
 | Preset | Command | Notes |
 |---|---|---|
-| `claude` | `claude -p --verbose` | Requires `claude` on PATH |
+| `claude` | `claude -p --verbose` | Default adapter. Requires `claude` on PATH |
 | `codex` | `codex exec` | Requires `codex` on PATH |
 | `aider` | `aider --message-file` | Requires `aider` on PATH |
+| `copilot` | GitHub Copilot SDK | Requires `@anthropic-ai/copilot-sdk` |
 | `echo` | (in-process) | Test adapter — echoes prompts, no external agent |
 
 ### How Adapters Work
 
-1. The adapter queries the recall index for relevant memories (automatic, in-process)
-2. The orchestrator builds a full prompt within a 32k token budget (SOUL → WISDOM → recall results → daily logs (budget-trimmed) → session state → roster → task)
-3. The prompt is written to a temp file
-4. The agent CLI is spawned with the prompt
-5. stdout/stderr are captured for result parsing
-6. The output is parsed for embedded handoff blocks
-7. The recall index is synced to pick up any files the agent created/modified
-8. Temp files are cleaned up
+1. **Auto-compaction** — If daily logs exceed the 24k token budget, oldest weeks are compacted into weekly summaries
+2. **Two-pass recall** — Pass 1: keyword extraction → query variation generation → frontmatter catalog matching → multi-query fusion with dedup. Pass 2: agents can search mid-task via `teammates-recall search`
+3. The orchestrator builds a full prompt with token-budgeted sections (identity → wisdom → recall → daily logs → roster → services → date/time/environment → user profile → task → output protocol → session/memory instructions)
+4. The prompt is written to a temp file
+5. The agent CLI is spawned with the prompt
+6. stdout/stderr are captured for result parsing
+7. **Empty response defense** — If the agent returns no text: retry with raw mode (no prompt wrapping), then minimal prompt, then synthetic fallback from metadata
+8. The output is parsed for embedded handoff blocks (with natural-language fallback)
+9. The recall index is synced to pick up any files the agent created/modified
+10. Temp files are cleaned up
 
 ### Writing a Custom Adapter
 
@@ -169,13 +173,15 @@ Or add a preset to `cli-proxy.ts` for any CLI agent that accepts a prompt and ru
 The CLI startup runs in two phases:
 
 **Phase 1 — Pre-TUI (console I/O)**
-1. **User profile setup** — Prompts for alias (required), name, role, experience, preferences, context. Creates `USER.md` and a user avatar folder at `.teammates/<alias>/` with `SOUL.md` (`**Type:** human`).
-2. **Team onboarding** (if no `.teammates/` exists) — Offers New team / Import / Solo / Exit. Onboarding agents run non-interactively to completion.
+1. **User profile setup** — If `USER.md` is missing, offers three paths: **GitHub** (imports name/alias via `gh api user`), **Manual** (prompts for alias, name, role, experience, preferences), or **Skip**. Creates `USER.md` and a user avatar folder at `.teammates/<alias>/` with `SOUL.md` (`**Type:** human`). Auto-detects the user's timezone.
+2. **Team onboarding** (if `.teammates/` was just created) — Offers **Pick teammates** (persona templates), **Auto-generate** (agent-driven), **Import** (from another project), **Solo mode**, or **Exit**.
 3. **Orchestrator init** — Loads existing teammates from `.teammates/`, registers user avatar with `type: "human"` and `presence: "online"`.
+4. **Startup maintenance** — Runs auto-compaction and recall sync for all teammates (silent — progress bar only, no feed output unless actual work was done).
 
 **Phase 2 — TUI (Consolonia)**
-4. Animated startup banner with roster
-5. REPL starts — routing, slash commands, handoff approval
+5. Animated startup banner with presence-colored roster
+6. REPL starts — routing, slash commands, handoff approval
+7. System tasks (compaction, summarization, wisdom distillation) run in the background without blocking user tasks
 
 All user interaction during Phase 1 uses plain console I/O (readline + ora spinners), avoiding mouse tracking issues that would occur inside the TUI.
 
@@ -191,7 +197,7 @@ The CLI ships with 15 built-in persona templates that serve as starting points w
 | **2 — Specialist** | Security (`shield`), Designer (`canvas`), Tech Writer (`quill`), Data Engineer (`forge`), SRE (`watchtower`), Architect (`blueprint`) |
 | **3 — Niche** | Frontend (`pixel`), Backend (`engine`), Mobile (`orbit`), ML/AI (`neuron`), Performance (`tempo`) |
 
-During onboarding, the CLI uses these personas to scaffold teammates. The user picks roles, optionally renames them, and the persona's SOUL.md body becomes the starting template — project-specific sections (commands, file patterns, technologies) are filled in by the onboarding agent.
+During onboarding, the CLI uses these personas to scaffold teammates. Use **Pick teammates** during initial onboarding or `/init pick` in-session to choose from the list. The user picks roles, optionally renames them, and the persona's SOUL.md body becomes the starting template — project-specific sections (commands, file patterns, technologies) are filled in by the onboarding agent.
 
 ## Architecture
 
@@ -201,12 +207,18 @@ cli/src/
   orchestrator.ts   # Task routing, session management, presence tracking
   adapter.ts        # AgentAdapter interface, prompt builder, handoff formatting
   registry.ts       # Discovers teammates from .teammates/, loads SOUL.md + memory, type detection
+  compact.ts        # Episodic memory compaction (daily→weekly→monthly) + auto-compaction
+  banner.ts         # Animated startup banner with presence roster and segmented footer
   personas.ts       # Persona loader — reads and parses bundled persona templates
+  theme.ts          # Theme configuration, color palette, styled text shortcuts
+  cli-args.ts       # CLI argument parsing, .teammates/ directory discovery
+  cli-utils.ts      # Pure utility functions (relativeTime, wrapLine, findAtMention, etc.)
   types.ts          # Core types (TeammateConfig, TaskResult, HandoffEnvelope, TeammateType, PresenceState)
   onboard.ts        # Template copying, team import, onboarding/adaptation prompts
   dropdown.ts       # Terminal dropdown/wordwheel widget
   adapters/
-    cli-proxy.ts    # Generic subprocess adapter with agent presets
+    cli-proxy.ts    # Generic subprocess adapter with agent presets (claude, codex, aider)
+    copilot.ts      # GitHub Copilot adapter
     echo.ts         # Test adapter (no-op)
 cli/personas/       # 15 persona template files (pm.md, swe.md, devops.md, etc.)
 ```
@@ -246,6 +258,11 @@ Tests use [Vitest](https://vitest.dev/) and cover the core modules:
 | `src/adapter.test.ts` | `buildTeammatePrompt`, `formatHandoffContext` |
 | `src/orchestrator.test.ts` | Task routing, assignment, reset |
 | `src/registry.test.ts` | Teammate discovery, SOUL.md parsing (role, ownership), daily logs |
+| `src/compact.test.ts` | Daily→weekly compaction, auto-compaction, partial merge |
+| `src/personas.test.ts` | Persona loading and scaffolding |
+| `src/theme.test.ts` | Theme configuration |
+| `src/cli-args.test.ts` | Argument parsing, directory discovery |
+| `src/cli-utils.test.ts` | Utility functions |
 | `src/adapters/echo.test.ts` | Echo adapter session and task execution |
 
 ## Dependencies

package/dist/adapter.js

@@ -225,7 +225,6 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
         "- The `# Subject` line is REQUIRED — it becomes the message title.",
         "- Always write a substantive body. Never return just the subject.",
         "- Use markdown: headings, lists, code blocks, bold, etc.",
-        "- **Write your text response FIRST, then update session/memory files.** This ensures visible output even if the agent turn ends early.",
         "",
         "### Handoffs",
         "",
@@ -245,10 +244,10 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     ];
     // Session state (conditional)
     if (options?.sessionFile) {
-        instrLines.push("", "### Session State", "", `Your session file is at: \`${options.sessionFile}\``, "", "**After writing your text response**, append a brief entry to this file with:", "- What you did", "- Key decisions made", "- Files changed", "- Anything the next task should know", "", "This is how you maintain continuity across tasks. Always read it, always update it.");
+        instrLines.push("", "### Session State", "", `Your session file is at: \`${options.sessionFile}\``, "", "**After completing the task**, append a brief entry to this file with:", "- What you did", "- Key decisions made", "- Files changed", "- Anything the next task should know", "", "This is how you maintain continuity across tasks. Always read it, always update it.");
     }
     // Memory updates
-    instrLines.push("", "### Memory Updates", "", "**After writing your text response**, update your memory files:", "", `1. **Daily log** — Read \`.teammates/${teammate.name}/memory/${today}.md\` first (it may have entries from earlier tasks today), then write it back with your entry added. Create the file if it doesn't exist.`, "   - What you did", "   - Key decisions made", "   - Files changed", "   - Anything the next task should know", "", `2. **Typed memories** — If you learned something durable (a decision, pattern, feedback, or reference), create a typed memory file at \`.teammates/${teammate.name}/memory/<type>_<topic>.md\` with frontmatter (\`name\`, \`description\`, \`type\`). Update existing memory files if the topic already has one.`, "", "3. **WISDOM.md** — Do not edit directly. Wisdom entries are distilled from typed memories during compaction.", "", "These files are your persistent memory. Without them, your next session starts from scratch.");
+    instrLines.push("", "### Memory Updates", "", "**After completing the task**, update your memory files:", "", `1. **Daily log** — Read \`.teammates/${teammate.name}/memory/${today}.md\` first (it may have entries from earlier tasks today), then write it back with your entry added. Create the file if it doesn't exist.`, "   - What you did", "   - Key decisions made", "   - Files changed", "   - Anything the next task should know", "", `2. **Typed memories** — If you learned something durable (a decision, pattern, feedback, or reference), create a typed memory file at \`.teammates/${teammate.name}/memory/<type>_<topic>.md\` with frontmatter (\`name\`, \`description\`, \`type\`). Update existing memory files if the topic already has one.`, "", "3. **WISDOM.md** — Do not edit directly. Wisdom entries are distilled from typed memories during compaction.", "", "These files are your persistent memory. Without them, your next session starts from scratch.");
     // Section Reinforcement — back-references from high-attention bottom edge to each section tag
     instrLines.push("", "### Section Reinforcement", "");
     instrLines.push("- Stay in character as defined in `<IDENTITY>` — never break persona or speak as a generic assistant.");
@@ -274,7 +273,7 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     if (options?.handoffContext) {
         instrLines.push("- When `<HANDOFF_CONTEXT>` is present, address its requirements and open questions directly.");
     }
-    instrLines.push("- Your response must answer `<TASK>` — everything else is supporting context.", "", "**REMINDER: Write your text response (TO: user) FIRST, then update session/memory files. A turn with only file edits and no text output is a failed turn.**");
+    instrLines.push("- Your response must answer `<TASK>` — everything else is supporting context.", "", "**REMINDER: You MUST end your turn with visible text output. A turn with only file edits and no text is a failed turn.**");
     parts.push(instrLines.join("\n"));
     return parts.join("\n");
 }

package/dist/adapters/cli-proxy.js

@@ -210,6 +210,7 @@ export class CliProxyAdapter {
                 : spawn.output;
             const teammateNames = this.roster.map((r) => r.name);
             const result = parseResult(teammate.name, output, teammateNames, prompt);
+            result.fullPrompt = fullPrompt;
             result.diagnostics = {
                 exitCode: spawn.exitCode,
                 signal: spawn.signal,

package/dist/adapters/copilot.js

@@ -152,7 +152,9 @@ export class CopilotAdapter {
             // Use the final assistant message content, fall back to collected deltas
             const output = reply?.data?.content ?? outputParts.join("");
             const teammateNames = this.roster.map((r) => r.name);
-            return parseResult(teammate.name, output, teammateNames, prompt);
+            const result = parseResult(teammate.name, output, teammateNames, prompt);
+            result.fullPrompt = fullPrompt;
+            return result;
         }
         finally {
             // Disconnect the session (preserves data for potential resume)

package/dist/cli-utils.d.ts

@@ -17,5 +17,34 @@ export declare function findAtMention(line: string, cursor: number): {
 } | null;
 /** Set of recognized image file extensions. */
 export declare const IMAGE_EXTS: Set<string>;
+/** A single entry in the conversation history. */
+export interface ConversationEntry {
+    role: string;
+    text: string;
+}
+/**
+ * Strip protocol artifacts (TO: header, handoff blocks, trailing JSON) from
+ * an agent's raw output, returning just the message body.
+ */
+export declare function cleanResponseBody(rawOutput: string): string;
+/**
+ * Format a conversation entry for inclusion in a prompt.
+ * Single-line text stays inline; multi-line text gets the body on the next line.
+ */
+export declare function formatConversationEntry(role: string, text: string): string;
+/**
+ * Build the conversation context section for a teammate prompt.
+ * Works backwards from newest entries, including whole entries up to the budget.
+ */
+export declare function buildConversationContext(history: ConversationEntry[], summary: string, budget: number): string;
+/**
+ * Find the split index where older conversation entries should be summarized.
+ * Returns 0 if everything fits within the budget (nothing to summarize).
+ */
+export declare function findSummarizationSplit(history: ConversationEntry[], budget: number): number;
+/**
+ * Build the summarization prompt text from entries being pushed out of the budget.
+ */
+export declare function buildSummarizationPrompt(entries: ConversationEntry[], existingSummary: string): string;
 /** Check if a string looks like an image file path. */
 export declare function isImagePath(text: string): boolean;

package/dist/cli-utils.js

@@ -61,6 +61,80 @@ export const IMAGE_EXTS = new Set([
     ".svg",
     ".ico",
 ]);
+/**
+ * Strip protocol artifacts (TO: header, handoff blocks, trailing JSON) from
+ * an agent's raw output, returning just the message body.
+ */
+export function cleanResponseBody(rawOutput) {
+    return rawOutput
+        .replace(/^TO:\s*\S+\s*\n/im, "")
+        .replace(/```handoff\s*\n@\w+\s*\n[\s\S]*?```/g, "")
+        .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/g, "")
+        .trim();
+}
+/**
+ * Format a conversation entry for inclusion in a prompt.
+ * Single-line text stays inline; multi-line text gets the body on the next line.
+ */
+export function formatConversationEntry(role, text) {
+    return text.includes("\n")
+        ? `**${role}:**\n${text}\n`
+        : `**${role}:** ${text}\n`;
+}
+/**
+ * Build the conversation context section for a teammate prompt.
+ * Works backwards from newest entries, including whole entries up to the budget.
+ */
+export function buildConversationContext(history, summary, budget) {
+    if (history.length === 0 && !summary)
+        return "";
+    const parts = ["## Conversation History\n"];
+    if (summary) {
+        parts.push(`### Previous Conversation Summary\n\n${summary}\n`);
+    }
+    const entries = [];
+    let used = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const entry = formatConversationEntry(history[i].role, history[i].text);
+        if (used + entry.length > budget && entries.length > 0)
+            break;
+        entries.unshift(entry);
+        used += entry.length;
+    }
+    if (entries.length > 0)
+        parts.push(entries.join("\n"));
+    return parts.join("\n");
+}
+/**
+ * Find the split index where older conversation entries should be summarized.
+ * Returns 0 if everything fits within the budget (nothing to summarize).
+ */
+export function findSummarizationSplit(history, budget) {
+    let recentChars = 0;
+    let splitIdx = history.length;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const entry = formatConversationEntry(history[i].role, history[i].text);
+        if (recentChars + entry.length > budget)
+            break;
+        recentChars += entry.length;
+        splitIdx = i;
+    }
+    return splitIdx === history.length ? 0 : splitIdx;
+}
+/**
+ * Build the summarization prompt text from entries being pushed out of the budget.
+ */
+export function buildSummarizationPrompt(entries, existingSummary) {
+    const entriesText = entries
+        .map((e) => e.text.includes("\n")
+        ? `**${e.role}:**\n${e.text}`
+        : `**${e.role}:** ${e.text}`)
+        .join("\n\n");
+    const instructions = `## Instructions\n\nReturn ONLY the ${existingSummary ? "updated " : ""}summary — no preamble, no explanation. The summary should:\n- Be a concise bulleted list of key topics discussed, decisions made, and work completed\n- Preserve important context that future messages might reference\n- Drop trivial or redundant details\n- Stay under 2000 characters\n- Do NOT include any output protocol (no TO:, no # Subject, no handoff blocks)`;
+    return existingSummary
+        ? `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Update the existing summary to incorporate the new conversation entries below.\n\n## Current Summary\n\n${existingSummary}\n\n## New Entries to Incorporate\n\n${entriesText}\n\n${instructions}`
+        : `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Summarize the conversation entries below.\n\n## Entries to Summarize\n\n${entriesText}\n\n${instructions}`;
+}
 /** Check if a string looks like an image file path. */
 export function isImagePath(text) {
     // Must look like a file path (contains slash or backslash, or starts with drive letter)

package/dist/cli-utils.test.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { findAtMention, IMAGE_EXTS, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
+import { buildConversationContext, buildSummarizationPrompt, cleanResponseBody, findAtMention, findSummarizationSplit, formatConversationEntry, IMAGE_EXTS, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
 // ── relativeTime ────────────────────────────────────────────────────
 describe("relativeTime", () => {
     beforeEach(() => {
@@ -177,3 +177,187 @@ describe("IMAGE_EXTS", () => {
         expect(IMAGE_EXTS.size).toBe(8);
     });
 });
+// ── cleanResponseBody ──────────────────────────────────────────────
+describe("cleanResponseBody", () => {
+    it("strips TO: header", () => {
+        const raw = "TO: user\n# Subject\n\nBody text here";
+        expect(cleanResponseBody(raw)).toBe("# Subject\n\nBody text here");
+    });
+    it("strips TO: header case-insensitively", () => {
+        const raw = "to: User\n# Subject\n\nBody text here";
+        expect(cleanResponseBody(raw)).toBe("# Subject\n\nBody text here");
+    });
+    it("strips handoff blocks", () => {
+        const raw = "Some text\n\n```handoff\n@scribe\nDo this task\n```\n\nMore text";
+        expect(cleanResponseBody(raw)).toContain("Some text");
+        expect(cleanResponseBody(raw)).toContain("More text");
+        expect(cleanResponseBody(raw)).not.toContain("handoff");
+        expect(cleanResponseBody(raw)).not.toContain("@scribe");
+    });
+    it("strips multiple handoff blocks", () => {
+        const raw = "Text\n```handoff\n@scribe\ntask1\n```\nmiddle\n```handoff\n@beacon\ntask2\n```\nend";
+        expect(cleanResponseBody(raw)).toBe("Text\n\nmiddle\n\nend");
+    });
+    it("strips trailing JSON blocks", () => {
+        const raw = 'Body text\n\n```json\n{ "summary": "done" }\n```';
+        expect(cleanResponseBody(raw)).toBe("Body text");
+    });
+    it("strips all protocol artifacts together", () => {
+        const raw = 'TO: user\n# Done\n\nI finished the task.\n\n```handoff\n@pipeline\nDeploy it\n```\n\n```json\n{ "summary": "Done" }\n```';
+        expect(cleanResponseBody(raw)).toBe("# Done\n\nI finished the task.");
+    });
+    it("returns empty string for empty input", () => {
+        expect(cleanResponseBody("")).toBe("");
+    });
+    it("returns body unchanged when no protocol artifacts exist", () => {
+        expect(cleanResponseBody("Just a plain message")).toBe("Just a plain message");
+    });
+    it("trims surrounding whitespace", () => {
+        expect(cleanResponseBody("  \n  Hello  \n  ")).toBe("Hello");
+    });
+});
+// ── formatConversationEntry ────────────────────────────────────────
+describe("formatConversationEntry", () => {
+    it("formats single-line text inline", () => {
+        expect(formatConversationEntry("scribe", "Task completed")).toBe("**scribe:** Task completed\n");
+    });
+    it("formats multi-line text with body on next line", () => {
+        expect(formatConversationEntry("beacon", "Line 1\nLine 2")).toBe("**beacon:**\nLine 1\nLine 2\n");
+    });
+    it("treats single line with no newline as inline", () => {
+        expect(formatConversationEntry("user", "hello")).toBe("**user:** hello\n");
+    });
+});
+// ── buildConversationContext ────────────────────────────────────────
+describe("buildConversationContext", () => {
+    it("returns empty string for empty history and no summary", () => {
+        expect(buildConversationContext([], "", 1000)).toBe("");
+    });
+    it("includes summary when present", () => {
+        const result = buildConversationContext([], "Previous topics discussed", 1000);
+        expect(result).toContain("## Conversation History");
+        expect(result).toContain("### Previous Conversation Summary");
+        expect(result).toContain("Previous topics discussed");
+    });
+    it("includes all entries when within budget", () => {
+        const history = [
+            { role: "stevenic", text: "Hello" },
+            { role: "scribe", text: "Hi there" },
+            { role: "stevenic", text: "Do the thing" },
+        ];
+        const result = buildConversationContext(history, "", 10_000);
+        expect(result).toContain("**stevenic:** Hello");
+        expect(result).toContain("**scribe:** Hi there");
+        expect(result).toContain("**stevenic:** Do the thing");
+    });
+    it("drops oldest entries when over budget", () => {
+        const history = [
+            { role: "old", text: "A".repeat(500) },
+            { role: "mid", text: "B".repeat(500) },
+            { role: "new", text: "C".repeat(500) },
+        ];
+        // Budget enough for ~2 entries but not 3
+        const budget = 1100;
+        const result = buildConversationContext(history, "", budget);
+        expect(result).not.toContain("**old:**");
+        expect(result).toContain("**new:**");
+    });
+    it("always includes at least the newest entry even if over budget", () => {
+        const history = [
+            { role: "beacon", text: "A".repeat(2000) },
+        ];
+        const result = buildConversationContext(history, "", 100);
+        expect(result).toContain("**beacon:**");
+    });
+    it("formats multi-line entries with body on next line", () => {
+        const history = [
+            { role: "scribe", text: "Line 1\nLine 2\nLine 3" },
+        ];
+        const result = buildConversationContext(history, "", 10_000);
+        expect(result).toContain("**scribe:**\nLine 1\nLine 2\nLine 3");
+    });
+    it("includes both summary and entries", () => {
+        const history = [
+            { role: "stevenic", text: "Latest message" },
+        ];
+        const result = buildConversationContext(history, "Earlier we discussed X", 10_000);
+        expect(result).toContain("### Previous Conversation Summary");
+        expect(result).toContain("Earlier we discussed X");
+        expect(result).toContain("**stevenic:** Latest message");
+    });
+});
+// ── findSummarizationSplit ─────────────────────────────────────────
+describe("findSummarizationSplit", () => {
+    it("returns 0 when everything fits in budget", () => {
+        const history = [
+            { role: "a", text: "short" },
+            { role: "b", text: "also short" },
+        ];
+        expect(findSummarizationSplit(history, 10_000)).toBe(0);
+    });
+    it("returns 0 for empty history", () => {
+        expect(findSummarizationSplit([], 1000)).toBe(0);
+    });
+    it("returns split index when history exceeds budget", () => {
+        const history = [
+            { role: "old1", text: "A".repeat(400) },
+            { role: "old2", text: "B".repeat(400) },
+            { role: "new1", text: "C".repeat(400) },
+            { role: "new2", text: "D".repeat(400) },
+        ];
+        // Budget fits ~2 entries (~430 chars each with formatting)
+        const budget = 900;
+        const split = findSummarizationSplit(history, budget);
+        expect(split).toBeGreaterThan(0);
+        expect(split).toBeLessThan(history.length);
+    });
+    it("keeps newest entries and pushes oldest out", () => {
+        const history = [
+            { role: "oldest", text: "X".repeat(300) },
+            { role: "middle", text: "Y".repeat(300) },
+            { role: "newest", text: "Z".repeat(300) },
+        ];
+        // Budget fits 1 entry
+        const budget = 350;
+        const split = findSummarizationSplit(history, budget);
+        // Split should be 2 — entries 0 and 1 get summarized, entry 2 (newest) stays
+        expect(split).toBe(2);
+    });
+    it("returns 0 when single entry fits", () => {
+        const history = [{ role: "a", text: "hello" }];
+        expect(findSummarizationSplit(history, 10_000)).toBe(0);
+    });
+});
+// ── buildSummarizationPrompt ───────────────────────────────────────
+describe("buildSummarizationPrompt", () => {
+    const entries = [
+        { role: "stevenic", text: "Build the feature" },
+        { role: "beacon", text: "Done, here's what I did" },
+    ];
+    it("builds a fresh summarization prompt when no existing summary", () => {
+        const prompt = buildSummarizationPrompt(entries, "");
+        expect(prompt).toContain("Summarize the conversation entries below");
+        expect(prompt).toContain("**stevenic:** Build the feature");
+        expect(prompt).toContain("**beacon:** Done, here's what I did");
+        expect(prompt).not.toContain("Current Summary");
+    });
+    it("builds an update prompt when existing summary is present", () => {
+        const prompt = buildSummarizationPrompt(entries, "Previously discussed X");
+        expect(prompt).toContain("Update the existing summary");
+        expect(prompt).toContain("## Current Summary");
+        expect(prompt).toContain("Previously discussed X");
+        expect(prompt).toContain("## New Entries to Incorporate");
+    });
+    it("includes instruction constraints", () => {
+        const prompt = buildSummarizationPrompt(entries, "");
+        expect(prompt).toContain("Stay under 2000 characters");
+        expect(prompt).toContain("Do NOT include any output protocol");
+    });
+    it("formats multi-line entries correctly", () => {
+        const multiLine = [
+            { role: "scribe", text: "Line 1\nLine 2" },
+        ];
+        const prompt = buildSummarizationPrompt(multiLine, "");
+        expect(prompt).toContain("**scribe:**\nLine 1\nLine 2");
+    });
+});

package/dist/cli.js

@@ -10,7 +10,7 @@
 import { exec as execCb, execSync, spawnSync } from "node:child_process";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { createInterface } from "node:readline";
 import { App, ChatView, concat, esc, pen, renderMarkdown, stripAnsi, } from "@teammates/consolonia";
 import chalk from "chalk";
@@ -18,7 +18,7 @@ import ora from "ora";
 import { DAILY_LOG_BUDGET_TOKENS, syncRecallIndex } from "./adapter.js";
 import { AnimatedBanner, } from "./banner.js";
 import { findTeammatesDir, PKG_VERSION, parseCliArgs, printUsage, resolveAdapter, } from "./cli-args.js";
-import { findAtMention, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
+import { buildConversationContext as buildConvCtx, buildSummarizationPrompt, cleanResponseBody, findAtMention, findSummarizationSplit, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
 import { autoCompactForBudget, buildWisdomPrompt, compactEpisodic, purgeStaleDailies, } from "./compact.js";
 import { PromptInput } from "./console/prompt-input.js";
 import { buildTitle } from "./console/startup.js";
@@ -44,9 +44,12 @@ class TeammatesREPL {
     storeResult(result) {
         this.lastResult = result;
         this.lastResults.set(result.teammate, result);
+        // Store the full response body in conversation history — not just the
+        // subject line.  The 24k-token budget + auto-summarization handle size.
+        const body = cleanResponseBody(result.rawOutput ?? "");
         this.conversationHistory.push({
             role: result.teammate,
-            text: result.summary,
+            text: body || result.summary,
         });
     }
     /**
@@ -152,27 +155,7 @@ class TeammatesREPL {
     /** Token budget for recent conversation history (24k tokens ≈ 96k chars). */
     static CONV_HISTORY_CHARS = 24_000 * 4;
     buildConversationContext() {
-        if (this.conversationHistory.length === 0 && !this.conversationSummary)
-            return "";
-        const budget = TeammatesREPL.CONV_HISTORY_CHARS;
-        const parts = ["## Conversation History\n"];
-        // Include running summary of older conversation if present
-        if (this.conversationSummary) {
-            parts.push(`### Previous Conversation Summary\n\n${this.conversationSummary}\n`);
-        }
-        // Work backwards from newest — include whole entries up to 24k tokens
-        const entries = [];
-        let used = 0;
-        for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
-            const line = `**${this.conversationHistory[i].role}:** ${this.conversationHistory[i].text}\n`;
-            if (used + line.length > budget && entries.length > 0)
-                break;
-            entries.unshift(line);
-            used += line.length;
-        }
-        if (entries.length > 0)
-            parts.push(entries.join("\n"));
-        return parts.join("\n");
+        return buildConvCtx(this.conversationHistory, this.conversationSummary, TeammatesREPL.CONV_HISTORY_CHARS);
     }
     /**
      * Check if conversation history exceeds the 24k token budget.
@@ -180,28 +163,11 @@ class TeammatesREPL {
      * and queue a summarization task to the coding agent.
      */
     maybeQueueSummarization() {
-        const budget = TeammatesREPL.CONV_HISTORY_CHARS;
-        // Calculate how many recent entries fit in the budget (newest first)
-        let recentChars = 0;
-        let splitIdx = this.conversationHistory.length;
-        for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
-            const line = `**${this.conversationHistory[i].role}:** ${this.conversationHistory[i].text}\n`;
-            if (recentChars + line.length > budget)
-                break;
-            recentChars += line.length;
-            splitIdx = i;
-        }
+        const splitIdx = findSummarizationSplit(this.conversationHistory, TeammatesREPL.CONV_HISTORY_CHARS);
         if (splitIdx === 0)
             return; // everything fits — nothing to summarize
-        // Collect entries that are being pushed out
         const toSummarize = this.conversationHistory.slice(0, splitIdx);
-        const entriesText = toSummarize
-            .map((e) => `**${e.role}:** ${e.text}`)
-            .join("\n");
-        // Build the summarization prompt
-        const prompt = this.conversationSummary
-            ? `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Update the existing summary to incorporate the new conversation entries below.\n\n## Current Summary\n\n${this.conversationSummary}\n\n## New Entries to Incorporate\n\n${entriesText}\n\n## Instructions\n\nReturn ONLY the updated summary — no preamble, no explanation. The summary should:\n- Be a concise bulleted list of key topics discussed, decisions made, and work completed\n- Preserve important context that future messages might reference\n- Drop trivial or redundant details\n- Stay under 2000 characters\n- Do NOT include any output protocol (no TO:, no # Subject, no handoff blocks)`
-            : `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Summarize the conversation entries below.\n\n## Entries to Summarize\n\n${entriesText}\n\n## Instructions\n\nReturn ONLY the summary — no preamble, no explanation. The summary should:\n- Be a concise bulleted list of key topics discussed, decisions made, and work completed\n- Preserve important context that future messages might reference\n- Drop trivial or redundant details\n- Stay under 2000 characters\n- Do NOT include any output protocol (no TO:, no # Subject, no handoff blocks)`;
+        const prompt = buildSummarizationPrompt(toSummarize, this.conversationSummary);
         // Remove the summarized entries — they'll be captured in the summary
         this.conversationHistory.splice(0, splitIdx);
         // Queue the summarization task through the user's agent
@@ -217,6 +183,8 @@ class TeammatesREPL {
     taskQueue = [];
     /** Per-agent active tasks — one per agent running in parallel. */
     agentActive = new Map();
+    /** Active system tasks — multiple can run concurrently per agent. */
+    systemActive = new Map();
     /** Agents currently in a silent retry — suppress all events. */
     silentAgents = new Set();
     /** Per-agent drain locks — prevents double-draining a single agent. */
@@ -330,37 +298,74 @@ class TeammatesREPL {
             this.input.setStatus(null);
         }
     }
+    /**
+     * Truncate a path for display, collapsing middle segments if too long.
+     * E.g. C:\source\some\deep\project → C:\source\...\project
+     */
+    static truncatePath(fullPath, maxLen = 30) {
+        if (fullPath.length <= maxLen)
+            return fullPath;
+        const parts = fullPath.split(sep);
+        if (parts.length <= 2)
+            return fullPath;
+        const last = parts[parts.length - 1];
+        // Keep adding segments from the front until we'd exceed maxLen
+        let front = parts[0];
+        for (let i = 1; i < parts.length - 1; i++) {
+            const candidate = `${front + sep + parts[i] + sep}...${sep}${last}`;
+            if (candidate.length > maxLen)
+                break;
+            front += sep + parts[i];
+        }
+        return `${front + sep}...${sep}${last}`;
+    }
+    /** Format elapsed seconds as (Ns), (Nm Ns), or (Nh Nm Ns). */
+    static formatElapsed(totalSeconds) {
+        const s = totalSeconds % 60;
+        const m = Math.floor(totalSeconds / 60) % 60;
+        const h = Math.floor(totalSeconds / 3600);
+        if (h > 0)
+            return `(${h}h ${m}m ${s}s)`;
+        if (m > 0)
+            return `(${m}m ${s}s)`;
+        return `(${s}s)`;
+    }
     /** 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 total = entries.length;
+        const idx = this.statusRotateIndex % total;
+        const { teammate, task, startTime } = entries[idx];
         const displayName = teammate === this.selfName ? this.adapterName : teammate;
         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) - displayName.length - 10);
-            const taskText = cleanTask.length > maxLen
-                ? `${cleanTask.slice(0, maxLen - 1)}…`
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        const elapsedStr = TeammatesREPL.formatElapsed(elapsed);
+        // Build the tag: (1/3 - 2m 5s) when multiple, (2m 5s) when single
+        const tag = total > 1
+            ? `(${idx + 1}/${total} - ${elapsedStr.slice(1, -1)})`
+            : elapsedStr;
+        // Target 80 chars total: "<spinner> <name>... <task> <tag>"
+        const prefix = `${spinChar} ${displayName}... `;
+        const suffix = ` ${tag}`;
+        const maxTask = 80 - prefix.length - suffix.length;
+        const cleanTask = task.replace(/[\r\n]+/g, " ").trim();
+        const taskText = maxTask <= 3
+            ? ""
+            : cleanTask.length > maxTask
+                ? `${cleanTask.slice(0, maxTask - 1)}…`
                 : cleanTask;
-            const queueTag = this.activeTasks.size > 1
-                ? ` (${idx + 1}/${this.activeTasks.size})`
-                : "";
-            this.chatView.setProgress(concat(tp.accent(`${spinChar} ${displayName}… `), tp.muted(taskText + queueTag)));
+        if (this.chatView) {
+            this.chatView.setProgress(concat(tp.accent(`${spinChar} ${displayName}... `), tp.muted(`${taskText}${suffix}`)));
             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(displayName) +
-                chalk.gray(`… ${taskPreview}`) +
-                (queueInfo ? chalk.gray(queueInfo) : "");
+                chalk.gray(`... ${taskText}`) +
+                chalk.gray(suffix);
             this.input.setStatus(line);
         }
     }
@@ -1032,9 +1037,24 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         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. */
+    /** Returns true if the queue entry is a system-initiated (non-blocking) task. */
+    isSystemTask(entry) {
+        return (entry.type === "compact" ||
+            entry.type === "summarize" ||
+            (entry.type === "agent" && entry.system === true));
+    }
+    /** Start draining per-agent queues in parallel. Each agent gets its own drain loop.
+     *  System tasks are extracted and run concurrently without blocking user tasks. */
     kickDrain() {
-        // Find agents that have queued tasks but no active drain
+        // Extract system tasks and fire them concurrently (non-blocking)
+        for (let i = this.taskQueue.length - 1; i >= 0; i--) {
+            const entry = this.taskQueue[i];
+            if (this.isSystemTask(entry)) {
+                this.taskQueue.splice(i, 1);
+                this.runSystemTask(entry);
+            }
+        }
+        // Find agents that have user tasks but no active drain
         const agentsWithWork = new Set();
         for (const entry of this.taskQueue) {
             agentsWithWork.add(entry.teammate);
@@ -1048,6 +1068,53 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             }
         }
     }
+    /**
+     * Run a system-initiated task concurrently without blocking user tasks.
+     * Purely background — no progress bar, no /status. Only reports errors.
+     */
+    async runSystemTask(entry) {
+        const taskId = `sys-${entry.teammate}-${Date.now()}`;
+        this.systemActive.set(taskId, entry);
+        const startTime = Date.now();
+        try {
+            if (entry.type === "compact") {
+                await this.runCompact(entry.teammate, true);
+            }
+            else if (entry.type === "summarize") {
+                const result = await this.orchestrator.assign({
+                    teammate: entry.teammate,
+                    task: entry.task,
+                    system: true,
+                });
+                const raw = result.rawOutput ?? "";
+                this.conversationSummary = raw
+                    .replace(/^TO:\s*\S+\s*\n/im, "")
+                    .replace(/^#\s+.+\n*/m, "")
+                    .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/g, "")
+                    .trim();
+            }
+            else {
+                // System agent tasks (e.g. wisdom distillation)
+                const result = await this.orchestrator.assign({
+                    teammate: entry.teammate,
+                    task: entry.task,
+                    system: true,
+                });
+                // Write debug entry for system tasks too
+                this.writeDebugEntry(entry.teammate, entry.task, result, startTime);
+            }
+        }
+        catch (err) {
+            // System task errors always show in feed
+            const msg = err?.message ?? String(err);
+            const displayName = entry.teammate === this.selfName ? this.adapterName : entry.teammate;
+            this.feedLine(tp.error(`  ✖  @${displayName} (system): ${msg}`));
+            this.refreshView();
+        }
+        finally {
+            this.systemActive.delete(taskId);
+        }
+    }
     // ─── Onboarding ───────────────────────────────────────────────────
     /**
      * Interactive prompt for team onboarding after user profile is set up.
@@ -2355,11 +2422,11 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             progressStyle: { fg: t.progress, italic: true },
             dropdownHighlightStyle: { fg: t.accent },
             dropdownStyle: { fg: t.textMuted },
-            footer: concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`), tp.muted("  "), tp.text(this.adapterName)),
+            footer: concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`), tp.muted("  "), tp.text(this.adapterName), tp.muted("  "), tp.dim(TeammatesREPL.truncatePath(dirname(this.teammatesDir)))),
             footerRight: tp.muted("? /help "),
             footerStyle: { fg: t.textDim },
         });
-        this.defaultFooter = concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`), tp.muted("  "), tp.text(this.adapterName));
+        this.defaultFooter = concat(tp.accent(" Teammates"), tp.dim(` v${PKG_VERSION}`), tp.muted("  "), tp.text(this.adapterName), tp.muted("  "), tp.dim(TeammatesREPL.truncatePath(dirname(this.teammatesDir))));
         this.defaultFooterRight = tp.muted("? /help ");
         // Wire ChatView events for input handling
         this.chatView.on("submit", (rawLine) => {
@@ -2968,7 +3035,7 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             {
                 name: "debug",
                 aliases: ["raw"],
-                usage: "/debug [teammate]",
+                usage: "/debug [teammate] [focus]",
                 description: "Analyze the last agent task with the coding agent",
                 run: (args) => this.cmdDebug(args),
             },
@@ -3089,16 +3156,24 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             return;
         switch (event.type) {
             case "task_assigned": {
+                // System tasks (compaction, summarization, wisdom distillation) are
+                // invisible — don't track them in the progress bar.
+                if (event.assignment.system)
+                    break;
                 // 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,
+                    startTime: Date.now(),
                 });
                 this.startStatusAnimation();
                 break;
             }
             case "task_completed": {
+                // System task completions — don't touch activeTasks (was never added)
+                if (event.result.system)
+                    break;
                 // Remove from active tasks and stop spinner.
                 // Result display is deferred to drainAgentQueue() so the defensive
                 // retry can update rawOutput before anything is shown to the user.
@@ -3186,10 +3261,13 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         this.refreshView();
     }
     async cmdDebug(argsStr) {
-        const arg = argsStr.trim().replace(/^@/, "");
+        const parts = argsStr.trim().split(/\s+/);
+        const firstArg = (parts[0] ?? "").replace(/^@/, "");
+        // Everything after the teammate name is the debug focus
+        const debugFocus = parts.slice(1).join(" ").trim() || undefined;
         // Resolve which teammate to debug
         let targetName;
-        if (arg === "everyone") {
+        if (firstArg === "everyone") {
             // Pick all teammates with debug files, queue one analysis per teammate
             const names = [];
             for (const [name] of this.lastDebugFiles) {
@@ -3202,28 +3280,29 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 return;
             }
             for (const name of names) {
-                this.queueDebugAnalysis(name);
+                this.queueDebugAnalysis(name, debugFocus);
             }
             return;
         }
-        else if (arg) {
-            targetName = arg;
+        else if (firstArg) {
+            targetName = firstArg;
         }
         else if (this.lastResult) {
             targetName = this.lastResult.teammate;
         }
         else {
-            this.feedLine(tp.muted("  No debug info available. Try: /debug [teammate]"));
+            this.feedLine(tp.muted("  No debug info available. Try: /debug [teammate] [focus]"));
             this.refreshView();
             return;
         }
-        this.queueDebugAnalysis(targetName);
+        this.queueDebugAnalysis(targetName, debugFocus);
     }
     /**
      * Queue a debug analysis task — sends the last request + debug log
      * to the base coding agent for analysis.
+     * @param debugFocus Optional focus area the user wants to investigate
      */
-    queueDebugAnalysis(teammate) {
+    queueDebugAnalysis(teammate, debugFocus) {
         const debugFile = this.lastDebugFiles.get(teammate);
         const lastPrompt = this.lastTaskPrompts.get(teammate);
         if (!debugFile) {
@@ -3241,8 +3320,11 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             this.refreshView();
             return;
         }
+        const focusLine = debugFocus
+            ? `\n\n**Focus your analysis on:** ${debugFocus}`
+            : "";
         const analysisPrompt = [
-            `Analyze the following debug log from @${teammate}'s last task execution. Identify any issues, errors, or anomalies. If the response was empty, explain likely causes. Provide a concise diagnosis and suggest fixes if applicable.`,
+            `Analyze the following debug log from @${teammate}'s last task execution. Identify any issues, errors, or anomalies. If the response was empty, explain likely causes. Provide a concise diagnosis and suggest fixes if applicable.${focusLine}`,
             "",
             "## Last Request Sent to Agent",
             "",
@@ -3254,6 +3336,9 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         ].join("\n");
         // Show the debug log path — ctrl+click to open
         this.feedLine(concat(tp.muted("  Debug log: "), tp.accent(debugFile)));
+        if (debugFocus) {
+            this.feedLine(tp.muted(`  Focus: ${debugFocus}`));
+        }
         this.feedLine(tp.muted("  Queuing analysis…"));
         this.refreshView();
         this.taskQueue.push({
@@ -3280,34 +3365,18 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         this.feedLine(concat(tp.muted("  Cancelled: "), tp.accent(`@${cancelDisplay}`), tp.muted(" — "), tp.text(removed.task.slice(0, 60))));
         this.refreshView();
     }
-    /** Drain tasks for a single agent — runs in parallel with other agents. */
+    /** Drain user tasks for a single agent — runs in parallel with other agents.
+     *  System tasks are handled separately by runSystemTask(). */
     async drainAgentQueue(agent) {
         while (true) {
-            const idx = this.taskQueue.findIndex((e) => e.teammate === agent);
+            const idx = this.taskQueue.findIndex((e) => e.teammate === agent && !this.isSystemTask(e));
             if (idx < 0)
                 break;
             const entry = this.taskQueue.splice(idx, 1)[0];
             this.agentActive.set(agent, entry);
             const startTime = Date.now();
             try {
-                if (entry.type === "compact") {
-                    await this.runCompact(entry.teammate);
-                }
-                else if (entry.type === "summarize") {
-                    // Internal housekeeping — summarize older conversation history
-                    const result = await this.orchestrator.assign({
-                        teammate: entry.teammate,
-                        task: entry.task,
-                    });
-                    // Extract the summary from the agent's output (strip protocol artifacts)
-                    const raw = result.rawOutput ?? "";
-                    this.conversationSummary = raw
-                        .replace(/^TO:\s*\S+\s*\n/im, "")
-                        .replace(/^#\s+.+\n*/m, "")
-                        .replace(/```json\s*\n\s*\{[\s\S]*?\}\s*\n\s*```\s*$/g, "")
-                        .trim();
-                }
-                else {
+                {
                     // btw and debug tasks skip conversation context (not part of main thread)
                     const extraContext = entry.type === "btw" || entry.type === "debug"
                         ? ""
@@ -3418,6 +3487,14 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 task,
                 "",
             ];
+            // Include the full prompt sent to the agent (with identity, memory, etc.)
+            const fullPrompt = result?.fullPrompt;
+            if (fullPrompt) {
+                lines.push("## Full Prompt");
+                lines.push("");
+                lines.push(fullPrompt);
+                lines.push("");
+            }
             if (error) {
                 lines.push("## Result");
                 lines.push("");
@@ -3474,7 +3551,7 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             lines.push("");
             writeFileSync(debugFile, lines.join("\n"), "utf-8");
             this.lastDebugFiles.set(teammate, debugFile);
-            this.lastTaskPrompts.set(teammate, task);
+            this.lastTaskPrompts.set(teammate, fullPrompt ?? task);
         }
         catch {
             // Don't let debug logging break task execution
@@ -3655,12 +3732,12 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
      */
     async runCompact(name, silent = false) {
         const teammateDir = join(this.teammatesDir, name);
-        if (this.chatView) {
+        if (!silent && this.chatView) {
             this.chatView.setProgress(`Compacting ${name}...`);
             this.refreshView();
         }
         let spinner = null;
-        if (!this.chatView) {
+        if (!silent && !this.chatView) {
             spinner = ora({ text: `Compacting ${name}...`, color: "cyan" }).start();
         }
         try {
@@ -3698,16 +3775,16 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 if (this.chatView)
                     this.feedLine(tp.success(`  ✔  ${name}: ${parts.join(", ")}`));
             }
-            if (this.chatView)
+            if (!silent && this.chatView)
                 this.chatView.setProgress(null);
             // Sync recall index for this teammate (bundled library call)
             try {
-                if (this.chatView) {
+                if (!silent && this.chatView) {
                     this.chatView.setProgress(`Syncing ${name} index...`);
                     this.refreshView();
                 }
                 let syncSpinner = null;
-                if (!this.chatView) {
+                if (!silent && !this.chatView) {
                     syncSpinner = ora({
                         text: `Syncing ${name} index...`,
                         color: "cyan",
@@ -3717,7 +3794,8 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 if (syncSpinner)
                     syncSpinner.succeed(`${name}: index synced`);
                 if (this.chatView) {
-                    this.chatView.setProgress(null);
+                    if (!silent)
+                        this.chatView.setProgress(null);
                     if (!silent)
                         this.feedLine(tp.success(`  ✔  ${name}: index synced`));
                 }
@@ -3734,9 +3812,9 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                         type: "agent",
                         teammate: name,
                         task: wisdomPrompt,
+                        system: true,
                     });
-                    if (this.chatView && !silent)
-                        this.feedLine(tp.muted(`  ↻ ${name}: queued wisdom distillation`));
+                    this.kickDrain();
                 }
             }
             catch {
@@ -3748,7 +3826,8 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             if (spinner)
                 spinner.fail(`${name}: ${msg}`);
             if (this.chatView) {
-                this.chatView.setProgress(null);
+                if (!silent)
+                    this.chatView.setProgress(null);
                 // Errors always show in feed
                 this.feedLine(tp.error(`  ✖  ${name}: ${msg}`));
             }
@@ -3879,16 +3958,8 @@ Issues that can't be resolved unilaterally — they need input from other teamma
         // 1. Run compaction for all teammates (auto-compact + episodic + sync + wisdom)
         //    Progress bar shows status; feed only shows lines when actual work is done
         for (const name of teammates) {
-            if (this.chatView) {
-                this.chatView.setProgress(`Maintaining @${name}...`);
-                this.refreshView();
-            }
             await this.runCompact(name, true);
         }
-        if (this.chatView) {
-            this.chatView.setProgress(null);
-            this.refreshView();
-        }
         // 2. Purge daily logs older than 30 days (disk + Vectra)
         const { Indexer } = await import("@teammates/recall");
         const indexer = new Indexer({ teammatesDir: this.teammatesDir });

package/dist/orchestrator.js

@@ -82,6 +82,9 @@ export class Orchestrator {
         const result = await this.adapter.executeTask(sessionId, teammate, prompt, {
             raw: assignment.raw,
         });
+        // Propagate system flag so event handlers can distinguish system vs user tasks
+        if (assignment.system)
+            result.system = true;
         this.onEvent({ type: "task_completed", result });
         // Update status (preserve presence)
         const postPresence = this.statuses.get(assignment.teammate)?.presence ?? "online";

package/dist/types.d.ts

@@ -64,6 +64,8 @@ export interface HandoffEnvelope {
 export interface TaskResult {
     /** The teammate that executed the task */
     teammate: string;
+    /** Whether this was a system-initiated task */
+    system?: boolean;
     /** Whether the task completed successfully */
     success: boolean;
     /** Summary of what was done */
@@ -74,6 +76,8 @@ export interface TaskResult {
     handoffs: HandoffEnvelope[];
     /** Raw output from the agent */
     rawOutput?: string;
+    /** The full prompt sent to the agent (for debug logging) */
+    fullPrompt?: string;
     /** Process diagnostics for debugging empty/failed responses */
     diagnostics?: {
         /** Process exit code (null if killed by signal) */
@@ -98,6 +102,8 @@ export interface TaskAssignment {
     extraContext?: string;
     /** When true, skip identity/memory prompt wrapping — send task as-is */
     raw?: boolean;
+    /** When true, this is a system-initiated task — suppress progress bar */
+    system?: boolean;
 }
 /** Orchestrator event for logging/hooks */
 export type OrchestratorEvent = {
@@ -116,6 +122,7 @@ export type QueueEntry = {
     type: "agent";
     teammate: string;
     task: string;
+    system?: boolean;
 } | {
     type: "compact";
     teammate: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/cli",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Agent-agnostic CLI for teammates. Routes tasks, manages handoffs, and plugs into any coding agent backend.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,8 +34,8 @@
   "license": "MIT",
   "dependencies": {
     "@github/copilot-sdk": "^0.1.32",
-    "@teammates/consolonia": "0.5.1",
-    "@teammates/recall": "0.5.1",
+    "@teammates/consolonia": "0.5.3",
+    "@teammates/recall": "0.5.3",
     "chalk": "^5.6.2",
     "ora": "^9.3.0"
   },