codeep 2.15.0 → 2.17.0

package/dist/renderer/components/AgentTimeline.d.ts

@@ -0,0 +1,44 @@
+export type TimelineStageId = 'PLAN' | 'READ' | 'EDIT' | 'VERIFY' | 'SUMMARY';
+export type TimelineStageStatus = 'done' | 'active' | 'pending';
+export interface TimelineAction {
+    type: string;
+    target: string;
+    result: string;
+}
+export interface TimelineStage {
+    id: TimelineStageId;
+    status: TimelineStageStatus;
+    summary: string;
+    detail: string;
+}
+export interface TimelineFile {
+    type: 'write' | 'edit' | 'delete' | 'mkdir';
+    target: string;
+    result: string;
+}
+export interface TimelineCheck {
+    target: string;
+    result: string;
+}
+export interface AgentTimelineModel {
+    currentStage: TimelineStageId;
+    currentTarget: string;
+    stages: TimelineStage[];
+    files: TimelineFile[];
+    checks: TimelineCheck[];
+    progress: number;
+}
+export declare function buildAgentTimelineModel(args: {
+    actions: TimelineAction[];
+    thinking: string;
+    waitingForAI: boolean;
+    iteration: number;
+    maxIterations: number;
+}): AgentTimelineModel;
+export declare function formatElapsed(milliseconds: number): string;
+/**
+ * Truncate to a column budget, not a code-unit budget: Screen.write advances
+ * by charWidth, so a CJK/emoji prompt measured with String.length would draw
+ * up to twice as wide as the pane it was sized for.
+ */
+export declare function truncateMiddle(value: string, maxLength: number): string;

package/dist/renderer/components/AgentTimeline.js

@@ -0,0 +1,157 @@
+import { charWidth, stringWidth } from '../ansi.js';
+const READ_TYPES = new Set(['read', 'search', 'list', 'fetch']);
+const EDIT_TYPES = new Set(['write', 'edit', 'delete', 'mkdir']);
+function stageForAction(type) {
+    if (READ_TYPES.has(type))
+        return 'READ';
+    if (EDIT_TYPES.has(type))
+        return 'EDIT';
+    if (type === 'command')
+        return 'VERIFY';
+    return null;
+}
+function parseThinking(thinking) {
+    const separator = thinking.indexOf(':');
+    if (separator < 0)
+        return { type: '', target: '' };
+    const type = thinking.slice(0, separator).trim().toLowerCase();
+    const knownType = READ_TYPES.has(type) || EDIT_TYPES.has(type) || type === 'command';
+    if (!knownType)
+        return { type: '', target: '' };
+    return {
+        type,
+        target: thinking.slice(separator + 1).trim(),
+    };
+}
+function uniqueByTarget(items) {
+    const seen = new Set();
+    const result = [];
+    for (let index = items.length - 1; index >= 0; index--) {
+        const item = items[index];
+        if (!item.target || seen.has(item.target))
+            continue;
+        seen.add(item.target);
+        result.unshift(item);
+    }
+    return result;
+}
+export function buildAgentTimelineModel(args) {
+    const thinking = parseThinking(args.thinking);
+    const lastAction = args.actions[args.actions.length - 1];
+    const explicitStage = !args.waitingForAI ? stageForAction(thinking.type) : null;
+    const lastStage = lastAction ? stageForAction(lastAction.type) : null;
+    const currentStage = explicitStage
+        ?? lastStage
+        ?? 'PLAN';
+    const currentTarget = explicitStage
+        ? thinking.target
+        : (lastAction?.target || thinking.target);
+    const readActions = args.actions.filter(action => READ_TYPES.has(action.type));
+    const fileActions = args.actions.filter((action) => EDIT_TYPES.has(action.type));
+    const commandActions = args.actions.filter(action => action.type === 'command');
+    const stageStatus = (id, hasCompletedAction) => {
+        if (id === currentStage)
+            return 'active';
+        if (id === 'PLAN' && (args.iteration > 0 || args.actions.length > 0))
+            return 'done';
+        if (hasCompletedAction)
+            return 'done';
+        return 'pending';
+    };
+    const stages = [
+        {
+            id: 'PLAN',
+            status: stageStatus('PLAN', args.iteration > 0),
+            summary: 'Understand the request and choose the next safe step',
+            detail: args.iteration > 0 ? `${args.iteration} model step${args.iteration === 1 ? '' : 's'}` : 'Building execution plan',
+        },
+        {
+            id: 'READ',
+            status: stageStatus('READ', readActions.length > 0),
+            summary: 'Inspect project context and relevant files',
+            detail: readActions.length > 0
+                ? `${readActions.length} read/search action${readActions.length === 1 ? '' : 's'}`
+                : 'Waiting for project inspection',
+        },
+        {
+            id: 'EDIT',
+            status: stageStatus('EDIT', fileActions.some(action => action.result === 'success')),
+            summary: 'Apply focused changes to the workspace',
+            detail: fileActions.length > 0
+                ? `${uniqueByTarget(fileActions).length} file${uniqueByTarget(fileActions).length === 1 ? '' : 's'} touched`
+                : 'No file changes yet',
+        },
+        {
+            id: 'VERIFY',
+            status: stageStatus('VERIFY', commandActions.some(action => action.result === 'success')),
+            summary: 'Run commands and confirm the result',
+            detail: commandActions.length > 0
+                ? `${commandActions.length} command${commandActions.length === 1 ? '' : 's'} run`
+                : 'Checks pending',
+        },
+        {
+            id: 'SUMMARY',
+            status: 'pending',
+            summary: 'Summarize changes and next steps',
+            detail: 'Appears when the run completes',
+        },
+    ];
+    return {
+        currentStage,
+        currentTarget,
+        stages,
+        files: uniqueByTarget(fileActions),
+        checks: commandActions.slice(-4).map(action => ({
+            target: action.target,
+            result: action.result,
+        })),
+        progress: args.maxIterations > 0
+            ? Math.min(Math.max(args.iteration / args.maxIterations, 0), 1)
+            : 0,
+    };
+}
+export function formatElapsed(milliseconds) {
+    const totalSeconds = Math.max(0, Math.floor(milliseconds / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0) {
+        return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+    }
+    return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+}
+/**
+ * Truncate to a column budget, not a code-unit budget: Screen.write advances
+ * by charWidth, so a CJK/emoji prompt measured with String.length would draw
+ * up to twice as wide as the pane it was sized for.
+ */
+export function truncateMiddle(value, maxLength) {
+    if (maxLength <= 0)
+        return '';
+    if (stringWidth(value) <= maxLength)
+        return value;
+    if (maxLength <= 3)
+        return '.'.repeat(maxLength);
+    const chars = [...value];
+    const leftBudget = Math.ceil((maxLength - 1) / 2);
+    const rightBudget = Math.floor((maxLength - 1) / 2);
+    let head = '';
+    let headWidth = 0;
+    for (const char of chars) {
+        const w = charWidth(char);
+        if (headWidth + w > leftBudget)
+            break;
+        head += char;
+        headWidth += w;
+    }
+    let tail = '';
+    let tailWidth = 0;
+    for (let index = chars.length - 1; index >= 0; index--) {
+        const w = charWidth(chars[index]);
+        if (tailWidth + w > rightBudget)
+            break;
+        tail = chars[index] + tail;
+        tailWidth += w;
+    }
+    return `${head}…${tail}`;
+}

package/dist/renderer/components/Autocomplete.d.ts

@@ -31,3 +31,28 @@ export interface AutocompleteResult {
  * @returns Match list, or `null` when the dropdown should be hidden.
  */
 export declare function filterCommands(value: string, commands: string[]): AutocompleteResult | null;
+/**
+ * The position and query of an in-progress `@mention`, or `null` when
+ * the cursor isn't inside a mention being typed.
+ *
+ * A mention is "in progress" when, scanning backwards from `cursorPos`:
+ *   1. We find an `@`.
+ *   2. Between `@` and the cursor there are only "path characters"
+ *      (letters, digits, `/`, `.`, `_`, `-`, `\`) and no whitespace.
+ *   3. The `@` itself is at the start of the string OR preceded by a
+ *      boundary char (space, `(`, `[`, …) — so `user@host` doesn't
+ *      count. Mirrors `extractMentions` in `utils/mentions.ts`.
+ */
+export interface MentionQuery {
+    /** Start index of the `@` in the source string. */
+    atStart: number;
+    /** The text typed so far after the `@` (may be empty). */
+    query: string;
+}
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export declare function detectMentionQuery(text: string, cursorPos: number): MentionQuery | null;

package/dist/renderer/components/Autocomplete.js

@@ -5,6 +5,7 @@
  * only triggered for command-shaped input) can be unit-tested without
  * the editor / render machinery.
  */
+import { MENTION_BOUNDARY } from '../../utils/mentions.js';
 /**
  * Filter `commands` to those that start with the typed prefix and the
  * dropdown should appear.
@@ -38,3 +39,37 @@ export function filterCommands(value, commands) {
         return { items: [], index: 0 };
     return { items, index: 0 };
 }
+const PATH_CHAR = /[A-Za-z0-9._\/\\-]/;
+/**
+ * Detect whether the cursor sits inside an `@mention` being typed, and
+ * if so, return the query text (everything after `@`). Pure — no FS.
+ *
+ * Used by the autocomplete layer to know when to show the file picker.
+ */
+export function detectMentionQuery(text, cursorPos) {
+    if (cursorPos < 1 || cursorPos > text.length)
+        return null;
+    // Scan backwards from the cursor, collecting path chars until we hit `@`.
+    let i = cursorPos - 1;
+    let query = '';
+    while (i >= 0) {
+        const ch = text[i];
+        if (ch === '@') {
+            // Found the `@`. Check the preceding char is a boundary (or start).
+            // Boundary set mirrors `extractMentions` in `utils/mentions.ts`.
+            const before = i > 0 ? text[i - 1] : '';
+            // Keep in lockstep with `MENTION_RE`'s lookbehind in utils/mentions.ts.
+            // If this set is looser, the picker offers a completion the expander
+            // then refuses to treat as a mention and the file is never attached.
+            if (before === '' || MENTION_BOUNDARY.test(before)) {
+                return { atStart: i, query };
+            }
+            return null; // `@` not at a boundary → email/handle, not a mention.
+        }
+        if (!PATH_CHAR.test(ch))
+            return null; // hit a non-path char before `@`.
+        query = ch + query;
+        i--;
+    }
+    return null; // no `@` found before the cursor.
+}

package/dist/renderer/components/Status.d.ts

@@ -11,6 +11,7 @@ export interface StatusInfo {
      *  when non-auto AND the active model supports a graded knob; undefined hides it. */
     reasoningEffort?: string;
     projectPath: string;
+    branch?: string;
     hasWriteAccess: boolean;
     sessionId: string;
     messageCount: number;
@@ -19,6 +20,7 @@ export interface StatusInfo {
         promptTokens: number;
         completionTokens: number;
         requestCount: number;
+        estimatedCost?: number;
     };
 }
 /**

package/dist/renderer/layout.d.ts

@@ -38,6 +38,9 @@ export interface LayoutSnapshot {
     readonly settingsCount: number;
     readonly showAutocomplete: boolean;
     readonly autocompleteItemCount: number;
+    readonly hunkPickerOpen: boolean;
+    readonly mentionPickerOpen: boolean;
+    readonly mentionItemCount: number;
 }
 /**
  * Compute how many terminal rows the bottom panel (paste info, agent box,
@@ -144,7 +147,7 @@ export declare function statusBarRightHint(args: {
     isLoading: boolean;
 }): string;
 /** The panel that currently owns keyboard focus, in priority order. */
-export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'chat';
+export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'hunkPicker' | 'chat';
 export interface PanelState {
     readonly pasteInfoOpen: boolean;
     readonly permissionOpen: boolean;
@@ -159,6 +162,7 @@ export interface PanelState {
     readonly loginOpen: boolean;
     readonly menuOpen: boolean;
     readonly showAutocomplete: boolean;
+    readonly hunkPickerOpen: boolean;
 }
 /**
  * Return the highest-priority open panel. `chat` is the fallback when no

package/dist/renderer/layout.js

@@ -36,6 +36,10 @@ export function bottomPanelHeight(s) {
     if (s.confirmOpen) {
         return s.confirmMessageCount + 5; // title + messages + buttons + padding
     }
+    if (s.hunkPickerOpen) {
+        // Title + progress + path + header + up to 12 diff lines + more marker + legend.
+        return 18;
+    }
     if (s.statusOpen) {
         return 16; // Status info panel
     }
@@ -65,6 +69,12 @@ export function bottomPanelHeight(s) {
     if (s.showAutocomplete && s.autocompleteItemCount > 0) {
         return Math.min(s.autocompleteItemCount + 3, 12);
     }
+    // `@`-mention picker: separator + title + up to 8 rows + footer. Without
+    // this branch the panel measured 0 while the picker still painted its rows,
+    // so it drew straight over the bottom of the chat transcript.
+    if (s.mentionPickerOpen && s.mentionItemCount > 0) {
+        return Math.min(s.mentionItemCount, 8) + 3;
+    }
     return 0;
 }
 export function chatLayout(height, panelHeight) {
@@ -237,6 +247,8 @@ export function activePanel(s) {
         return 'login';
     if (s.menuOpen)
         return 'menu';
+    if (s.hunkPickerOpen)
+        return 'hunkPicker';
     if (s.showAutocomplete)
         return 'autocomplete';
     return 'chat';

package/dist/renderer/main.js

@@ -16,15 +16,20 @@ import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, autoSaveSession
 import { isProjectDirectory, getProjectContext, } from '../utils/project.js';
 import { getCurrentVersion, checkForUpdates, getUpdateInstructions } from '../utils/update.js';
 import { getProviderList, isNoApiKeyProvider, resolveReasoningTier } from '../config/providers.js';
-import { getSessionStats, getCostBreakdown } from '../utils/tokenTracker.js';
-import { isGitRepository } from '../utils/git.js';
+import { getSessionStats, getCostBreakdown, getRecordCount } from '../utils/tokenTracker.js';
+import { getGitStatus, isGitRepository } from '../utils/git.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
 import { checkApiRateLimit } from '../utils/ratelimit.js';
+import { expandFileAndFolderMentions, expandGitMentions } from '../utils/mentions.js';
+import { expandWebMentions } from '../utils/webFetch.js';
 import { handleCommand as dispatchCommand } from './commands.js';
 import { logAppError } from '../utils/logger.js';
 import { executeAgentTask, runAgentTask, } from './agentExecution.js';
 // ─── Global state ─────────────────────────────────────────────────────────────
 let projectPath = process.cwd();
+/** Cached header branch. Resolved on first use so `--version`/`--help` never
+ *  shell out to git, and cached because getStatus runs on every render frame. */
+let gitBranchCache = null;
 let projectContext = null;
 let hasWriteAccess = false;
 let sessionId = getCurrentSessionId();
@@ -32,6 +37,14 @@ let app;
 /** Human-readable session name derived from the first user message */
 let sessionDisplayName = null;
 const addedFiles = new Map();
+/** Branch shown in the persistent header, re-read whenever the project moved
+ *  or an agent run finished (an agent can check out a different branch). */
+function getHeaderBranch() {
+    if (!gitBranchCache || gitBranchCache.path !== projectPath) {
+        gitBranchCache = { path: projectPath, branch: getGitStatus(projectPath).branch };
+    }
+    return gitBranchCache.branch;
+}
 /** Derive a short display name from a user message (first ~5 words, max 48 chars). */
 export function deriveSessionName(message) {
     const clean = message.replace(/\s+/g, ' ').trim();
@@ -53,7 +66,10 @@ function makeCtx() {
         sessionDisplayName: sessionDisplayName ?? undefined,
         abortController: agentAbortController,
         isAgentRunning: () => isAgentRunningFlag,
-        setAgentRunning: (v) => { isAgentRunningFlag = v; },
+        // A finished run may have switched branches — drop the cache so the next
+        // header render re-reads it.
+        setAgentRunning: (v) => { isAgentRunningFlag = v; if (!v)
+            gitBranchCache = null; },
         setAbortController: (ctrl) => { agentAbortController = ctrl; },
         formatAddedFilesContext,
         handleCommand: (cmd, args) => dispatchCommand(cmd, args, makeCtx()),
@@ -75,7 +91,7 @@ function getStatus() {
     const stats = getSessionStats();
     // Show the thinking-effort tier beside the model. Resolve the (global) tier
     // to what THIS model actually runs — e.g. a global 'low' shows as 'high' on
-    // GLM-5.2, which only grades high|max. 'auto'/unsupported → hidden.
+    // Kimi K3, where the global medium tier resolves to high. 'auto'/unsupported → hidden.
     const resolved = resolveReasoningTier(provider.id, config.get('model'), config.get('reasoningEffort'));
     const reasoningEffort = resolved !== 'auto' ? resolved : undefined;
     return {
@@ -85,6 +101,7 @@ function getStatus() {
         agentMode: config.get('agentMode') || 'off',
         reasoningEffort,
         projectPath,
+        branch: getHeaderBranch(),
         hasWriteAccess,
         sessionId,
         messageCount: app ? app.getMessages().length : 0,
@@ -93,6 +110,7 @@ function getStatus() {
             promptTokens: stats.totalPromptTokens,
             completionTokens: stats.totalCompletionTokens,
             requestCount: stats.requestCount,
+            estimatedCost: stats.estimatedCost,
         },
     };
 }
@@ -160,14 +178,85 @@ async function handleSubmit(message) {
         runAgentTask(message, false, ctx, () => pendingInteractiveContext, (v) => { pendingInteractiveContext = v; });
         return;
     }
+    // Captured before the turn starts so the delta can be reported from both the
+    // success path and the catch. An aborted or failed turn has still burned
+    // tokens, and gracefulShutdown no longer sends a cumulative catch-all that
+    // would have swept them up later.
+    const tokenReportStart = getRecordCount();
+    // Cloud stats are append-only events, so report only this prompt's delta.
+    // Sending the full session accumulator after every prompt makes totals grow
+    // 1× + 2× + 3× and is the source of the inflated dashboard token count.
+    // pingWhenEmpty sends a bare session event when nothing was spent — wanted on
+    // the success path, not when the turn failed before reaching the model.
+    const reportTurnStats = (pingWhenEmpty) => {
+        const sharedFields = {
+            sessionId,
+            sessionName: sessionDisplayName || sessionId,
+            messageCount: app.getMessages().length,
+            cliVersion: getCurrentVersion(),
+            projectName: projectContext?.name,
+            projectId: projectPath ? generateProjectId(projectPath) : undefined,
+            language: projectContext?.type,
+            isGit: isGitRepository(process.cwd()),
+        };
+        const costBreakdown = getCostBreakdown(tokenReportStart);
+        if (costBreakdown.length === 0) {
+            if (pingWhenEmpty) {
+                reportStats({ ...sharedFields, model: config.get('model'), provider: config.get('provider') });
+            }
+            return;
+        }
+        for (const entry of costBreakdown) {
+            reportStats({
+                ...sharedFields,
+                model: entry.model,
+                provider: entry.provider,
+                inputTokens: entry.promptTokens || undefined,
+                outputTokens: entry.completionTokens || undefined,
+                cacheCreationTokens: entry.cacheCreationTokens || undefined,
+                cacheReadTokens: entry.cacheReadTokens || undefined,
+                estimatedCost: entry.estimatedCost || undefined,
+            });
+        }
+    };
     try {
         app.startStreaming();
         const history = app.getChatHistory();
+        // Expand inline @-mentions (@src/file.ts) into the prompt's context.
+        // Done after history capture (mentions are per-message) but before
+        // deriveSessionName so the title reflects what the user typed, not the
+        // expanded path.
+        const mentionRoot = projectContext?.root || projectPath || process.cwd();
+        // Expand @folder and @file mentions in one pass, merged into a single
+        // [Attached files] block.
+        const { enrichedPrompt: fileExpanded, loaded: loadedMentions, failures: mentionFailures } = expandFileAndFolderMentions(message, { root: mentionRoot });
+        if (loadedMentions.length > 0) {
+            app.notify(`Loaded ${loadedMentions.length} file(s) from @mentions/@folder`);
+        }
+        for (const f of mentionFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
+        // Expand @git <ref> mentions — resolve diffs / file-at-ref / commit
+        // patches into a [Git ref] block. Runs between file and web mentions
+        // so the prompt flows: [files] [git] [web] <text>.
+        const { enrichedPrompt: gitExpanded, failures: gitFailures } = await expandGitMentions(fileExpanded, { root: mentionRoot });
+        for (const f of gitFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
+        // Expand @web <url> mentions — fetch each page and prepend its text.
+        // Runs after file mentions so the prompt flows: [files] [web] <text>.
+        const { enrichedPrompt: webExpanded, loaded: loadedPages, failures: webFailures } = await expandWebMentions(gitExpanded);
+        if (loadedPages.length > 0) {
+            app.notify(`Fetched ${loadedPages.length} page(s) from @web`);
+        }
+        for (const f of webFailures) {
+            app.notify(`${f.mention}: ${f.reason}`);
+        }
         if (!sessionDisplayName && history.filter(m => m.role === 'user').length === 0) {
             sessionDisplayName = deriveSessionName(message);
         }
         const fileContext = formatAddedFilesContext();
-        const enrichedMessage = fileContext ? fileContext + message : message;
+        const enrichedMessage = fileContext ? fileContext + webExpanded : webExpanded;
         await chat(enrichedMessage, history, (chunk) => app.addStreamChunk(chunk), undefined, projectContext, undefined);
         app.endStreaming();
         autoSaveSession(app.getMessages(), projectPath);
@@ -194,7 +283,10 @@ async function handleSubmit(message) {
             language: projectContext?.type,
             isGit: isGitRepository(process.cwd()),
         };
-        const costBreakdown = getCostBreakdown();
+        // Cloud stats are append-only events, so report only this prompt's delta.
+        // Sending the full session accumulator after every prompt makes totals grow
+        // 1× + 2× + 3× and is the source of the inflated dashboard token count.
+        const costBreakdown = getCostBreakdown(tokenReportStart);
         if (costBreakdown.length > 0) {
             for (const entry of costBreakdown) {
                 reportStats({
@@ -621,6 +713,7 @@ Commands (in chat):
         getStatus,
         hasWriteAccess: () => hasWriteAccess,
         hasProjectContext: () => projectContext !== null,
+        getProjectRoot: () => projectContext?.root || projectPath || process.cwd(),
     });
     const provider = getCurrentProvider();
     const providers = getProviderList();
@@ -905,31 +998,18 @@ async function gracefulShutdown() {
         return;
     const messages = app.getMessages();
     autoSaveSession(messages, projectPath);
-    const { syncSessionAsync, reportStatsAsync, generateProjectId } = require('../utils/codeepCloud.js');
-    const tokenStats = getSessionStats();
+    const { syncSessionAsync, generateProjectId } = require('../utils/codeepCloud.js');
     const projectId = projectPath ? generateProjectId(projectPath) : undefined;
-    await Promise.all([
-        syncSessionAsync({
-            sessionId,
-            sessionName: sessionId,
-            projectName: projectContext?.name,
-            messages,
-        }),
-        reportStatsAsync({
-            model: config.get('model'),
-            provider: config.get('provider'),
-            sessionId,
-            sessionName: sessionId,
-            messageCount: messages.length,
-            projectName: projectContext?.name,
-            projectId,
-            inputTokens: tokenStats.totalPromptTokens || undefined,
-            outputTokens: tokenStats.totalCompletionTokens || undefined,
-            cacheCreationTokens: tokenStats.totalCacheCreationTokens || undefined,
-            cacheReadTokens: tokenStats.totalCacheReadTokens || undefined,
-            estimatedCost: tokenStats.estimatedCost || undefined,
-        }),
-    ]);
+    // Successful manual and agent turns report their token deltas immediately.
+    // Re-sending the cumulative session total here would count every token a
+    // second time when the append-only dashboard endpoint stores this event.
+    await syncSessionAsync({
+        sessionId,
+        sessionName: sessionDisplayName || sessionId,
+        projectName: projectContext?.name,
+        projectId,
+        messages,
+    });
 }
 // ─── Last-resort crash handlers ───────────────────────────────────────────────
 // Without these, a stray throw or rejected promise (deep in the agent loop or a

package/dist/utils/agent.js

@@ -163,7 +163,7 @@ export function buildPausedResult(kind, ctx) {
     };
 }
 const DEFAULT_OPTIONS = {
-    // Modern models (GLM-5.1, Claude 4.5, GPT-4.1) complete typical coding tasks in
+    // Modern models (GLM-5.2, Claude 5, GPT-5.x) complete typical coding tasks in
     // 3–8 iterations. The old cap of 100 mostly let broken loops wander for minutes
     // before giving up. 25 is still generous — covers multi-file refactors — without
     // turning small fixes into marathons. Users can still raise this via /settings.

package/dist/utils/agents.d.ts

@@ -18,7 +18,7 @@
  *   name: reviewer
  *   description: Reviews a diff for correctness & security
  *   tools: [read_file, search_code, execute_command]   # allowlist; omit = all
- *   model: glm-5.1            # optional provider/model or model override
+ *   model: glm-5.2            # optional provider/model or model override
  *   personality: security     # optional — reuse a personality preset
  *   maxIterations: 15         # optional budget
  *   ---

package/dist/utils/agents.js

@@ -18,7 +18,7 @@
  *   name: reviewer
  *   description: Reviews a diff for correctness & security
  *   tools: [read_file, search_code, execute_command]   # allowlist; omit = all
- *   model: glm-5.1            # optional provider/model or model override
+ *   model: glm-5.2            # optional provider/model or model override
  *   personality: security     # optional — reuse a personality preset
  *   maxIterations: 15         # optional budget
  *   ---

package/dist/utils/checkpoints.d.ts

@@ -27,7 +27,7 @@
  *   "createdAt": "...",
  *   "sessionId": "session-2026-05-18-...",
  *   "provider": "z.ai",
- *   "model": "glm-5.1",
+ *   "model": "glm-5.2",
  *   "messages": [ ... ],
  *   "filesTouched": ["src/a.ts", "src/b.ts"],
  *   "gitHead": "abcdef0"        // optional, recorded only if cwd is a git repo

package/dist/utils/checkpoints.js

@@ -27,7 +27,7 @@
  *   "createdAt": "...",
  *   "sessionId": "session-2026-05-18-...",
  *   "provider": "z.ai",
- *   "model": "glm-5.1",
+ *   "model": "glm-5.2",
  *   "messages": [ ... ],
  *   "filesTouched": ["src/a.ts", "src/b.ts"],
  *   "gitHead": "abcdef0"        // optional, recorded only if cwd is a git repo

package/dist/utils/diffPreview.d.ts

@@ -55,3 +55,34 @@ export declare function formatDiffPreview(diffs: FileDiff[]): string;
  * Calculate diff statistics
  */
 export declare function getDiffStats(diffs: FileDiff[]): DiffPreviewResult;
+/**
+ * Apply a subset of a file diff's hunks to the original content.
+ *
+ * Hunk indices in `acceptedHunks` refer to positions in `diff.hunks`
+ * (0-based). Hunks not in the set are skipped — their original lines
+ * stay, their additions are dropped.
+ *
+ * Returns the resulting file content. The caller writes it to disk.
+ *
+ * For `type === 'create'`, the whole file is either accepted (any hunk
+ * accepted) or rejected (empty set) — there's no original to merge
+ * against. For `type === 'delete'`, accepting any hunk deletes the file.
+ */
+export declare function applyHunks(diff: FileDiff, acceptedHunks: Set<number>): string;
+/**
+ * Apply accepted hunks across multiple file diffs and return the
+ * resulting content for each. The caller writes the files to disk.
+ *
+ * `accepted` maps file path → set of accepted hunk indices. Files not
+ * in the map are skipped entirely.
+ */
+export declare function applyHunksToFiles(diffs: FileDiff[], accepted: Map<string, Set<number>>): Array<{
+    path: string;
+    content: string;
+    type: FileDiff['type'];
+}>;
+/**
+ * Count how many hunks in a diff contain actual changes (not just
+ * context). Used to label hunks in the UI ("hunk 2/5").
+ */
+export declare function countChangeHunks(diff: FileDiff): number;