@teammates/cli 0.5.3 → 0.6.1

package/dist/compact.d.ts

@@ -67,3 +67,32 @@ export declare function buildWisdomPrompt(teammateDir: string, teammateName: str
  * Returns the list of deleted filenames.
  */
 export declare function purgeStaleDailies(teammateDir: string): Promise<string[]>;
+/**
+ * Find all daily logs that are not yet compressed (no `compressed: true`
+ * frontmatter). Returns an array of { date, file } for each uncompressed log.
+ */
+export declare function findUncompressedDailies(teammateDir: string): Promise<{
+    date: string;
+    file: string;
+}[]>;
+/**
+ * Build a prompt for an agent to compress multiple daily logs in bulk.
+ * Used during version migrations to compress all historical daily logs.
+ * Returns null if there are no uncompressed dailies.
+ */
+export declare function buildMigrationCompressionPrompt(_teammateDir: string, teammateName: string, dailies: {
+    date: string;
+    file: string;
+}[]): Promise<string | null>;
+/**
+ * Check if the previous day's log needs compression and return a prompt
+ * to compress it. Returns null if no compression is needed.
+ *
+ * A daily log is eligible for compression when:
+ * - Today's log does not yet exist (new day boundary)
+ * - Yesterday's log exists and is not already compressed (no `compressed: true` frontmatter)
+ */
+export declare function buildDailyCompressionPrompt(teammateDir: string): Promise<{
+    date: string;
+    prompt: string;
+} | null>;

package/dist/compact.js

@@ -84,6 +84,7 @@ function buildWeeklySummary(weekKey, dailies, partial = false) {
     const lastDate = sorted[sorted.length - 1].date;
     const lines = [];
     lines.push("---");
+    lines.push("version: 0.6.0");
     lines.push(`type: weekly`);
     lines.push(`week: ${weekKey}`);
     lines.push(`period: ${firstDate} to ${lastDate}`);
@@ -110,6 +111,7 @@ function buildMonthlySummary(monthKey, weeklies) {
     const lastWeek = sorted[sorted.length - 1].week;
     const lines = [];
     lines.push("---");
+    lines.push("version: 0.6.0");
     lines.push(`type: monthly`);
     lines.push(`month: ${monthKey}`);
     lines.push(`period: ${firstWeek} to ${lastWeek}`);
@@ -534,3 +536,132 @@ export async function purgeStaleDailies(teammateDir) {
     }
     return purged;
 }
+/**
+ * Find all daily logs that are not yet compressed (no `compressed: true`
+ * frontmatter). Returns an array of { date, file } for each uncompressed log.
+ */
+export async function findUncompressedDailies(teammateDir) {
+    const memoryDir = join(teammateDir, "memory");
+    const entries = await readdir(memoryDir).catch(() => []);
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const stem = basename(entry, ".md");
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(stem))
+            continue;
+        const content = await readFile(join(memoryDir, entry), "utf-8");
+        if (content.startsWith("---") && /compressed:\s*true/.test(content)) {
+            continue; // Already compressed
+        }
+        results.push({ date: stem, file: entry });
+    }
+    return results.sort((a, b) => a.date.localeCompare(b.date));
+}
+/**
+ * Build a prompt for an agent to compress multiple daily logs in bulk.
+ * Used during version migrations to compress all historical daily logs.
+ * Returns null if there are no uncompressed dailies.
+ */
+export async function buildMigrationCompressionPrompt(_teammateDir, teammateName, dailies) {
+    if (dailies.length === 0)
+        return null;
+    const filePaths = dailies
+        .map((d) => `.teammates/${teammateName}/memory/${d.file}`)
+        .join("\n- ");
+    return `You are compressing daily work logs to save context window space. There are ${dailies.length} uncompressed daily logs that need compression.
+
+## Rules
+
+For EACH file listed below:
+1. Read the file
+2. Rewrite it into a shorter version that preserves:
+   - Task names and one-line summaries of what was done
+   - Key decisions and their rationale
+   - Files changed (as a flat list per task, not grouped subsections)
+   - Important context for future tasks
+3. Remove:
+   - Detailed "What was done" step-by-step breakdowns
+   - Build/test status lines (unless something failed)
+   - Redundant section headers
+4. Keep the same markdown structure (# date header, ## Task headers) but make each task entry 3-5 lines max
+5. Start the file with this frontmatter:
+\`\`\`
+---
+version: 0.6.0
+type: daily
+compressed: true
+---
+\`\`\`
+
+## Files to Compress
+
+- ${filePaths}
+
+Process each file one at a time. Read it, compress it, write it back. Do NOT skip any files.`;
+}
+/**
+ * Check if the previous day's log needs compression and return a prompt
+ * to compress it. Returns null if no compression is needed.
+ *
+ * A daily log is eligible for compression when:
+ * - Today's log does not yet exist (new day boundary)
+ * - Yesterday's log exists and is not already compressed (no `compressed: true` frontmatter)
+ */
+export async function buildDailyCompressionPrompt(teammateDir) {
+    const memoryDir = join(teammateDir, "memory");
+    const today = new Date().toISOString().slice(0, 10);
+    // Find yesterday's date
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStr = yesterday.toISOString().slice(0, 10);
+    // Check if yesterday's log exists
+    const yesterdayFile = join(memoryDir, `${yesterdayStr}.md`);
+    let content;
+    try {
+        content = await readFile(yesterdayFile, "utf-8");
+    }
+    catch {
+        return null; // No yesterday log
+    }
+    // Skip if already compressed
+    if (content.startsWith("---") && /compressed:\s*true/.test(content)) {
+        return null;
+    }
+    // Skip if today's log already exists (we already passed the day boundary)
+    const todayFile = join(memoryDir, `${today}.md`);
+    try {
+        await readFile(todayFile, "utf-8");
+        // Today's log exists — this isn't a fresh day boundary, skip
+        return null;
+    }
+    catch {
+        // Today's log doesn't exist — this is a new day, compress yesterday
+    }
+    const prompt = `You are compressing a daily work log to save context window space. Rewrite the log below into a shorter version that preserves:
+- Task names and one-line summaries of what was done
+- Key decisions and their rationale
+- Files changed (as a flat list per task, not grouped subsections)
+- Important context for future tasks
+
+Remove:
+- Detailed "What was done" step-by-step breakdowns
+- Build/test status lines (unless something failed)
+- Redundant section headers
+
+Keep the same markdown structure (# date header, ## Task headers) but make each task entry 3-5 lines max.
+
+Write the compressed version to \`.teammates/${basename(teammateDir)}/memory/${yesterdayStr}.md\`. Start the file with this frontmatter:
+\`\`\`
+---
+version: 0.6.0
+type: daily
+compressed: true
+---
+\`\`\`
+
+## Original Log
+
+${content}`;
+    return { date: yesterdayStr, prompt };
+}

package/dist/index.d.ts

@@ -1,15 +1,17 @@
 export type { AgentAdapter, InstalledService, RecallContext, RosterEntry, } from "./adapter.js";
 export { buildTeammatePrompt, DAILY_LOG_BUDGET_TOKENS, formatHandoffContext, queryRecallContext, syncRecallIndex, } from "./adapter.js";
-export { autoCompactForBudget } from "./compact.js";
 export { type AgentPreset, CliProxyAdapter, type CliProxyOptions, PRESETS, } from "./adapters/cli-proxy.js";
 export { EchoAdapter } from "./adapters/echo.js";
 export type { BannerInfo, ServiceInfo, ServiceStatus } from "./banner.js";
 export { AnimatedBanner } from "./banner.js";
 export type { CliArgs } from "./cli-args.js";
 export { findTeammatesDir, PKG_VERSION, parseCliArgs } from "./cli-args.js";
+export { autoCompactForBudget, buildDailyCompressionPrompt, buildMigrationCompressionPrompt, findUncompressedDailies, } from "./compact.js";
+export type { LogEntry } from "./log-parser.js";
+export { buildConversationLog, formatLogTimeline, parseClaudeDebugLog, parseCodexOutput, parseRawOutput, } from "./log-parser.js";
 export { Orchestrator, type OrchestratorConfig, type TeammateStatus, } from "./orchestrator.js";
 export type { Persona } from "./personas.js";
 export { loadPersonas, scaffoldFromPersona } from "./personas.js";
 export { Registry } from "./registry.js";
 export { tp } from "./theme.js";
-export type { DailyLog, HandoffEnvelope, OrchestratorEvent, OwnershipRules, PresenceState, QueueEntry, SandboxLevel, SlashCommand, TaskAssignment, TaskResult, TeammateConfig, TeammateType, } from "./types.js";
+export type { DailyLog, HandoffEnvelope, InterruptState, OrchestratorEvent, OwnershipRules, PresenceState, QueueEntry, SandboxLevel, SlashCommand, TaskAssignment, TaskResult, TeammateConfig, TeammateType, } from "./types.js";

package/dist/index.js

@@ -1,10 +1,11 @@
 // Public API for @teammates/cli
 export { buildTeammatePrompt, DAILY_LOG_BUDGET_TOKENS, formatHandoffContext, queryRecallContext, syncRecallIndex, } from "./adapter.js";
-export { autoCompactForBudget } from "./compact.js";
 export { CliProxyAdapter, PRESETS, } from "./adapters/cli-proxy.js";
 export { EchoAdapter } from "./adapters/echo.js";
 export { AnimatedBanner } from "./banner.js";
 export { findTeammatesDir, PKG_VERSION, parseCliArgs } from "./cli-args.js";
+export { autoCompactForBudget, buildDailyCompressionPrompt, buildMigrationCompressionPrompt, findUncompressedDailies, } from "./compact.js";
+export { buildConversationLog, formatLogTimeline, parseClaudeDebugLog, parseCodexOutput, parseRawOutput, } from "./log-parser.js";
 export { Orchestrator, } from "./orchestrator.js";
 export { loadPersonas, scaffoldFromPersona } from "./personas.js";
 export { Registry } from "./registry.js";

package/dist/log-parser.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agent log parser — extracts condensed conversation timelines from agent
+ * debug logs and stdout for the interrupt-and-resume system.
+ *
+ * Each agent type has a different log format:
+ * - Claude: structured --debug-file with tool calls and results
+ * - Codex: JSONL with item.completed events
+ * - Others: raw stdout (truncated)
+ */
+/** A single action extracted from an agent's conversation log. */
+export interface LogEntry {
+    /** Tool name or action type (e.g. "Write", "Read", "Search", "text") */
+    action: string;
+    /** Key parameters — file paths, search queries (NOT full file contents) */
+    summary: string;
+}
+/**
+ * Parse a Claude --debug-file into condensed log entries.
+ *
+ * The debug file contains the full conversation log including tool calls
+ * and their results. We extract tool names and key parameters (file paths,
+ * search queries) but NOT full file contents to keep the resume prompt compact.
+ */
+export declare function parseClaudeDebugLog(debugFilePath: string): LogEntry[];
+/**
+ * Parse Codex JSONL output into condensed log entries.
+ */
+export declare function parseCodexOutput(stdout: string): LogEntry[];
+/**
+ * Parse raw stdout into condensed log entries (fallback for unknown agents).
+ */
+export declare function parseRawOutput(output: string): LogEntry[];
+/**
+ * Format log entries into a condensed markdown timeline for the resume prompt.
+ *
+ * Keeps the output compact — file paths and search queries only, no content.
+ * Groups consecutive same-action entries (e.g., "Wrote 15 files: ...").
+ */
+export declare function formatLogTimeline(entries: LogEntry[]): string;
+/**
+ * Estimate the token count of a string (rough: 1 token ≈ 4 chars).
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Build a condensed conversation log from the available sources.
+ * Tries Claude debug file first, then Codex JSONL, then raw stdout.
+ * Truncates to the token budget if needed.
+ */
+export declare function buildConversationLog(debugFile: string | undefined, stdout: string, presetName: string, tokenBudget?: number): {
+    log: string;
+    toolCallCount: number;
+    filesChanged: string[];
+};

package/dist/log-parser.js

@@ -0,0 +1,228 @@
+/**
+ * Agent log parser — extracts condensed conversation timelines from agent
+ * debug logs and stdout for the interrupt-and-resume system.
+ *
+ * Each agent type has a different log format:
+ * - Claude: structured --debug-file with tool calls and results
+ * - Codex: JSONL with item.completed events
+ * - Others: raw stdout (truncated)
+ */
+import { readFileSync } from "node:fs";
+/**
+ * Parse a Claude --debug-file into condensed log entries.
+ *
+ * The debug file contains the full conversation log including tool calls
+ * and their results. We extract tool names and key parameters (file paths,
+ * search queries) but NOT full file contents to keep the resume prompt compact.
+ */
+export function parseClaudeDebugLog(debugFilePath) {
+    let content;
+    try {
+        content = readFileSync(debugFilePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    // Claude debug logs contain tool_use and tool_result blocks
+    // Extract tool calls with their key parameters
+    const toolUsePattern = /Tool call:\s*(\w+)\s*\{([^}]*)\}|"type":\s*"tool_use".*?"name":\s*"(\w+)".*?"input":\s*\{([^}]*)\}/g;
+    let match;
+    while ((match = toolUsePattern.exec(content)) !== null) {
+        const toolName = match[1] || match[3];
+        const params = match[2] || match[4];
+        if (!toolName)
+            continue;
+        const summary = extractKeyParams(toolName, params);
+        entries.push({ action: toolName, summary });
+    }
+    // If structured parsing found nothing, try line-by-line patterns
+    if (entries.length === 0) {
+        for (const line of content.split("\n")) {
+            // Look for common Claude debug log patterns
+            const writeMatch = line.match(/(?:Write|Edit|Create)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+            if (writeMatch) {
+                entries.push({ action: "Write", summary: writeMatch[1] });
+                continue;
+            }
+            const readMatch = line.match(/(?:Read)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+            if (readMatch) {
+                entries.push({ action: "Read", summary: readMatch[1] });
+                continue;
+            }
+            const searchMatch = line.match(/(?:Search|Grep|Glob)\s+.*?["']([^"']+)["']/i);
+            if (searchMatch) {
+                entries.push({ action: "Search", summary: searchMatch[1] });
+                continue;
+            }
+            const bashMatch = line.match(/(?:Bash|Shell|Execute)\s+.*?["'`]([^"'`]+)["'`]/i);
+            if (bashMatch) {
+                entries.push({
+                    action: "Bash",
+                    summary: bashMatch[1].slice(0, 80),
+                });
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Parse Codex JSONL output into condensed log entries.
+ */
+export function parseCodexOutput(stdout) {
+    const entries = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "item.completed") {
+                if (event.item?.type === "tool_call") {
+                    const toolName = event.item.name ?? "tool";
+                    const summary = event.item.arguments
+                        ? extractKeyParams(toolName, JSON.stringify(event.item.arguments))
+                        : "";
+                    entries.push({ action: toolName, summary });
+                }
+                else if (event.item?.type === "agent_message" && event.item.text) {
+                    entries.push({
+                        action: "text",
+                        summary: event.item.text.slice(0, 100),
+                    });
+                }
+            }
+        }
+        catch {
+            /* skip non-JSON lines */
+        }
+    }
+    return entries;
+}
+/**
+ * Parse raw stdout into condensed log entries (fallback for unknown agents).
+ */
+export function parseRawOutput(output) {
+    const entries = [];
+    for (const line of output.split("\n")) {
+        const writeMatch = line.match(/(?:Created|Modified|Updated|Wrote|Edited)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+        if (writeMatch) {
+            entries.push({ action: "Write", summary: writeMatch[1] });
+        }
+    }
+    return entries;
+}
+/**
+ * Format log entries into a condensed markdown timeline for the resume prompt.
+ *
+ * Keeps the output compact — file paths and search queries only, no content.
+ * Groups consecutive same-action entries (e.g., "Wrote 15 files: ...").
+ */
+export function formatLogTimeline(entries) {
+    if (entries.length === 0)
+        return "(no tool calls captured)";
+    const lines = [];
+    let i = 0;
+    while (i < entries.length) {
+        const entry = entries[i];
+        // Group consecutive same-action entries
+        let groupEnd = i + 1;
+        while (groupEnd < entries.length &&
+            entries[groupEnd].action === entry.action) {
+            groupEnd++;
+        }
+        const groupSize = groupEnd - i;
+        if (groupSize > 3 && entry.action !== "text") {
+            // Collapse large groups
+            const summaries = entries
+                .slice(i, groupEnd)
+                .map((e) => e.summary)
+                .filter(Boolean);
+            const preview = summaries.slice(0, 3).join(", ");
+            const more = summaries.length > 3 ? ` (+${summaries.length - 3} more)` : "";
+            lines.push(`${lines.length + 1}. ${entry.action} ${groupSize} items: ${preview}${more}`);
+            i = groupEnd;
+        }
+        else {
+            // Individual entries
+            for (let j = i; j < groupEnd; j++) {
+                const e = entries[j];
+                const desc = e.summary ? ` ${e.summary}` : "";
+                lines.push(`${lines.length + 1}. ${e.action}${desc}`);
+            }
+            i = groupEnd;
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Extract key parameters from a tool call — file paths and search queries,
+ * NOT full file contents. Keeps the resume prompt compact.
+ */
+function extractKeyParams(toolName, paramsStr) {
+    const lower = toolName.toLowerCase();
+    // Extract file_path parameter
+    const filePathMatch = paramsStr.match(/file_path["']?\s*[:=]\s*["']([^"']+)["']/);
+    if (filePathMatch)
+        return filePathMatch[1];
+    // Extract path parameter
+    const pathMatch = paramsStr.match(/["']?path["']?\s*[:=]\s*["']([^"']+)["']/);
+    if (pathMatch)
+        return pathMatch[1];
+    // Extract command for bash/shell tools
+    if (lower === "bash" || lower === "shell" || lower === "execute") {
+        const cmdMatch = paramsStr.match(/["']?command["']?\s*[:=]\s*["']([^"']+)["']/);
+        if (cmdMatch)
+            return cmdMatch[1].slice(0, 80);
+    }
+    // Extract query/pattern for search tools
+    if (lower === "search" || lower === "grep" || lower === "glob") {
+        const queryMatch = paramsStr.match(/["']?(?:query|pattern)["']?\s*[:=]\s*["']([^"']+)["']/);
+        if (queryMatch)
+            return queryMatch[1];
+    }
+    return "";
+}
+/**
+ * Estimate the token count of a string (rough: 1 token ≈ 4 chars).
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Build a condensed conversation log from the available sources.
+ * Tries Claude debug file first, then Codex JSONL, then raw stdout.
+ * Truncates to the token budget if needed.
+ */
+export function buildConversationLog(debugFile, stdout, presetName, tokenBudget = 8_000) {
+    let entries;
+    if (debugFile && presetName === "claude") {
+        entries = parseClaudeDebugLog(debugFile);
+    }
+    else if (presetName === "codex") {
+        entries = parseCodexOutput(stdout);
+    }
+    else {
+        entries = parseRawOutput(stdout);
+    }
+    // Extract files changed
+    const filesChanged = entries
+        .filter((e) => ["Write", "Edit", "Create", "write", "edit", "create"].includes(e.action))
+        .map((e) => e.summary)
+        .filter(Boolean);
+    const toolCallCount = entries.filter((e) => e.action !== "text").length;
+    let log = formatLogTimeline(entries);
+    // Truncate if over budget
+    if (estimateTokens(log) > tokenBudget) {
+        // Keep first and last entries, summarize the middle
+        const lines = log.split("\n");
+        const keepFirst = Math.floor(lines.length * 0.3);
+        const keepLast = Math.floor(lines.length * 0.2);
+        const omitted = lines.length - keepFirst - keepLast;
+        log = [
+            ...lines.slice(0, keepFirst),
+            `... (${omitted} steps omitted for brevity) ...`,
+            ...lines.slice(lines.length - keepLast),
+        ].join("\n");
+    }
+    return { log, toolCallCount, filesChanged };
+}

package/dist/log-parser.test.d.ts

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

package/dist/log-parser.test.js

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { buildConversationLog, formatLogTimeline, parseCodexOutput, parseRawOutput, } from "./log-parser.js";
+describe("parseRawOutput", () => {
+    it("extracts file write patterns from stdout", () => {
+        const output = [
+            "Created file: `src/foo.ts`",
+            "Modified bar.js",
+            "Some other output",
+            "Wrote `packages/cli/src/index.ts`",
+        ].join("\n");
+        const entries = parseRawOutput(output);
+        expect(entries).toHaveLength(3);
+        expect(entries[0]).toEqual({ action: "Write", summary: "src/foo.ts" });
+        expect(entries[1]).toEqual({ action: "Write", summary: "bar.js" });
+        expect(entries[2]).toEqual({
+            action: "Write",
+            summary: "packages/cli/src/index.ts",
+        });
+    });
+    it("returns empty array for output with no file patterns", () => {
+        const entries = parseRawOutput("Just some plain text output");
+        expect(entries).toHaveLength(0);
+    });
+});
+describe("parseCodexOutput", () => {
+    it("extracts tool calls from JSONL events", () => {
+        const output = [
+            JSON.stringify({
+                type: "item.completed",
+                item: {
+                    type: "tool_call",
+                    name: "write_file",
+                    arguments: { path: "src/foo.ts" },
+                },
+            }),
+            JSON.stringify({
+                type: "item.completed",
+                item: { type: "agent_message", text: "Done with the task" },
+            }),
+        ].join("\n");
+        const entries = parseCodexOutput(output);
+        expect(entries).toHaveLength(2);
+        expect(entries[0].action).toBe("write_file");
+        expect(entries[1]).toEqual({
+            action: "text",
+            summary: "Done with the task",
+        });
+    });
+    it("skips non-JSON lines", () => {
+        const output = "not json\n{invalid\n";
+        const entries = parseCodexOutput(output);
+        expect(entries).toHaveLength(0);
+    });
+});
+describe("formatLogTimeline", () => {
+    it("formats individual entries with numbered steps", () => {
+        const entries = [
+            { action: "Read", summary: "src/foo.ts" },
+            { action: "Write", summary: "src/bar.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toBe("1. Read src/foo.ts\n2. Write src/bar.ts");
+    });
+    it("groups consecutive same-action entries when > 3", () => {
+        const entries = [
+            { action: "Write", summary: "a.ts" },
+            { action: "Write", summary: "b.ts" },
+            { action: "Write", summary: "c.ts" },
+            { action: "Write", summary: "d.ts" },
+            { action: "Write", summary: "e.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toContain("Write 5 items");
+        expect(result).toContain("a.ts, b.ts, c.ts");
+        expect(result).toContain("(+2 more)");
+    });
+    it("does not group when 3 or fewer consecutive entries", () => {
+        const entries = [
+            { action: "Write", summary: "a.ts" },
+            { action: "Write", summary: "b.ts" },
+            { action: "Write", summary: "c.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toBe("1. Write a.ts\n2. Write b.ts\n3. Write c.ts");
+    });
+    it("returns fallback for empty entries", () => {
+        expect(formatLogTimeline([])).toBe("(no tool calls captured)");
+    });
+});
+describe("buildConversationLog", () => {
+    it("uses raw output parser for unknown presets", () => {
+        const stdout = "Created file: `test.ts`\nDone";
+        const result = buildConversationLog(undefined, stdout, "aider");
+        expect(result.filesChanged).toContain("test.ts");
+        expect(result.toolCallCount).toBe(1);
+        expect(result.log).toContain("Write");
+    });
+    it("groups large batch writes into a compact summary", () => {
+        // 200 file writes should be grouped, not listed individually
+        const entries = Array.from({ length: 200 }, (_, i) => `Created file: \`file${i}.ts\``).join("\n");
+        const result = buildConversationLog(undefined, entries, "generic");
+        expect(result.toolCallCount).toBe(200);
+        expect(result.log).toContain("Write 200 items");
+        // The grouped output should be compact (single line)
+        expect(result.log.split("\n")).toHaveLength(1);
+    });
+    it("handles empty output gracefully", () => {
+        const result = buildConversationLog(undefined, "", "claude");
+        expect(result.toolCallCount).toBe(0);
+        expect(result.filesChanged).toHaveLength(0);
+        expect(result.log).toBe("(no tool calls captured)");
+    });
+});

package/dist/orchestrator.d.ts

@@ -42,6 +42,8 @@ export declare class Orchestrator {
     listTeammates(): string[];
     /** Get the registry for direct access */
     getRegistry(): Registry;
+    /** Get the adapter for direct access (used by /interrupt) */
+    getAdapter(): AgentAdapter;
     /**
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.

package/dist/orchestrator.js

@@ -42,6 +42,10 @@ export class Orchestrator {
     getRegistry() {
         return this.registry;
     }
+    /** Get the adapter for direct access (used by /interrupt) */
+    getAdapter() {
+        return this.adapter;
+    }
     /**
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.

package/dist/registry.js

@@ -100,8 +100,8 @@ async function loadDailyLogs(memoryDir) {
             // 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 });
+            const raw = await readFile(join(memoryDir, entry), "utf-8");
+            logs.push({ date: stem, content: raw });
         }
         // Most recent first
         logs.sort((a, b) => b.date.localeCompare(a.date));
@@ -124,8 +124,8 @@ async function loadWeeklyLogs(memoryDir) {
             // 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 });
+            const raw = await readFile(join(weeklyDir, entry), "utf-8");
+            logs.push({ week: stem, content: raw });
         }
         // Most recent first
         logs.sort((a, b) => b.week.localeCompare(a.week));