@teammates/cli 0.1.0

package/dist/orchestrator.test.js

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi } from "vitest";
+import { Orchestrator } from "./orchestrator.js";
+function makeTeammate(name, role = "Test role.", primary = []) {
+    return {
+        name,
+        role,
+        soul: `# ${name}\n\n${role}`,
+        memories: "",
+        dailyLogs: [],
+        ownership: { primary, secondary: [] },
+    };
+}
+function makeMockAdapter(results) {
+    let sessionCounter = 0;
+    return {
+        name: "mock",
+        startSession: vi.fn(async (t) => `mock-${t.name}-${++sessionCounter}`),
+        executeTask: vi.fn(async (_sid, t, _prompt) => {
+            if (results?.has(t.name))
+                return results.get(t.name);
+            return {
+                teammate: t.name,
+                success: true,
+                summary: `${t.name} completed task`,
+                changedFiles: [],
+            };
+        }),
+        destroySession: vi.fn(async () => { }),
+    };
+}
+function createOrchestrator(teammates, adapter, onEvent) {
+    const mockAdapter = adapter ?? makeMockAdapter();
+    const orch = new Orchestrator({
+        teammatesDir: "/fake/.teammates",
+        adapter: mockAdapter,
+        onEvent,
+    });
+    // Register teammates directly instead of loading from disk
+    const registry = orch.getRegistry();
+    for (const t of teammates) {
+        registry.register(t);
+    }
+    // Initialize statuses
+    for (const t of teammates) {
+        orch.getAllStatuses().set(t.name, { state: "idle" });
+    }
+    return { orch, adapter: mockAdapter };
+}
+describe("Orchestrator.route", () => {
+    it("routes based on ownership keywords", () => {
+        const { orch } = createOrchestrator([
+            makeTeammate("beacon", "Platform engineer.", ["recall/src/**", "cli/src/**"]),
+            makeTeammate("scribe", "Documentation writer.", ["docs/**", "README.md"]),
+        ]);
+        expect(orch.route("fix the recall search")).toBe("beacon");
+        expect(orch.route("update the docs README")).toBe("scribe");
+    });
+    it("returns null when no keywords match", () => {
+        const { orch } = createOrchestrator([
+            makeTeammate("beacon", "Platform engineer.", ["recall/src/**"]),
+        ]);
+        expect(orch.route("deploy to production")).toBeNull();
+    });
+    it("scores primary ownership higher than secondary", () => {
+        const t1 = makeTeammate("beacon", "Platform engineer.");
+        t1.ownership = { primary: ["cli/src/**"], secondary: [] };
+        const t2 = makeTeammate("helper", "General helper.");
+        t2.ownership = { primary: [], secondary: ["cli/src/**"] };
+        const { orch } = createOrchestrator([t1, t2]);
+        expect(orch.route("fix the cli")).toBe("beacon");
+    });
+    it("considers role keywords", () => {
+        const { orch } = createOrchestrator([
+            makeTeammate("beacon", "Platform engineer with search expertise."),
+            makeTeammate("scribe", "Documentation writer.", ["docs/**"]),
+        ]);
+        // "write documentation" matches role word "documentation" (1pt) + ownership keyword "docs" (2pt)
+        expect(orch.route("write docs and documentation")).toBe("scribe");
+    });
+    it("returns null for weak matches (score < 2)", () => {
+        const { orch } = createOrchestrator([
+            makeTeammate("beacon", "Platform engineer."),
+            makeTeammate("scribe", "Documentation writer."),
+        ]);
+        // "documentation" only matches a role word (1pt) — too weak to route confidently
+        expect(orch.route("write documentation")).toBeNull();
+    });
+});
+describe("Orchestrator.assign", () => {
+    it("assigns a task and returns result", async () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        const result = await orch.assign({ teammate: "beacon", task: "do stuff" });
+        expect(result.success).toBe(true);
+        expect(result.teammate).toBe("beacon");
+    });
+    it("strips @ from teammate name", async () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        const result = await orch.assign({ teammate: "@beacon", task: "do stuff" });
+        expect(result.success).toBe(true);
+        expect(result.teammate).toBe("beacon");
+    });
+    it("returns error for unknown teammate", async () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        const result = await orch.assign({ teammate: "unknown", task: "do stuff" });
+        expect(result.success).toBe(false);
+        expect(result.summary).toContain("Unknown teammate");
+    });
+    it("updates status to working during task", async () => {
+        const statuses = [];
+        const adapter = makeMockAdapter();
+        const origExecute = adapter.executeTask;
+        adapter.executeTask = async (sid, t, p) => {
+            const { orch } = { orch: orchRef };
+            statuses.push(orch.getStatus(t.name)?.state ?? "none");
+            return origExecute(sid, t, p);
+        };
+        const { orch } = createOrchestrator([makeTeammate("beacon")], adapter);
+        const orchRef = orch;
+        await orch.assign({ teammate: "beacon", task: "do stuff" });
+        expect(statuses).toContain("working");
+        expect(orch.getStatus("beacon")?.state).toBe("idle");
+    });
+    it("emits task_assigned and task_completed events", async () => {
+        const events = [];
+        const { orch } = createOrchestrator([makeTeammate("beacon")], undefined, (e) => events.push(e));
+        await orch.assign({ teammate: "beacon", task: "do stuff" });
+        expect(events.map((e) => e.type)).toEqual(["task_assigned", "task_completed"]);
+    });
+    it("reuses existing session", async () => {
+        const adapter = makeMockAdapter();
+        const { orch } = createOrchestrator([makeTeammate("beacon")], adapter);
+        await orch.assign({ teammate: "beacon", task: "task 1" });
+        await orch.assign({ teammate: "beacon", task: "task 2" });
+        expect(adapter.startSession).toHaveBeenCalledTimes(1);
+        expect(adapter.executeTask).toHaveBeenCalledTimes(2);
+    });
+});
+describe("Orchestrator handoffs", () => {
+    it("parks handoff when requireApproval is true", async () => {
+        const results = new Map();
+        results.set("beacon", {
+            teammate: "beacon",
+            success: true,
+            summary: "done",
+            changedFiles: [],
+            handoff: { from: "beacon", to: "scribe", task: "update docs" },
+        });
+        const adapter = makeMockAdapter(results);
+        const { orch } = createOrchestrator([makeTeammate("beacon"), makeTeammate("scribe")], adapter);
+        orch.requireApproval = true;
+        await orch.assign({ teammate: "beacon", task: "do stuff" });
+        expect(orch.getStatus("beacon")?.state).toBe("pending-handoff");
+        expect(orch.getPendingHandoff()?.to).toBe("scribe");
+    });
+    it("auto-follows handoff when requireApproval is false", async () => {
+        const results = new Map();
+        results.set("beacon", {
+            teammate: "beacon",
+            success: true,
+            summary: "done",
+            changedFiles: [],
+            handoff: { from: "beacon", to: "scribe", task: "update docs" },
+        });
+        const adapter = makeMockAdapter(results);
+        const { orch } = createOrchestrator([makeTeammate("beacon"), makeTeammate("scribe")], adapter);
+        orch.requireApproval = false;
+        const result = await orch.assign({ teammate: "beacon", task: "do stuff" });
+        // Final result should be from scribe (the handoff target)
+        expect(result.teammate).toBe("scribe");
+    });
+    it("detects handoff cycles", async () => {
+        const results = new Map();
+        results.set("beacon", {
+            teammate: "beacon",
+            success: true,
+            summary: "done",
+            changedFiles: [],
+            handoff: { from: "beacon", to: "scribe", task: "your turn" },
+        });
+        results.set("scribe", {
+            teammate: "scribe",
+            success: true,
+            summary: "done",
+            changedFiles: [],
+            handoff: { from: "scribe", to: "beacon", task: "back to you" },
+        });
+        const adapter = makeMockAdapter(results);
+        const { orch } = createOrchestrator([makeTeammate("beacon"), makeTeammate("scribe")], adapter);
+        orch.requireApproval = false;
+        const result = await orch.assign({ teammate: "beacon", task: "do stuff" });
+        expect(result.success).toBe(false);
+        expect(result.summary).toContain("cycle");
+    });
+    it("respects max handoff depth", async () => {
+        // Create a chain: a -> b -> c -> d -> e -> f (depth 5 should stop)
+        const teammates = ["a", "b", "c", "d", "e", "f"].map((n) => makeTeammate(n));
+        const results = new Map();
+        for (let i = 0; i < 5; i++) {
+            const from = teammates[i].name;
+            const to = teammates[i + 1].name;
+            results.set(from, {
+                teammate: from,
+                success: true,
+                summary: "done",
+                changedFiles: [],
+                handoff: { from, to, task: "next" },
+            });
+        }
+        const adapter = makeMockAdapter(results);
+        const { orch } = createOrchestrator(teammates, adapter);
+        orch.requireApproval = false;
+        const result = await orch.assign({ teammate: "a", task: "start" });
+        // Should stop at max depth, returning result from the teammate at depth limit
+        expect(adapter.executeTask).toHaveBeenCalled();
+    });
+    it("clears pending handoff on reject", () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        orch.getAllStatuses().set("beacon", {
+            state: "pending-handoff",
+            pendingHandoff: { from: "beacon", to: "scribe", task: "docs" },
+        });
+        orch.clearPendingHandoff("beacon");
+        expect(orch.getStatus("beacon")?.state).toBe("idle");
+        expect(orch.getStatus("beacon")?.pendingHandoff).toBeUndefined();
+    });
+});
+describe("Orchestrator.reset", () => {
+    it("resets all statuses to idle and clears sessions", async () => {
+        const adapter = makeMockAdapter();
+        const { orch } = createOrchestrator([makeTeammate("beacon"), makeTeammate("scribe")], adapter);
+        await orch.assign({ teammate: "beacon", task: "task" });
+        await orch.reset();
+        expect(orch.getStatus("beacon")?.state).toBe("idle");
+        expect(adapter.destroySession).toHaveBeenCalled();
+    });
+});
+describe("Orchestrator.shutdown", () => {
+    it("destroys all sessions", async () => {
+        const adapter = makeMockAdapter();
+        const { orch } = createOrchestrator([makeTeammate("beacon")], adapter);
+        await orch.assign({ teammate: "beacon", task: "task" });
+        await orch.shutdown();
+        expect(adapter.destroySession).toHaveBeenCalled();
+    });
+});

package/dist/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Teammate registry.
+ *
+ * Discovers teammates from .teammates/ and loads their configs
+ * (SOUL.md, MEMORIES.md, daily logs, ownership rules).
+ */
+import type { TeammateConfig } from "./types.js";
+export declare class Registry {
+    private teammatesDir;
+    private teammates;
+    constructor(teammatesDir: string);
+    /** Discover and load all teammates from .teammates/ */
+    loadAll(): Promise<Map<string, TeammateConfig>>;
+    /** Load a single teammate by name */
+    loadTeammate(name: string): Promise<TeammateConfig | null>;
+    /** Register a teammate programmatically (e.g. the agent itself) */
+    register(config: TeammateConfig): void;
+    /** Get a loaded teammate by name */
+    get(name: string): TeammateConfig | undefined;
+    /** List all loaded teammate names */
+    list(): string[];
+    /** Get the full roster */
+    all(): Map<string, TeammateConfig>;
+}

package/dist/registry.js

@@ -0,0 +1,145 @@
+/**
+ * Teammate registry.
+ *
+ * Discovers teammates from .teammates/ and loads their configs
+ * (SOUL.md, MEMORIES.md, daily logs, ownership rules).
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, basename } from "node:path";
+export class Registry {
+    teammatesDir;
+    teammates = new Map();
+    constructor(teammatesDir) {
+        this.teammatesDir = teammatesDir;
+    }
+    /** Discover and load all teammates from .teammates/ */
+    async loadAll() {
+        const entries = await readdir(this.teammatesDir, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+        for (const dir of dirs) {
+            const config = await this.loadTeammate(dir.name);
+            if (config) {
+                this.teammates.set(dir.name, config);
+            }
+        }
+        return this.teammates;
+    }
+    /** Load a single teammate by name */
+    async loadTeammate(name) {
+        const dir = join(this.teammatesDir, name);
+        const soulPath = join(dir, "SOUL.md");
+        try {
+            await stat(soulPath);
+        }
+        catch {
+            return null; // Not a teammate folder
+        }
+        const soul = await readFile(soulPath, "utf-8");
+        const memories = await readFileSafe(join(dir, "MEMORIES.md"));
+        const dailyLogs = await loadDailyLogs(join(dir, "memory"));
+        const ownership = parseOwnership(soul);
+        const role = parseRole(soul);
+        const config = {
+            name,
+            role,
+            soul,
+            memories,
+            dailyLogs,
+            ownership,
+        };
+        this.teammates.set(name, config);
+        return config;
+    }
+    /** Register a teammate programmatically (e.g. the agent itself) */
+    register(config) {
+        this.teammates.set(config.name, config);
+    }
+    /** Get a loaded teammate by name */
+    get(name) {
+        return this.teammates.get(name);
+    }
+    /** List all loaded teammate names */
+    list() {
+        return Array.from(this.teammates.keys());
+    }
+    /** Get the full roster */
+    all() {
+        return this.teammates;
+    }
+}
+/** Read a file, return empty string if missing */
+async function readFileSafe(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Load daily logs from memory/ directory, most recent first */
+async function loadDailyLogs(memoryDir) {
+    try {
+        const entries = await readdir(memoryDir);
+        const logs = [];
+        for (const entry of entries) {
+            if (entry.endsWith(".md")) {
+                const date = basename(entry, ".md");
+                const content = await readFile(join(memoryDir, entry), "utf-8");
+                logs.push({ date, content });
+            }
+        }
+        // Most recent first
+        logs.sort((a, b) => b.date.localeCompare(a.date));
+        return logs;
+    }
+    catch {
+        return [];
+    }
+}
+/** Extract role from SOUL.md — uses ## Identity paragraph or **Persona:** line */
+function parseRole(soul) {
+    // Look for a line like "**Persona:** Some role description"
+    const personaMatch = soul.match(/\*\*Persona:\*\*\s*(.+)/);
+    if (personaMatch)
+        return personaMatch[1].trim();
+    // Look for the paragraph under ## Identity
+    const identityMatch = soul.match(/## Identity\s*\n\s*\n(.+)/);
+    if (identityMatch) {
+        // Return just the first sentence
+        const firstSentence = identityMatch[1].split(/\.\s/)[0];
+        return firstSentence.endsWith(".") ? firstSentence : firstSentence + ".";
+    }
+    // Fallback: first non-heading, non-empty line
+    const lines = soul.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("---")) {
+            const firstSentence = trimmed.split(/\.\s/)[0];
+            return firstSentence.endsWith(".") ? firstSentence : firstSentence + ".";
+        }
+    }
+    return "teammate";
+}
+/** Parse ownership patterns from SOUL.md */
+function parseOwnership(soul) {
+    const rules = { primary: [], secondary: [] };
+    const primaryMatch = soul.match(/### Primary[\s\S]*?(?=###|## |$)/);
+    if (primaryMatch) {
+        rules.primary = extractPatterns(primaryMatch[0]);
+    }
+    const secondaryMatch = soul.match(/### Secondary[\s\S]*?(?=###|## |$)/);
+    if (secondaryMatch) {
+        rules.secondary = extractPatterns(secondaryMatch[0]);
+    }
+    return rules;
+}
+/** Extract file patterns (backtick-wrapped) from a markdown section */
+function extractPatterns(section) {
+    const patterns = [];
+    const regex = /`([^`]+)`/g;
+    let match;
+    while ((match = regex.exec(section)) !== null) {
+        patterns.push(match[1]);
+    }
+    return patterns;
+}

package/dist/registry.test.d.ts

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

package/dist/registry.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { Registry } from "./registry.js";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+let tempDir;
+beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "teammates-test-"));
+});
+afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+});
+async function createTeammate(name, soul, options) {
+    const dir = join(tempDir, name);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, "SOUL.md"), soul);
+    if (options?.memories) {
+        await writeFile(join(dir, "MEMORIES.md"), options.memories);
+    }
+    if (options?.dailyLogs) {
+        const memDir = join(dir, "memory");
+        await mkdir(memDir, { recursive: true });
+        for (const log of options.dailyLogs) {
+            await writeFile(join(memDir, `${log.date}.md`), log.content);
+        }
+    }
+}
+describe("Registry.loadAll", () => {
+    it("discovers teammates with SOUL.md", async () => {
+        await createTeammate("beacon", "# Beacon\n\nPlatform engineer.");
+        await createTeammate("scribe", "# Scribe\n\nDocumentation writer.");
+        const registry = new Registry(tempDir);
+        await registry.loadAll();
+        expect(registry.list().sort()).toEqual(["beacon", "scribe"]);
+    });
+    it("skips directories without SOUL.md", async () => {
+        await createTeammate("beacon", "# Beacon\n\nPlatform engineer.");
+        await mkdir(join(tempDir, "not-a-teammate"), { recursive: true });
+        const registry = new Registry(tempDir);
+        await registry.loadAll();
+        expect(registry.list()).toEqual(["beacon"]);
+    });
+    it("skips dot directories", async () => {
+        await createTeammate("beacon", "# Beacon\n\nPlatform engineer.");
+        await mkdir(join(tempDir, ".hidden"), { recursive: true });
+        await writeFile(join(tempDir, ".hidden", "SOUL.md"), "hidden");
+        const registry = new Registry(tempDir);
+        await registry.loadAll();
+        expect(registry.list()).toEqual(["beacon"]);
+    });
+});
+describe("Registry.loadTeammate", () => {
+    it("loads soul content", async () => {
+        const soul = "# Beacon\n\nBeacon owns the recall package.";
+        await createTeammate("beacon", soul);
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.soul).toBe(soul);
+    });
+    it("loads memories", async () => {
+        await createTeammate("beacon", "# Beacon", {
+            memories: "Important decision made",
+        });
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.memories).toBe("Important decision made");
+    });
+    it("loads daily logs sorted most recent first", async () => {
+        await createTeammate("beacon", "# Beacon", {
+            dailyLogs: [
+                { date: "2026-03-11", content: "Day 1" },
+                { date: "2026-03-13", content: "Day 3" },
+                { date: "2026-03-12", content: "Day 2" },
+            ],
+        });
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.dailyLogs.map((l) => l.date)).toEqual([
+            "2026-03-13",
+            "2026-03-12",
+            "2026-03-11",
+        ]);
+    });
+    it("returns null for missing teammate", async () => {
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("nonexistent");
+        expect(config).toBeNull();
+    });
+    it("returns empty memories when MEMORIES.md is missing", async () => {
+        await createTeammate("beacon", "# Beacon");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.memories).toBe("");
+    });
+    it("returns empty daily logs when memory/ is missing", async () => {
+        await createTeammate("beacon", "# Beacon");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.dailyLogs).toEqual([]);
+    });
+});
+describe("Registry role parsing", () => {
+    it("parses role from ## Identity paragraph", async () => {
+        await createTeammate("beacon", "# Beacon\n\n## Identity\n\nBeacon owns the recall package. It does stuff.");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.role).toBe("Beacon owns the recall package.");
+    });
+    it("parses role from **Persona:** line", async () => {
+        await createTeammate("beacon", "# Beacon\n\n**Persona:** The platform engineer.");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.role).toBe("The platform engineer.");
+    });
+    it("falls back to first non-heading line", async () => {
+        await createTeammate("beacon", "# Beacon\n\nSome role description here.");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.role).toBe("Some role description here.");
+    });
+    it("returns 'teammate' when no role found", async () => {
+        await createTeammate("beacon", "# Beacon\n\n---");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.role).toBe("teammate");
+    });
+});
+describe("Registry ownership parsing", () => {
+    it("parses primary ownership patterns", async () => {
+        const soul = `# Beacon
+
+## Ownership
+
+### Primary
+
+- \`recall/src/**\` — All source files
+- \`recall/package.json\` — Package manifest
+
+### Secondary
+
+- \`.teammates/.index/**\` — Vector indexes
+`;
+        await createTeammate("beacon", soul);
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.ownership.primary).toEqual(["recall/src/**", "recall/package.json"]);
+        expect(config?.ownership.secondary).toEqual([".teammates/.index/**"]);
+    });
+    it("returns empty arrays when no ownership section", async () => {
+        await createTeammate("beacon", "# Beacon\n\nJust a description.");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.ownership.primary).toEqual([]);
+        expect(config?.ownership.secondary).toEqual([]);
+    });
+});
+describe("Registry.register", () => {
+    it("registers a teammate programmatically", () => {
+        const registry = new Registry(tempDir);
+        registry.register({
+            name: "test",
+            role: "Test role.",
+            soul: "# Test",
+            memories: "",
+            dailyLogs: [],
+            ownership: { primary: [], secondary: [] },
+        });
+        expect(registry.list()).toEqual(["test"]);
+        expect(registry.get("test")?.role).toBe("Test role.");
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Core types for @teammates/cli.
+ */
+/** Sandbox level controlling what a teammate can do */
+export type SandboxLevel = "read-only" | "workspace-write" | "danger-full-access";
+/** A teammate's loaded configuration */
+export interface TeammateConfig {
+    /** Teammate name (folder name under .teammates/) */
+    name: string;
+    /** Role description from SOUL.md */
+    role: string;
+    /** Full SOUL.md content */
+    soul: string;
+    /** Full MEMORIES.md content */
+    memories: string;
+    /** Daily log entries (most recent first) */
+    dailyLogs: DailyLog[];
+    /** File ownership patterns from SOUL.md */
+    ownership: OwnershipRules;
+    /** Working directory scope (defaults to repo root) */
+    cwd?: string;
+    /** Sandbox level (defaults to workspace-write) */
+    sandbox?: SandboxLevel;
+}
+export interface DailyLog {
+    date: string;
+    content: string;
+}
+export interface OwnershipRules {
+    primary: string[];
+    secondary: string[];
+}
+/** Structured handoff envelope passed between teammates */
+export interface HandoffEnvelope {
+    from: string;
+    to: string;
+    task: string;
+    changedFiles?: string[];
+    acceptanceCriteria?: string[];
+    openQuestions?: string[];
+    context?: string;
+}
+/** Result from an agent completing a task */
+export interface TaskResult {
+    /** The teammate that executed the task */
+    teammate: string;
+    /** Whether the task completed successfully */
+    success: boolean;
+    /** Summary of what was done */
+    summary: string;
+    /** Files that were changed */
+    changedFiles: string[];
+    /** Optional handoff request to another teammate */
+    handoff?: HandoffEnvelope;
+    /** Raw output from the agent */
+    rawOutput?: string;
+}
+/** Task assignment to a teammate */
+export interface TaskAssignment {
+    /** Target teammate name */
+    teammate: string;
+    /** Task description / prompt */
+    task: string;
+    /** Optional handoff envelope if this came from another teammate */
+    handoff?: HandoffEnvelope;
+    /** Extra context to include in the prompt */
+    extraContext?: string;
+}
+/** Orchestrator event for logging/hooks */
+export type OrchestratorEvent = {
+    type: "task_assigned";
+    assignment: TaskAssignment;
+} | {
+    type: "task_completed";
+    result: TaskResult;
+} | {
+    type: "handoff_initiated";
+    envelope: HandoffEnvelope;
+} | {
+    type: "handoff_completed";
+    envelope: HandoffEnvelope;
+    result: TaskResult;
+} | {
+    type: "error";
+    teammate: string;
+    error: string;
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for @teammates/cli.
+ */
+export {};