@teammates/cli 0.1.0

package/README.md

@@ -0,0 +1,212 @@
+# @teammates/cli
+
+Agent-agnostic CLI orchestrator for teammates. Routes tasks to teammates, manages handoffs, and plugs into any coding agent backend.
+
+## Quick Start
+
+```bash
+cd cli
+npm install
+npm run build
+```
+
+Then launch a session with your preferred agent:
+
+```bash
+teammates claude       # Claude Code
+teammates codex        # OpenAI Codex
+teammates aider        # Aider
+teammates echo         # Test adapter (no external agent)
+```
+
+The CLI auto-discovers your `.teammates/` directory by walking up from the current working directory.
+
+## Usage
+
+```
+teammates <agent> [options] [-- agent-flags...]
+```
+
+### Options
+
+| Flag | Description |
+|---|---|
+| `--model <model>` | Override the agent's model |
+| `--dir <path>` | Override `.teammates/` directory location |
+| `--help` | Show usage information |
+
+Any arguments after the agent name are passed through to the underlying agent CLI.
+
+## In-Session Commands
+
+Once inside the REPL, you can interact with teammates using `@mentions`, `/commands`, or bare text (auto-routed).
+
+### Task Assignment
+
+| Input | Behavior |
+|---|---|
+| `@beacon fix the search index` | Assign directly to a teammate |
+| `fix the search index` | Auto-route to the best teammate based on keywords |
+| `/route fix the search index` | Explicitly auto-route |
+
+### Slash Commands
+
+| Command | Aliases | Description |
+|---|---|---|
+| `/route <task>` | `/r` | Auto-route a task to the best teammate |
+| `/status` | `/s` | Show teammate roster and session status |
+| `/teammates` | `/team`, `/t` | List all teammates and their roles |
+| `/log [teammate]` | `/l` | Show the last task result (optionally for a specific teammate) |
+| `/debug [teammate]` | `/raw` | Show raw agent output from the last task |
+| `/queue @teammate <task>` | `/qu` | Add a task to the background queue |
+| `/queue` | `/qu` | Show the current queue |
+| `/cancel <n>` | | Cancel a queued task by number |
+| `/install <service>` | | Install an optional service (e.g. `recall`) |
+| `/clear` | `/cls`, `/reset` | Clear conversation history, reset all sessions, and reprint banner |
+| `/help` | `/h`, `/?` | Show available commands |
+| `/exit` | `/q`, `/quit` | Exit the session |
+
+### Autocomplete
+
+- Type `/` to see a command wordwheel — arrow keys to navigate, `Tab` to accept
+- Type `@` anywhere in a line to autocomplete teammate names
+- Command arguments that take teammate names also autocomplete (e.g. `/log b` → `/log beacon`)
+
+## Task Queue
+
+Queue multiple tasks to run sequentially in the background while the REPL stays responsive:
+
+```
+/queue @beacon update the search index
+/queue @scribe update the onboarding docs
+/queue                    # show queue status
+/cancel 2                 # cancel a queued task
+```
+
+Queued tasks drain one at a time. If a handoff requires approval, the queue pauses until you respond.
+
+## Handoffs
+
+When a teammate finishes a task, it may propose a handoff to another teammate. The CLI presents a menu:
+
+```
+  1) Approve          — execute the handoff
+  2) Always approve   — auto-approve all future handoffs this session
+  3) Reject           — decline the handoff
+```
+
+Handoff details (task, changed files, acceptance criteria, open questions) are displayed before you choose.
+
+## Conversation History
+
+The CLI maintains a rolling conversation history (last 10 exchanges) that is passed as context to each task. This lets teammates reference prior work in the session without re-reading files.
+
+## Agent Adapters
+
+The CLI uses a generic adapter interface to support any coding agent. Each adapter spawns the agent as a subprocess and streams its output.
+
+### Built-in Presets
+
+| Preset | Command | Notes |
+|---|---|---|
+| `claude` | `claude -p --verbose` | Requires `claude` on PATH |
+| `codex` | `codex exec` | Requires `codex` on PATH |
+| `aider` | `aider --message-file` | Requires `aider` on PATH |
+| `echo` | (in-process) | Test adapter — echoes prompts, no external agent |
+
+### How Adapters Work
+
+1. The orchestrator builds a full prompt (identity + memory + roster + task)
+2. The prompt is written to a temp file
+3. The agent CLI is spawned with the prompt
+4. stdout/stderr are captured for result parsing
+5. The output is parsed for structured JSON result/handoff blocks
+6. Temp files are cleaned up
+
+### Writing a Custom Adapter
+
+Implement the `AgentAdapter` interface:
+
+```typescript
+import type { AgentAdapter } from "./adapter.js";
+import type { TeammateConfig, TaskResult } from "./types.js";
+
+class MyAdapter implements AgentAdapter {
+  readonly name = "my-agent";
+
+  async startSession(teammate: TeammateConfig): Promise<string> {
+    return `my-agent-${teammate.name}`;
+  }
+
+  async executeTask(
+    sessionId: string,
+    teammate: TeammateConfig,
+    prompt: string
+  ): Promise<TaskResult> {
+    // Call your agent and return results
+  }
+}
+```
+
+Or add a preset to `cli-proxy.ts` for any CLI agent that accepts a prompt and runs to completion.
+
+## Architecture
+
+```
+cli/src/
+  cli.ts            # Entry point, REPL, slash commands, wordwheel UI
+  orchestrator.ts   # Task routing, handoff chains, session management
+  adapter.ts        # AgentAdapter interface, prompt builder, handoff formatting
+  registry.ts       # Discovers teammates from .teammates/, loads SOUL.md + memory
+  types.ts          # Core types (TeammateConfig, TaskResult, HandoffEnvelope)
+  dropdown.ts       # Terminal dropdown/wordwheel widget
+  adapters/
+    cli-proxy.ts    # Generic subprocess adapter with agent presets
+    echo.ts         # Test adapter (no-op)
+```
+
+### Output Protocol
+
+Agents are instructed to end their response with a structured JSON block:
+
+```json
+{ "result": { "summary": "...", "changedFiles": ["..."] } }
+```
+
+Or for handoffs:
+
+```json
+{ "handoff": { "to": "teammate", "task": "...", "context": "..." } }
+```
+
+The CLI parses the last JSON fence in the output. If no structured block is found, it falls back to scraping file paths and summaries from freeform output.
+
+## Testing
+
+Run the test suite:
+
+```bash
+cd cli
+npm test
+```
+
+Run tests in watch mode during development:
+
+```bash
+npm run test:watch
+```
+
+Tests use [Vitest](https://vitest.dev/) and cover the core modules:
+
+| File | Covers |
+|---|---|
+| `src/adapter.test.ts` | `buildTeammatePrompt`, `formatHandoffContext` |
+| `src/orchestrator.test.ts` | Task routing, assignment, handoff chains, cycle detection, reset |
+| `src/registry.test.ts` | Teammate discovery, SOUL.md parsing (role, ownership), daily logs |
+| `src/adapters/echo.test.ts` | Echo adapter session and task execution |
+
+## Requirements
+
+- Node.js >= 20
+- A `.teammates/` directory in your project (see [ONBOARDING.md](../ONBOARDING.md))
+- The agent CLI on your PATH (for non-echo adapters)

package/dist/adapter.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Agent adapter interface.
+ *
+ * Implement this to plug any coding agent into the teammates CLI.
+ * Each adapter wraps a specific agent backend (Codex, Claude Code, Cursor, etc.)
+ * and translates between the orchestrator's protocol and the agent's native API.
+ */
+import type { TeammateConfig, TaskResult } from "./types.js";
+export interface AgentAdapter {
+    /** Human-readable name of the agent backend (e.g. "codex", "claude-code") */
+    readonly name: string;
+    /**
+     * Start a new session for a teammate.
+     * Returns a session/thread ID for continuity.
+     */
+    startSession(teammate: TeammateConfig): Promise<string>;
+    /**
+     * Send a task prompt to a teammate's session.
+     * The adapter hydrates the prompt with identity, memory, and handoff context.
+     */
+    executeTask(sessionId: string, teammate: TeammateConfig, prompt: string): Promise<TaskResult>;
+    /**
+     * Resume an existing session (for agents that support continuity).
+     * Falls back to startSession if not implemented.
+     */
+    resumeSession?(teammate: TeammateConfig, sessionId: string): Promise<string>;
+    /** Clean up a session. */
+    destroySession?(sessionId: string): Promise<void>;
+    /**
+     * Quick routing call — ask the agent which teammate should handle a task.
+     * Returns a teammate name. The agent can return its own name if it should handle it.
+     */
+    routeTask?(task: string, roster: RosterEntry[]): Promise<string | null>;
+}
+/** Minimal teammate info for the roster section of a prompt. */
+export interface RosterEntry {
+    name: string;
+    role: string;
+    ownership: {
+        primary: string[];
+        secondary: string[];
+    };
+}
+/** A service that's been installed and is available to teammates. */
+export interface InstalledService {
+    name: string;
+    description: string;
+    usage: string;
+}
+/**
+ * Build the full prompt for a teammate session.
+ * Includes identity, memory, roster, output protocol, and the task.
+ */
+export declare function buildTeammatePrompt(teammate: TeammateConfig, taskPrompt: string, options?: {
+    handoffContext?: string;
+    roster?: RosterEntry[];
+    services?: InstalledService[];
+    sessionFile?: string;
+}): string;
+/**
+ * Format a handoff envelope into a human-readable context string.
+ */
+export declare function formatHandoffContext(envelope: {
+    from: string;
+    task: string;
+    changedFiles?: string[];
+    acceptanceCriteria?: string[];
+    openQuestions?: string[];
+    context?: string;
+}): string;

package/dist/adapter.js

@@ -0,0 +1,159 @@
+/**
+ * Agent adapter interface.
+ *
+ * Implement this to plug any coding agent into the teammates CLI.
+ * Each adapter wraps a specific agent backend (Codex, Claude Code, Cursor, etc.)
+ * and translates between the orchestrator's protocol and the agent's native API.
+ */
+/**
+ * Build the full prompt for a teammate session.
+ * Includes identity, memory, roster, output protocol, and the task.
+ */
+export function buildTeammatePrompt(teammate, taskPrompt, options) {
+    const parts = [];
+    // ── Identity ──────────────────────────────────────────────────────
+    parts.push(`# You are ${teammate.name}\n`);
+    parts.push(teammate.soul);
+    parts.push("\n---\n");
+    // ── Memories ──────────────────────────────────────────────────────
+    if (teammate.memories.trim()) {
+        parts.push("## Your Memories\n");
+        parts.push(teammate.memories);
+        parts.push("\n---\n");
+    }
+    if (teammate.dailyLogs.length > 0) {
+        parts.push("## Recent Daily Logs\n");
+        for (const log of teammate.dailyLogs.slice(0, 3)) {
+            parts.push(`### ${log.date}\n${log.content}\n`);
+        }
+        parts.push("\n---\n");
+    }
+    // ── Team roster ───────────────────────────────────────────────────
+    if (options?.roster && options.roster.length > 0) {
+        parts.push("## Your Team\n");
+        parts.push("These are the other teammates you can hand off work to:\n");
+        for (const t of options.roster) {
+            if (t.name === teammate.name)
+                continue;
+            const owns = t.ownership.primary.length > 0
+                ? ` — owns: ${t.ownership.primary.join(", ")}`
+                : "";
+            parts.push(`- **@${t.name}**: ${t.role}${owns}`);
+        }
+        parts.push("\n---\n");
+    }
+    // ── Installed services ──────────────────────────────────────────────
+    if (options?.services && options.services.length > 0) {
+        parts.push("## Available Services\n");
+        parts.push("These services are installed and available for you to use:\n");
+        for (const svc of options.services) {
+            parts.push(`### ${svc.name}\n`);
+            parts.push(svc.description);
+            parts.push(`\n**Usage:** \`${svc.usage}\`\n`);
+        }
+        parts.push("\n---\n");
+    }
+    // ── Handoff context (if this task came from another teammate) ─────
+    if (options?.handoffContext) {
+        parts.push("## Handoff Context\n");
+        parts.push(options.handoffContext);
+        parts.push("\n---\n");
+    }
+    // ── Session state ────────────────────────────────────────────────
+    if (options?.sessionFile) {
+        parts.push("## Session State\n");
+        parts.push(`Your session file is at: \`${options.sessionFile}\`
+
+**Read this file first** — it contains context from your prior tasks in this session.
+
+**Before returning your result**, 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.
+`);
+        parts.push("\n---\n");
+    }
+    // ── Memory updates ─────────────────────────────────────────────────
+    const today = new Date().toISOString().slice(0, 10);
+    parts.push("## Memory Updates\n");
+    parts.push(`**Before returning your result**, 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. **MEMORIES.md** — If you learned something durable (a decision, pattern, gotcha, or bug), read \`.teammates/${teammate.name}/MEMORIES.md\`, then write it back with your entry added.
+
+These files are your persistent memory. Without them, your next session starts from scratch.
+`);
+    parts.push("\n---\n");
+    // ── Output protocol ───────────────────────────────────────────────
+    parts.push("## Output Protocol\n");
+    parts.push(`When you finish, you MUST end your response with exactly one of these two blocks:
+
+### Option 1: Direct response
+
+If you can complete the task yourself, do the work and then end with:
+
+\`\`\`json
+{ "result": { "summary": "<one-line summary of what you did>", "changedFiles": ["<file>", ...] } }
+\`\`\`
+
+### Option 2: Handoff
+
+If the task (or part of it) belongs to another teammate, end with:
+
+\`\`\`json
+{ "handoff": { "to": "<teammate>", "task": "<specific request for them>", "changedFiles": ["<files you changed, if any>"], "context": "<any context they need>" } }
+\`\`\`
+
+You may also write a task file (e.g. \`.teammates/tasks/<name>.md\`) with detailed instructions and reference it in the handoff:
+
+\`\`\`json
+{ "handoff": { "to": "<teammate>", "task": "See .teammates/tasks/<name>.md", "changedFiles": [".teammates/tasks/<name>.md"] } }
+\`\`\`
+
+Rules:
+- Always include exactly one JSON block at the end — either \`result\` or \`handoff\`.
+- Only hand off to teammates listed in "Your Team" above.
+- Do as much of the work as you can before handing off.
+- If the task is outside everyone's ownership, do your best and return a result.
+`);
+    parts.push("\n---\n");
+    // ── Task ──────────────────────────────────────────────────────────
+    parts.push("## Task\n");
+    parts.push(taskPrompt);
+    return parts.join("\n");
+}
+/**
+ * Format a handoff envelope into a human-readable context string.
+ */
+export function formatHandoffContext(envelope) {
+    const lines = [];
+    lines.push(`**Handed off from:** ${envelope.from}`);
+    lines.push(`**Task:** ${envelope.task}`);
+    if (envelope.changedFiles?.length) {
+        lines.push("\n**Changed files:**");
+        for (const f of envelope.changedFiles)
+            lines.push(`- ${f}`);
+    }
+    if (envelope.acceptanceCriteria?.length) {
+        lines.push("\n**Acceptance criteria:**");
+        for (const c of envelope.acceptanceCriteria)
+            lines.push(`- ${c}`);
+    }
+    if (envelope.openQuestions?.length) {
+        lines.push("\n**Open questions:**");
+        for (const q of envelope.openQuestions)
+            lines.push(`- ${q}`);
+    }
+    if (envelope.context) {
+        lines.push(`\n**Additional context:**\n${envelope.context}`);
+    }
+    return lines.join("\n");
+}

package/dist/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapter.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect } from "vitest";
+import { buildTeammatePrompt, formatHandoffContext } from "./adapter.js";
+function makeConfig(overrides) {
+    return {
+        name: "beacon",
+        role: "Platform engineer.",
+        soul: "# Beacon\n\nBeacon owns the recall package.",
+        memories: "",
+        dailyLogs: [],
+        ownership: { primary: ["recall/src/**"], secondary: [] },
+        ...overrides,
+    };
+}
+describe("buildTeammatePrompt", () => {
+    it("includes identity header", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "do the thing");
+        expect(prompt).toContain("# You are beacon");
+    });
+    it("includes soul content", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "do the thing");
+        expect(prompt).toContain("Beacon owns the recall package");
+    });
+    it("includes the task", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "fix the bug");
+        expect(prompt).toContain("## Task");
+        expect(prompt).toContain("fix the bug");
+    });
+    it("includes output protocol", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "task");
+        expect(prompt).toContain("## Output Protocol");
+        expect(prompt).toContain('"result"');
+        expect(prompt).toContain('"handoff"');
+    });
+    it("includes memory updates section", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "task");
+        expect(prompt).toContain("## Memory Updates");
+        expect(prompt).toContain(".teammates/beacon/memory/");
+    });
+    it("skips memories section when empty", () => {
+        const prompt = buildTeammatePrompt(makeConfig({ memories: "" }), "task");
+        expect(prompt).not.toContain("## Your Memories");
+    });
+    it("includes memories when present", () => {
+        const prompt = buildTeammatePrompt(makeConfig({ memories: "Some important memory" }), "task");
+        expect(prompt).toContain("## Your Memories");
+        expect(prompt).toContain("Some important memory");
+    });
+    it("includes daily logs (up to 3)", () => {
+        const logs = [
+            { date: "2026-03-13", content: "Did stuff today" },
+            { date: "2026-03-12", content: "Did stuff yesterday" },
+            { date: "2026-03-11", content: "Day before" },
+            { date: "2026-03-10", content: "Should be excluded" },
+        ];
+        const prompt = buildTeammatePrompt(makeConfig({ dailyLogs: logs }), "task");
+        expect(prompt).toContain("## Recent Daily Logs");
+        expect(prompt).toContain("2026-03-13");
+        expect(prompt).toContain("2026-03-12");
+        expect(prompt).toContain("2026-03-11");
+        expect(prompt).not.toContain("2026-03-10");
+        expect(prompt).not.toContain("Should be excluded");
+    });
+    it("includes roster excluding self", () => {
+        const roster = [
+            { name: "beacon", role: "Platform engineer.", ownership: { primary: [], secondary: [] } },
+            { name: "scribe", role: "Documentation writer.", ownership: { primary: ["docs/**"], secondary: [] } },
+        ];
+        const prompt = buildTeammatePrompt(makeConfig(), "task", { roster });
+        expect(prompt).toContain("## Your Team");
+        expect(prompt).toContain("@scribe");
+        expect(prompt).toContain("Documentation writer.");
+        // Should not list self in roster
+        expect(prompt).not.toContain("@beacon");
+    });
+    it("includes handoff context when provided", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "task", {
+            handoffContext: "Handed off from scribe with files changed",
+        });
+        expect(prompt).toContain("## Handoff Context");
+        expect(prompt).toContain("Handed off from scribe");
+    });
+    it("includes session file when provided", () => {
+        const prompt = buildTeammatePrompt(makeConfig(), "task", {
+            sessionFile: "/tmp/beacon-session.md",
+        });
+        expect(prompt).toContain("## Session State");
+        expect(prompt).toContain("/tmp/beacon-session.md");
+    });
+});
+describe("formatHandoffContext", () => {
+    it("formats basic handoff", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "update the docs",
+        });
+        expect(result).toContain("**Handed off from:** beacon");
+        expect(result).toContain("**Task:** update the docs");
+    });
+    it("includes changed files", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "review",
+            changedFiles: ["src/foo.ts", "src/bar.ts"],
+        });
+        expect(result).toContain("**Changed files:**");
+        expect(result).toContain("- src/foo.ts");
+        expect(result).toContain("- src/bar.ts");
+    });
+    it("includes acceptance criteria", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "review",
+            acceptanceCriteria: ["Tests pass", "No lint errors"],
+        });
+        expect(result).toContain("**Acceptance criteria:**");
+        expect(result).toContain("- Tests pass");
+        expect(result).toContain("- No lint errors");
+    });
+    it("includes open questions", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "review",
+            openQuestions: ["Should we rename?"],
+        });
+        expect(result).toContain("**Open questions:**");
+        expect(result).toContain("- Should we rename?");
+    });
+    it("includes additional context", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "review",
+            context: "This is urgent",
+        });
+        expect(result).toContain("**Additional context:**");
+        expect(result).toContain("This is urgent");
+    });
+    it("omits sections with empty arrays", () => {
+        const result = formatHandoffContext({
+            from: "beacon",
+            task: "review",
+            changedFiles: [],
+        });
+        expect(result).not.toContain("**Changed files:**");
+    });
+});

package/dist/adapters/cli-proxy.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Generic CLI proxy adapter — spawns any coding agent as a subprocess
+ * and streams its output live to the user's terminal.
+ *
+ * Supports any CLI agent that accepts a prompt and runs to completion:
+ *   claude -p "prompt"
+ *   codex exec "prompt" --full-auto
+ *   aider --message "prompt"
+ *   etc.
+ *
+ * The adapter:
+ *   1. Writes the full prompt (identity + memory + task) to a temp file
+ *   2. Spawns the agent with the prompt file
+ *   3. Tees stdout/stderr to the user's terminal in real time
+ *   4. Captures output for result parsing (changed files, handoff envelopes)
+ */
+import type { AgentAdapter, RosterEntry, InstalledService } from "../adapter.js";
+import type { TeammateConfig, TaskResult, SandboxLevel } from "../types.js";
+export interface AgentPreset {
+    /** Display name */
+    name: string;
+    /** Binary / command to spawn */
+    command: string;
+    /** Build CLI args. `promptFile` is a temp file path, `prompt` is the raw text. */
+    buildArgs(ctx: {
+        promptFile: string;
+        prompt: string;
+    }, teammate: TeammateConfig, options: CliProxyOptions): string[];
+    /** Extra env vars to set (e.g. FORCE_COLOR) */
+    env?: Record<string, string>;
+    /** Whether the agent may prompt the user for input (connects stdin) */
+    interactive?: boolean;
+    /** Whether the command needs shell: true to run */
+    shell?: boolean;
+}
+export declare const PRESETS: Record<string, AgentPreset>;
+export interface CliProxyOptions {
+    /** Preset name or custom preset */
+    preset: string | AgentPreset;
+    /** Model override */
+    model?: string;
+    /** Default sandbox level */
+    defaultSandbox?: SandboxLevel;
+    /** Timeout in ms (default: 600_000 = 10 min) */
+    timeout?: number;
+    /** Extra CLI flags appended to the command */
+    extraFlags?: string[];
+    /** Custom command path override (e.g. "/usr/local/bin/claude") */
+    commandPath?: string;
+}
+export declare class CliProxyAdapter implements AgentAdapter {
+    readonly name: string;
+    /** Team roster — set by the orchestrator so prompts include teammate info. */
+    roster: RosterEntry[];
+    /** Installed services — set by the CLI so prompts include service info. */
+    services: InstalledService[];
+    private preset;
+    private options;
+    /** Session files per teammate — persists state across task invocations. */
+    private sessionFiles;
+    /** Base directory for session files. */
+    private sessionsDir;
+    /** Temp prompt files that need cleanup — guards against crashes before finally. */
+    private pendingTempFiles;
+    constructor(options: CliProxyOptions);
+    startSession(teammate: TeammateConfig): Promise<string>;
+    executeTask(sessionId: string, teammate: TeammateConfig, prompt: string): Promise<TaskResult>;
+    routeTask(task: string, roster: RosterEntry[]): Promise<string | null>;
+    destroySession(sessionId: string): Promise<void>;
+    /**
+     * Spawn the agent, stream its output live, and capture it.
+     */
+    private spawnAndProxy;
+}