@teammates/cli 0.1.0 → 0.2.0

package/dist/orchestrator.test.js

@@ -1,13 +1,15 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { Orchestrator } from "./orchestrator.js";
 function makeTeammate(name, role = "Test role.", primary = []) {
     return {
         name,
         role,
         soul: `# ${name}\n\n${role}`,
-        memories: "",
+        wisdom: "",
         dailyLogs: [],
+        weeklyLogs: [],
         ownership: { primary, secondary: [] },
+        routingKeywords: [],
     };
 }
 function makeMockAdapter(results) {
@@ -23,6 +25,7 @@ function makeMockAdapter(results) {
                 success: true,
                 summary: `${t.name} completed task`,
                 changedFiles: [],
+                handoffs: [],
             };
         }),
         destroySession: vi.fn(async () => { }),
@@ -49,7 +52,10 @@ function createOrchestrator(teammates, adapter, onEvent) {
 describe("Orchestrator.route", () => {
     it("routes based on ownership keywords", () => {
         const { orch } = createOrchestrator([
-            makeTeammate("beacon", "Platform engineer.", ["recall/src/**", "cli/src/**"]),
+            makeTeammate("beacon", "Platform engineer.", [
+                "recall/src/**",
+                "cli/src/**",
+            ]),
             makeTeammate("scribe", "Documentation writer.", ["docs/**", "README.md"]),
         ]);
         expect(orch.route("fix the recall search")).toBe("beacon");
@@ -77,6 +83,23 @@ describe("Orchestrator.route", () => {
         // "write documentation" matches role word "documentation" (1pt) + ownership keyword "docs" (2pt)
         expect(orch.route("write docs and documentation")).toBe("scribe");
     });
+    it("routes based on explicit routing keywords", () => {
+        const t1 = makeTeammate("beacon", "Platform engineer.");
+        t1.routingKeywords = ["search", "embeddings", "vector"];
+        const t2 = makeTeammate("scribe", "Documentation writer.");
+        t2.routingKeywords = ["template", "onboarding"];
+        const { orch } = createOrchestrator([t1, t2]);
+        expect(orch.route("fix the search feature")).toBe("beacon");
+        expect(orch.route("update the onboarding flow")).toBe("scribe");
+    });
+    it("routing keywords beat role-only matches", () => {
+        const t1 = makeTeammate("beacon", "Platform engineer.");
+        t1.routingKeywords = ["search"];
+        const t2 = makeTeammate("finder", "Search specialist.");
+        const { orch } = createOrchestrator([t1, t2]);
+        // "search" matches beacon's routing keyword (2pt) and finder's role (1pt)
+        expect(orch.route("improve search results")).toBe("beacon");
+    });
     it("returns null for weak matches (score < 2)", () => {
         const { orch } = createOrchestrator([
             makeTeammate("beacon", "Platform engineer."),
@@ -124,7 +147,10 @@ describe("Orchestrator.assign", () => {
         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"]);
+        expect(events.map((e) => e.type)).toEqual([
+            "task_assigned",
+            "task_completed",
+        ]);
     });
     it("reuses existing session", async () => {
         const adapter = makeMockAdapter();
@@ -136,92 +162,22 @@ describe("Orchestrator.assign", () => {
     });
 });
 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 () => {
+    it("returns handoffs in the result for CLI to handle", 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" },
+            handoffs: [{ 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" });
-        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(result.handoffs).toHaveLength(1);
+        expect(result.handoffs[0].to).toBe("scribe");
+        // Orchestrator doesn't auto-follow — status goes to idle
         expect(orch.getStatus("beacon")?.state).toBe("idle");
-        expect(orch.getStatus("beacon")?.pendingHandoff).toBeUndefined();
     });
 });
 describe("Orchestrator.reset", () => {
@@ -243,3 +199,27 @@ describe("Orchestrator.shutdown", () => {
         expect(adapter.destroySession).toHaveBeenCalled();
     });
 });
+describe("Orchestrator.refresh", () => {
+    it("detects new teammates added to registry after init", async () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        expect(orch.listTeammates()).toEqual(["beacon"]);
+        // Mock loadAll to simulate a new teammate appearing on disk
+        const registry = orch.getRegistry();
+        vi.spyOn(registry, "loadAll").mockImplementation(async () => {
+            registry.register(makeTeammate("pipeline", "DevOps engineer."));
+            return registry.all();
+        });
+        const added = await orch.refresh();
+        expect(added).toEqual(["pipeline"]);
+        expect(orch.listTeammates()).toContain("pipeline");
+        expect(orch.getStatus("pipeline")?.state).toBe("idle");
+    });
+    it("returns empty array when no new teammates", async () => {
+        const { orch } = createOrchestrator([makeTeammate("beacon")]);
+        // Mock loadAll to return existing teammates only
+        const registry = orch.getRegistry();
+        vi.spyOn(registry, "loadAll").mockImplementation(async () => registry.all());
+        const added = await orch.refresh();
+        expect(added).toEqual([]);
+    });
+});

package/dist/registry.d.ts

@@ -2,7 +2,7 @@
  * Teammate registry.
  *
  * Discovers teammates from .teammates/ and loads their configs
- * (SOUL.md, MEMORIES.md, daily logs, ownership rules).
+ * (SOUL.md, WISDOM.md, daily logs, ownership rules).
  */
 import type { TeammateConfig } from "./types.js";
 export declare class Registry {

package/dist/registry.js

@@ -2,10 +2,10 @@
  * Teammate registry.
  *
  * Discovers teammates from .teammates/ and loads their configs
- * (SOUL.md, MEMORIES.md, daily logs, ownership rules).
+ * (SOUL.md, WISDOM.md, daily logs, ownership rules).
  */
 import { readdir, readFile, stat } from "node:fs/promises";
-import { join, basename } from "node:path";
+import { basename, join } from "node:path";
 export class Registry {
     teammatesDir;
     teammates = new Map();
@@ -15,7 +15,7 @@ export class Registry {
     /** 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("."));
+        const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
         for (const dir of dirs) {
             const config = await this.loadTeammate(dir.name);
             if (config) {
@@ -35,17 +35,21 @@ export class Registry {
             return null; // Not a teammate folder
         }
         const soul = await readFile(soulPath, "utf-8");
-        const memories = await readFileSafe(join(dir, "MEMORIES.md"));
+        const wisdom = await readFileSafe(join(dir, "WISDOM.md"));
         const dailyLogs = await loadDailyLogs(join(dir, "memory"));
+        const weeklyLogs = await loadWeeklyLogs(join(dir, "memory"));
         const ownership = parseOwnership(soul);
         const role = parseRole(soul);
+        const routingKeywords = parseRoutingKeywords(soul);
         const config = {
             name,
             role,
             soul,
-            memories,
+            wisdom,
             dailyLogs,
+            weeklyLogs,
             ownership,
+            routingKeywords,
         };
         this.teammates.set(name, config);
         return config;
@@ -82,11 +86,14 @@ async function loadDailyLogs(memoryDir) {
         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 });
-            }
+            if (!entry.endsWith(".md"))
+                continue;
+            const stem = basename(entry, ".md");
+            // Only include daily logs (YYYY-MM-DD format), skip typed memory files
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(stem))
+                continue;
+            const content = await readFile(join(memoryDir, entry), "utf-8");
+            logs.push({ date: stem, content });
         }
         // Most recent first
         logs.sort((a, b) => b.date.localeCompare(a.date));
@@ -96,6 +103,30 @@ async function loadDailyLogs(memoryDir) {
         return [];
     }
 }
+/** Load weekly summaries from memory/weekly/ directory, most recent first */
+async function loadWeeklyLogs(memoryDir) {
+    const weeklyDir = join(memoryDir, "weekly");
+    try {
+        const entries = await readdir(weeklyDir);
+        const logs = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".md"))
+                continue;
+            const stem = basename(entry, ".md");
+            // Match YYYY-Wnn format
+            if (!/^\d{4}-W\d{2}$/.test(stem))
+                continue;
+            const content = await readFile(join(weeklyDir, entry), "utf-8");
+            logs.push({ week: stem, content });
+        }
+        // Most recent first
+        logs.sort((a, b) => b.week.localeCompare(a.week));
+        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"
@@ -107,7 +138,7 @@ function parseRole(soul) {
     if (identityMatch) {
         // Return just the first sentence
         const firstSentence = identityMatch[1].split(/\.\s/)[0];
-        return firstSentence.endsWith(".") ? firstSentence : firstSentence + ".";
+        return firstSentence.endsWith(".") ? firstSentence : `${firstSentence}.`;
     }
     // Fallback: first non-heading, non-empty line
     const lines = soul.split("\n");
@@ -115,7 +146,7 @@ function parseRole(soul) {
         const trimmed = line.trim();
         if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("---")) {
             const firstSentence = trimmed.split(/\.\s/)[0];
-            return firstSentence.endsWith(".") ? firstSentence : firstSentence + ".";
+            return firstSentence.endsWith(".") ? firstSentence : `${firstSentence}.`;
         }
     }
     return "teammate";
@@ -133,6 +164,19 @@ function parseOwnership(soul) {
     }
     return rules;
 }
+/**
+ * Parse explicit routing keywords from a ### Routing section in SOUL.md.
+ * Keywords are backtick-wrapped, comma-separated. Example:
+ *
+ *   ### Routing
+ *   - `search`, `embeddings`, `vector`, `semantic`
+ */
+function parseRoutingKeywords(soul) {
+    const routingMatch = soul.match(/### Routing[\s\S]*?(?=###|## |$)/);
+    if (!routingMatch)
+        return [];
+    return extractPatterns(routingMatch[0]);
+}
 /** Extract file patterns (backtick-wrapped) from a markdown section */
 function extractPatterns(section) {
     const patterns = [];

package/dist/registry.test.js

@@ -1,8 +1,8 @@
-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 { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { Registry } from "./registry.js";
 let tempDir;
 beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), "teammates-test-"));
@@ -14,8 +14,8 @@ 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?.wisdom) {
+        await writeFile(join(dir, "WISDOM.md"), options.wisdom);
     }
     if (options?.dailyLogs) {
         const memDir = join(dir, "memory");
@@ -48,6 +48,14 @@ describe("Registry.loadAll", () => {
         await registry.loadAll();
         expect(registry.list()).toEqual(["beacon"]);
     });
+    it("skips underscore-prefixed directories", async () => {
+        await createTeammate("beacon", "# Beacon\n\nPlatform engineer.");
+        await mkdir(join(tempDir, "_standups"), { recursive: true });
+        await mkdir(join(tempDir, "_tasks"), { recursive: true });
+        const registry = new Registry(tempDir);
+        await registry.loadAll();
+        expect(registry.list()).toEqual(["beacon"]);
+    });
 });
 describe("Registry.loadTeammate", () => {
     it("loads soul content", async () => {
@@ -57,13 +65,13 @@ describe("Registry.loadTeammate", () => {
         const config = await registry.loadTeammate("beacon");
         expect(config?.soul).toBe(soul);
     });
-    it("loads memories", async () => {
+    it("loads wisdom", async () => {
         await createTeammate("beacon", "# Beacon", {
-            memories: "Important decision made",
+            wisdom: "Important decision made",
         });
         const registry = new Registry(tempDir);
         const config = await registry.loadTeammate("beacon");
-        expect(config?.memories).toBe("Important decision made");
+        expect(config?.wisdom).toBe("Important decision made");
     });
     it("loads daily logs sorted most recent first", async () => {
         await createTeammate("beacon", "# Beacon", {
@@ -86,11 +94,11 @@ describe("Registry.loadTeammate", () => {
         const config = await registry.loadTeammate("nonexistent");
         expect(config).toBeNull();
     });
-    it("returns empty memories when MEMORIES.md is missing", async () => {
+    it("returns empty wisdom when WISDOM.md is missing", async () => {
         await createTeammate("beacon", "# Beacon");
         const registry = new Registry(tempDir);
         const config = await registry.loadTeammate("beacon");
-        expect(config?.memories).toBe("");
+        expect(config?.wisdom).toBe("");
     });
     it("returns empty daily logs when memory/ is missing", async () => {
         await createTeammate("beacon", "# Beacon");
@@ -143,7 +151,10 @@ describe("Registry ownership parsing", () => {
         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.primary).toEqual([
+            "recall/src/**",
+            "recall/package.json",
+        ]);
         expect(config?.ownership.secondary).toEqual([".teammates/.index/**"]);
     });
     it("returns empty arrays when no ownership section", async () => {
@@ -154,6 +165,37 @@ describe("Registry ownership parsing", () => {
         expect(config?.ownership.secondary).toEqual([]);
     });
 });
+describe("Registry routing keyword parsing", () => {
+    it("parses routing keywords from ### Routing section", async () => {
+        const soul = `# Beacon
+
+## Ownership
+
+### Primary
+
+- \`recall/src/**\` — All source files
+
+### Routing
+
+- \`search\`, \`embeddings\`, \`vector\`, \`semantic\`
+`;
+        await createTeammate("beacon", soul);
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.routingKeywords).toEqual([
+            "search",
+            "embeddings",
+            "vector",
+            "semantic",
+        ]);
+    });
+    it("returns empty array when no ### Routing section", async () => {
+        await createTeammate("beacon", "# Beacon\n\nJust a description.");
+        const registry = new Registry(tempDir);
+        const config = await registry.loadTeammate("beacon");
+        expect(config?.routingKeywords).toEqual([]);
+    });
+});
 describe("Registry.register", () => {
     it("registers a teammate programmatically", () => {
         const registry = new Registry(tempDir);
@@ -161,9 +203,11 @@ describe("Registry.register", () => {
             name: "test",
             role: "Test role.",
             soul: "# Test",
-            memories: "",
+            wisdom: "",
             dailyLogs: [],
+            weeklyLogs: [],
             ownership: { primary: [], secondary: [] },
+            routingKeywords: [],
         });
         expect(registry.list()).toEqual(["test"]);
         expect(registry.get("test")?.role).toBe("Test role.");

package/dist/theme.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Theme — centralized color palette for the teammates CLI.
+ *
+ * All semantic colors used throughout the UI are defined here.
+ * The default palette is derived from the base accent #3A96DD.
+ *
+ * To change the look of the entire CLI, modify the values in
+ * DEFAULT_THEME below. Run `/theme` inside a session to preview
+ * all variables with live examples.
+ */
+import { type Color } from "@teammates/consolonia";
+export interface Theme {
+    /** Primary accent — used for the logo, commands, teammate names. */
+    accent: Color;
+    /** Brighter accent — used for highlights, selected items. */
+    accentBright: Color;
+    /** Dimmed accent — used for borders, subtle accents. */
+    accentDim: Color;
+    /** Primary text — most readable foreground. */
+    text: Color;
+    /** Secondary / muted text — descriptions, metadata. */
+    textMuted: Color;
+    /** Dimmed text — separators, subtle UI chrome. */
+    textDim: Color;
+    /** Success — checkmarks, "installed", completed tasks. */
+    success: Color;
+    /** Warning — pending items, caution indicators. */
+    warning: Color;
+    /** Error — failures, error messages. */
+    error: Color;
+    /** Info — progress messages, working state. */
+    info: Color;
+    /** Prompt symbol color. */
+    prompt: Color;
+    /** User input text. */
+    input: Color;
+    /** Cursor foreground. */
+    cursorFg: Color;
+    /** Cursor background. */
+    cursorBg: Color;
+    /** Separator lines between sections. */
+    separator: Color;
+    /** Progress/status messages. */
+    progress: Color;
+    /** Dropdown: normal items. */
+    dropdown: Color;
+    /** Dropdown: highlighted/selected item. */
+    dropdownHighlight: Color;
+}
+export declare const DEFAULT_THEME: Theme;
+/** Get the current active theme. */
+export declare function theme(): Theme;
+/** Replace the active theme. */
+export declare function setTheme(t: Theme): void;
+/** Format a Color as a hex string for display. */
+export declare function colorToHex(c: Color): string;

package/dist/theme.js

@@ -0,0 +1,54 @@
+/**
+ * Theme — centralized color palette for the teammates CLI.
+ *
+ * All semantic colors used throughout the UI are defined here.
+ * The default palette is derived from the base accent #3A96DD.
+ *
+ * To change the look of the entire CLI, modify the values in
+ * DEFAULT_THEME below. Run `/theme` inside a session to preview
+ * all variables with live examples.
+ */
+import { color } from "@teammates/consolonia";
+// ── Default theme (based on #3A96DD) ─────────────────────────────
+export const DEFAULT_THEME = {
+    // Brand / accent — derived from #3A96DD
+    accent: color(58, 150, 221), // #3A96DD — the base blue
+    accentBright: color(85, 187, 255), // #55BBFF — lighter for highlights
+    accentDim: color(40, 100, 150), // #286496 — muted for borders
+    // Foreground
+    text: color(230, 230, 230), // #E6E6E6 — near-white primary text
+    textMuted: color(150, 150, 150), // #969696 — gray for descriptions
+    textDim: color(100, 100, 100), // #646464 — dim for separators
+    // Status
+    success: color(80, 200, 120), // #50C878 — green
+    warning: color(230, 180, 50), // #E6B432 — amber
+    error: color(230, 70, 70), // #E64646 — red
+    info: color(58, 150, 221), // #3A96DD — same as accent
+    // Interactive
+    prompt: color(150, 150, 150), // #969696 — gray prompt
+    input: color(230, 230, 230), // #E6E6E6 — near-white
+    cursorFg: color(0, 0, 0), // #000000 — black on light cursor
+    cursorBg: color(230, 230, 230), // #E6E6E6 — light block cursor
+    separator: color(100, 100, 100), // #646464 — dim rule lines
+    progress: color(58, 150, 221), // #3A96DD — blue italic
+    dropdown: color(58, 150, 221), // #3A96DD — accent for items
+    dropdownHighlight: color(85, 187, 255), // #55BBFF — bright for selected
+};
+// ── Active theme (mutable singleton) ─────────────────────────────
+let _active = { ...DEFAULT_THEME };
+/** Get the current active theme. */
+export function theme() {
+    return _active;
+}
+/** Replace the active theme. */
+export function setTheme(t) {
+    _active = { ...t };
+}
+// ── Helpers ──────────────────────────────────────────────────────
+/** Format a Color as a hex string for display. */
+export function colorToHex(c) {
+    const r = c.r.toString(16).padStart(2, "0");
+    const g = c.g.toString(16).padStart(2, "0");
+    const b = c.b.toString(16).padStart(2, "0");
+    return `#${r}${g}${b}`.toUpperCase();
+}

package/dist/types.d.ts

@@ -11,12 +11,16 @@ export interface TeammateConfig {
     role: string;
     /** Full SOUL.md content */
     soul: string;
-    /** Full MEMORIES.md content */
-    memories: string;
+    /** Full WISDOM.md content */
+    wisdom: string;
     /** Daily log entries (most recent first) */
     dailyLogs: DailyLog[];
+    /** Weekly summary entries (most recent first) */
+    weeklyLogs: WeeklyLog[];
     /** File ownership patterns from SOUL.md */
     ownership: OwnershipRules;
+    /** Explicit routing keywords from SOUL.md ### Routing section */
+    routingKeywords: string[];
     /** Working directory scope (defaults to repo root) */
     cwd?: string;
     /** Sandbox level (defaults to workspace-write) */
@@ -26,6 +30,16 @@ export interface DailyLog {
     date: string;
     content: string;
 }
+export interface WeeklyLog {
+    /** ISO week string, e.g. "2026-W11" */
+    week: string;
+    content: string;
+}
+export interface MonthlyLog {
+    /** Month string, e.g. "2026-03" */
+    month: string;
+    content: string;
+}
 export interface OwnershipRules {
     primary: string[];
     secondary: string[];
@@ -50,8 +64,8 @@ export interface TaskResult {
     summary: string;
     /** Files that were changed */
     changedFiles: string[];
-    /** Optional handoff request to another teammate */
-    handoff?: HandoffEnvelope;
+    /** Handoff requests to other teammates */
+    handoffs: HandoffEnvelope[];
     /** Raw output from the agent */
     rawOutput?: string;
 }
@@ -61,8 +75,6 @@ export interface TaskAssignment {
     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;
 }
@@ -73,13 +85,6 @@ export type OrchestratorEvent = {
 } | {
     type: "task_completed";
     result: TaskResult;
-} | {
-    type: "handoff_initiated";
-    envelope: HandoffEnvelope;
-} | {
-    type: "handoff_completed";
-    envelope: HandoffEnvelope;
-    result: TaskResult;
 } | {
     type: "error";
     teammate: string;