@teammates/cli 0.1.0 → 0.2.0

package/dist/onboard.js

@@ -6,8 +6,8 @@
  * target .teammates/ directory before the agent runs, so the agent only needs to
  * analyze the codebase and create teammate-specific folders.
  */
-import { readFile, readdir, copyFile, mkdir, stat } from "node:fs/promises";
-import { resolve, join, dirname } from "node:path";
+import { copyFile, mkdir, readdir, readFile, stat, writeFile, } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
@@ -49,7 +49,9 @@ export async function copyTemplateFiles(teammatesDir) {
                 await copyFile(src, dest);
                 copied.push(file);
             }
-            catch { /* template file missing, skip */ }
+            catch {
+                /* template file missing, skip */
+            }
         }
     }
     // Create .gitignore if it doesn't exist
@@ -78,10 +80,169 @@ export async function copyTemplateFiles(teammatesDir) {
                 copied.push(`example/${file}`);
             }
         }
-        catch { /* template example dir missing, skip */ }
+        catch {
+            /* template example dir missing, skip */
+        }
     }
     return copied;
 }
+/**
+ * Check if a directory entry name is a non-teammate entry.
+ * Directories starting with "." are local/ephemeral (gitignored).
+ * Directories starting with "_" are shared non-teammate folders.
+ * Files (non-directories) and special names are also excluded.
+ */
+const NON_TEAMMATE_NAMES = new Set(["example", "services.json"]);
+function isNonTeammateEntry(name) {
+    return (name.startsWith(".") || name.startsWith("_") || NON_TEAMMATE_NAMES.has(name));
+}
+/**
+ * Detect whether a directory entry is a teammate folder (has SOUL.md).
+ */
+async function isTeammateFolder(dirPath) {
+    try {
+        await stat(join(dirPath, "SOUL.md"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Import teammates from another project's .teammates/ dir.
+ *
+ * Only copies SOUL.md and WISDOM.md per teammate (identity + wisdom carry over).
+ * Creates an empty memory/ dir for each (fresh start — no daily logs or typed memories).
+ * Also copies USER.md if present. Framework files (CROSS-TEAM.md, README.md, etc.)
+ * are project-specific and NOT copied — they get created fresh from the template.
+ *
+ * Skips teammates that already exist in the target (idempotent).
+ * Returns { teammates: string[], files: string[] }.
+ */
+export async function importTeammates(sourceDir, targetDir) {
+    // Validate source exists and looks like a .teammates/ dir
+    try {
+        await stat(sourceDir);
+    }
+    catch {
+        throw new Error(`Source directory not found: ${sourceDir}`);
+    }
+    await mkdir(targetDir, { recursive: true });
+    const teammates = [];
+    const files = [];
+    const entries = await readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(sourceDir, entry.name);
+        const destPath = join(targetDir, entry.name);
+        if (entry.isDirectory() && !isNonTeammateEntry(entry.name)) {
+            // Check if it's a teammate folder
+            if (await isTeammateFolder(srcPath)) {
+                // Skip if teammate already exists in target
+                try {
+                    await stat(destPath);
+                    continue;
+                }
+                catch {
+                    /* doesn't exist, proceed */
+                }
+                // Create teammate dir and copy only SOUL.md + WISDOM.md
+                await mkdir(destPath, { recursive: true });
+                // SOUL.md (required — isTeammateFolder confirmed it exists)
+                await copyFile(join(srcPath, "SOUL.md"), join(destPath, "SOUL.md"));
+                files.push(`${entry.name}/SOUL.md`);
+                // WISDOM.md (optional)
+                try {
+                    await copyFile(join(srcPath, "WISDOM.md"), join(destPath, "WISDOM.md"));
+                    files.push(`${entry.name}/WISDOM.md`);
+                }
+                catch {
+                    /* no WISDOM.md in source, skip */
+                }
+                // Create empty memory/ dir (fresh start)
+                await mkdir(join(destPath, "memory"), { recursive: true });
+                teammates.push(entry.name);
+            }
+        }
+        else if (entry.isFile() && entry.name === "USER.md") {
+            // Only USER.md transfers — framework files (CROSS-TEAM.md, README.md,
+            // PROTOCOL.md, TEMPLATE.md) are project-specific and get created fresh
+            // from the template by copyTemplateFiles().
+            try {
+                await stat(destPath);
+            }
+            catch {
+                await copyFile(srcPath, destPath);
+                files.push(entry.name);
+            }
+        }
+    }
+    // Ensure .gitignore exists
+    const gitignoreDest = join(targetDir, ".gitignore");
+    try {
+        await stat(gitignoreDest);
+    }
+    catch {
+        await writeFile(gitignoreDest, "USER.md\n.index/\n", "utf-8");
+        files.push(".gitignore");
+    }
+    return { teammates, files };
+}
+/**
+ * Build the adaptation prompt for a single imported teammate.
+ * Tells the agent to update ownership patterns, file paths, and boundaries
+ * for the new codebase while preserving identity, principles, and wisdom.
+ *
+ * @param teammatesDir - The .teammates/ directory in the target project
+ * @param teammateName - The name of the teammate to adapt
+ */
+export async function buildAdaptationPrompt(teammatesDir, teammateName) {
+    const teammateDir = join(teammatesDir, teammateName);
+    // Read the teammate's current SOUL.md and WISDOM.md
+    let soulContent = "";
+    let wisdomContent = "";
+    try {
+        soulContent = await readFile(join(teammateDir, "SOUL.md"), "utf-8");
+    }
+    catch {
+        /* missing — agent will create from scratch */
+    }
+    try {
+        wisdomContent = await readFile(join(teammateDir, "WISDOM.md"), "utf-8");
+    }
+    catch {
+        /* missing — that's fine */
+    }
+    const soulSection = soulContent
+        ? `\n\n## Current SOUL.md\n\n\`\`\`markdown\n${soulContent}\n\`\`\``
+        : "\n\n*No SOUL.md found — create one from the template.*";
+    const wisdomSection = wisdomContent
+        ? `\n\n## Current WISDOM.md\n\n\`\`\`markdown\n${wisdomContent}\n\`\`\``
+        : "";
+    return `You are adapting the imported teammate **${teammateName}** to this new codebase.
+
+**Teammate directory:** \`${teammateDir}\`
+
+This teammate was imported from another project. Their SOUL.md and WISDOM.md contain identity, principles, and accumulated wisdom that should be preserved, but their **ownership patterns**, **file paths**, **boundaries**, **capabilities**, and **routing keywords** need to be updated for this codebase.
+${soulSection}${wisdomSection}
+
+## Your job:
+
+1. **Analyze this codebase** — read the project structure, entry points, package manifest, and key files to understand the architecture.
+
+2. **Update ${teammateName}'s SOUL.md**:
+   - **Preserve**: Identity, Core Principles, Ethics, personality, tone
+   - **Update**: Ownership patterns (primary/secondary file globs), Boundaries (reference correct teammate names), Capabilities (commands, file patterns, technologies), Routing keywords, Quality Bar
+   - **Adapt**: Any codebase-specific references (paths, package names, tools)
+
+3. **Update ${teammateName}'s WISDOM.md**:
+   - **Preserve**: Wisdom entries that are universal (principles, patterns, lessons)
+   - **Remove or update**: Entries referencing old project paths, file names, or architecture
+   - **Add**: A creation entry noting this teammate was imported and adapted
+
+4. **Verify** that ownership globs are valid for this codebase.
+
+Present your proposed changes before applying them. Focus only on **${teammateName}** — other teammates will be adapted separately.`;
+}
 /**
  * Load ONBOARDING.md from the project dir, package root, or built-in fallback.
  */
@@ -98,7 +259,9 @@ export async function getOnboardingPrompt(projectDir) {
                 return wrapPrompt(content, projectDir);
             }
         }
-        catch { /* not found, try next */ }
+        catch {
+            /* not found, try next */
+        }
     }
     return wrapPrompt(BUILTIN_ONBOARDING, projectDir);
 }
@@ -110,16 +273,16 @@ function wrapPrompt(onboardingContent, projectDir) {
 **Framework files have already been copied** into \`${projectDir}/.teammates/\` from the template. The following files are already in place:
 - CROSS-TEAM.md — fill in the Ownership Scopes table as you create teammates
 - PROTOCOL.md — team protocol (ready to use)
-- TEMPLATE.md — reference for creating teammate SOUL.md and MEMORIES.md files
+- TEMPLATE.md — reference for creating teammate SOUL.md and WISDOM.md files
 - USER.md — user profile (gitignored, user fills in later)
 - README.md — update with project-specific roster and info
 - .gitignore — configured for USER.md and .index/
-- example/ — example SOUL.md and MEMORIES.md for reference
+- example/ — example SOUL.md and WISDOM.md for reference
 
 **Your job is to:**
 1. Analyze the codebase (Step 1)
 2. Design the team roster (Step 2)
-3. Create teammate folders with SOUL.md and MEMORIES.md (Step 3) — use TEMPLATE.md for the structure
+3. Create teammate folders with SOUL.md and WISDOM.md (Step 3) — use TEMPLATE.md for the structure
 4. Update README.md and CROSS-TEAM.md with the roster info (Step 3)
 5. Verify everything is in place (Step 4)
 
@@ -175,7 +338,7 @@ For each teammate, create \`.teammates/<name>/\` with:
 
 **SOUL.md** — Use the template from \`.teammates/TEMPLATE.md\`. Fill in identity, core principles, boundaries, capabilities, ownership, ethics.
 
-**MEMORIES.md** — Start with one entry recording creation and key decisions.
+**WISDOM.md** — Start with one entry recording creation and key decisions.
 
 **memory/** — Empty directory for daily logs.
 
@@ -186,7 +349,7 @@ For each teammate, create \`.teammates/<name>/\` with:
 ## Step 4: Verify
 
 Check:
-- Every roster teammate has a folder with SOUL.md and MEMORIES.md
+- Every roster teammate has a folder with SOUL.md and WISDOM.md
 - Ownership globs cover the codebase without major gaps
 - Boundaries reference the correct owning teammate
 - CROSS-TEAM.md Ownership Scopes table has one row per teammate with correct paths
@@ -194,6 +357,6 @@ Check:
 
 ## Tips
 - Small projects are fine with 2–3 teammates
-- MEMORIES.md starts light — just one creation entry
+- WISDOM.md starts light — just one creation entry
 - Prompt the user to fill in USER.md after setup
 `;

package/dist/orchestrator.d.ts

@@ -4,9 +4,9 @@
  * Routes tasks to teammates, manages handoff chains,
  * and delegates execution to the plugged-in agent adapter.
  */
-import type { TaskAssignment, TaskResult, HandoffEnvelope, OrchestratorEvent } from "./types.js";
 import type { AgentAdapter } from "./adapter.js";
 import { Registry } from "./registry.js";
+import type { OrchestratorEvent, TaskAssignment, TaskResult } from "./types.js";
 export interface OrchestratorConfig {
     /** Path to .teammates/ directory */
     teammatesDir: string;
@@ -18,21 +18,17 @@ export interface OrchestratorConfig {
     onEvent?: (event: OrchestratorEvent) => void;
 }
 export interface TeammateStatus {
-    state: "idle" | "working" | "pending-handoff";
+    state: "idle" | "working";
     lastSummary?: string;
     lastChangedFiles?: string[];
     lastTimestamp?: Date;
-    pendingHandoff?: HandoffEnvelope;
 }
 export declare class Orchestrator {
     private registry;
     private adapter;
     private sessions;
     private statuses;
-    private maxHandoffDepth;
     private onEvent;
-    /** When true, handoffs require explicit /approve */
-    requireApproval: boolean;
     constructor(config: OrchestratorConfig);
     /** Initialize: load all teammates from disk */
     init(): Promise<void>;
@@ -40,10 +36,6 @@ export declare class Orchestrator {
     getStatus(name: string): TeammateStatus | undefined;
     /** Get all statuses */
     getAllStatuses(): Map<string, TeammateStatus>;
-    /** Get the pending handoff if any teammate has one */
-    getPendingHandoff(): HandoffEnvelope | null;
-    /** Clear a pending handoff (on reject) */
-    clearPendingHandoff(teammate: string): void;
     /** List available teammates */
     listTeammates(): string[];
     /** Get the registry for direct access */
@@ -52,7 +44,7 @@ export declare class Orchestrator {
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.
      */
-    assign(assignment: TaskAssignment, depth?: number, visited?: Set<string>): Promise<TaskResult>;
+    assign(assignment: TaskAssignment): Promise<TaskResult>;
     /**
      * Route a task to the best teammate based on keyword matching.
      * Uses the routing guide from .teammates/README.md ownership patterns.
@@ -63,6 +55,11 @@ export declare class Orchestrator {
      * Used as a fallback when keyword routing doesn't find a strong match.
      */
     agentRoute(task: string): Promise<string | null>;
+    /**
+     * Reload the registry from disk and detect new teammates.
+     * Returns the names of any newly discovered teammates.
+     */
+    refresh(): Promise<string[]>;
     /** Reset all teammate statuses to idle and clear sessions */
     reset(): Promise<void>;
     /** Destroy all sessions */

package/dist/orchestrator.js

@@ -4,21 +4,16 @@
  * Routes tasks to teammates, manages handoff chains,
  * and delegates execution to the plugged-in agent adapter.
  */
-import { formatHandoffContext } from "./adapter.js";
 import { Registry } from "./registry.js";
 export class Orchestrator {
     registry;
     adapter;
-    sessions = new Map(); // teammate -> sessionId
+    sessions = new Map();
     statuses = new Map();
-    maxHandoffDepth;
     onEvent;
-    /** When true, handoffs require explicit /approve */
-    requireApproval = true;
     constructor(config) {
         this.registry = new Registry(config.teammatesDir);
         this.adapter = config.adapter;
-        this.maxHandoffDepth = config.maxHandoffDepth ?? 5;
         this.onEvent = config.onEvent ?? (() => { });
     }
     /** Initialize: load all teammates from disk */
@@ -36,23 +31,6 @@ export class Orchestrator {
     getAllStatuses() {
         return this.statuses;
     }
-    /** Get the pending handoff if any teammate has one */
-    getPendingHandoff() {
-        for (const [, status] of this.statuses) {
-            if (status.state === "pending-handoff" && status.pendingHandoff) {
-                return status.pendingHandoff;
-            }
-        }
-        return null;
-    }
-    /** Clear a pending handoff (on reject) */
-    clearPendingHandoff(teammate) {
-        const status = this.statuses.get(teammate);
-        if (status && status.state === "pending-handoff") {
-            status.state = "idle";
-            status.pendingHandoff = undefined;
-        }
-    }
     /** List available teammates */
     listTeammates() {
         return this.registry.list();
@@ -65,13 +43,9 @@ export class Orchestrator {
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.
      */
-    async assign(assignment, depth = 0, visited) {
-        // Normalize: strip leading @ from teammate names (agents may use @mentions)
+    async assign(assignment) {
+        // Normalize: strip leading @ from teammate names
         assignment.teammate = assignment.teammate.replace(/^@/, "");
-        if (assignment.handoff) {
-            assignment.handoff.to = assignment.handoff.to.replace(/^@/, "");
-            assignment.handoff.from = assignment.handoff.from.replace(/^@/, "");
-        }
         const teammate = this.registry.get(assignment.teammate);
         if (!teammate) {
             const error = `Unknown teammate: ${assignment.teammate}`;
@@ -81,24 +55,10 @@ export class Orchestrator {
                 success: false,
                 summary: error,
                 changedFiles: [],
+                handoffs: [],
             };
         }
-        // ── Handoff cycle detection ──────────────────────────────────
-        const chain = visited ?? new Set();
-        if (chain.has(assignment.teammate)) {
-            const cycle = [...chain, assignment.teammate].join(" → ");
-            const error = `Handoff cycle detected: ${cycle}`;
-            this.onEvent({ type: "error", teammate: assignment.teammate, error });
-            return {
-                teammate: assignment.teammate,
-                success: false,
-                summary: error,
-                changedFiles: [],
-            };
-        }
-        chain.add(assignment.teammate);
         this.onEvent({ type: "task_assigned", assignment });
-        // Update status
         this.statuses.set(assignment.teammate, { state: "working" });
         // Get or create session
         let sessionId = this.sessions.get(assignment.teammate);
@@ -106,51 +66,21 @@ export class Orchestrator {
             sessionId = await this.adapter.startSession(teammate);
             this.sessions.set(assignment.teammate, sessionId);
         }
-        // Build prompt with handoff context if present
+        // Build prompt
         let prompt = assignment.task;
-        if (assignment.handoff) {
-            const handoffCtx = formatHandoffContext(assignment.handoff);
-            prompt = `${handoffCtx}\n\n---\n\n${prompt}`;
-        }
         if (assignment.extraContext) {
             prompt = `${assignment.extraContext}\n\n---\n\n${prompt}`;
         }
         // Execute
         const result = await this.adapter.executeTask(sessionId, teammate, prompt);
         this.onEvent({ type: "task_completed", result });
-        // Update status with result
-        const newStatus = {
+        // Update status
+        this.statuses.set(assignment.teammate, {
             state: "idle",
             lastSummary: result.summary,
             lastChangedFiles: result.changedFiles,
             lastTimestamp: new Date(),
-        };
-        // Handle handoff
-        if (result.handoff && depth < this.maxHandoffDepth) {
-            this.onEvent({ type: "handoff_initiated", envelope: result.handoff });
-            if (this.requireApproval) {
-                // Park the handoff — user must /approve
-                newStatus.state = "pending-handoff";
-                newStatus.pendingHandoff = result.handoff;
-                this.statuses.set(assignment.teammate, newStatus);
-                return result;
-            }
-            // Auto-follow handoff
-            this.statuses.set(assignment.teammate, newStatus);
-            const nextAssignment = {
-                teammate: result.handoff.to,
-                task: result.handoff.task,
-                handoff: result.handoff,
-            };
-            const handoffResult = await this.assign(nextAssignment, depth + 1, chain);
-            this.onEvent({
-                type: "handoff_completed",
-                envelope: result.handoff,
-                result: handoffResult,
-            });
-            return handoffResult;
-        }
-        this.statuses.set(assignment.teammate, newStatus);
+        });
         return result;
     }
     /**
@@ -163,6 +93,12 @@ export class Orchestrator {
         let bestScore = 0;
         for (const [name, config] of this.registry.all()) {
             let score = 0;
+            // Check explicit routing keywords (highest priority, same weight as primary)
+            for (const kw of config.routingKeywords) {
+                if (taskLower.includes(kw.toLowerCase())) {
+                    score += 2;
+                }
+            }
             // Check ownership patterns against task text
             for (const pattern of [
                 ...config.ownership.primary,
@@ -170,7 +106,7 @@ export class Orchestrator {
             ]) {
                 // Extract meaningful keywords from glob patterns
                 const keywords = pattern
-                    .replace(/[*\/{}]/g, " ")
+                    .replace(/[*/{}]/g, " ")
                     .split(/\s+/)
                     .filter((w) => w.length > 2);
                 for (const kw of keywords) {
@@ -216,9 +152,25 @@ export class Orchestrator {
         });
         return this.adapter.routeTask(task, roster);
     }
+    /**
+     * Reload the registry from disk and detect new teammates.
+     * Returns the names of any newly discovered teammates.
+     */
+    async refresh() {
+        const before = new Set(this.registry.list());
+        await this.registry.loadAll();
+        const added = [];
+        for (const name of this.registry.list()) {
+            if (!before.has(name)) {
+                this.statuses.set(name, { state: "idle" });
+                added.push(name);
+            }
+        }
+        return added;
+    }
     /** Reset all teammate statuses to idle and clear sessions */
     async reset() {
-        for (const [name, sessionId] of this.sessions) {
+        for (const [_name, sessionId] of this.sessions) {
             if (this.adapter.destroySession) {
                 await this.adapter.destroySession(sessionId);
             }
@@ -230,7 +182,7 @@ export class Orchestrator {
     }
     /** Destroy all sessions */
     async shutdown() {
-        for (const [name, sessionId] of this.sessions) {
+        for (const [_name, sessionId] of this.sessions) {
             if (this.adapter.destroySession) {
                 await this.adapter.destroySession(sessionId);
             }