@teammates/cli 0.5.2 → 0.6.0

package/dist/cli.js

@@ -18,10 +18,11 @@ import ora from "ora";
 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 { findAtMention, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
-import { autoCompactForBudget, buildWisdomPrompt, compactEpisodic, purgeStaleDailies, } from "./compact.js";
+import { buildConversationContext as buildConvCtx, buildSummarizationPrompt, cleanResponseBody, findAtMention, findSummarizationSplit, isImagePath, relativeTime, wrapLine, } from "./cli-utils.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";
@@ -44,9 +45,12 @@ class TeammatesREPL {
     storeResult(result) {
         this.lastResult = result;
         this.lastResults.set(result.teammate, result);
+        // Store the full response body in conversation history — not just the
+        // subject line.  The 24k-token budget + auto-summarization handle size.
+        const body = cleanResponseBody(result.rawOutput ?? "");
         this.conversationHistory.push({
             role: result.teammate,
-            text: result.summary,
+            text: body || result.summary,
         });
     }
     /**
@@ -151,28 +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() {
-        if (this.conversationHistory.length === 0 && !this.conversationSummary)
-            return "";
-        const budget = TeammatesREPL.CONV_HISTORY_CHARS;
-        const parts = ["## Conversation History\n"];
-        // Include running summary of older conversation if present
-        if (this.conversationSummary) {
-            parts.push(`### Previous Conversation Summary\n\n${this.conversationSummary}\n`);
-        }
-        // Work backwards from newest — include whole entries up to 24k tokens
-        const entries = [];
-        let used = 0;
-        for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
-            const line = `**${this.conversationHistory[i].role}:** ${this.conversationHistory[i].text}\n`;
-            if (used + line.length > budget && entries.length > 0)
-                break;
-            entries.unshift(line);
-            used += line.length;
-        }
-        if (entries.length > 0)
-            parts.push(entries.join("\n"));
-        return parts.join("\n");
+        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.
@@ -180,28 +176,11 @@ class TeammatesREPL {
      * and queue a summarization task to the coding agent.
      */
     maybeQueueSummarization() {
-        const budget = TeammatesREPL.CONV_HISTORY_CHARS;
-        // Calculate how many recent entries fit in the budget (newest first)
-        let recentChars = 0;
-        let splitIdx = this.conversationHistory.length;
-        for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
-            const line = `**${this.conversationHistory[i].role}:** ${this.conversationHistory[i].text}\n`;
-            if (recentChars + line.length > budget)
-                break;
-            recentChars += line.length;
-            splitIdx = i;
-        }
+        const splitIdx = findSummarizationSplit(this.conversationHistory, TeammatesREPL.CONV_HISTORY_CHARS);
         if (splitIdx === 0)
             return; // everything fits — nothing to summarize
-        // Collect entries that are being pushed out
         const toSummarize = this.conversationHistory.slice(0, splitIdx);
-        const entriesText = toSummarize
-            .map((e) => `**${e.role}:** ${e.text}`)
-            .join("\n");
-        // Build the summarization prompt
-        const prompt = this.conversationSummary
-            ? `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Update the existing summary to incorporate the new conversation entries below.\n\n## Current Summary\n\n${this.conversationSummary}\n\n## New Entries to Incorporate\n\n${entriesText}\n\n## Instructions\n\nReturn ONLY the updated summary — no preamble, no explanation. The summary should:\n- Be a concise bulleted list of key topics discussed, decisions made, and work completed\n- Preserve important context that future messages might reference\n- Drop trivial or redundant details\n- Stay under 2000 characters\n- Do NOT include any output protocol (no TO:, no # Subject, no handoff blocks)`
-            : `You are maintaining a running summary of an ongoing conversation between a user and their AI teammates. Summarize the conversation entries below.\n\n## Entries to Summarize\n\n${entriesText}\n\n## Instructions\n\nReturn ONLY the summary — no preamble, no explanation. The summary should:\n- Be a concise bulleted list of key topics discussed, decisions made, and work completed\n- Preserve important context that future messages might reference\n- Drop trivial or redundant details\n- Stay under 2000 characters\n- Do NOT include any output protocol (no TO:, no # Subject, no handoff blocks)`;
+        const prompt = buildSummarizationPrompt(toSummarize, this.conversationSummary);
         // Remove the summarized entries — they'll be captured in the summary
         this.conversationHistory.splice(0, splitIdx);
         // Queue the summarization task through the user's agent
@@ -221,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. */
@@ -242,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. */
@@ -346,12 +329,12 @@ class TeammatesREPL {
         // Keep adding segments from the front until we'd exceed maxLen
         let front = parts[0];
         for (let i = 1; i < parts.length - 1; i++) {
-            const candidate = front + sep + parts[i] + sep + "..." + sep + last;
+            const candidate = `${front + sep + parts[i] + sep}...${sep}${last}`;
             if (candidate.length > maxLen)
                 break;
             front += sep + parts[i];
         }
-        return front + sep + "..." + sep + last;
+        return `${front + sep}...${sep}${last}`;
     }
     /** Format elapsed seconds as (Ns), (Nm Ns), or (Nh Nm Ns). */
     static formatElapsed(totalSeconds) {
@@ -761,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)
@@ -1147,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 ───────────────────────────────────────────────────
@@ -2584,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);
             }
@@ -3080,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"],
@@ -3399,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) {
@@ -3463,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);
@@ -3967,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");
@@ -3994,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) {
@@ -4009,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);
         }
@@ -4017,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>;