@teammates/cli 0.5.3 → 0.6.1

package/dist/cli.js

@@ -8,9 +8,9 @@
  *   teammates --dir <path>        Override .teammates/ location
  */
 import { exec as execCb, execSync, spawnSync } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
-import { dirname, join, resolve, sep } from "node:path";
+import { basename, dirname, join, resolve, sep } from "node:path";
 import { createInterface } from "node:readline";
 import { App, ChatView, concat, esc, pen, renderMarkdown, stripAnsi, } from "@teammates/consolonia";
 import chalk from "chalk";
@@ -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 { buildConversationContext as buildConvCtx, buildSummarizationPrompt, cleanResponseBody, findAtMention, findSummarizationSplit, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
-import { autoCompactForBudget, buildWisdomPrompt, compactEpisodic, purgeStaleDailies, } from "./compact.js";
+import { buildConversationContext as buildConvCtx, buildSummarizationPrompt, cleanResponseBody, compressConversationEntries, findAtMention, findSummarizationSplit, formatConversationEntry, 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";
@@ -120,8 +121,11 @@ class TeammatesREPL {
         if (this.chatView && cleaned) {
             const t = theme();
             const teammate = result.teammate;
-            const replyId = `reply-${teammate}-${Date.now()}`;
+            const ts = Date.now();
+            const replyId = `reply-${teammate}-${ts}`;
+            const copyId = `copy-${teammate}-${ts}`;
             this._replyContexts.set(replyId, { teammate, message: cleaned });
+            this._copyContexts.set(copyId, cleaned);
             this.chatView.appendActionList([
                 {
                     id: replyId,
@@ -135,7 +139,7 @@ class TeammatesREPL {
                     }),
                 },
                 {
-                    id: "copy",
+                    id: copyId,
                     normalStyle: this.makeSpan({
                         text: " [copy]",
                         style: { fg: t.textDim },
@@ -152,15 +156,25 @@ class TeammatesREPL {
         this.refreshTeammates();
         this.showPrompt();
     }
-    /** Token budget for recent conversation history (24k tokens ≈ 96k chars). */
-    static CONV_HISTORY_CHARS = 24_000 * 4;
-    buildConversationContext() {
-        return buildConvCtx(this.conversationHistory, this.conversationSummary, TeammatesREPL.CONV_HISTORY_CHARS);
+    /** Target context window in tokens. Conversation history budget is derived from this. */
+    static TARGET_CONTEXT_TOKENS = 128_000;
+    /** Estimated tokens used by non-conversation prompt sections (identity, wisdom, logs, recall, instructions, task). */
+    static PROMPT_OVERHEAD_TOKENS = 32_000;
+    /** Chars-per-token approximation (matches adapter.ts). */
+    static CHARS_PER_TOKEN = 4;
+    /** Character budget for conversation history = (target − overhead) × chars/token. */
+    static CONV_HISTORY_CHARS = (TeammatesREPL.TARGET_CONTEXT_TOKENS -
+        TeammatesREPL.PROMPT_OVERHEAD_TOKENS) *
+        TeammatesREPL.CHARS_PER_TOKEN;
+    buildConversationContext(_teammate, snapshot) {
+        const history = snapshot ? snapshot.history : this.conversationHistory;
+        const summary = snapshot ? snapshot.summary : this.conversationSummary;
+        return buildConvCtx(history, summary, TeammatesREPL.CONV_HISTORY_CHARS);
     }
     /**
-     * Check if conversation history exceeds the 24k token budget.
+     * Check if conversation history exceeds the token budget.
      * If so, take the older entries that won't fit, combine with existing summary,
-     * and queue a summarization task to the coding agent.
+     * and queue a summarization task to the coding agent for high-quality compression.
      */
     maybeQueueSummarization() {
         const splitIdx = findSummarizationSplit(this.conversationHistory, TeammatesREPL.CONV_HISTORY_CHARS);
@@ -178,6 +192,23 @@ class TeammatesREPL {
         });
         this.kickDrain();
     }
+    /**
+     * Pre-dispatch compression: if conversation history exceeds the token budget,
+     * mechanically compress older entries into bullet summaries BEFORE building the
+     * prompt. This ensures the prompt always fits within the target context window,
+     * even if the async agent-quality summarization hasn't completed yet.
+     */
+    preDispatchCompress() {
+        const totalChars = this.conversationHistory.reduce((sum, e) => sum + formatConversationEntry(e.role, e.text).length, 0);
+        if (totalChars <= TeammatesREPL.CONV_HISTORY_CHARS)
+            return;
+        const splitIdx = findSummarizationSplit(this.conversationHistory, TeammatesREPL.CONV_HISTORY_CHARS);
+        if (splitIdx === 0)
+            return;
+        const toCompress = this.conversationHistory.slice(0, splitIdx);
+        this.conversationSummary = compressConversationEntries(toCompress, this.conversationSummary);
+        this.conversationHistory.splice(0, splitIdx);
+    }
     adapterName;
     teammatesDir;
     taskQueue = [];
@@ -187,6 +218,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. */
@@ -199,6 +232,8 @@ class TeammatesREPL {
     ctrlcPending = false; // true after first Ctrl+C, waiting for second
     ctrlcTimer = null;
     lastCleanedOutput = ""; // last teammate output for clipboard copy
+    /** Maps copy action IDs to the cleaned output text for that response. */
+    _copyContexts = new Map();
     autoApproveHandoffs = false;
     /** Last debug log file path per teammate — for /debug analysis. */
     lastDebugFiles = new Map();
@@ -208,6 +243,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 +764,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)
@@ -976,8 +1142,14 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         if (everyoneMatch) {
             const task = everyoneMatch[1];
             const names = allNames.filter((n) => n !== this.selfName && n !== this.adapterName);
+            // Atomic snapshot: freeze conversation state ONCE so all agents see
+            // the same context regardless of concurrent preDispatchCompress mutations.
+            const contextSnapshot = {
+                history: this.conversationHistory.map((e) => ({ ...e })),
+                summary: this.conversationSummary,
+            };
             for (const teammate of names) {
-                this.taskQueue.push({ type: "agent", teammate, task });
+                this.taskQueue.push({ type: "agent", teammate, task, contextSnapshot });
             }
             const bg = this._userBg;
             const t = theme();
@@ -1113,6 +1285,22 @@ 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 */
+                    }
+                    // Persist version LAST — only after all migration tasks finish
+                    this.commitVersionUpdate();
+                }
+            }
         }
     }
     // ─── Onboarding ───────────────────────────────────────────────────
@@ -1952,9 +2140,51 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
         compact: new Set([0]),
         debug: new Set([0]),
         retro: new Set([0]),
+        interrupt: new Set([0]),
+        int: new Set([0]),
     };
     /** Build param-completion items for the current line, if any. */
     getParamItems(cmdName, argsBefore, partial) {
+        // Script subcommand + name completion for /script
+        if (cmdName === "script") {
+            const completedArgs = argsBefore.trim()
+                ? argsBefore.trim().split(/\s+/).length
+                : 0;
+            const lower = partial.toLowerCase();
+            if (completedArgs === 0) {
+                // First arg — suggest subcommands
+                const subs = [
+                    { name: "list", desc: "List saved scripts" },
+                    { name: "run", desc: "Run an existing script" },
+                ];
+                return subs
+                    .filter((s) => s.name.startsWith(lower))
+                    .map((s) => ({
+                    label: s.name,
+                    description: s.desc,
+                    completion: `/script ${s.name} `,
+                }));
+            }
+            if (completedArgs === 1 && argsBefore.trim() === "run") {
+                // Second arg after "run" — suggest script filenames
+                const scriptsDir = join(this.teammatesDir, this.selfName, "scripts");
+                let files = [];
+                try {
+                    files = readdirSync(scriptsDir).filter((f) => !f.startsWith("."));
+                }
+                catch {
+                    // directory doesn't exist yet
+                }
+                return files
+                    .filter((f) => f.toLowerCase().startsWith(lower))
+                    .map((f) => ({
+                    label: f,
+                    description: "saved script",
+                    completion: `/script run ${f}`,
+                }));
+            }
+            return [];
+        }
         // Service name completion for /configure
         if (cmdName === "configure" || cmdName === "config") {
             const completedArgs = argsBefore.trim()
@@ -2543,13 +2773,17 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             if (id.startsWith("copy-cmd:")) {
                 this.doCopy(id.slice("copy-cmd:".length));
             }
-            else if (id === "copy") {
-                this.doCopy(this.lastCleanedOutput || undefined);
+            else if (id.startsWith("copy-")) {
+                const text = this._copyContexts.get(id);
+                this.doCopy(text || this.lastCleanedOutput || undefined);
             }
             else if (id.startsWith("retro-approve-") ||
                 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 +3280,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"],
@@ -3095,6 +3336,13 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 description: "Ask a quick side question without interrupting the main conversation",
                 run: (args) => this.cmdBtw(args),
             },
+            {
+                name: "script",
+                aliases: [],
+                usage: "/script [list | run <name> | what should the script do?]",
+                description: "Write and run reusable scripts via the coding agent",
+                run: (args) => this.cmdScript(args),
+            },
             {
                 name: "theme",
                 aliases: [],
@@ -3365,6 +3613,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) {
@@ -3378,9 +3734,16 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
             try {
                 {
                     // btw and debug tasks skip conversation context (not part of main thread)
-                    const extraContext = entry.type === "btw" || entry.type === "debug"
-                        ? ""
-                        : this.buildConversationContext();
+                    const isMainThread = entry.type !== "btw" && entry.type !== "debug";
+                    // Snapshot-aware context building: if the entry has a frozen snapshot
+                    // (@everyone), use it directly — no mutation of shared state.
+                    // Otherwise, compress live state as before.
+                    const snapshot = entry.type === "agent" ? entry.contextSnapshot : undefined;
+                    if (isMainThread && !snapshot)
+                        this.preDispatchCompress();
+                    const extraContext = isMainThread
+                        ? this.buildConversationContext(entry.teammate, snapshot)
+                        : "";
                     let result = await this.orchestrator.assign({
                         teammate: entry.teammate,
                         task: entry.task,
@@ -3429,6 +3792,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 +4304,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 +4345,64 @@ 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;
+            // If no migration tasks were actually queued, commit version now
+            if (migrationCount === 0) {
+                this.commitVersionUpdate();
+            }
+        }
+        else if (versionUpdate) {
+            // No migration needed — commit the version update immediately
+            this.commitVersionUpdate();
+        }
+        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 +4417,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 +4425,60 @@ 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.
+     * Does NOT update settings.json — call `commitVersionUpdate()` after
+     * migration tasks are complete to persist the new version.
+     */
+    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
+        }
+        const previous = settings.cliVersion ?? "";
+        const current = PKG_VERSION;
+        if (previous === current)
+            return null;
+        return { previous, current };
+    }
+    /**
+     * Persist the current CLI version to settings.json.
+     * Called after all migration tasks complete (or immediately if no migration needed).
+     */
+    commitVersionUpdate() {
+        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;
+        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 */
+        }
+        // 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);
+        if (isMajorMinor) {
+            this.feedLine(tp.accent(`  ✔  Updated from v${previous} → v${current}`));
+            this.feedLine();
+            this.refreshView();
+        }
+    }
     async cmdCopy() {
         this.doCopy(); // copies entire session
     }
@@ -4136,6 +4632,116 @@ Issues that can't be resolved unilaterally — they need input from other teamma
         this.refreshView();
         this.kickDrain();
     }
+    async cmdScript(argsStr) {
+        const args = argsStr.trim();
+        const scriptsDir = join(this.teammatesDir, this.selfName, "scripts");
+        // /script (no args) — show usage
+        if (!args) {
+            this.feedLine();
+            this.feedLine(tp.bold("  /script — write and run reusable scripts"));
+            this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
+            this.feedLine(concat(tp.accent("  /script list".padEnd(36)), tp.text("List saved scripts")));
+            this.feedLine(concat(tp.accent("  /script run <name>".padEnd(36)), tp.text("Run an existing script")));
+            this.feedLine(concat(tp.accent("  /script <description>".padEnd(36)), tp.text("Create and run a new script")));
+            this.feedLine();
+            this.feedLine(tp.muted(`  Scripts are saved to ${scriptsDir}`));
+            this.feedLine();
+            this.refreshView();
+            return;
+        }
+        // /script list — list saved scripts
+        if (args === "list") {
+            let files = [];
+            try {
+                files = readdirSync(scriptsDir).filter((f) => !f.startsWith("."));
+            }
+            catch {
+                // directory doesn't exist yet
+            }
+            this.feedLine();
+            if (files.length === 0) {
+                this.feedLine(tp.muted("  No scripts saved yet."));
+                this.feedLine(tp.muted("  Use /script <description> to create one."));
+            }
+            else {
+                this.feedLine(tp.bold("  Saved scripts"));
+                this.feedLine(tp.muted(`  ${"─".repeat(50)}`));
+                for (const f of files) {
+                    this.feedLine(concat(tp.accent(`  ${f}`)));
+                }
+            }
+            this.feedLine();
+            this.refreshView();
+            return;
+        }
+        // /script run <name> — run an existing script
+        if (args.startsWith("run ")) {
+            const name = args.slice(4).trim();
+            if (!name) {
+                this.feedLine(tp.muted("  Usage: /script run <name>"));
+                this.refreshView();
+                return;
+            }
+            // Find the script file (try exact match, then with common extensions)
+            const candidates = [
+                name,
+                `${name}.sh`,
+                `${name}.ts`,
+                `${name}.js`,
+                `${name}.ps1`,
+                `${name}.py`,
+            ];
+            let scriptPath = null;
+            for (const c of candidates) {
+                const p = join(scriptsDir, c);
+                if (existsSync(p)) {
+                    scriptPath = p;
+                    break;
+                }
+            }
+            if (!scriptPath) {
+                this.feedLine(tp.warning(`  Script not found: ${name}`));
+                this.feedLine(tp.muted("  Use /script list to see available scripts."));
+                this.refreshView();
+                return;
+            }
+            const scriptContent = readFileSync(scriptPath, "utf-8");
+            const task = `Run the following script located at ${scriptPath}:\n\n\`\`\`\n${scriptContent}\n\`\`\`\n\nExecute it and report the results. If it fails, diagnose the issue and fix it.`;
+            this.taskQueue.push({
+                type: "script",
+                teammate: this.selfName,
+                task,
+            });
+            this.feedLine(concat(tp.muted("  Running script "), tp.accent(basename(scriptPath)), tp.muted(" → "), tp.accent(`@${this.adapterName}`)));
+            this.feedLine();
+            this.refreshView();
+            this.kickDrain();
+            return;
+        }
+        // /script <description> — create and run a new script
+        const task = [
+            `The user wants a reusable script. Their request:`,
+            ``,
+            args,
+            ``,
+            `Instructions:`,
+            `1. Write the script and save it to the scripts directory: ${scriptsDir}`,
+            `2. Create the directory if it doesn't exist.`,
+            `3. Choose a short, descriptive filename (kebab-case, with appropriate extension like .sh, .ts, .js, .py, .ps1).`,
+            `4. Make the script executable if applicable.`,
+            `5. Run the script and report the results.`,
+            `6. If the script needs to be parameterized, use command-line arguments.`,
+        ].join("\n");
+        this.taskQueue.push({
+            type: "script",
+            teammate: this.selfName,
+            task,
+        });
+        this.feedLine(concat(tp.muted("  Script task → "), tp.accent(`@${this.adapterName}`)));
+        this.feedLine();
+        this.refreshView();
+        this.kickDrain();
+    }
     async cmdTheme() {
         const t = theme();
         this.feedLine();