groove-dev 0.27.180 → 0.27.182

package/node_modules/@groove-dev/daemon/src/tokentracker.js

@@ -12,6 +12,14 @@ const COLD_START_PER_FILE = 15;
 const COLD_START_PER_DIR = 40;
 // Estimated tokens wasted per file conflict (agent discovers, backs off, retries)
 const CONFLICT_OVERHEAD = 500;
+// Max per-agent session records kept. Aggregates are cumulative and unaffected;
+// windowed queries (getVelocity/getTokensInWindow) only need the recent tail,
+// which 500 records covers by orders of magnitude. Uncapped, tokens.json grew
+// to 13.8MB and was rewritten on every assistant stream event.
+const SESSION_CAP = 500;
+// Debounce window for persisting to disk. record() fires per assistant event —
+// writing the full ledger each time is a hot-path full-file rewrite.
+const SAVE_DEBOUNCE_MS = 5_000;
 
 export class TokenTracker {
   constructor(grooveDir) {
@@ -23,6 +31,7 @@ export class TokenTracker {
     this.coldStartsSkipped = 0;
     this.projectFiles = 0;   // Set from indexer stats
     this.projectDirs = 0;
+    this._saveTimer = null;
     this.load();
   }
 
@@ -47,6 +56,7 @@ export class TokenTracker {
           if (!entry.totalDurationMs) entry.totalDurationMs = 0;
           if (!entry.totalTurns) entry.totalTurns = 0;
           if (!entry.modelDistribution) entry.modelDistribution = {};
+          this._capSessions(entry);
         }
       } catch {
         this.usage = {};
@@ -55,6 +65,10 @@ export class TokenTracker {
   }
 
   save() {
+    if (this._saveTimer) {
+      clearTimeout(this._saveTimer);
+      this._saveTimer = null;
+    }
     writeFileSync(this.path, JSON.stringify({
       usage: this.usage,
       rotationSavings: this.rotationSavings,
@@ -64,6 +78,30 @@ export class TokenTracker {
     }, null, 2));
   }
 
+  // Debounced persistence for hot-path recording. In-memory state is always
+  // current; at most SAVE_DEBOUNCE_MS of records are at risk on a crash.
+  _scheduleSave() {
+    if (this._saveTimer) return;
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null;
+      try { this.save(); } catch { /* best-effort */ }
+    }, SAVE_DEBOUNCE_MS);
+    this._saveTimer.unref?.();
+  }
+
+  // Write any pending debounced state to disk. Call on daemon shutdown.
+  flush() {
+    if (this._saveTimer) {
+      try { this.save(); } catch { /* best-effort */ }
+    }
+  }
+
+  _capSessions(entry) {
+    if (Array.isArray(entry.sessions) && entry.sessions.length > SESSION_CAP) {
+      entry.sessions.splice(0, entry.sessions.length - SESSION_CAP);
+    }
+  }
+
   _initAgent(agentId) {
     if (!this.usage[agentId]) {
       this.usage[agentId] = {
@@ -89,7 +127,8 @@ export class TokenTracker {
     if (typeof detail === 'number') {
       entry.total += detail;
       entry.sessions.push({ tokens: detail, timestamp: new Date().toISOString() });
-      this.save();
+      this._capSessions(entry);
+      this._scheduleSave();
       return;
     }
 
@@ -121,8 +160,9 @@ export class TokenTracker {
       projectRoot: detail.projectRoot || null,
       timestamp: new Date().toISOString(),
     });
+    this._capSessions(entry);
 
-    this.save();
+    this._scheduleSave();
   }
 
   // Sum tokens recorded for an agent since a given timestamp.
@@ -152,25 +192,25 @@ export class TokenTracker {
     if (costUsd) entry.totalCostUsd += costUsd;
     if (durationMs) entry.totalDurationMs += durationMs;
     if (turns) entry.totalTurns += turns;
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a rotation saved context tokens
   recordRotation(agentId, tokensBefore) {
     this.rotationSavings += Math.round(tokensBefore * 0.3); // ~30% of context was degraded
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a conflict was prevented (scope enforcement)
   recordConflictPrevented() {
     this.conflictsPrevented++;
-    this.save();
+    this._scheduleSave();
   }
 
   // Record that a cold-start was skipped (Journalist provided context)
   recordColdStartSkipped() {
     this.coldStartsSkipped++;
-    this.save();
+    this._scheduleSave();
   }
 
   // Set project size from indexer for dynamic cold-start estimation

package/node_modules/@groove-dev/daemon/test/claude-code-provider.test.js

@@ -0,0 +1,128 @@
+// GROOVE — Claude Code Provider Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { ClaudeCodeProvider } from '../src/providers/claude-code.js';
+
+const provider = new ClaudeCodeProvider();
+
+describe('ClaudeCodeProvider result parsing', () => {
+  // Regression: the "phantom interrupt" bug. On --resume with an orphaned
+  // background shell task, the CLI aborts the turn before calling the model.
+  // These fields were previously dropped, so the abort was indistinguishable
+  // from a successful turn and the user's message vanished with no UI signal.
+  it('surfaces error signals from an aborted turn', () => {
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result',
+      subtype: 'error_during_execution',
+      is_error: true,
+      duration_ms: 5126,
+      duration_api_ms: 0,
+      num_turns: 2,
+      total_cost_usd: 0,
+      terminal_reason: 'aborted_streaming',
+    }));
+
+    assert.equal(out.type, 'result');
+    assert.equal(out.isError, true);
+    assert.equal(out.apiDurationMs, 0, 'api duration 0 proves the model was never reached');
+    assert.equal(out.terminalReason, 'aborted_streaming');
+  });
+
+  it('treats an error_during_execution subtype as an error even without is_error', () => {
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'error_during_execution', duration_api_ms: 0,
+    }));
+    assert.equal(out.isError, true);
+  });
+
+  it('does not flag a successful turn as an error', () => {
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      duration_ms: 17850,
+      duration_api_ms: 17672,
+      num_turns: 3,
+      total_cost_usd: 0.42,
+      terminal_reason: 'completed',
+    }));
+
+    assert.equal(out.isError, false);
+    assert.equal(out.apiDurationMs, 17672);
+    assert.equal(out.cost, 0.42);
+  });
+
+  // The retry gate is (isError && apiDurationMs === 0). A turn that failed
+  // *after* reaching the model has real cost and must not be auto-retried.
+  it('distinguishes a pre-model abort from a post-model failure', () => {
+    const preModel = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'error_during_execution', is_error: true, duration_api_ms: 0,
+    }));
+    const postModel = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'error_during_execution', is_error: true, duration_api_ms: 8400,
+    }));
+
+    assert.equal(preModel.isError && preModel.apiDurationMs === 0, true, 'free to retry');
+    assert.equal(postModel.isError && postModel.apiDurationMs === 0, false, 'already billed — do not retry');
+  });
+});
+
+describe('ClaudeCodeProvider resume handshake (CLI >= 2.1.212)', () => {
+  // The 0-turn no-op result the CLI emits ~180ms into --resume reconciliation.
+  const HANDSHAKE = JSON.stringify({
+    type: 'result', subtype: 'success', is_error: false,
+    duration_ms: 186, duration_api_ms: 0, num_turns: 0, total_cost_usd: 0,
+  });
+  const ABORT = JSON.stringify({
+    type: 'result', subtype: 'error_during_execution', is_error: true,
+    duration_ms: 5126, duration_api_ms: 0, num_turns: 2, total_cost_usd: 0,
+    terminal_reason: 'aborted_streaming',
+  });
+
+  // This is the gate the daemon uses to decide whether a result means "the
+  // turn completed". Treating the handshake as a completion arms a 5s
+  // force-kill that SIGTERMs the process mid-turn.
+  const reachedModel = (o) => o.apiDurationMs === undefined || o.apiDurationMs > 0;
+
+  it('does not count the resume handshake as a completed turn', () => {
+    const out = provider.parseOutput(HANDSHAKE);
+    assert.equal(out.isError, false);
+    assert.equal(reachedModel(out), false,
+      'handshake must not arm the force-kill or clear the queued message');
+  });
+
+  it('counts a real turn as completed', () => {
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'success', is_error: false,
+      duration_ms: 17850, duration_api_ms: 17672, num_turns: 3, total_cost_usd: 0.42,
+    }));
+    assert.equal(reachedModel(out), true);
+  });
+
+  it('providers without an API duration still count as completed', () => {
+    // codex / gemini / ollama don't report duration_api_ms — they must be
+    // unaffected by the guard.
+    const out = provider.parseOutput(JSON.stringify({
+      type: 'result', subtype: 'success', duration_ms: 1200, num_turns: 1,
+    }));
+    assert.equal(out.apiDurationMs, undefined);
+    assert.equal(reachedModel(out), true);
+  });
+
+  // Regression: taking the first result in a chunk let the handshake mask a
+  // subsequent abort, so the failure looked like a clean completion.
+  it('surfaces the abort when a chunk carries handshake + abort together', () => {
+    const out = provider.parseOutput(`${HANDSHAKE}\n${ABORT}`);
+    assert.equal(out.isError, true, 'abort must win over the no-op success result');
+    assert.equal(out.terminalReason, 'aborted_streaming');
+    assert.equal(reachedModel(out), false);
+  });
+});
+
+describe('ClaudeCodeProvider models', () => {
+  it('offers Fable 5', () => {
+    assert.ok(ClaudeCodeProvider.models.some((m) => m.id === 'claude-fable-5'));
+  });
+});

package/node_modules/@groove-dev/daemon/test/journalist.test.js

@@ -174,13 +174,15 @@ describe('Journalist', () => {
       const { daemon, grooveDir } = createMockDaemon();
       const journalist = new Journalist(daemon);
 
-      // Create a mock log — filename must match agent.id ('a1')
+      // Create a mock log — filename must match agent.name ('backend-1'),
+      // mirroring the writer in process.js (logs are keyed by sanitized name
+      // so rotated agents keep appending to the same file)
       const logLines = [
         JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Write', input: { file_path: 'src/api/auth.js' } }] } }),
         JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Edit', input: { file_path: 'src/api/users.js', old_string: 'old', new_string: 'new' } }] } }),
         JSON.stringify({ type: 'user', message: { content: 'Add JWT middleware to the auth route' } }),
       ].join('\n');
-      writeFileSync(join(grooveDir, 'logs', 'a1.log'), logLines);
+      writeFileSync(join(grooveDir, 'logs', 'backend-1.log'), logLines);
 
       const agent = {
         id: 'a1', name: 'backend-1', role: 'backend',

package/node_modules/@groove-dev/daemon/test/rotator.test.js

@@ -452,4 +452,135 @@ describe('Rotator', () => {
     assert.equal(appendArgs.teamId, 'team-alpha');
     assert.equal(appendArgs.role, 'backend');
   });
+
+  it('should rotate idle Claude Code agent above the replay ceiling', async () => {
+    const agent = {
+      id: 'rc1', name: 'claude-chat', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.55, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(), // idle 5 min
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'replay_ceiling');
+  });
+
+  it('should NOT replay-ceiling rotate below the ceiling or during cooldown', async () => {
+    const agent = {
+      id: 'rc2', name: 'claude-chat-2', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.45, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // Below ceiling — no rotation
+    await rotator.check();
+    assert.equal(rotator.getHistory().length, 0);
+
+    // Above ceiling but on cooldown — still no rotation
+    agent.contextUsage = 0.60;
+    rotator.lastRotationTime.set('rc2', Date.now() - 60_000);
+    await rotator.check();
+    assert.equal(rotator.getHistory().length, 0);
+  });
+
+  it('should block auto-rotation of a chat agent when no conversation thread is extractable', async () => {
+    const agent = {
+      id: 'rc3', name: 'claude-chat-3', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.70, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // Agent has chat history, but journalist can't extract the thread
+    rotator.recordUserMessage('rc3');
+    mockDaemon.journalist.buildConversationResumePrompt = () => null;
+
+    const result = await rotator.rotate('rc3', { reason: 'replay_ceiling' });
+
+    assert.equal(result, null);
+    assert.equal(rotator.getHistory().length, 0);
+    const blocked = broadcasts.find((b) => b.type === 'rotation:blocked');
+    assert.ok(blocked, 'should broadcast rotation:blocked');
+    assert.equal(blocked.reason, 'no_conversation_thread');
+  });
+
+  it('should not let Instructions boilerplate defeat the low-confidence handoff guard', async () => {
+    const agent = {
+      id: 'rc4', name: 'claude-chat-4', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.70, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+
+    // A content-free brief padded with the static Instructions block —
+    // this is exactly what generateHandoffBrief emits when logs are empty
+    mockDaemon.journalist.generateHandoffBrief = async () => [
+      '# Handoff Brief',
+      '- role: backend',
+      '## Instructions',
+      '',
+      'Continue and finish the in-progress task — deliver the output. Stay focused on that specific task only.',
+      '- Do NOT explore the codebase looking for other things to fix or improve',
+      '- Do NOT start new work outside the original task scope',
+      '- Do NOT act on TODO comments, code quality issues, or improvements you notice in passing',
+      '- If the task is already complete, report what was accomplished and STOP — await new instructions from the user',
+    ].join('\n');
+
+    const result = await rotator.rotate('rc4', { reason: 'replay_ceiling' });
+
+    assert.equal(result, null);
+    assert.equal(rotator.getHistory().length, 0);
+    const blocked = broadcasts.find((b) => b.type === 'rotation:blocked');
+    assert.ok(blocked, 'should broadcast rotation:blocked');
+    assert.equal(blocked.reason, 'low_confidence_handoff');
+  });
+
+  it('should force-rotate any provider on velocity ceiling', async () => {
+    const agent = {
+      id: 'v1', name: 'claude-runaway', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 400_000, contextUsage: 0.30, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5_000).toISOString(), // active
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.tokens.getVelocity = () => 300_000; // above 250K/5min default
+
+    // Even on cooldown — velocity is a safety override
+    rotator.lastRotationTime.set('v1', Date.now() - 60_000);
+
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'velocity_ceiling');
+  });
+
+  it('should not velocity-rotate under the ceiling', async () => {
+    const agent = {
+      id: 'v2', name: 'claude-normal', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 50_000, contextUsage: 0.30, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.tokens.getVelocity = () => 80_000;
+
+    await rotator.check();
+
+    assert.equal(rotator.getHistory().length, 0);
+  });
 });

package/node_modules/@groove-dev/daemon/test/tokentracker.test.js

@@ -61,6 +61,10 @@ describe('TokenTracker', () => {
     tracker.record('agent-1', 100);
     tracker.record('agent-2', 200);
 
+    // record() debounces disk writes (hot path); flush forces the pending save,
+    // mirroring what the daemon does on shutdown.
+    tracker.flush();
+
     const tracker2 = new TokenTracker(tmpDir);
     assert.equal(tracker2.getAgent('agent-1').total, 100);
     assert.equal(tracker2.getAgent('agent-2').total, 200);

package/node_modules/@groove-dev/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.180",
+  "version": "0.27.182",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.180",
+  "version": "0.27.182",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.180",
+  "version": "0.27.182",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.180",
+  "version": "0.27.182",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/scripts/repair-tokens.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// One-off ledger repair for ~/.groove/tokens.json (2026-07 efficiency audit).
+//
+// Entry c3789b6f recorded $20,536.57 from a duplicate-ingestion loop (4,631
+// session records in 380s, payloads duplicated up to 10×). The ingestion bug
+// is fixed in claude-code.js, but the poisoned data still dominates every cost
+// dashboard: recorded all-time spend ~$24K vs ~$3.5K real. This script:
+//   1. Sets the poisoned entry's totalCostUsd to its audited real value (~$325)
+//   2. Truncates every entry's sessions array to the last 500 records
+//      (matches SESSION_CAP in tokentracker.js; aggregates are untouched)
+//   3. Writes a timestamped .bak of the original file first
+//
+// MUST run with the daemon STOPPED — the daemon holds the ledger in memory and
+// rewrites the file, so a live edit gets clobbered. The script checks and aborts.
+//
+// Usage: node repair-tokens.mjs [path-to-tokens.json] [--entry c3789b6f] [--cost 325]
+
+import { readFileSync, writeFileSync, copyFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+const args = process.argv.slice(2);
+const flag = (name, dflt) => {
+  const i = args.indexOf(`--${name}`);
+  return i !== -1 && args[i + 1] ? args[i + 1] : dflt;
+};
+const tokensPath = args[0] && !args[0].startsWith('--')
+  ? resolve(args[0])
+  : resolve(homedir(), '.groove', 'tokens.json');
+const entryId = flag('entry', 'c3789b6f');
+const correctedCost = Number(flag('cost', '325'));
+const SESSION_CAP = 500;
+
+// Refuse to edit under a live daemon
+try {
+  const res = await fetch('http://127.0.0.1:31415/api/health', { signal: AbortSignal.timeout(1500) });
+  if (res.ok) {
+    console.error('ABORT: GROOVE daemon is running on :31415. Stop it first (groove stop) — it rewrites tokens.json and will clobber this repair.');
+    process.exit(1);
+  }
+} catch { /* no daemon — safe to proceed */ }
+
+if (!existsSync(tokensPath)) {
+  console.error(`ABORT: ${tokensPath} not found. Pass the path explicitly: node repair-tokens.mjs /path/to/tokens.json`);
+  process.exit(1);
+}
+
+const backupPath = `${tokensPath}.${new Date().toISOString().replace(/[:.]/g, '-')}.bak`;
+copyFileSync(tokensPath, backupPath);
+console.log(`Backup written: ${backupPath}`);
+
+const data = JSON.parse(readFileSync(tokensPath, 'utf8'));
+const usage = data.usage || data;
+
+const target = usage[entryId];
+if (target) {
+  const before = target.totalCostUsd;
+  target.totalCostUsd = correctedCost;
+  target.note = `totalCostUsd corrected ${before} -> ${correctedCost} on ${new Date().toISOString().slice(0, 10)} (duplicate-ingestion inflation, see 2026-07 efficiency audit)`;
+  console.log(`Entry ${entryId}: totalCostUsd ${before} -> ${correctedCost}`);
+} else {
+  console.warn(`Entry ${entryId} not found — skipping cost correction.`);
+}
+
+let trimmed = 0;
+for (const entry of Object.values(usage)) {
+  if (Array.isArray(entry?.sessions) && entry.sessions.length > SESSION_CAP) {
+    trimmed += entry.sessions.length - SESSION_CAP;
+    entry.sessions.splice(0, entry.sessions.length - SESSION_CAP);
+  }
+}
+console.log(`Trimmed ${trimmed} session records across all entries (cap ${SESSION_CAP}).`);
+
+writeFileSync(tokensPath, JSON.stringify(data, null, 2));
+const sizeMb = (Buffer.byteLength(JSON.stringify(data)) / 1024 / 1024).toFixed(1);
+console.log(`Repaired ledger written: ${tokensPath} (${sizeMb}MB)`);

package/packages/daemon/src/api.js

@@ -1438,7 +1438,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'port', 'journalistInterval', 'rotationThreshold', 'autoRotation',
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
-      'dataSharingDismissed',
+      'dataSharingDismissed', 'replayCeiling', 'velocityCeiling', 'journalistModelTier',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

package/packages/daemon/src/index.js

@@ -836,6 +836,7 @@ export class Daemon {
     // Persist state before shutdown
     this.state.set('agents', this.registry.getAll());
     await this.state.save();
+    try { this.tokens.flush(); } catch { /* best-effort */ }
 
     // Stop background services
     await this.gateways.stop();

package/packages/daemon/src/journalist.js

@@ -5,6 +5,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'fs
 import { resolve } from 'path';
 import { execFile, spawn as cpSpawn } from 'child_process';
 import { getProvider, getInstalledProviders, resolveProviderCommand } from './providers/index.js';
+import { agentLogPath } from './process.js';
 
 const DEFAULT_INTERVAL = 300_000; // 5 minutes (safety-net fallback; event-driven triggers handle the normal case)
 const MAX_LOG_CHARS = 100_000; // ~25k tokens budget for synthesis input (captures 80-90% of recent activity)
@@ -168,7 +169,7 @@ export class Journalist {
 
   hasNewActivity(agents) {
     for (const agent of agents) {
-      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
+      const logPath = agentLogPath(this.daemon.grooveDir, agent);
       if (!existsSync(logPath)) continue;
       try {
         const size = statSync(logPath).size;
@@ -182,7 +183,7 @@ export class Journalist {
     const result = {};
 
     for (const agent of agents) {
-      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
+      const logPath = agentLogPath(this.daemon.grooveDir, agent);
       if (!existsSync(logPath)) {
         result[agent.id] = { agent, entries: [], explorationEntries: [] };
         continue;
@@ -574,9 +575,15 @@ export class Journalist {
       const provider = getProvider(providerId);
       if (!provider) continue;
 
-      const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
-        || provider.constructor.models?.find((m) => m.tier === 'light')
-        || provider.constructor.models?.[0];
+      // Digests are light-tier work (Haiku-shaped): default internal overhead to
+      // the cheapest tier, escalate via config only on evidence of quality issues.
+      // On Claude, medium→light cuts the journalist's marginal cost ~90%.
+      const models = provider.constructor.models || [];
+      const preferredTier = this.daemon.config?.journalistModelTier || 'light';
+      const selectedModel = models.find((m) => m.tier === preferredTier)
+        || models.find((m) => m.tier === 'light')
+        || models.find((m) => m.tier === 'medium')
+        || models[0];
       const modelId = selectedModel?.id || null;
 
       // Try CLI headless command first
@@ -1055,7 +1062,7 @@ export class Journalist {
    * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
    */
   extractConversationThread(agent, { maxChars = 60000 } = {}) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
+    const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return null;
 
     let content;
@@ -1297,7 +1304,7 @@ export class Journalist {
    * Used by the Introducer to tell new agents what their teammates built.
    */
   getAgentFiles(agent) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
+    const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return [];
 
     try {
@@ -1335,7 +1342,7 @@ export class Journalist {
    * Used to capture planner conclusions, build summaries, etc.
    */
   getAgentResult(agent) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
+    const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return '';
 
     try {