@teammates/cli 0.5.3 → 0.6.0

package/dist/adapter.d.ts

@@ -29,6 +29,12 @@ export interface AgentAdapter {
     resumeSession?(teammate: TeammateConfig, sessionId: string): Promise<string>;
     /** Get the session file path for a teammate (if session is active). */
     getSessionFile?(teammateName: string): string | undefined;
+    /**
+     * Kill a running agent and return its partial output.
+     * Used by the interrupt-and-resume system to capture in-progress work.
+     * Returns null if no agent is running for this teammate.
+     */
+    killAgent?(teammate: string): Promise<import("./adapters/cli-proxy.js").SpawnResult | null>;
     /** Clean up a session. */
     destroySession?(sessionId: string): Promise<void>;
     /**
@@ -82,7 +88,7 @@ export declare function syncRecallIndex(teammatesDir: string, teammate?: string)
  * - Last recall entry can push total up to budget + RECALL_OVERFLOW (4k grace)
  * - Weekly summaries are excluded (already indexed by recall)
  */
-export declare const DAILY_LOG_BUDGET_TOKENS = 24000;
+export declare const DAILY_LOG_BUDGET_TOKENS = 12000;
 /**
  * Build the full prompt for a teammate session.
  * Includes identity, memory, roster, output protocol, and the task.

package/dist/adapter.js

@@ -67,7 +67,7 @@ const CHARS_PER_TOKEN = 4;
  * - Last recall entry can push total up to budget + RECALL_OVERFLOW (4k grace)
  * - Weekly summaries are excluded (already indexed by recall)
  */
-export const DAILY_LOG_BUDGET_TOKENS = 24_000;
+export const DAILY_LOG_BUDGET_TOKENS = 12_000;
 const RECALL_MIN_BUDGET_TOKENS = 8_000;
 const RECALL_OVERFLOW_TOKENS = 4_000;
 /** Estimate tokens from character count. */
@@ -171,7 +171,14 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     // ── Task-adjacent context (close to task for maximum relevance) ───
     // <RECALL_RESULTS> — budget-allocated, adjacent to task
     const recallBudget = Math.max(RECALL_MIN_BUDGET_TOKENS, RECALL_MIN_BUDGET_TOKENS + dailyBudget);
-    const recallResults = options?.recallResults ?? [];
+    // Filter recall results that duplicate daily log content already in the prompt
+    const dailyLogDates = new Set(teammate.dailyLogs.slice(0, 7).map((log) => log.date));
+    const recallResults = (options?.recallResults ?? []).filter((r) => {
+        const dailyMatch = r.uri.match(/memory\/(\d{4}-\d{2}-\d{2})\.md/);
+        if (dailyMatch && dailyLogDates.has(dailyMatch[1]))
+            return false;
+        return true;
+    });
     if (recallResults.length > 0) {
         const lines = [
             "<RECALL_RESULTS>",
@@ -207,6 +214,8 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     const instrLines = [
         "<INSTRUCTIONS>",
         "",
+        "**Your FIRST priority is answering the user's request in `<TASK>`. Session updates, memory writes, and continuity housekeeping are SECONDARY — do them AFTER producing your text response, not before.**",
+        "",
         "### Output Protocol (CRITICAL)",
         "",
         "**Your #1 job is to produce a visible text response.** Session updates and memory writes are secondary — they support continuity but are not the deliverable. The user sees ONLY your text output. If you update files but return no text, the user sees an empty message and your work is invisible.",
@@ -246,6 +255,10 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     if (options?.sessionFile) {
         instrLines.push("", "### Session State", "", `Your session file is at: \`${options.sessionFile}\``, "", "**After completing the task**, append a brief entry to this file with:", "- What you did", "- Key decisions made", "- Files changed", "- Anything the next task should know", "", "This is how you maintain continuity across tasks. Always read it, always update it.");
     }
+    // Cross-folder write boundary (AI teammates only)
+    if (teammate.type === "ai") {
+        instrLines.push("", "### Folder Boundaries (ENFORCED)", "", `**You MUST NOT create, edit, or delete files inside another teammate's folder (\`.teammates/<other>/\`).** Your folder is \`.teammates/${teammate.name}/\` — you may only write inside it. Shared folders (\`.teammates/_*/\`) and ephemeral folders (\`.teammates/.*/\`) are also writable.`, "", "If your task requires changes to another teammate's files, you MUST hand off that work using the handoff block format above. Violation of this rule will cause your changes to be flagged and potentially reverted.");
+    }
     // Memory updates
     instrLines.push("", "### Memory Updates", "", "**After completing the task**, update your memory files:", "", `1. **Daily log** — Read \`.teammates/${teammate.name}/memory/${today}.md\` first (it may have entries from earlier tasks today), then write it back with your entry added. Create the file if it doesn't exist.`, "   - What you did", "   - Key decisions made", "   - Files changed", "   - Anything the next task should know", "", `2. **Typed memories** — If you learned something durable (a decision, pattern, feedback, or reference), create a typed memory file at \`.teammates/${teammate.name}/memory/<type>_<topic>.md\` with frontmatter (\`name\`, \`description\`, \`type\`). Update existing memory files if the topic already has one.`, "", "3. **WISDOM.md** — Do not edit directly. Wisdom entries are distilled from typed memories during compaction.", "", "These files are your persistent memory. Without them, your next session starts from scratch.");
     // Section Reinforcement — back-references from high-attention bottom edge to each section tag
@@ -273,7 +286,19 @@ export function buildTeammatePrompt(teammate, taskPrompt, options) {
     if (options?.handoffContext) {
         instrLines.push("- When `<HANDOFF_CONTEXT>` is present, address its requirements and open questions directly.");
     }
-    instrLines.push("- Your response must answer `<TASK>` — everything else is supporting context.", "", "**REMINDER: You MUST end your turn with visible text output. A turn with only file edits and no text is a failed turn.**");
+    instrLines.push("- Your response must answer `<TASK>` — everything else is supporting context.");
+    // Echo the user's actual request at the bottom edge for maximum attention.
+    // The orchestrator prepends conversation history before a "---" separator,
+    // so the user's raw message is the last segment after splitting on "---".
+    const segments = taskPrompt.split(/\n\n---\n\n/);
+    const userRequest = segments[segments.length - 1].trim();
+    if (userRequest.length > 0 && userRequest.length < 500) {
+        instrLines.push("", `**THE USER'S REQUEST:** ${userRequest}`);
+    }
+    else if (userRequest.length >= 500) {
+        instrLines.push("", "**IMPORTANT: The user's actual request is at the end of `<TASK>`. Read and address it before doing anything else.**");
+    }
+    instrLines.push("", "**REMINDER: You MUST end your turn with visible text output. A turn with only file edits and no text is a failed turn.**");
     parts.push(instrLines.join("\n"));
     return parts.join("\n");
 }

package/dist/adapter.test.js

@@ -101,27 +101,24 @@ describe("buildTeammatePrompt", () => {
         expect(prompt).toContain("### Session State");
         expect(prompt).toContain("/tmp/beacon-session.md");
     });
-    it("drops daily logs that exceed the 24k daily budget", () => {
-        // Each log is ~50k chars = ~12.5k tokens. Only 1 fits in 24k daily budget.
+    it("drops daily logs that exceed the 12k daily budget", () => {
+        // Each log is ~50k chars = ~12.5k tokens. First one exceeds 12k budget, dropped.
         const bigContent = "D".repeat(50_000);
         const config = makeConfig({
             dailyLogs: [
                 { date: "2026-03-18", content: "Today's log — never trimmed" },
-                { date: "2026-03-17", content: bigContent }, // day 2 — fits in 24k
-                { date: "2026-03-16", content: bigContent }, // day 3 — exceeds 24k, dropped
+                { date: "2026-03-17", content: bigContent }, // day 2 — exceeds 12k, dropped
             ],
         });
         const prompt = buildTeammatePrompt(config, "task");
         // Today's log is always fully present (never trimmed)
         expect(prompt).toContain("Today's log — never trimmed");
-        // Day 2 fits within 24k
-        expect(prompt).toContain("2026-03-17");
-        // Day 3 doesn't fit (12.5k + 12.5k > 24k)
-        expect(prompt).not.toContain("2026-03-16");
+        // Day 2 doesn't fit (12.5k > 12k)
+        expect(prompt).not.toContain("2026-03-17");
     });
-    it("recall gets at least 8k tokens even when daily logs use full 24k", () => {
-        // Daily logs fill their 24k budget. Recall still gets its guaranteed 8k minimum.
-        const dailyContent = "D".repeat(90_000); // ~22.5k tokens — fits in 24k
+    it("recall gets at least 8k tokens even when daily logs use full 12k", () => {
+        // Daily logs fill their 12k budget. Recall still gets its guaranteed 8k minimum.
+        const dailyContent = "D".repeat(40_000); // ~10k tokens — fits in 12k
         const config = makeConfig({
             dailyLogs: [
                 { date: "2026-03-18", content: "today" },
@@ -144,7 +141,7 @@ describe("buildTeammatePrompt", () => {
         expect(prompt).toContain("<RECALL_RESULTS>");
     });
     it("recall gets unused daily log budget", () => {
-        // Small daily logs leave most of 24k unused — recall gets the surplus.
+        // Small daily logs leave most of 12k unused — recall gets the surplus.
         const config = makeConfig({
             dailyLogs: [
                 { date: "2026-03-18", content: "today" },
@@ -152,7 +149,7 @@ describe("buildTeammatePrompt", () => {
             ],
         });
         // Large recall result — should fit because daily logs barely used any budget
-        const recallText = "R".repeat(80_000); // ~20k tokens — fits in (8k + ~24k unused)
+        const recallText = "R".repeat(80_000); // ~20k tokens — fits in (8k + ~12k unused)
         const prompt = buildTeammatePrompt(config, "task", {
             recallResults: [
                 {

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

@@ -86,6 +86,8 @@ export declare class CliProxyAdapter implements AgentAdapter {
     private sessionsDir;
     /** Temp prompt files that need cleanup — guards against crashes before finally. */
     private pendingTempFiles;
+    /** Active child processes per teammate — used by killAgent() for interruption. */
+    private activeProcesses;
     constructor(options: CliProxyOptions);
     startSession(teammate: TeammateConfig): Promise<string>;
     executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string, options?: {
@@ -93,6 +95,7 @@ export declare class CliProxyAdapter implements AgentAdapter {
     }): Promise<TaskResult>;
     routeTask(task: string, roster: RosterEntry[]): Promise<string | null>;
     getSessionFile(teammateName: string): string | undefined;
+    killAgent(teammate: string): Promise<SpawnResult | null>;
     destroySession(_sessionId: string): Promise<void>;
     /**
      * Spawn the agent, stream its output live, and capture it.

package/dist/adapters/cli-proxy.js

@@ -20,7 +20,7 @@ import { mkdirSync } from "node:fs";
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { DAILY_LOG_BUDGET_TOKENS, buildTeammatePrompt, queryRecallContext, } from "../adapter.js";
+import { buildTeammatePrompt, DAILY_LOG_BUDGET_TOKENS, queryRecallContext, } from "../adapter.js";
 import { autoCompactForBudget } from "../compact.js";
 export const PRESETS = {
     claude: {
@@ -103,6 +103,8 @@ export class CliProxyAdapter {
     sessionsDir = "";
     /** Temp prompt files that need cleanup — guards against crashes before finally. */
     pendingTempFiles = new Set();
+    /** Active child processes per teammate — used by killAgent() for interruption. */
+    activeProcesses = new Map();
     constructor(options) {
         this.options = options;
         this.preset =
@@ -321,6 +323,20 @@ export class CliProxyAdapter {
     getSessionFile(teammateName) {
         return this.sessionFiles.get(teammateName);
     }
+    async killAgent(teammate) {
+        const entry = this.activeProcesses.get(teammate);
+        if (!entry || entry.child.killed)
+            return null;
+        // Kill with SIGTERM → 5s → SIGKILL
+        entry.child.kill("SIGTERM");
+        setTimeout(() => {
+            if (!entry.child.killed) {
+                entry.child.kill("SIGKILL");
+            }
+        }, 5_000);
+        // Wait for the process to exit — the spawnAndProxy close handler resolves this
+        return entry.done;
+    }
     async destroySession(_sessionId) {
         // Clean up any leaked temp prompt files
         for (const file of this.pendingTempFiles) {
@@ -337,119 +353,128 @@ export class CliProxyAdapter {
      * Spawn the agent, stream its output live, and capture it.
      */
     spawnAndProxy(teammate, promptFile, fullPrompt) {
-        return new Promise((resolve, reject) => {
-            // Always generate a debug log file for presets that support it (e.g. Claude's --debug-file).
-            // Written to .teammates/.tmp/debug/ so startup maintenance can clean old logs.
-            let debugFile;
-            if (this.preset.supportsDebugFile) {
-                const debugDir = join(teammate.cwd ?? process.cwd(), ".teammates", ".tmp", "debug");
-                try {
-                    mkdirSync(debugDir, { recursive: true });
-                }
-                catch {
-                    /* best effort */
-                }
-                debugFile = join(debugDir, `agent-${teammate.name}-${Date.now()}.log`);
-            }
-            const args = [
-                ...this.preset.buildArgs({ promptFile, prompt: fullPrompt, debugFile }, teammate, this.options),
-                ...(this.options.extraFlags ?? []),
-            ];
-            const command = this.options.commandPath ?? this.preset.command;
-            const env = { ...process.env, ...this.preset.env };
-            const timeout = this.options.timeout ?? 600_000;
-            const interactive = this.preset.interactive ?? false;
-            const useStdin = this.preset.stdinPrompt ?? false;
-            // Suppress Node.js ExperimentalWarning (e.g. SQLite) in agent
-            // subprocesses so it doesn't leak into the terminal UI.
-            const existingNodeOpts = env.NODE_OPTIONS ?? "";
-            if (!existingNodeOpts.includes("--disable-warning=ExperimentalWarning")) {
-                env.NODE_OPTIONS = existingNodeOpts
-                    ? `${existingNodeOpts} --disable-warning=ExperimentalWarning`
-                    : "--disable-warning=ExperimentalWarning";
+        // Create a deferred promise so killAgent() can await the same result
+        let resolveOuter;
+        let rejectOuter;
+        const done = new Promise((res, rej) => {
+            resolveOuter = res;
+            rejectOuter = rej;
+        });
+        // Always generate a debug log file for presets that support it (e.g. Claude's --debug-file).
+        // Written to .teammates/.tmp/debug/ so startup maintenance can clean old logs.
+        let debugFile;
+        if (this.preset.supportsDebugFile) {
+            const debugDir = join(teammate.cwd ?? process.cwd(), ".teammates", ".tmp", "debug");
+            try {
+                mkdirSync(debugDir, { recursive: true });
             }
-            // On Windows, npm-installed CLIs are .cmd wrappers that require shell.
-            // When using shell mode, pass command+args as a single string to avoid
-            // Node DEP0190 deprecation warning about unescaped args with shell: true.
-            const needsShell = this.preset.shell ?? process.platform === "win32";
-            const spawnCmd = needsShell ? [command, ...args].join(" ") : command;
-            const spawnArgs = needsShell ? [] : args;
-            const child = spawn(spawnCmd, spawnArgs, {
-                cwd: teammate.cwd ?? process.cwd(),
-                env,
-                stdio: [interactive || useStdin ? "pipe" : "ignore", "pipe", "pipe"],
-                shell: needsShell,
-            });
-            // Pipe prompt via stdin if the preset requires it
-            if (useStdin && child.stdin) {
-                child.stdin.write(fullPrompt);
-                child.stdin.end();
+            catch {
+                /* best effort */
             }
-            // ── Timeout with SIGTERM → SIGKILL escalation ──────────────
-            let killed = false;
-            let killTimer = null;
-            const timeoutTimer = setTimeout(() => {
-                if (!child.killed) {
-                    killed = true;
-                    child.kill("SIGTERM");
-                    // If SIGTERM doesn't work after 5s, force-kill
-                    killTimer = setTimeout(() => {
-                        if (!child.killed) {
-                            child.kill("SIGKILL");
-                        }
-                    }, 5_000);
-                }
-            }, timeout);
-            // Connect user's stdin → child only if agent may ask questions
-            let onUserInput = null;
-            if (interactive && !useStdin && child.stdin) {
-                onUserInput = (chunk) => {
-                    child.stdin?.write(chunk);
-                };
-                if (process.stdin.isTTY) {
-                    process.stdin.setRawMode(false);
-                }
-                process.stdin.resume();
-                process.stdin.on("data", onUserInput);
+            debugFile = join(debugDir, `agent-${teammate.name}-${Date.now()}.log`);
+        }
+        const args = [
+            ...this.preset.buildArgs({ promptFile, prompt: fullPrompt, debugFile }, teammate, this.options),
+            ...(this.options.extraFlags ?? []),
+        ];
+        const command = this.options.commandPath ?? this.preset.command;
+        const env = { ...process.env, ...this.preset.env };
+        const timeout = this.options.timeout ?? 600_000;
+        const interactive = this.preset.interactive ?? false;
+        const useStdin = this.preset.stdinPrompt ?? false;
+        // Suppress Node.js ExperimentalWarning (e.g. SQLite) in agent
+        // subprocesses so it doesn't leak into the terminal UI.
+        const existingNodeOpts = env.NODE_OPTIONS ?? "";
+        if (!existingNodeOpts.includes("--disable-warning=ExperimentalWarning")) {
+            env.NODE_OPTIONS = existingNodeOpts
+                ? `${existingNodeOpts} --disable-warning=ExperimentalWarning`
+                : "--disable-warning=ExperimentalWarning";
+        }
+        // On Windows, npm-installed CLIs are .cmd wrappers that require shell.
+        // When using shell mode, pass command+args as a single string to avoid
+        // Node DEP0190 deprecation warning about unescaped args with shell: true.
+        const needsShell = this.preset.shell ?? process.platform === "win32";
+        const spawnCmd = needsShell ? [command, ...args].join(" ") : command;
+        const spawnArgs = needsShell ? [] : args;
+        const child = spawn(spawnCmd, spawnArgs, {
+            cwd: teammate.cwd ?? process.cwd(),
+            env,
+            stdio: [interactive || useStdin ? "pipe" : "ignore", "pipe", "pipe"],
+            shell: needsShell,
+        });
+        // Register the active process for killAgent() access
+        this.activeProcesses.set(teammate.name, { child, done, debugFile });
+        // Pipe prompt via stdin if the preset requires it
+        if (useStdin && child.stdin) {
+            child.stdin.write(fullPrompt);
+            child.stdin.end();
+        }
+        // ── Timeout with SIGTERM → SIGKILL escalation ──────────────
+        let killed = false;
+        let killTimer = null;
+        const timeoutTimer = setTimeout(() => {
+            if (!child.killed) {
+                killed = true;
+                child.kill("SIGTERM");
+                // If SIGTERM doesn't work after 5s, force-kill
+                killTimer = setTimeout(() => {
+                    if (!child.killed) {
+                        child.kill("SIGKILL");
+                    }
+                }, 5_000);
             }
-            const stdoutBufs = [];
-            const stderrBufs = [];
-            child.stdout?.on("data", (chunk) => {
-                stdoutBufs.push(chunk);
-            });
-            child.stderr?.on("data", (chunk) => {
-                stderrBufs.push(chunk);
-            });
-            const cleanup = () => {
-                clearTimeout(timeoutTimer);
-                if (killTimer)
-                    clearTimeout(killTimer);
-                if (onUserInput) {
-                    process.stdin.removeListener("data", onUserInput);
-                }
+        }, timeout);
+        // Connect user's stdin → child only if agent may ask questions
+        let onUserInput = null;
+        if (interactive && !useStdin && child.stdin) {
+            onUserInput = (chunk) => {
+                child.stdin?.write(chunk);
             };
-            child.on("close", (code, signal) => {
-                cleanup();
-                const stdout = Buffer.concat(stdoutBufs).toString("utf-8");
-                const stderr = Buffer.concat(stderrBufs).toString("utf-8");
-                const output = stdout + (stderr ? `\n${stderr}` : "");
-                resolve({
-                    output: killed
-                        ? `${output}\n\n[TIMEOUT] Agent process killed after ${timeout}ms`
-                        : output,
-                    stdout,
-                    stderr,
-                    exitCode: code,
-                    signal: signal ?? null,
-                    timedOut: killed,
-                    debugFile,
-                });
-            });
-            child.on("error", (err) => {
-                cleanup();
-                reject(new Error(`Failed to spawn ${command}: ${err.message}`));
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.resume();
+            process.stdin.on("data", onUserInput);
+        }
+        const stdoutBufs = [];
+        const stderrBufs = [];
+        child.stdout?.on("data", (chunk) => {
+            stdoutBufs.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderrBufs.push(chunk);
+        });
+        const cleanup = () => {
+            clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (onUserInput) {
+                process.stdin.removeListener("data", onUserInput);
+            }
+            this.activeProcesses.delete(teammate.name);
+        };
+        child.on("close", (code, signal) => {
+            cleanup();
+            const stdout = Buffer.concat(stdoutBufs).toString("utf-8");
+            const stderr = Buffer.concat(stderrBufs).toString("utf-8");
+            const output = stdout + (stderr ? `\n${stderr}` : "");
+            resolveOuter({
+                output: killed
+                    ? `${output}\n\n[TIMEOUT] Agent process killed after ${timeout}ms`
+                    : output,
+                stdout,
+                stderr,
+                exitCode: code,
+                signal: signal ?? null,
+                timedOut: killed,
+                debugFile,
             });
         });
+        child.on("error", (err) => {
+            cleanup();
+            rejectOuter(new Error(`Failed to spawn ${command}: ${err.message}`));
+        });
+        return done;
     }
 }
 // ─── Output parsing (shared across all agents) ─────────────────────