@teammates/cli 0.5.3 → 0.6.0

package/dist/cli.js

@@ -19,9 +19,10 @@ import { DAILY_LOG_BUDGET_TOKENS, syncRecallIndex } from "./adapter.js";
 import { AnimatedBanner, } from "./banner.js";
 import { findTeammatesDir, PKG_VERSION, parseCliArgs, printUsage, resolveAdapter, } from "./cli-args.js";
 import { buildConversationContext as buildConvCtx, buildSummarizationPrompt, cleanResponseBody, findAtMention, findSummarizationSplit, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
-import { autoCompactForBudget, buildWisdomPrompt, compactEpisodic, purgeStaleDailies, } from "./compact.js";
+import { autoCompactForBudget, buildDailyCompressionPrompt, buildMigrationCompressionPrompt, buildWisdomPrompt, compactEpisodic, findUncompressedDailies, purgeStaleDailies, } from "./compact.js";
 import { PromptInput } from "./console/prompt-input.js";
 import { buildTitle } from "./console/startup.js";
+import { buildConversationLog } from "./log-parser.js";
 import { buildImportAdaptationPrompt, copyTemplateFiles, getOnboardingPrompt, importTeammates, } from "./onboard.js";
 import { Orchestrator } from "./orchestrator.js";
 import { loadPersonas, scaffoldFromPersona } from "./personas.js";
@@ -154,8 +155,20 @@ class TeammatesREPL {
     }
     /** Token budget for recent conversation history (24k tokens ≈ 96k chars). */
     static CONV_HISTORY_CHARS = 24_000 * 4;
+    /** Threshold (chars) above which conversation history is written to a temp file. */
+    static CONV_FILE_THRESHOLD = 8_000;
     buildConversationContext() {
-        return buildConvCtx(this.conversationHistory, this.conversationSummary, TeammatesREPL.CONV_HISTORY_CHARS);
+        const context = buildConvCtx(this.conversationHistory, this.conversationSummary, TeammatesREPL.CONV_HISTORY_CHARS);
+        // If the conversation context is very long, write it to a temp file
+        // and return a pointer instead — reduces inline prompt noise.
+        if (context.length > TeammatesREPL.CONV_FILE_THRESHOLD) {
+            const tmpDir = join(this.teammatesDir, ".tmp");
+            mkdirSync(tmpDir, { recursive: true });
+            const convFile = join(tmpDir, "conversation.md");
+            writeFileSync(convFile, context, "utf-8");
+            return `## Conversation History\n\nThe full conversation history is in \`.teammates/.tmp/conversation.md\`. Read it before responding to understand prior context.`;
+        }
+        return context;
     }
     /**
      * Check if conversation history exceeds the 24k token budget.
@@ -187,6 +200,8 @@ class TeammatesREPL {
     systemActive = new Map();
     /** Agents currently in a silent retry — suppress all events. */
     silentAgents = new Set();
+    /** Counter for pending migration compression tasks — triggers re-index when it hits 0. */
+    pendingMigrationSyncs = 0;
     /** Per-agent drain locks — prevents double-draining a single agent. */
     agentDrainLocks = new Map();
     /** Stored pasted text keyed by paste number, expanded on Enter. */
@@ -208,6 +223,8 @@ class TeammatesREPL {
     pendingHandoffs = [];
     /** Pending retro proposals awaiting user approval. */
     pendingRetroProposals = [];
+    /** Pending cross-folder violations awaiting user decision. */
+    pendingViolations = [];
     /** Maps reply action IDs to their context (teammate + message). */
     _replyContexts = new Map();
     /** Quoted reply text to expand on next submit. */
@@ -727,6 +744,135 @@ class TeammatesREPL {
             return;
         }
     }
+    /**
+     * Audit a task result for cross-folder writes.
+     * AI teammates must not write to another teammate's folder.
+     * Returns violating file paths (relative), or empty array if clean.
+     */
+    auditCrossFolderWrites(teammate, changedFiles) {
+        // Normalize .teammates/ prefix for comparison
+        const tmPrefix = ".teammates/";
+        const ownPrefix = `${tmPrefix}${teammate}/`;
+        return changedFiles.filter((f) => {
+            const normalized = f.replace(/\\/g, "/");
+            // Only care about files inside .teammates/
+            if (!normalized.startsWith(tmPrefix))
+                return false;
+            // Own folder is fine
+            if (normalized.startsWith(ownPrefix))
+                return false;
+            // Shared folders (_prefix) are fine
+            const subPath = normalized.slice(tmPrefix.length);
+            if (subPath.startsWith("_"))
+                return false;
+            // Ephemeral folders (.prefix) are fine
+            if (subPath.startsWith("."))
+                return false;
+            // Root-level shared files (USER.md, settings.json, CROSS-TEAM.md, etc.)
+            if (!subPath.includes("/"))
+                return false;
+            // Everything else is a violation
+            return true;
+        });
+    }
+    /**
+     * Show cross-folder violation warning with [revert] / [allow] actions.
+     */
+    showViolationWarning(teammate, violations) {
+        const t = theme();
+        this.feedLine(tp.warning(`  ⚠  @${teammate} wrote to another teammate's folder:`));
+        for (const f of violations) {
+            this.feedLine(tp.muted(`     ${f}`));
+        }
+        if (this.chatView) {
+            const violationId = `violation-${Date.now()}`;
+            const actionIdx = this.chatView.feedLineCount;
+            this.chatView.appendActionList([
+                {
+                    id: `revert-${violationId}`,
+                    normalStyle: this.makeSpan({
+                        text: "  [revert]",
+                        style: { fg: t.error },
+                    }),
+                    hoverStyle: this.makeSpan({
+                        text: "  [revert]",
+                        style: { fg: t.accent },
+                    }),
+                },
+                {
+                    id: `allow-${violationId}`,
+                    normalStyle: this.makeSpan({
+                        text: " [allow]",
+                        style: { fg: t.textDim },
+                    }),
+                    hoverStyle: this.makeSpan({
+                        text: " [allow]",
+                        style: { fg: t.accent },
+                    }),
+                },
+            ]);
+            this.pendingViolations.push({
+                id: violationId,
+                teammate,
+                files: violations,
+                actionIdx,
+            });
+        }
+    }
+    /**
+     * Handle revert/allow actions for cross-folder violations.
+     */
+    handleViolationAction(actionId) {
+        const revertMatch = actionId.match(/^revert-(violation-.+)$/);
+        if (revertMatch) {
+            const vId = revertMatch[1];
+            const idx = this.pendingViolations.findIndex((v) => v.id === vId);
+            if (idx >= 0 && this.chatView) {
+                const v = this.pendingViolations.splice(idx, 1)[0];
+                // Revert violating files via git checkout
+                for (const f of v.files) {
+                    try {
+                        execSync(`git checkout -- "${f}"`, {
+                            cwd: resolve(this.teammatesDir, ".."),
+                            stdio: "pipe",
+                        });
+                    }
+                    catch {
+                        // File might be untracked — try git rm
+                        try {
+                            execSync(`git rm -f "${f}"`, {
+                                cwd: resolve(this.teammatesDir, ".."),
+                                stdio: "pipe",
+                            });
+                        }
+                        catch {
+                            // Best effort — file may already be clean
+                        }
+                    }
+                }
+                this.chatView.updateFeedLine(v.actionIdx, this.makeSpan({
+                    text: `  reverted ${v.files.length} file(s)`,
+                    style: { fg: theme().success },
+                }));
+                this.refreshView();
+            }
+            return;
+        }
+        const allowMatch = actionId.match(/^allow-(violation-.+)$/);
+        if (allowMatch) {
+            const vId = allowMatch[1];
+            const idx = this.pendingViolations.findIndex((v) => v.id === vId);
+            if (idx >= 0 && this.chatView) {
+                const v = this.pendingViolations.splice(idx, 1)[0];
+                this.chatView.updateFeedLine(v.actionIdx, this.makeSpan({
+                    text: "  allowed",
+                    style: { fg: theme().textDim },
+                }));
+                this.refreshView();
+            }
+            return;
+        }
+    }
     /** Handle bulk handoff actions. */
     handleBulkHandoff(action) {
         if (!this.chatView)
@@ -1113,6 +1259,20 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         }
         finally {
             this.systemActive.delete(taskId);
+            // Migration tasks: decrement counter and re-index when all are done
+            if (entry.type === "agent" && entry.migration) {
+                this.pendingMigrationSyncs--;
+                if (this.pendingMigrationSyncs <= 0) {
+                    try {
+                        await syncRecallIndex(this.teammatesDir);
+                        this.feedLine(tp.success("  ✔  v0.6.0 migration complete — indexes rebuilt"));
+                        this.refreshView();
+                    }
+                    catch {
+                        /* re-index failed — non-fatal, next startup will retry */
+                    }
+                }
+            }
         }
     }
     // ─── Onboarding ───────────────────────────────────────────────────
@@ -2550,6 +2710,9 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 id.startsWith("retro-reject-")) {
                 this.handleRetroAction(id);
             }
+            else if (id.startsWith("revert-") || id.startsWith("allow-")) {
+                this.handleViolationAction(id);
+            }
             else if (id.startsWith("approve-") || id.startsWith("reject-")) {
                 this.handleHandoffAction(id);
             }
@@ -3046,6 +3209,13 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 description: "Cancel a queued task by number",
                 run: (args) => this.cmdCancel(args),
             },
+            {
+                name: "interrupt",
+                aliases: ["int"],
+                usage: "/interrupt <teammate> [message]",
+                description: "Interrupt a running agent and resume with a steering message",
+                run: (args) => this.cmdInterrupt(args),
+            },
             {
                 name: "init",
                 aliases: ["onboard", "setup"],
@@ -3365,6 +3535,114 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         this.feedLine(concat(tp.muted("  Cancelled: "), tp.accent(`@${cancelDisplay}`), tp.muted(" — "), tp.text(removed.task.slice(0, 60))));
         this.refreshView();
     }
+    /**
+     * /interrupt <teammate> [message] — Kill a running agent and resume with context.
+     */
+    async cmdInterrupt(argsStr) {
+        const parts = argsStr.trim().split(/\s+/);
+        const teammateName = parts[0]?.replace(/^@/, "").toLowerCase();
+        const steeringMessage = parts.slice(1).join(" ").trim() ||
+            "Wrap up your current work and report what you've done so far.";
+        if (!teammateName) {
+            this.feedLine(tp.warning("  Usage: /interrupt <teammate> [message]"));
+            this.refreshView();
+            return;
+        }
+        // Resolve display name → internal name
+        const resolvedName = teammateName === this.adapterName ? this.selfName : teammateName;
+        // Check if the teammate has an active task
+        const activeEntry = this.agentActive.get(resolvedName);
+        if (!activeEntry) {
+            this.feedLine(tp.warning(`  @${teammateName} has no active task to interrupt.`));
+            this.refreshView();
+            return;
+        }
+        // Check if the adapter supports killing
+        const adapter = this.orchestrator.getAdapter();
+        if (!adapter?.killAgent) {
+            this.feedLine(tp.warning("  This adapter does not support interruption."));
+            this.refreshView();
+            return;
+        }
+        // Show interruption status
+        const displayName = resolvedName === this.selfName ? this.adapterName : resolvedName;
+        this.feedLine(concat(tp.warning("  ⚡  Interrupting "), tp.accent(`@${displayName}`), tp.warning("...")));
+        this.refreshView();
+        try {
+            // Kill the agent process and capture its output
+            const spawnResult = await adapter.killAgent(resolvedName);
+            if (!spawnResult) {
+                this.feedLine(tp.warning(`  @${displayName} process already exited.`));
+                this.refreshView();
+                return;
+            }
+            // Get the original full prompt for this agent
+            const _originalFullPrompt = this.lastTaskPrompts.get(resolvedName) ?? "";
+            const originalTask = activeEntry.task;
+            // Parse the conversation log from available sources
+            const presetName = adapter.name ?? "unknown";
+            const { log, toolCallCount, filesChanged } = buildConversationLog(spawnResult.debugFile, spawnResult.stdout, presetName);
+            // Build the resume prompt
+            const resumePrompt = this.buildResumePrompt(originalTask, log, steeringMessage, toolCallCount, filesChanged);
+            // Report what happened
+            const elapsed = this.activeTasks.get(resolvedName)?.startTime
+                ? `${((Date.now() - this.activeTasks.get(resolvedName).startTime) / 1000).toFixed(0)}s`
+                : "unknown";
+            this.feedLine(concat(tp.success("  ⚡  Interrupted "), tp.accent(`@${displayName}`), tp.muted(` (${elapsed}, ${toolCallCount} tool calls, ${filesChanged.length} files changed)`)));
+            this.feedLine(concat(tp.muted("  Resuming with: "), tp.text(steeringMessage.slice(0, 70))));
+            this.refreshView();
+            // Clean up the active task state — the drainAgentQueue loop will see
+            // the agent as inactive and the queue entry was already removed
+            this.activeTasks.delete(resolvedName);
+            this.agentActive.delete(resolvedName);
+            if (this.activeTasks.size === 0)
+                this.stopStatusAnimation();
+            // Queue the resumed task
+            this.taskQueue.push({
+                type: "agent",
+                teammate: resolvedName,
+                task: resumePrompt,
+            });
+            this.kickDrain();
+        }
+        catch (err) {
+            this.feedLine(tp.error(`  ✖  Failed to interrupt @${displayName}: ${err?.message ?? String(err)}`));
+            this.refreshView();
+        }
+    }
+    /**
+     * Build a resume prompt from the original task, conversation log, and steering message.
+     */
+    buildResumePrompt(originalTask, conversationLog, steeringMessage, toolCallCount, filesChanged) {
+        const parts = [];
+        parts.push("<RESUME_CONTEXT>");
+        parts.push("This is a resumed task. You were previously working on this task but were interrupted.");
+        parts.push("Below is the log of what you accomplished before the interruption.");
+        parts.push("");
+        parts.push("DO NOT repeat work that is already done. Check the filesystem for files you already wrote.");
+        parts.push("Continue from where you left off.");
+        parts.push("");
+        parts.push("## What You Did Before Interruption");
+        parts.push("");
+        parts.push(`Tool calls: ${toolCallCount}`);
+        if (filesChanged.length > 0) {
+            parts.push(`Files changed: ${filesChanged.slice(0, 20).join(", ")}${filesChanged.length > 20 ? ` (+${filesChanged.length - 20} more)` : ""}`);
+        }
+        parts.push("");
+        parts.push(conversationLog);
+        parts.push("");
+        parts.push("## Interruption");
+        parts.push("");
+        parts.push(steeringMessage);
+        parts.push("");
+        parts.push("## Your Task Now");
+        parts.push("");
+        parts.push("Continue the original task from where you left off. The original task was:");
+        parts.push("");
+        parts.push(originalTask);
+        parts.push("</RESUME_CONTEXT>");
+        return parts.join("\n");
+    }
     /** Drain user tasks for a single agent — runs in parallel with other agents.
      *  System tasks are handled separately by runSystemTask(). */
     async drainAgentQueue(agent) {
@@ -3429,6 +3707,14 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                     }
                     // Display the (possibly retried) result to the user
                     this.displayTaskResult(result, entry.type);
+                    // Audit cross-folder writes for AI teammates
+                    const tmConfig = this.orchestrator.getRegistry().get(entry.teammate);
+                    if (tmConfig?.type === "ai" && result.changedFiles.length > 0) {
+                        const violations = this.auditCrossFolderWrites(entry.teammate, result.changedFiles);
+                        if (violations.length > 0) {
+                            this.showViolationWarning(entry.teammate, violations);
+                        }
+                    }
                     // Write debug entry — skip for debug analysis tasks (avoid recursion)
                     if (entry.type !== "debug") {
                         this.writeDebugEntry(entry.teammate, entry.task, result, startTime);
@@ -3933,7 +4219,21 @@ Issues that can't be resolved unilaterally — they need input from other teamma
             }
         }
     }
+    /** Compare two semver strings. Returns true if `a` is less than `b`. */
+    static semverLessThan(a, b) {
+        const pa = a.split(".").map(Number);
+        const pb = b.split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+            if ((pa[i] ?? 0) < (pb[i] ?? 0))
+                return true;
+            if ((pa[i] ?? 0) > (pb[i] ?? 0))
+                return false;
+        }
+        return false;
+    }
     async startupMaintenance() {
+        // Check and update installed CLI version
+        const versionUpdate = this.checkVersionUpdate();
         const tmpDir = join(this.teammatesDir, ".tmp");
         // Clean up debug log files older than 1 day
         const debugDir = join(tmpDir, "debug");
@@ -3960,7 +4260,56 @@ Issues that can't be resolved unilaterally — they need input from other teamma
         for (const name of teammates) {
             await this.runCompact(name, true);
         }
-        // 2. Purge daily logs older than 30 days (disk + Vectra)
+        // 2. Compress previous day's log for each teammate (queued as system tasks)
+        for (const name of teammates) {
+            try {
+                const compression = await buildDailyCompressionPrompt(join(this.teammatesDir, name));
+                if (compression) {
+                    this.taskQueue.push({
+                        type: "agent",
+                        teammate: name,
+                        task: compression.prompt,
+                        system: true,
+                    });
+                }
+            }
+            catch {
+                /* compression check failed — non-fatal */
+            }
+        }
+        // 2b. v0.6.0 migration — compress ALL uncompressed daily logs + re-index
+        const needsMigration = versionUpdate &&
+            (versionUpdate.previous === "" ||
+                TeammatesREPL.semverLessThan(versionUpdate.previous, "0.6.0"));
+        if (needsMigration) {
+            this.feedLine(tp.accent("  ℹ  Migrating to v0.6.0 — compressing daily logs..."));
+            this.refreshView();
+            let migrationCount = 0;
+            for (const name of teammates) {
+                try {
+                    const uncompressed = await findUncompressedDailies(join(this.teammatesDir, name));
+                    if (uncompressed.length === 0)
+                        continue;
+                    const prompt = await buildMigrationCompressionPrompt(join(this.teammatesDir, name), name, uncompressed);
+                    if (prompt) {
+                        migrationCount++;
+                        this.taskQueue.push({
+                            type: "agent",
+                            teammate: name,
+                            task: prompt,
+                            system: true,
+                            migration: true,
+                        });
+                    }
+                }
+                catch {
+                    /* migration compression failed — non-fatal */
+                }
+            }
+            this.pendingMigrationSyncs = migrationCount;
+        }
+        this.kickDrain();
+        // 3. Purge daily logs older than 30 days (disk + Vectra)
         const { Indexer } = await import("@teammates/recall");
         const indexer = new Indexer({ teammatesDir: this.teammatesDir });
         for (const name of teammates) {
@@ -3975,7 +4324,7 @@ Issues that can't be resolved unilaterally — they need input from other teamma
                 /* purge failed — non-fatal */
             }
         }
-        // 3. Sync recall indexes (bundled library call)
+        // 4. Sync recall indexes (bundled library call)
         try {
             await syncRecallIndex(this.teammatesDir);
         }
@@ -3983,6 +4332,45 @@ Issues that can't be resolved unilaterally — they need input from other teamma
             /* sync failed — non-fatal */
         }
     }
+    /**
+     * Check if the CLI version has changed since last run.
+     * Updates settings.json with the current version.
+     * Returns the previous version if it changed, null otherwise.
+     */
+    checkVersionUpdate() {
+        const settingsPath = join(this.teammatesDir, "settings.json");
+        let settings = {};
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            // No settings file or invalid JSON — create one
+        }
+        const previous = settings.cliVersion ?? "";
+        const current = PKG_VERSION;
+        if (previous === current)
+            return null;
+        // Detect major/minor version change (not just patch)
+        const [prevMajor, prevMinor] = previous.split(".").map(Number);
+        const [curMajor, curMinor] = current.split(".").map(Number);
+        const isMajorMinor = previous !== "" && (prevMajor !== curMajor || prevMinor !== curMinor);
+        // Update the stored version
+        settings.cliVersion = current;
+        if (!settings.version)
+            settings.version = 1;
+        try {
+            writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+        }
+        catch {
+            /* write failed — non-fatal */
+        }
+        if (isMajorMinor) {
+            this.feedLine(tp.accent(`  ✔  Updated from v${previous} → v${current}`));
+            this.feedLine();
+            this.refreshView();
+        }
+        return { previous, current };
+    }
     async cmdCopy() {
         this.doCopy(); // copies entire session
     }

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

@@ -534,3 +534,128 @@ 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:
+\`\`\`
+---
+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:
+\`\`\`
+---
+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";