@teammates/cli 0.4.1 → 0.5.1

package/dist/compact.d.ts

@@ -9,6 +9,8 @@
  *   daily logs (7 days) → weekly summary (kept 52 weeks)
  *   weekly summaries (>52 weeks) → monthly summary (kept permanently)
  */
+/** How long daily logs are kept on disk before purging (30 days). */
+export declare const DAILY_LOG_RETENTION_DAYS = 30;
 export interface CompactionResult {
     teammate: string;
     weekliesCreated: string[];
@@ -19,11 +21,27 @@ export interface CompactionResult {
 /**
  * Compact daily logs into weekly summaries for a single teammate.
  * Only compacts complete weeks (not the current week).
+ * If a partial weekly exists for a week, merges new dailies into it.
  */
 export declare function compactDailies(teammateDir: string): Promise<{
     created: string[];
     removed: string[];
 }>;
+/**
+ * Auto-compact oldest daily logs into weekly summaries when the total
+ * daily log token count exceeds the budget. Unlike `compactDailies()`,
+ * this WILL compact the current week if needed, marking the result as
+ * `partial: true` in frontmatter. Partial weeklies are later merged
+ * by `compactDailies()` when more dailies arrive.
+ *
+ * @param teammateDir - Path to the teammate directory
+ * @param budgetTokens - Maximum token budget for daily logs
+ * @returns What was compacted, or null if budget was not exceeded
+ */
+export declare function autoCompactForBudget(teammateDir: string, budgetTokens: number): Promise<{
+    created: string[];
+    compactedDates: string[];
+} | null>;
 /**
  * Compact weekly summaries older than 52 weeks into monthly summaries.
  */
@@ -44,3 +62,8 @@ export declare function compactEpisodic(teammateDir: string, teammateName: strin
  * Returns null if there are no typed memories to distill from.
  */
 export declare function buildWisdomPrompt(teammateDir: string, teammateName: string): Promise<string | null>;
+/**
+ * Purge daily logs older than DAILY_LOG_RETENTION_DAYS from disk.
+ * Returns the list of deleted filenames.
+ */
+export declare function purgeStaleDailies(teammateDir: string): Promise<string[]>;

package/dist/compact.js

@@ -11,6 +11,8 @@
  */
 import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
+/** How long daily logs are kept on disk before purging (30 days). */
+export const DAILY_LOG_RETENTION_DAYS = 30;
 /**
  * Get ISO week number and year for a date.
  * Returns { year, week } where week is 1-53.
@@ -34,7 +36,7 @@ function formatWeek(year, week) {
 function groupDailiesByWeek(dailies) {
     const groups = new Map();
     for (const daily of dailies) {
-        const d = new Date(`${daily.date}T00:00:00Z`);
+        const d = new Date(`${daily.date}T00:00:00`);
         const { year, week } = getISOWeek(d);
         const key = formatWeek(year, week);
         const group = groups.get(key) ?? [];
@@ -72,8 +74,10 @@ function groupWeekliesByMonth(weeklies) {
 /**
  * Build a weekly summary from daily logs.
  * This is a structural concatenation — the agent can refine it afterward.
+ * When `partial` is true, adds `partial: true` to frontmatter to indicate
+ * the week is incomplete and may be merged with later dailies.
  */
-function buildWeeklySummary(weekKey, dailies) {
+function buildWeeklySummary(weekKey, dailies, partial = false) {
     // Sort chronologically
     const sorted = [...dailies].sort((a, b) => a.date.localeCompare(b.date));
     const firstDate = sorted[0].date;
@@ -83,6 +87,8 @@ function buildWeeklySummary(weekKey, dailies) {
     lines.push(`type: weekly`);
     lines.push(`week: ${weekKey}`);
     lines.push(`period: ${firstDate} to ${lastDate}`);
+    if (partial)
+        lines.push("partial: true");
     lines.push("---");
     lines.push("");
     lines.push(`# Week ${weekKey}`);
@@ -122,6 +128,7 @@ function buildMonthlySummary(monthKey, weeklies) {
 /**
  * Compact daily logs into weekly summaries for a single teammate.
  * Only compacts complete weeks (not the current week).
+ * If a partial weekly exists for a week, merges new dailies into it.
  */
 export async function compactDailies(teammateDir) {
     const memoryDir = join(teammateDir, "memory");
@@ -146,13 +153,21 @@ export async function compactDailies(teammateDir) {
     const now = new Date();
     const { year: curYear, week: curWeek } = getISOWeek(now);
     const currentWeek = formatWeek(curYear, curWeek);
-    // Check which weekly summaries already exist
+    // Check which weekly summaries already exist and which are partial
     const existingWeeklies = new Set();
+    const partialWeeklies = new Set();
     try {
         const wEntries = await readdir(weeklyDir);
         for (const e of wEntries) {
-            if (e.endsWith(".md"))
-                existingWeeklies.add(basename(e, ".md"));
+            if (!e.endsWith(".md"))
+                continue;
+            const stem = basename(e, ".md");
+            existingWeeklies.add(stem);
+            // Check if this weekly is partial
+            const content = await readFile(join(weeklyDir, e), "utf-8");
+            if (/^partial:\s*true/m.test(content)) {
+                partialWeeklies.add(stem);
+            }
         }
     }
     catch {
@@ -164,7 +179,25 @@ export async function compactDailies(teammateDir) {
         // Skip current week
         if (weekKey === currentWeek)
             continue;
-        // Skip if weekly summary already exists
+        // If a partial weekly exists for this week, merge new dailies into it
+        if (partialWeeklies.has(weekKey)) {
+            const existingDailies = await extractDailiesFromWeekly(join(weeklyDir, `${weekKey}.md`));
+            // Merge: combine existing + new, dedup by date
+            const dateSet = new Set(existingDailies.map((d) => d.date));
+            const merged = [...existingDailies];
+            for (const d of weekDailies) {
+                if (!dateSet.has(d.date)) {
+                    merged.push({ date: d.date, content: d.content });
+                    dateSet.add(d.date);
+                }
+            }
+            // Rewrite as non-partial (complete week now, since current week is excluded)
+            const summary = buildWeeklySummary(weekKey, merged, false);
+            await writeFile(join(weeklyDir, `${weekKey}.md`), summary, "utf-8");
+            created.push(`${weekKey}.md (merged)`);
+            continue;
+        }
+        // Skip if weekly summary already exists (non-partial)
         if (existingWeeklies.has(weekKey))
             continue;
         // Create weekly dir if needed
@@ -174,14 +207,127 @@ export async function compactDailies(teammateDir) {
         const weeklyFile = join(weeklyDir, `${weekKey}.md`);
         await writeFile(weeklyFile, summary, "utf-8");
         created.push(`${weekKey}.md`);
-        // Delete the daily logs that were compacted
-        for (const daily of weekDailies) {
-            await unlink(join(memoryDir, daily.file)).catch(() => { });
-            removed.push(daily.file);
-        }
+        // Daily logs are kept on disk for DAILY_LOG_RETENTION_DAYS (purged separately)
     }
     return { created, removed };
 }
+/**
+ * Extract daily log entries from a weekly summary file.
+ * Parses `## YYYY-MM-DD` sections back into individual entries.
+ */
+async function extractDailiesFromWeekly(weeklyPath) {
+    let raw;
+    try {
+        raw = await readFile(weeklyPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    // Strip frontmatter
+    raw = raw.replace(/^---[\s\S]*?---\s*\n/, "");
+    // Split on ## YYYY-MM-DD headers
+    const entries = [];
+    const parts = raw.split(/^## (\d{4}-\d{2}-\d{2})\s*$/m);
+    // parts[0] = preamble (# Week header), then alternating: date, content, date, content...
+    for (let i = 1; i < parts.length; i += 2) {
+        const date = parts[i];
+        const content = (parts[i + 1] ?? "").trim();
+        if (date && content) {
+            entries.push({ date, content });
+        }
+    }
+    return entries;
+}
+/** Approximate chars per token for budget estimation. */
+const CHARS_PER_TOKEN = 4;
+/** Estimate tokens from character count. */
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+/**
+ * Auto-compact oldest daily logs into weekly summaries when the total
+ * daily log token count exceeds the budget. Unlike `compactDailies()`,
+ * this WILL compact the current week if needed, marking the result as
+ * `partial: true` in frontmatter. Partial weeklies are later merged
+ * by `compactDailies()` when more dailies arrive.
+ *
+ * @param teammateDir - Path to the teammate directory
+ * @param budgetTokens - Maximum token budget for daily logs
+ * @returns What was compacted, or null if budget was not exceeded
+ */
+export async function autoCompactForBudget(teammateDir, budgetTokens) {
+    const memoryDir = join(teammateDir, "memory");
+    const weeklyDir = join(memoryDir, "weekly");
+    // Read all daily logs
+    const entries = await readdir(memoryDir).catch(() => []);
+    const dailies = [];
+    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");
+        dailies.push({ date: stem, content, file: entry });
+    }
+    if (dailies.length === 0)
+        return null;
+    // Sort chronologically (oldest first)
+    dailies.sort((a, b) => a.date.localeCompare(b.date));
+    // Estimate total token cost (excluding today — today is always in prompt)
+    const today = new Date().toISOString().slice(0, 10);
+    const pastDailies = dailies.filter((d) => d.date !== today);
+    const totalTokens = pastDailies.reduce((sum, d) => sum + estimateTokens(`### ${d.date}\n${d.content}`), 0);
+    // If under budget, nothing to do
+    if (totalTokens <= budgetTokens)
+        return null;
+    // Group by ISO week
+    const groups = groupDailiesByWeek(pastDailies);
+    // Sort week keys chronologically (oldest first)
+    const sortedWeeks = [...groups.keys()].sort();
+    // Determine current week
+    const now = new Date();
+    const { year: curYear, week: curWeek } = getISOWeek(now);
+    const currentWeek = formatWeek(curYear, curWeek);
+    // Check existing weeklies
+    const existingWeeklies = new Set();
+    try {
+        const wEntries = await readdir(weeklyDir);
+        for (const e of wEntries) {
+            if (e.endsWith(".md"))
+                existingWeeklies.add(basename(e, ".md"));
+        }
+    }
+    catch {
+        // No weekly dir yet
+    }
+    // Compact oldest weeks first until remaining dailies fit in budget
+    let remainingTokens = totalTokens;
+    const created = [];
+    const compactedDates = [];
+    for (const weekKey of sortedWeeks) {
+        if (remainingTokens <= budgetTokens)
+            break;
+        // Skip weeks that already have a (non-partial) weekly summary
+        if (existingWeeklies.has(weekKey))
+            continue;
+        const weekDailies = groups.get(weekKey);
+        const weekTokens = weekDailies.reduce((sum, d) => sum + estimateTokens(`### ${d.date}\n${d.content}`), 0);
+        // Mark as partial if this is the current week
+        const isPartial = weekKey === currentWeek;
+        await mkdir(weeklyDir, { recursive: true });
+        const summary = buildWeeklySummary(weekKey, weekDailies, isPartial);
+        await writeFile(join(weeklyDir, `${weekKey}.md`), summary, "utf-8");
+        created.push(`${weekKey}.md${isPartial ? " (partial)" : ""}`);
+        for (const d of weekDailies) {
+            compactedDates.push(d.date);
+        }
+        remainingTokens -= weekTokens;
+    }
+    if (created.length === 0)
+        return null;
+    return { created, compactedDates };
+}
 /**
  * Compact weekly summaries older than 52 weeks into monthly summaries.
  */
@@ -364,3 +510,27 @@ export async function buildWisdomPrompt(teammateDir, teammateName) {
     parts.push(`Read your current WISDOM.md at \`.teammates/${teammateName}/WISDOM.md\` and rewrite it with updated, distilled entries. Write the file directly — this is the one time you are allowed to edit WISDOM.md.`);
     return parts.join("\n");
 }
+/**
+ * Purge daily logs older than DAILY_LOG_RETENTION_DAYS from disk.
+ * Returns the list of deleted filenames.
+ */
+export async function purgeStaleDailies(teammateDir) {
+    const memoryDir = join(teammateDir, "memory");
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - DAILY_LOG_RETENTION_DAYS);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    const entries = await readdir(memoryDir).catch(() => []);
+    const purged = [];
+    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;
+        if (stem < cutoffStr) {
+            await unlink(join(memoryDir, entry)).catch(() => { });
+            purged.push(entry);
+        }
+    }
+    return purged;
+}

package/dist/compact.test.js

@@ -2,7 +2,7 @@ import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { compactDailies, compactEpisodic, compactWeeklies } from "./compact.js";
+import { DAILY_LOG_RETENTION_DAYS, autoCompactForBudget, buildWisdomPrompt, compactDailies, compactEpisodic, compactWeeklies, purgeStaleDailies, } from "./compact.js";
 let testDir;
 beforeEach(async () => {
     testDir = join(tmpdir(), `compact-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -24,10 +24,8 @@ describe("compactDailies", () => {
         const result = await compactDailies(testDir);
         expect(result.created).toHaveLength(1);
         expect(result.created[0]).toBe("2024-W10.md");
-        expect(result.removed).toHaveLength(3);
-        expect(result.removed).toContain("2024-03-05.md");
-        expect(result.removed).toContain("2024-03-06.md");
-        expect(result.removed).toContain("2024-03-07.md");
+        // Daily logs are no longer deleted during compaction (kept 30 days)
+        expect(result.removed).toHaveLength(0);
         // Verify the weekly summary was actually written
         const weeklyDir = join(memDir, "weekly");
         const weeklyFiles = await readdir(weeklyDir);
@@ -57,7 +55,8 @@ describe("compactDailies", () => {
         await writeFile(join(memDir, "2024-03-13.md"), "# W11 day2");
         const result = await compactDailies(testDir);
         expect(result.created).toHaveLength(2);
-        expect(result.removed).toHaveLength(4);
+        // Daily logs are no longer deleted during compaction (kept 30 days)
+        expect(result.removed).toHaveLength(0);
     });
     it("skips weeks that already have a weekly summary", async () => {
         const memDir = join(testDir, "memory");
@@ -181,7 +180,8 @@ describe("compactEpisodic", () => {
         const result = await compactEpisodic(testDir, "test");
         expect(result.teammate).toBe("test");
         expect(result.weekliesCreated).toHaveLength(1);
-        expect(result.dailiesRemoved).toHaveLength(2);
+        // Daily logs are no longer deleted during compaction (kept 30 days)
+        expect(result.dailiesRemoved).toHaveLength(0);
         // The newly created weekly (2024-W10) is >52 weeks old, so compactWeeklies
         // immediately compacts it into a monthly summary
         expect(result.monthliesCreated).toHaveLength(1);
@@ -196,3 +196,319 @@ describe("compactEpisodic", () => {
         expect(result.weekliesRemoved).toEqual([]);
     });
 });
+describe("buildWisdomPrompt", () => {
+    it("returns null when no typed memories or daily logs exist", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        const result = await buildWisdomPrompt(testDir, "test");
+        expect(result).toBeNull();
+    });
+    it("returns null when memory dir does not exist", async () => {
+        const result = await buildWisdomPrompt(testDir, "test");
+        expect(result).toBeNull();
+    });
+    it("includes typed memory files in the prompt", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(memDir, "feedback_testing.md"), "---\nname: Testing feedback\ntype: feedback\n---\nAlways run tests before committing.");
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        expect(result).toContain("## Typed Memories");
+        expect(result).toContain("feedback_testing.md");
+        expect(result).toContain("Always run tests before committing.");
+    });
+    it("includes recent daily logs in the prompt", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        const today = new Date().toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${today}.md`), "# Today\n\nDid some work.");
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        expect(result).toContain("## Recent Daily Logs");
+        expect(result).toContain("Did some work.");
+    });
+    it("includes current WISDOM.md in the prompt when it exists", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(testDir, "WISDOM.md"), "# Beacon — Wisdom\n\n### Important pattern\nAlways check types.");
+        await writeFile(join(memDir, "decision_types.md"), "---\nname: Type checking\ntype: decision\n---\nUse strict mode.");
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        expect(result).toContain("## Current WISDOM.md");
+        expect(result).toContain("Important pattern");
+    });
+    it("skips daily log files from typed memories", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(memDir, "2026-03-20.md"), "# Daily log content");
+        await writeFile(join(memDir, "feedback_test.md"), "---\nname: Test\ntype: feedback\n---\nSome feedback.");
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        // Typed memories should NOT include the daily log
+        const typedSection = result.indexOf("## Typed Memories");
+        const dailySection = result.indexOf("## Recent Daily Logs");
+        if (typedSection >= 0) {
+            const typedContent = result.slice(typedSection, dailySection > typedSection ? dailySection : undefined);
+            expect(typedContent).not.toContain("2026-03-20.md");
+        }
+    });
+    it("includes distillation rules", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(memDir, "ref_test.md"), "---\nname: Ref\ntype: reference\n---\nA reference.");
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        expect(result).toContain("## Rules");
+        expect(result).toContain("distilled principles");
+        expect(result).toContain("Last compacted:");
+    });
+    it("limits daily logs to 7 most recent", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Create 10 daily logs
+        for (let i = 1; i <= 10; i++) {
+            const day = i.toString().padStart(2, "0");
+            await writeFile(join(memDir, `2026-03-${day}.md`), `# Day ${i}`);
+        }
+        const result = await buildWisdomPrompt(testDir, "beacon");
+        expect(result).not.toBeNull();
+        // Should include most recent 7, not all 10
+        // Count the day headers in the Recent Daily Logs section
+        const dailySection = result.slice(result.indexOf("## Recent Daily Logs"));
+        const dayHeaders = dailySection.match(/### 2026-03-\d{2}/g);
+        expect(dayHeaders).toHaveLength(7);
+    });
+    it("includes teammate name in instructions", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(memDir, "ref_x.md"), "---\nname: X\ntype: reference\n---\nContent.");
+        const result = await buildWisdomPrompt(testDir, "mybot");
+        expect(result).not.toBeNull();
+        expect(result).toContain(".teammates/mybot/WISDOM.md");
+    });
+});
+describe("autoCompactForBudget", () => {
+    it("returns null when daily logs are under budget", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Write a small daily log from a past week
+        await writeFile(join(memDir, "2024-03-05.md"), "# Short log");
+        const result = await autoCompactForBudget(testDir, 100_000);
+        expect(result).toBeNull();
+    });
+    it("compacts oldest weeks when over budget", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Create large daily logs in two past weeks (W10 and W11)
+        const bigContent = "x".repeat(50_000); // ~12,500 tokens each
+        await writeFile(join(memDir, "2024-03-05.md"), bigContent); // W10
+        await writeFile(join(memDir, "2024-03-06.md"), bigContent); // W10
+        await writeFile(join(memDir, "2024-03-12.md"), bigContent); // W11
+        await writeFile(join(memDir, "2024-03-13.md"), bigContent); // W11
+        // Budget that fits ~2 logs but not 4
+        const result = await autoCompactForBudget(testDir, 30_000);
+        expect(result).not.toBeNull();
+        expect(result.created.length).toBeGreaterThanOrEqual(1);
+        // Oldest week (W10) should be compacted first
+        expect(result.created[0]).toContain("2024-W10");
+        expect(result.compactedDates).toContain("2024-03-05");
+        expect(result.compactedDates).toContain("2024-03-06");
+        // Verify weekly file was written
+        const weeklyDir = join(memDir, "weekly");
+        const files = await readdir(weeklyDir);
+        expect(files).toContain("2024-W10.md");
+    });
+    it("marks current week compaction as partial", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Create a large daily log in a past week and one for today's week
+        const bigContent = "x".repeat(100_000); // ~25,000 tokens
+        await writeFile(join(memDir, "2024-03-05.md"), bigContent); // W10
+        // Create a log in current week (not today specifically)
+        const now = new Date();
+        const yesterday = new Date(now);
+        yesterday.setDate(yesterday.getDate() - 1);
+        const yesterdayStr = yesterday.toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${yesterdayStr}.md`), bigContent);
+        // Very tight budget forces compacting both weeks
+        const result = await autoCompactForBudget(testDir, 1_000);
+        expect(result).not.toBeNull();
+        // Check if any entry is marked partial (current week)
+        const weeklyDir = join(memDir, "weekly");
+        const files = await readdir(weeklyDir);
+        let hasPartial = false;
+        for (const f of files) {
+            const content = await readFile(join(weeklyDir, f), "utf-8");
+            if (content.includes("partial: true")) {
+                hasPartial = true;
+            }
+        }
+        // If yesterday is in a different week than today, there may not be a partial
+        // But W10 should always be compacted
+        expect(result.created.some((c) => c.includes("2024-W10"))).toBe(true);
+        // If the current week was compacted, it should be partial
+        const currentWeekCompacted = result.created.find((c) => c.includes("(partial)"));
+        if (currentWeekCompacted) {
+            expect(hasPartial).toBe(true);
+        }
+    });
+    it("skips today's log when calculating budget", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Write today's log (should not be compacted)
+        const today = new Date().toISOString().slice(0, 10);
+        const bigContent = "x".repeat(200_000);
+        await writeFile(join(memDir, `${today}.md`), bigContent);
+        // Even with a tiny budget, today should not trigger compaction
+        const result = await autoCompactForBudget(testDir, 1_000);
+        // No past dailies to compact, so result should be null
+        expect(result).toBeNull();
+    });
+    it("returns null when memory dir does not exist", async () => {
+        const result = await autoCompactForBudget(testDir, 24_000);
+        expect(result).toBeNull();
+    });
+    it("does not compact weeks that already have a weekly summary", async () => {
+        const memDir = join(testDir, "memory");
+        const weeklyDir = join(memDir, "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        const bigContent = "x".repeat(100_000);
+        await writeFile(join(memDir, "2024-03-05.md"), bigContent); // W10
+        await writeFile(join(memDir, "2024-03-12.md"), bigContent); // W11
+        // Pre-existing weekly for W10
+        await writeFile(join(weeklyDir, "2024-W10.md"), "# Already compacted");
+        const result = await autoCompactForBudget(testDir, 1_000);
+        expect(result).not.toBeNull();
+        // Should compact W11, not W10
+        expect(result.created.some((c) => c.includes("2024-W11"))).toBe(true);
+        expect(result.created.some((c) => c.includes("2024-W10"))).toBe(false);
+    });
+});
+describe("compactDailies — partial merge", () => {
+    it("merges new dailies into a partial weekly", async () => {
+        const memDir = join(testDir, "memory");
+        const weeklyDir = join(memDir, "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        // Create a partial weekly for W10 with only 2024-03-05
+        const partialContent = [
+            "---",
+            "type: weekly",
+            "week: 2024-W10",
+            "period: 2024-03-05 to 2024-03-05",
+            "partial: true",
+            "---",
+            "",
+            "# Week 2024-W10",
+            "",
+            "## 2024-03-05",
+            "",
+            "# Tuesday work",
+            "",
+        ].join("\n");
+        await writeFile(join(weeklyDir, "2024-W10.md"), partialContent);
+        // Add new dailies for the same week
+        await writeFile(join(memDir, "2024-03-06.md"), "# Wednesday work");
+        await writeFile(join(memDir, "2024-03-07.md"), "# Thursday work");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(1);
+        expect(result.created[0]).toBe("2024-W10.md (merged)");
+        // Verify the merged weekly has all 3 days and no partial flag
+        const content = await readFile(join(weeklyDir, "2024-W10.md"), "utf-8");
+        expect(content).toContain("2024-03-05");
+        expect(content).toContain("2024-03-06");
+        expect(content).toContain("2024-03-07");
+        expect(content).toContain("Tuesday work");
+        expect(content).toContain("Wednesday work");
+        expect(content).toContain("Thursday work");
+        expect(content).not.toContain("partial: true");
+    });
+    it("does not duplicate dates when merging", async () => {
+        const memDir = join(testDir, "memory");
+        const weeklyDir = join(memDir, "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        // Partial weekly with 2024-03-05
+        const partialContent = [
+            "---",
+            "type: weekly",
+            "week: 2024-W10",
+            "period: 2024-03-05 to 2024-03-05",
+            "partial: true",
+            "---",
+            "",
+            "# Week 2024-W10",
+            "",
+            "## 2024-03-05",
+            "",
+            "# Original Tuesday",
+            "",
+        ].join("\n");
+        await writeFile(join(weeklyDir, "2024-W10.md"), partialContent);
+        // Same date exists as a daily log (shouldn't duplicate)
+        await writeFile(join(memDir, "2024-03-05.md"), "# Updated Tuesday");
+        await writeFile(join(memDir, "2024-03-06.md"), "# Wednesday");
+        const result = await compactDailies(testDir);
+        const content = await readFile(join(weeklyDir, "2024-W10.md"), "utf-8");
+        // Should contain the original (from partial), not duplicated
+        const tuesdayMatches = content.match(/## 2024-03-05/g);
+        expect(tuesdayMatches).toHaveLength(1);
+    });
+    it("skips non-partial existing weeklies", async () => {
+        const memDir = join(testDir, "memory");
+        const weeklyDir = join(memDir, "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        // Complete (non-partial) weekly
+        const completeContent = [
+            "---",
+            "type: weekly",
+            "week: 2024-W10",
+            "period: 2024-03-05 to 2024-03-07",
+            "---",
+            "",
+            "# Week 2024-W10",
+            "",
+            "## 2024-03-05",
+            "",
+            "# Content",
+            "",
+        ].join("\n");
+        await writeFile(join(weeklyDir, "2024-W10.md"), completeContent);
+        await writeFile(join(memDir, "2024-03-06.md"), "# New daily");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(0);
+    });
+});
+describe("purgeStaleDailies", () => {
+    it("deletes daily logs older than retention period", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Create a daily log well past the retention period
+        const old = new Date();
+        old.setDate(old.getDate() - DAILY_LOG_RETENTION_DAYS - 5);
+        const oldDate = old.toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${oldDate}.md`), "# Old log");
+        // Create a recent daily log
+        const recent = new Date();
+        recent.setDate(recent.getDate() - 2);
+        const recentDate = recent.toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${recentDate}.md`), "# Recent log");
+        // Create a typed memory (should not be touched)
+        await writeFile(join(memDir, "feedback_test.md"), "# Feedback");
+        const purged = await purgeStaleDailies(testDir);
+        expect(purged).toContain(`${oldDate}.md`);
+        expect(purged).not.toContain(`${recentDate}.md`);
+        expect(purged).not.toContain("feedback_test.md");
+        // Verify the old file is gone and others remain
+        const remaining = await readdir(memDir);
+        expect(remaining).not.toContain(`${oldDate}.md`);
+        expect(remaining).toContain(`${recentDate}.md`);
+        expect(remaining).toContain("feedback_test.md");
+    });
+    it("returns empty array when no stale logs exist", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        const today = new Date().toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${today}.md`), "# Today");
+        const purged = await purgeStaleDailies(testDir);
+        expect(purged).toHaveLength(0);
+    });
+});