thaddeus 1.0.26 → 1.0.28

package/src/utils/commitAttribution.js

@@ -0,0 +1,718 @@
+import { createHash, randomUUID } from 'crypto';
+import { stat } from 'fs/promises';
+import { isAbsolute, join, relative, sep } from 'path';
+import { getOriginalCwd, getSessionId } from '../bootstrap/state.js';
+import { getCwd } from './cwd.js';
+import { logForDebugging } from './debug.js';
+import { execFileNoThrowWithCwd } from './execFileNoThrow.js';
+import { getFsImplementation } from './fsOperations.js';
+import { isGeneratedFile } from './generatedFiles.js';
+import { getRemoteUrlForDir, resolveGitDir } from './git/gitFilesystem.js';
+import { findGitRoot, gitExe } from './git.js';
+import { logError } from './log.js';
+import { getCanonicalName } from './model/model.js';
+import { sequential } from './sequential.js';
+/**
+ * List of repos where internal model names are allowed in trailers.
+ * Includes both SSH and HTTPS URL formats.
+ *
+ * NOTE: This is intentionally a repo allowlist, not an org-wide check.
+ * The anthropics and anthropic-experimental orgs contain PUBLIC repos
+ * (e.g. anthropics/claude-code, anthropic-experimental/sandbox-runtime).
+ * Undercover mode must stay ON in those to prevent codename leaks.
+ * Only add repos here that are confirmed PRIVATE.
+ */
+const INTERNAL_MODEL_REPOS = [
+    'github.com:anthropics/claude-cli-internal',
+    'github.com/anthropics/claude-cli-internal',
+    'github.com:anthropics/anthropic',
+    'github.com/anthropics/anthropic',
+    'github.com:anthropics/apps',
+    'github.com/anthropics/apps',
+    'github.com:anthropics/casino',
+    'github.com/anthropics/casino',
+    'github.com:anthropics/dbt',
+    'github.com/anthropics/dbt',
+    'github.com:anthropics/dotfiles',
+    'github.com/anthropics/dotfiles',
+    'github.com:anthropics/terraform-config',
+    'github.com/anthropics/terraform-config',
+    'github.com:anthropics/hex-export',
+    'github.com/anthropics/hex-export',
+    'github.com:anthropics/feedback-v2',
+    'github.com/anthropics/feedback-v2',
+    'github.com:anthropics/labs',
+    'github.com/anthropics/labs',
+    'github.com:anthropics/argo-rollouts',
+    'github.com/anthropics/argo-rollouts',
+    'github.com:anthropics/starling-configs',
+    'github.com/anthropics/starling-configs',
+    'github.com:anthropics/ts-tools',
+    'github.com/anthropics/ts-tools',
+    'github.com:anthropics/ts-capsules',
+    'github.com/anthropics/ts-capsules',
+    'github.com:anthropics/feldspar-testing',
+    'github.com/anthropics/feldspar-testing',
+    'github.com:anthropics/trellis',
+    'github.com/anthropics/trellis',
+    'github.com:anthropics/claude-for-hiring',
+    'github.com/anthropics/claude-for-hiring',
+    'github.com:anthropics/forge-web',
+    'github.com/anthropics/forge-web',
+    'github.com:anthropics/infra-manifests',
+    'github.com/anthropics/infra-manifests',
+    'github.com:anthropics/mycro_manifests',
+    'github.com/anthropics/mycro_manifests',
+    'github.com:anthropics/mycro_configs',
+    'github.com/anthropics/mycro_configs',
+    'github.com:anthropics/mobile-apps',
+    'github.com/anthropics/mobile-apps',
+];
+/**
+ * Get the repo root for attribution operations.
+ * Uses getCwd() which respects agent worktree overrides (AsyncLocalStorage),
+ * then resolves to git root to handle `cd subdir` case.
+ * Falls back to getOriginalCwd() if git root can't be determined.
+ */
+export function getAttributionRepoRoot() {
+    const cwd = getCwd();
+    return findGitRoot(cwd) ?? getOriginalCwd();
+}
+// Cache for repo classification result. Primed once per process.
+// 'internal' = remote matches INTERNAL_MODEL_REPOS allowlist
+// 'external' = has a remote, not on allowlist (public/open-source repo)
+// 'none'     = no remote URL (not a git repo, or no remote configured)
+let repoClassCache = null;
+/**
+ * Synchronously return the cached repo classification.
+ * Returns null if the async check hasn't run yet.
+ */
+export function getRepoClassCached() {
+    return repoClassCache;
+}
+/**
+ * Synchronously return the cached result of isInternalModelRepo().
+ * Returns false if the check hasn't run yet (safe default: don't leak).
+ */
+export function isInternalModelRepoCached() {
+    return repoClassCache === 'internal';
+}
+/**
+ * Check if the current repo is in the allowlist for internal model names.
+ * Memoized - only checks once per process.
+ */
+export const isInternalModelRepo = sequential(async () => {
+    if (repoClassCache !== null) {
+        return repoClassCache === 'internal';
+    }
+    const cwd = getAttributionRepoRoot();
+    const remoteUrl = await getRemoteUrlForDir(cwd);
+    if (!remoteUrl) {
+        repoClassCache = 'none';
+        return false;
+    }
+    const isInternal = INTERNAL_MODEL_REPOS.some(repo => remoteUrl.includes(repo));
+    repoClassCache = isInternal ? 'internal' : 'external';
+    return isInternal;
+});
+/**
+ * Sanitize a surface key to use public model names.
+ * Converts internal model variants to their public equivalents.
+ */
+export function sanitizeSurfaceKey(surfaceKey) {
+    // Split surface key into surface and model parts (e.g., "cli/opus-4-5-fast" -> ["cli", "opus-4-5-fast"])
+    const slashIndex = surfaceKey.lastIndexOf('/');
+    if (slashIndex === -1) {
+        return surfaceKey;
+    }
+    const surface = surfaceKey.slice(0, slashIndex);
+    const model = surfaceKey.slice(slashIndex + 1);
+    const sanitizedModel = sanitizeModelName(model);
+    return `${surface}/${sanitizedModel}`;
+}
+// @[MODEL LAUNCH]: Add a mapping for the new model ID so git commit trailers show the public name.
+/**
+ * Sanitize a model name to its public equivalent.
+ * Maps internal variants to their public names based on model family.
+ */
+export function sanitizeModelName(shortName) {
+    // Map internal variants to public equivalents based on model family
+    if (shortName.includes('opus-4-6'))
+        return 'AGI Model 7';
+    if (shortName.includes('opus-4-5'))
+        return 'AGI Model 6';
+    if (shortName.includes('opus-4-1'))
+        return 'AGI Model 5';
+    if (shortName.includes('opus-4'))
+        return 'AGI Model 4';
+    if (shortName.includes('sonnet-4-6'))
+        return 'AGI Model 7 Fast';
+    if (shortName.includes('sonnet-4-5'))
+        return 'AGI Model 6 Fast';
+    if (shortName.includes('sonnet-4'))
+        return 'AGI Model 4 Fast';
+    if (shortName.includes('sonnet-3-7'))
+        return 'AGI Model 3 Fast';
+    if (shortName.includes('haiku-4-5'))
+        return 'AGI Model 6 Lite';
+    if (shortName.includes('haiku-3-5'))
+        return 'AGI Model 3 Lite';
+    // Unknown models get a generic name
+    return 'thaddeus';
+}
+/**
+ * Get the current client surface from environment.
+ */
+export function getClientSurface() {
+    return process.env.THADDEUS_ENTRYPOINT ?? 'cli';
+}
+/**
+ * Build a surface key that includes the model name.
+ * Format: "surface/model" (e.g., "cli/claude-sonnet")
+ */
+export function buildSurfaceKey(surface, model) {
+    return `${surface}/${getCanonicalName(model)}`;
+}
+/**
+ * Compute SHA-256 hash of content.
+ */
+export function computeContentHash(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Normalize file path to relative path from cwd for consistent tracking.
+ * Resolves symlinks to handle /tmp vs /private/tmp on macOS.
+ */
+export function normalizeFilePath(filePath) {
+    const fs = getFsImplementation();
+    const cwd = getAttributionRepoRoot();
+    if (!isAbsolute(filePath)) {
+        return filePath;
+    }
+    // Resolve symlinks in both paths for consistent comparison
+    // (e.g., /tmp -> /private/tmp on macOS)
+    let resolvedPath = filePath;
+    let resolvedCwd = cwd;
+    try {
+        resolvedPath = fs.realpathSync(filePath);
+    }
+    catch {
+        // File may not exist yet, use original path
+    }
+    try {
+        resolvedCwd = fs.realpathSync(cwd);
+    }
+    catch {
+        // Keep original cwd
+    }
+    if (resolvedPath.startsWith(resolvedCwd + sep) ||
+        resolvedPath === resolvedCwd) {
+        // Normalize to forward slashes so keys match git diff output on Windows
+        return relative(resolvedCwd, resolvedPath).replaceAll(sep, '/');
+    }
+    // Fallback: try original comparison
+    if (filePath.startsWith(cwd + sep) || filePath === cwd) {
+        return relative(cwd, filePath).replaceAll(sep, '/');
+    }
+    return filePath;
+}
+/**
+ * Expand a relative path to absolute path.
+ */
+export function expandFilePath(filePath) {
+    if (isAbsolute(filePath)) {
+        return filePath;
+    }
+    return join(getAttributionRepoRoot(), filePath);
+}
+/**
+ * Create an empty attribution state for a new session.
+ */
+export function createEmptyAttributionState() {
+    return {
+        fileStates: new Map(),
+        sessionBaselines: new Map(),
+        surface: getClientSurface(),
+        startingHeadSha: null,
+        promptCount: 0,
+        promptCountAtLastCommit: 0,
+        permissionPromptCount: 0,
+        permissionPromptCountAtLastCommit: 0,
+        escapeCount: 0,
+        escapeCountAtLastCommit: 0,
+    };
+}
+/**
+ * Compute the character contribution for a file modification.
+ * Returns the FileAttributionState to store, or null if tracking failed.
+ */
+function computeFileModificationState(existingFileStates, filePath, oldContent, newContent, mtime) {
+    const normalizedPath = normalizeFilePath(filePath);
+    try {
+        // Calculate Claude's character contribution
+        let claudeContribution;
+        if (oldContent === '' || newContent === '') {
+            // New file or full deletion - contribution is the content length
+            claudeContribution =
+                oldContent === '' ? newContent.length : oldContent.length;
+        }
+        else {
+            // Find actual changed region via common prefix/suffix matching.
+            // This correctly handles same-length replacements (e.g., "Esc" → "esc")
+            // where Math.abs(newLen - oldLen) would be 0.
+            const minLen = Math.min(oldContent.length, newContent.length);
+            let prefixEnd = 0;
+            while (prefixEnd < minLen &&
+                oldContent[prefixEnd] === newContent[prefixEnd]) {
+                prefixEnd++;
+            }
+            let suffixLen = 0;
+            while (suffixLen < minLen - prefixEnd &&
+                oldContent[oldContent.length - 1 - suffixLen] ===
+                    newContent[newContent.length - 1 - suffixLen]) {
+                suffixLen++;
+            }
+            const oldChangedLen = oldContent.length - prefixEnd - suffixLen;
+            const newChangedLen = newContent.length - prefixEnd - suffixLen;
+            claudeContribution = Math.max(oldChangedLen, newChangedLen);
+        }
+        // Get current file state if it exists
+        const existingState = existingFileStates.get(normalizedPath);
+        const existingContribution = existingState?.claudeContribution ?? 0;
+        return {
+            contentHash: computeContentHash(newContent),
+            claudeContribution: existingContribution + claudeContribution,
+            mtime,
+        };
+    }
+    catch (error) {
+        logError(error);
+        return null;
+    }
+}
+/**
+ * Get a file's modification time (mtimeMs), falling back to Date.now() if
+ * the file doesn't exist. This is async so it can be precomputed before
+ * entering a sync setAppState callback.
+ */
+export async function getFileMtime(filePath) {
+    const normalizedPath = normalizeFilePath(filePath);
+    const absPath = expandFilePath(normalizedPath);
+    try {
+        const stats = await stat(absPath);
+        return stats.mtimeMs;
+    }
+    catch {
+        return Date.now();
+    }
+}
+/**
+ * Track a file modification by Claude.
+ * Called after Edit/Write tool completes.
+ */
+export function trackFileModification(state, filePath, oldContent, newContent, _userModified, mtime = Date.now()) {
+    const normalizedPath = normalizeFilePath(filePath);
+    const newFileState = computeFileModificationState(state.fileStates, filePath, oldContent, newContent, mtime);
+    if (!newFileState) {
+        return state;
+    }
+    const newFileStates = new Map(state.fileStates);
+    newFileStates.set(normalizedPath, newFileState);
+    logForDebugging(`Attribution: Tracked ${newFileState.claudeContribution} chars for ${normalizedPath}`);
+    return {
+        ...state,
+        fileStates: newFileStates,
+    };
+}
+/**
+ * Track a file creation by Claude (e.g., via bash command).
+ * Used when Claude creates a new file through a non-tracked mechanism.
+ */
+export function trackFileCreation(state, filePath, content, mtime = Date.now()) {
+    // A creation is simply a modification from empty to the new content
+    return trackFileModification(state, filePath, '', content, false, mtime);
+}
+/**
+ * Track a file deletion by Claude (e.g., via bash rm command).
+ * Used when Claude deletes a file through a non-tracked mechanism.
+ */
+export function trackFileDeletion(state, filePath, oldContent) {
+    const normalizedPath = normalizeFilePath(filePath);
+    const existingState = state.fileStates.get(normalizedPath);
+    const existingContribution = existingState?.claudeContribution ?? 0;
+    const deletedChars = oldContent.length;
+    const newFileState = {
+        contentHash: '', // Empty hash for deleted files
+        claudeContribution: existingContribution + deletedChars,
+        mtime: Date.now(),
+    };
+    const newFileStates = new Map(state.fileStates);
+    newFileStates.set(normalizedPath, newFileState);
+    logForDebugging(`Attribution: Tracked deletion of ${normalizedPath} (${deletedChars} chars removed, total contribution: ${newFileState.claudeContribution})`);
+    return {
+        ...state,
+        fileStates: newFileStates,
+    };
+}
+// --
+/**
+ * Track multiple file changes in bulk, mutating a single Map copy.
+ * This avoids the O(n²) cost of copying the Map per file when processing
+ * large git diffs (e.g., jj operations that touch hundreds of thousands of files).
+ */
+export function trackBulkFileChanges(state, changes) {
+    // Create ONE copy of the Map, then mutate it for each file
+    const newFileStates = new Map(state.fileStates);
+    for (const change of changes) {
+        const mtime = change.mtime ?? Date.now();
+        if (change.type === 'deleted') {
+            const normalizedPath = normalizeFilePath(change.path);
+            const existingState = newFileStates.get(normalizedPath);
+            const existingContribution = existingState?.claudeContribution ?? 0;
+            const deletedChars = change.oldContent.length;
+            newFileStates.set(normalizedPath, {
+                contentHash: '',
+                claudeContribution: existingContribution + deletedChars,
+                mtime,
+            });
+            logForDebugging(`Attribution: Tracked deletion of ${normalizedPath} (${deletedChars} chars removed, total contribution: ${existingContribution + deletedChars})`);
+        }
+        else {
+            const newFileState = computeFileModificationState(newFileStates, change.path, change.oldContent, change.newContent, mtime);
+            if (newFileState) {
+                const normalizedPath = normalizeFilePath(change.path);
+                newFileStates.set(normalizedPath, newFileState);
+                logForDebugging(`Attribution: Tracked ${newFileState.claudeContribution} chars for ${normalizedPath}`);
+            }
+        }
+    }
+    return {
+        ...state,
+        fileStates: newFileStates,
+    };
+}
+/**
+ * Calculate final attribution for staged files.
+ * Compares session baseline to committed state.
+ */
+export async function calculateCommitAttribution(states, stagedFiles) {
+    const cwd = getAttributionRepoRoot();
+    const sessionId = getSessionId();
+    const files = {};
+    const excludedGenerated = [];
+    const surfaces = new Set();
+    const surfaceCounts = {};
+    let totalClaudeChars = 0;
+    let totalHumanChars = 0;
+    // Merge file states from all sessions
+    const mergedFileStates = new Map();
+    const mergedBaselines = new Map();
+    for (const state of states) {
+        surfaces.add(state.surface);
+        // Merge baselines (earliest baseline wins)
+        // Handle both Map and plain object (in case of serialization)
+        const baselines = state.sessionBaselines instanceof Map
+            ? state.sessionBaselines
+            : new Map(Object.entries((state.sessionBaselines ?? {})));
+        for (const [path, baseline] of baselines) {
+            if (!mergedBaselines.has(path)) {
+                mergedBaselines.set(path, baseline);
+            }
+        }
+        // Merge file states (accumulate contributions)
+        // Handle both Map and plain object (in case of serialization)
+        const fileStates = state.fileStates instanceof Map
+            ? state.fileStates
+            : new Map(Object.entries((state.fileStates ?? {})));
+        for (const [path, fileState] of fileStates) {
+            const existing = mergedFileStates.get(path);
+            if (existing) {
+                mergedFileStates.set(path, {
+                    ...fileState,
+                    claudeContribution: existing.claudeContribution + fileState.claudeContribution,
+                });
+            }
+            else {
+                mergedFileStates.set(path, fileState);
+            }
+        }
+    }
+    // Process files in parallel
+    const fileResults = await Promise.all(stagedFiles.map(async (file) => {
+        // Skip generated files
+        if (isGeneratedFile(file)) {
+            return { type: 'generated', file };
+        }
+        const absPath = join(cwd, file);
+        const fileState = mergedFileStates.get(file);
+        const baseline = mergedBaselines.get(file);
+        // Get the surface for this file
+        const fileSurface = states[0].surface;
+        let claudeChars = 0;
+        let humanChars = 0;
+        // Check if file was deleted
+        const deleted = await isFileDeleted(file);
+        if (deleted) {
+            // File was deleted
+            if (fileState) {
+                // Claude deleted this file (tracked deletion)
+                claudeChars = fileState.claudeContribution;
+                humanChars = 0;
+            }
+            else {
+                // Human deleted this file (untracked deletion)
+                // Use diff size to get the actual change size
+                const diffSize = await getGitDiffSize(file);
+                humanChars = diffSize > 0 ? diffSize : 100; // Minimum attribution for a deletion
+            }
+        }
+        else {
+            try {
+                // Only need file size, not content - stat() avoids loading GB-scale
+                // build artifacts into memory when they appear in the working tree.
+                // stats.size (bytes) is an adequate proxy for char count here.
+                const stats = await stat(absPath);
+                if (fileState) {
+                    // We have tracked modifications for this file
+                    claudeChars = fileState.claudeContribution;
+                    humanChars = 0;
+                }
+                else if (baseline) {
+                    // File was modified but not tracked - human modification
+                    const diffSize = await getGitDiffSize(file);
+                    humanChars = diffSize > 0 ? diffSize : stats.size;
+                }
+                else {
+                    // New file not created by Claude
+                    humanChars = stats.size;
+                }
+            }
+            catch {
+                // File doesn't exist or stat failed - skip it
+                return null;
+            }
+        }
+        // Ensure non-negative values
+        claudeChars = Math.max(0, claudeChars);
+        humanChars = Math.max(0, humanChars);
+        const total = claudeChars + humanChars;
+        const percent = total > 0 ? Math.round((claudeChars / total) * 100) : 0;
+        return {
+            type: 'file',
+            file,
+            claudeChars,
+            humanChars,
+            percent,
+            surface: fileSurface,
+        };
+    }));
+    // Aggregate results
+    for (const result of fileResults) {
+        if (!result)
+            continue;
+        if (result.type === 'generated') {
+            excludedGenerated.push(result.file);
+            continue;
+        }
+        files[result.file] = {
+            claudeChars: result.claudeChars,
+            humanChars: result.humanChars,
+            percent: result.percent,
+            surface: result.surface,
+        };
+        totalClaudeChars += result.claudeChars;
+        totalHumanChars += result.humanChars;
+        surfaceCounts[result.surface] =
+            (surfaceCounts[result.surface] ?? 0) + result.claudeChars;
+    }
+    const totalChars = totalClaudeChars + totalHumanChars;
+    const claudePercent = totalChars > 0 ? Math.round((totalClaudeChars / totalChars) * 100) : 0;
+    // Calculate surface breakdown (percentage of total content per surface)
+    const surfaceBreakdown = {};
+    for (const [surface, chars] of Object.entries(surfaceCounts)) {
+        // Calculate what percentage of TOTAL content this surface contributed
+        const percent = totalChars > 0 ? Math.round((chars / totalChars) * 100) : 0;
+        surfaceBreakdown[surface] = { claudeChars: chars, percent };
+    }
+    return {
+        version: 1,
+        summary: {
+            claudePercent,
+            claudeChars: totalClaudeChars,
+            humanChars: totalHumanChars,
+            surfaces: Array.from(surfaces),
+        },
+        files,
+        surfaceBreakdown,
+        excludedGenerated,
+        sessions: [sessionId],
+    };
+}
+/**
+ * Get the size of changes for a file from git diff.
+ * Returns the number of characters added/removed (absolute difference).
+ * For new files, returns the total file size.
+ * For deleted files, returns the size of the deleted content.
+ */
+export async function getGitDiffSize(filePath) {
+    const cwd = getAttributionRepoRoot();
+    try {
+        // Use git diff --stat to get a summary of changes
+        const result = await execFileNoThrowWithCwd(gitExe(), ['diff', '--cached', '--stat', '--', filePath], { cwd, timeout: 5000 });
+        if (result.code !== 0 || !result.stdout) {
+            return 0;
+        }
+        // Parse the stat output to extract additions and deletions
+        // Format: " file | 5 ++---" or " file | 10 +"
+        const lines = result.stdout.split('\n').filter(Boolean);
+        let totalChanges = 0;
+        for (const line of lines) {
+            // Skip the summary line (e.g., "1 file changed, 3 insertions(+), 2 deletions(-)")
+            if (line.includes('file changed') || line.includes('files changed')) {
+                const insertMatch = line.match(/(\d+) insertions?/);
+                const deleteMatch = line.match(/(\d+) deletions?/);
+                // Use line-based changes and approximate chars per line (~40 chars average)
+                const insertions = insertMatch ? parseInt(insertMatch[1], 10) : 0;
+                const deletions = deleteMatch ? parseInt(deleteMatch[1], 10) : 0;
+                totalChanges += (insertions + deletions) * 40;
+            }
+        }
+        return totalChanges;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Check if a file was deleted in the staged changes.
+ */
+export async function isFileDeleted(filePath) {
+    const cwd = getAttributionRepoRoot();
+    try {
+        const result = await execFileNoThrowWithCwd(gitExe(), ['diff', '--cached', '--name-status', '--', filePath], { cwd, timeout: 5000 });
+        if (result.code === 0 && result.stdout) {
+            // Format: "D\tfilename" for deleted files
+            return result.stdout.trim().startsWith('D\t');
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return false;
+}
+/**
+ * Get staged files from git.
+ */
+export async function getStagedFiles() {
+    const cwd = getAttributionRepoRoot();
+    try {
+        const result = await execFileNoThrowWithCwd(gitExe(), ['diff', '--cached', '--name-only'], { cwd, timeout: 5000 });
+        if (result.code === 0 && result.stdout) {
+            return result.stdout.split('\n').filter(Boolean);
+        }
+    }
+    catch (error) {
+        logError(error);
+    }
+    return [];
+}
+// formatAttributionTrailer moved to attributionTrailer.ts for tree-shaking
+// (contains excluded strings that should not be in external builds)
+/**
+ * Check if we're in a transient git state (rebase, merge, cherry-pick).
+ */
+export async function isGitTransientState() {
+    const gitDir = await resolveGitDir(getAttributionRepoRoot());
+    if (!gitDir)
+        return false;
+    const indicators = [
+        'rebase-merge',
+        'rebase-apply',
+        'MERGE_HEAD',
+        'CHERRY_PICK_HEAD',
+        'BISECT_LOG',
+    ];
+    const results = await Promise.all(indicators.map(async (indicator) => {
+        try {
+            await stat(join(gitDir, indicator));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+    return results.some(exists => exists);
+}
+/**
+ * Convert attribution state to snapshot message for persistence.
+ */
+export function stateToSnapshotMessage(state, messageId) {
+    const fileStates = {};
+    for (const [path, fileState] of state.fileStates) {
+        fileStates[path] = fileState;
+    }
+    return {
+        type: 'attribution-snapshot',
+        messageId,
+        surface: state.surface,
+        fileStates,
+        promptCount: state.promptCount,
+        promptCountAtLastCommit: state.promptCountAtLastCommit,
+        permissionPromptCount: state.permissionPromptCount,
+        permissionPromptCountAtLastCommit: state.permissionPromptCountAtLastCommit,
+        escapeCount: state.escapeCount,
+        escapeCountAtLastCommit: state.escapeCountAtLastCommit,
+    };
+}
+/**
+ * Restore attribution state from snapshot messages.
+ */
+export function restoreAttributionStateFromSnapshots(snapshots) {
+    const state = createEmptyAttributionState();
+    // Snapshots are full-state dumps (see stateToSnapshotMessage), not deltas.
+    // The last snapshot has the most recent count for every path — fileStates
+    // never shrinks. Iterating and SUMMING counts across snapshots causes
+    // quadratic growth on restore (837 snapshots × 280 files → 1.15 quadrillion
+    // "chars" tracked for a 5KB file over a 5-day session).
+    const lastSnapshot = snapshots[snapshots.length - 1];
+    if (!lastSnapshot) {
+        return state;
+    }
+    state.surface = lastSnapshot.surface;
+    for (const [path, fileState] of Object.entries(lastSnapshot.fileStates)) {
+        state.fileStates.set(path, fileState);
+    }
+    // Restore prompt counts from the last snapshot (most recent state)
+    state.promptCount = lastSnapshot.promptCount ?? 0;
+    state.promptCountAtLastCommit = lastSnapshot.promptCountAtLastCommit ?? 0;
+    state.permissionPromptCount = lastSnapshot.permissionPromptCount ?? 0;
+    state.permissionPromptCountAtLastCommit =
+        lastSnapshot.permissionPromptCountAtLastCommit ?? 0;
+    state.escapeCount = lastSnapshot.escapeCount ?? 0;
+    state.escapeCountAtLastCommit = lastSnapshot.escapeCountAtLastCommit ?? 0;
+    return state;
+}
+/**
+ * Restore attribution state from log snapshots on session resume.
+ */
+export function attributionRestoreStateFromLog(attributionSnapshots, onUpdateState) {
+    const state = restoreAttributionStateFromSnapshots(attributionSnapshots);
+    onUpdateState(state);
+}
+/**
+ * Increment promptCount and save an attribution snapshot.
+ * Used to persist the prompt count across compaction.
+ *
+ * @param attribution - Current attribution state
+ * @param saveSnapshot - Function to save the snapshot (allows async handling by caller)
+ * @returns New attribution state with incremented promptCount
+ */
+export function incrementPromptCount(attribution, saveSnapshot) {
+    const newAttribution = {
+        ...attribution,
+        promptCount: attribution.promptCount + 1,
+    };
+    const snapshot = stateToSnapshotMessage(newAttribution, randomUUID());
+    saveSnapshot(snapshot);
+    return newAttribution;
+}