@renseiai/agentfactory 0.8.7 → 0.8.9

package/dist/src/orchestrator/artifact-tracker.d.ts

@@ -0,0 +1,93 @@
+import type { AgentEvent } from '../providers/types.js';
+/**
+ * Extended file action type for the artifact tracker.
+ * Includes 'searched' beyond what StructuredSummary uses.
+ */
+export type TrackedFileAction = 'read' | 'created' | 'modified' | 'deleted' | 'searched';
+/**
+ * A tracked file with its operation history
+ */
+export interface TrackedFile {
+    /** Absolute file path */
+    path: string;
+    /** Path relative to worktree root */
+    relativePath: string;
+    /** Chronological list of operations performed */
+    actions: TrackedFileAction[];
+    /** Unix timestamp when file was first encountered */
+    firstSeenAt: number;
+    /** Unix timestamp of most recent operation */
+    lastTouchedAt: number;
+    /** Number of lines read (from Read tool) */
+    linesRead?: number;
+    /** Number of lines modified (from Edit/Write tools) */
+    linesModified?: number;
+}
+/**
+ * The full artifact index
+ */
+export interface ArtifactIndex {
+    /** Map of absolute path to tracked file info */
+    files: Record<string, TrackedFile>;
+    /** Total read operations performed */
+    totalReads: number;
+    /** Total write operations performed */
+    totalWrites: number;
+    /** Unix timestamp of last index update */
+    lastUpdatedAt: number;
+}
+/**
+ * Tracks files read/modified during an agent session.
+ * Parses tool_use events to extract file operations and maintains
+ * a persistent index for context window management.
+ */
+export declare class ArtifactTracker {
+    private index;
+    private worktreeRoot;
+    constructor(worktreeRoot: string, existingIndex?: ArtifactIndex);
+    /**
+     * Process an agent event to extract file operations.
+     * Only processes tool_use events (not tool_result).
+     */
+    trackEvent(event: AgentEvent): void;
+    /**
+     * Process a tool_use event to extract file operations
+     */
+    private trackToolUseEvent;
+    /**
+     * Parse bash commands for file operation heuristics
+     */
+    private parseBashCommand;
+    /**
+     * Record a file action in the index
+     */
+    private recordAction;
+    /**
+     * Get the current artifact index
+     */
+    getIndex(): ArtifactIndex;
+    /**
+     * Get files matching optional filters
+     */
+    getFiles(filter?: {
+        action?: TrackedFileAction;
+        glob?: string;
+    }): TrackedFile[];
+    /**
+     * Persist the index to .agent/artifacts.json atomically
+     */
+    persist(): void;
+    /**
+     * Load a persisted artifact index from .agent/artifacts.json
+     */
+    static load(worktreeRoot: string): ArtifactTracker;
+    /**
+     * Generate a compact summary string for context injection
+     */
+    toContextString(): string;
+    /**
+     * Summarize action counts for a file
+     */
+    private summarizeActions;
+}
+//# sourceMappingURL=artifact-tracker.d.ts.map

package/dist/src/orchestrator/artifact-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-tracker.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/artifact-tracker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAG1E;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAA;AAExF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAA;IACrB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uDAAuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAClC,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,0CAA0C;IAC1C,aAAa,EAAE,MAAM,CAAA;CACtB;AAYD;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,YAAY,CAAQ;gBAEhB,YAAY,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa;IAU/D;;;OAGG;IACH,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAKnC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,QAAQ,IAAI,aAAa;IAIzB;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,iBAAiB,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,EAAE;IAyB/E;;OAEG;IACH,OAAO,IAAI,IAAI;IAef;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe;IAoBlD;;OAEG;IACH,eAAe,IAAI,MAAM;IAqCzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/src/orchestrator/artifact-tracker.js

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { resolve, relative } from 'path';
+import { initializeAgentDir, getAgentDir } from './state-recovery.js';
+/**
+ * Tracks files read/modified during an agent session.
+ * Parses tool_use events to extract file operations and maintains
+ * a persistent index for context window management.
+ */
+export class ArtifactTracker {
+    index;
+    worktreeRoot;
+    constructor(worktreeRoot, existingIndex) {
+        this.worktreeRoot = worktreeRoot;
+        this.index = existingIndex ?? {
+            files: {},
+            totalReads: 0,
+            totalWrites: 0,
+            lastUpdatedAt: Date.now(),
+        };
+    }
+    /**
+     * Process an agent event to extract file operations.
+     * Only processes tool_use events (not tool_result).
+     */
+    trackEvent(event) {
+        if (event.type !== 'tool_use')
+            return;
+        this.trackToolUseEvent(event);
+    }
+    /**
+     * Process a tool_use event to extract file operations
+     */
+    trackToolUseEvent(event) {
+        const { toolName, input } = event;
+        const now = Date.now();
+        switch (toolName) {
+            case 'Read': {
+                const filePath = input.file_path;
+                if (filePath) {
+                    this.recordAction(filePath, 'read', now);
+                    this.index.totalReads++;
+                }
+                break;
+            }
+            case 'Write': {
+                const filePath = input.file_path;
+                if (filePath) {
+                    // Check if file exists to determine created vs modified
+                    const action = existsSync(filePath) ? 'modified' : 'created';
+                    this.recordAction(filePath, action, now);
+                    this.index.totalWrites++;
+                }
+                break;
+            }
+            case 'Edit': {
+                const filePath = input.file_path;
+                if (filePath) {
+                    this.recordAction(filePath, 'modified', now);
+                    this.index.totalWrites++;
+                }
+                break;
+            }
+            case 'Glob': {
+                // Glob results are in tool_result, not tool_use; we track the search pattern
+                // We don't track individual files from glob since results come in tool_result
+                break;
+            }
+            case 'Grep': {
+                // Similar to Glob — results come in tool_result
+                break;
+            }
+            case 'Bash': {
+                const command = input.command;
+                if (command) {
+                    this.parseBashCommand(command, now);
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Parse bash commands for file operation heuristics
+     */
+    parseBashCommand(command, timestamp) {
+        // Detect rm commands
+        const rmMatch = command.match(/\brm\s+(?:-[rRfv]+\s+)*([^\s|;&]+)/);
+        if (rmMatch && rmMatch[1]) {
+            this.recordAction(rmMatch[1], 'deleted', timestamp);
+            this.index.totalWrites++;
+        }
+        // Detect mv commands (source deleted, dest created)
+        const mvMatch = command.match(/\bmv\s+(?:-[fv]+\s+)*([^\s|;&]+)\s+([^\s|;&]+)/);
+        if (mvMatch && mvMatch[1] && mvMatch[2]) {
+            this.recordAction(mvMatch[1], 'deleted', timestamp);
+            this.recordAction(mvMatch[2], 'created', timestamp);
+            this.index.totalWrites += 2;
+        }
+    }
+    /**
+     * Record a file action in the index
+     */
+    recordAction(filePath, action, timestamp) {
+        const absPath = resolve(this.worktreeRoot, filePath);
+        const relPath = relative(this.worktreeRoot, absPath);
+        const existing = this.index.files[absPath];
+        if (existing) {
+            existing.actions.push(action);
+            existing.lastTouchedAt = timestamp;
+        }
+        else {
+            this.index.files[absPath] = {
+                path: absPath,
+                relativePath: relPath,
+                actions: [action],
+                firstSeenAt: timestamp,
+                lastTouchedAt: timestamp,
+            };
+        }
+        this.index.lastUpdatedAt = timestamp;
+    }
+    /**
+     * Get the current artifact index
+     */
+    getIndex() {
+        return this.index;
+    }
+    /**
+     * Get files matching optional filters
+     */
+    getFiles(filter) {
+        let files = Object.values(this.index.files);
+        if (filter?.action) {
+            files = files.filter(f => f.actions.includes(filter.action));
+        }
+        if (filter?.glob) {
+            const pattern = filter.glob;
+            files = files.filter(f => {
+                // Simple glob matching: * matches anything except /, ** matches anything
+                const regex = new RegExp('^' + pattern
+                    .replace(/\*\*/g, '___DOUBLESTAR___')
+                    .replace(/\*/g, '[^/]*')
+                    .replace(/___DOUBLESTAR___/g, '.*')
+                    .replace(/\?/g, '[^/]') + '$');
+                return regex.test(f.relativePath);
+            });
+        }
+        return files;
+    }
+    /**
+     * Persist the index to .agent/artifacts.json atomically
+     */
+    persist() {
+        const agentDir = getAgentDir(this.worktreeRoot);
+        initializeAgentDir(this.worktreeRoot);
+        const artifactsPath = resolve(agentDir, 'artifacts.json');
+        const tempPath = artifactsPath + '.tmp';
+        const serialized = {
+            files: this.index.files,
+            totalReads: this.index.totalReads,
+            totalWrites: this.index.totalWrites,
+            lastUpdatedAt: this.index.lastUpdatedAt,
+        };
+        writeFileSync(tempPath, JSON.stringify(serialized, null, 2));
+        renameSync(tempPath, artifactsPath);
+    }
+    /**
+     * Load a persisted artifact index from .agent/artifacts.json
+     */
+    static load(worktreeRoot) {
+        const artifactsPath = resolve(getAgentDir(worktreeRoot), 'artifacts.json');
+        try {
+            if (!existsSync(artifactsPath)) {
+                return new ArtifactTracker(worktreeRoot);
+            }
+            const content = readFileSync(artifactsPath, 'utf-8');
+            const data = JSON.parse(content);
+            const index = {
+                files: data.files ?? {},
+                totalReads: data.totalReads ?? 0,
+                totalWrites: data.totalWrites ?? 0,
+                lastUpdatedAt: data.lastUpdatedAt ?? Date.now(),
+            };
+            return new ArtifactTracker(worktreeRoot, index);
+        }
+        catch {
+            return new ArtifactTracker(worktreeRoot);
+        }
+    }
+    /**
+     * Generate a compact summary string for context injection
+     */
+    toContextString() {
+        const files = Object.values(this.index.files);
+        if (files.length === 0)
+            return '## Files Tracked (0 files)\nNo files tracked yet.';
+        const modified = files.filter(f => f.actions.some(a => a === 'created' || a === 'modified' || a === 'deleted'));
+        const readOnly = files.filter(f => !f.actions.some(a => a === 'created' || a === 'modified' || a === 'deleted') && f.actions.includes('read'));
+        const searchedOnly = files.filter(f => f.actions.every(a => a === 'searched'));
+        const lines = [];
+        lines.push(`## Files Tracked (${files.length} files)`);
+        if (modified.length > 0) {
+            lines.push(`### Modified (${modified.length}):`);
+            for (const f of modified) {
+                const actionCounts = this.summarizeActions(f.actions);
+                lines.push(`- ${f.relativePath} (${actionCounts})`);
+            }
+        }
+        if (readOnly.length > 0) {
+            lines.push(`### Read-only (${readOnly.length}):`);
+            for (const f of readOnly) {
+                const readCount = f.actions.filter(a => a === 'read').length;
+                lines.push(`- ${f.relativePath} (read ${readCount}x)`);
+            }
+        }
+        if (searchedOnly.length > 0) {
+            lines.push(`### Searched (${searchedOnly.length}):`);
+            for (const f of searchedOnly) {
+                lines.push(`- ${f.relativePath}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Summarize action counts for a file
+     */
+    summarizeActions(actions) {
+        const counts = {};
+        for (const action of actions) {
+            counts[action] = (counts[action] ?? 0) + 1;
+        }
+        return Object.entries(counts)
+            .map(([action, count]) => `${action} ${count}x`)
+            .join(', ');
+    }
+}

package/dist/src/orchestrator/artifact-tracker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=artifact-tracker.test.d.ts.map

package/dist/src/orchestrator/artifact-tracker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-tracker.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/artifact-tracker.test.ts"],"names":[],"mappings":""}

package/dist/src/orchestrator/artifact-tracker.test.js

@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    renameSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { resolve } from 'path';
+import { ArtifactTracker } from './artifact-tracker.js';
+const WORKTREE = '/tmp/test-worktree';
+function makeToolUse(toolName, input) {
+    return {
+        type: 'tool_use',
+        toolName,
+        input,
+        raw: {},
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    // By default, existsSync returns true (for file existence checks in Write tool)
+    vi.mocked(existsSync).mockReturnValue(true);
+});
+describe('ArtifactTracker — trackEvent', () => {
+    it('tracks Read tool events', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        const index = tracker.getIndex();
+        expect(Object.keys(index.files)).toHaveLength(1);
+        expect(index.totalReads).toBe(1);
+        const file = Object.values(index.files)[0];
+        expect(file.relativePath).toBe('src/foo.ts');
+        expect(file.actions).toEqual(['read']);
+    });
+    it('tracks Write tool events as modified when file exists', () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Write', { file_path: '/tmp/test-worktree/src/bar.ts' }));
+        const index = tracker.getIndex();
+        expect(index.totalWrites).toBe(1);
+        const file = Object.values(index.files)[0];
+        expect(file.actions).toEqual(['modified']);
+    });
+    it('tracks Write tool events as created when file does not exist', () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Write', { file_path: '/tmp/test-worktree/src/new.ts' }));
+        const file = Object.values(tracker.getIndex().files)[0];
+        expect(file.actions).toEqual(['created']);
+    });
+    it('tracks Edit tool events as modified', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/src/edit.ts' }));
+        const file = Object.values(tracker.getIndex().files)[0];
+        expect(file.actions).toEqual(['modified']);
+        expect(tracker.getIndex().totalWrites).toBe(1);
+    });
+    it('accumulates actions for the same file', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        const file = Object.values(tracker.getIndex().files)[0];
+        expect(file.actions).toEqual(['read', 'modified', 'read']);
+        expect(tracker.getIndex().totalReads).toBe(2);
+        expect(tracker.getIndex().totalWrites).toBe(1);
+    });
+    it('ignores non-tool_use events', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent({ type: 'assistant_text', text: 'hello', raw: {} });
+        tracker.trackEvent({ type: 'system', subtype: 'status', raw: {} });
+        expect(Object.keys(tracker.getIndex().files)).toHaveLength(0);
+    });
+    it('parses bash rm commands', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Bash', { command: 'rm -f /tmp/test-worktree/src/old.ts' }));
+        const files = Object.values(tracker.getIndex().files);
+        expect(files).toHaveLength(1);
+        expect(files[0].actions).toEqual(['deleted']);
+    });
+    it('parses bash mv commands', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Bash', { command: 'mv /tmp/test-worktree/src/a.ts /tmp/test-worktree/src/b.ts' }));
+        const files = Object.values(tracker.getIndex().files);
+        expect(files).toHaveLength(2);
+    });
+    it('ignores tool_use events with missing file_path', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', {}));
+        tracker.trackEvent(makeToolUse('Write', {}));
+        tracker.trackEvent(makeToolUse('Edit', {}));
+        expect(Object.keys(tracker.getIndex().files)).toHaveLength(0);
+    });
+});
+describe('ArtifactTracker — getFiles', () => {
+    it('returns all files when no filter', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/a.ts' }));
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/b.ts' }));
+        expect(tracker.getFiles()).toHaveLength(2);
+    });
+    it('filters by action', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/a.ts' }));
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/b.ts' }));
+        expect(tracker.getFiles({ action: 'read' })).toHaveLength(1);
+        expect(tracker.getFiles({ action: 'modified' })).toHaveLength(1);
+    });
+    it('filters by glob pattern', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/test/bar.ts' }));
+        const srcFiles = tracker.getFiles({ glob: 'src/**' });
+        expect(srcFiles).toHaveLength(1);
+        expect(srcFiles[0].relativePath).toBe('src/foo.ts');
+    });
+});
+describe('ArtifactTracker — persistence', () => {
+    it('persists index atomically', () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.persist();
+        const artifactsPath = resolve(WORKTREE, '.agent', 'artifacts.json');
+        expect(writeFileSync).toHaveBeenCalledWith(artifactsPath + '.tmp', expect.any(String));
+        expect(renameSync).toHaveBeenCalledWith(artifactsPath + '.tmp', artifactsPath);
+    });
+    it('loads persisted index', () => {
+        const savedIndex = {
+            files: {
+                '/tmp/test-worktree/src/foo.ts': {
+                    path: '/tmp/test-worktree/src/foo.ts',
+                    relativePath: 'src/foo.ts',
+                    actions: ['read', 'modified'],
+                    firstSeenAt: 1000,
+                    lastTouchedAt: 2000,
+                }
+            },
+            totalReads: 1,
+            totalWrites: 1,
+            lastUpdatedAt: 2000,
+        };
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockReturnValue(JSON.stringify(savedIndex));
+        const tracker = ArtifactTracker.load(WORKTREE);
+        const index = tracker.getIndex();
+        expect(Object.keys(index.files)).toHaveLength(1);
+        expect(index.totalReads).toBe(1);
+        expect(index.totalWrites).toBe(1);
+    });
+    it('returns empty tracker when no persisted file exists', () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        const tracker = ArtifactTracker.load(WORKTREE);
+        expect(Object.keys(tracker.getIndex().files)).toHaveLength(0);
+    });
+    it('returns empty tracker when persisted file is invalid JSON', () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockReturnValue('not json');
+        const tracker = ArtifactTracker.load(WORKTREE);
+        expect(Object.keys(tracker.getIndex().files)).toHaveLength(0);
+    });
+});
+describe('ArtifactTracker — toContextString', () => {
+    it('returns empty message when no files tracked', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        expect(tracker.toContextString()).toContain('0 files');
+    });
+    it('categorizes files into modified, read-only, and searched', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/src/modified.ts' }));
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/readonly.ts' }));
+        const output = tracker.toContextString();
+        expect(output).toContain('Modified (1)');
+        expect(output).toContain('Read-only (1)');
+        expect(output).toContain('src/modified.ts');
+        expect(output).toContain('src/readonly.ts');
+    });
+    it('shows action counts for modified files', () => {
+        const tracker = new ArtifactTracker(WORKTREE);
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.trackEvent(makeToolUse('Edit', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        tracker.trackEvent(makeToolUse('Read', { file_path: '/tmp/test-worktree/src/foo.ts' }));
+        const output = tracker.toContextString();
+        expect(output).toContain('read 2x');
+        expect(output).toContain('modified 1x');
+    });
+});

package/dist/src/orchestrator/context-manager.d.ts

@@ -0,0 +1,72 @@
+import type { AgentEvent } from '../providers/types.js';
+import type { StructuredSummary } from './state-types.js';
+import type { ArtifactIndex } from './artifact-tracker.js';
+/**
+ * Configuration for the ContextManager
+ */
+export interface ContextManagerConfig {
+    /** Root path of the worktree for file resolution and persistence */
+    worktreeRoot: string;
+    /** Maximum events to buffer between compaction boundaries */
+    maxEventBufferSize?: number;
+}
+/**
+ * Coordinates ArtifactTracker, SummaryBuilder, and StructuredSummary
+ * for context window management during an agent session.
+ *
+ * Processes all agent events, tracks file operations, and handles
+ * compaction boundaries by generating incremental summaries.
+ */
+export declare class ContextManager {
+    private artifactTracker;
+    private summaryBuilder;
+    private currentSummary;
+    private eventBuffer;
+    private worktreeRoot;
+    private maxEventBufferSize;
+    private lastPersistAt;
+    constructor(config: ContextManagerConfig);
+    /**
+     * Process an agent event. Called for every event in the stream.
+     * Feeds tool events to ArtifactTracker and buffers events for compaction.
+     */
+    processEvent(event: AgentEvent): void;
+    /**
+     * Handle a compaction boundary event from the provider.
+     * Generates an incremental summary from buffered events and merges
+     * it with the existing persisted summary.
+     */
+    handleCompaction(): void;
+    /**
+     * Get the current context injection string for the agent prompt.
+     * Returns empty string if no summary exists yet.
+     */
+    getContextSection(): string;
+    /**
+     * Get the current structured summary (if any)
+     */
+    getSummary(): StructuredSummary | null;
+    /**
+     * Get the current artifact index
+     */
+    getArtifactIndex(): ArtifactIndex;
+    /**
+     * Persist all state (summary + artifacts) to disk.
+     * Uses atomic writes to survive crashes.
+     */
+    persist(): void;
+    /**
+     * Persist if enough time has passed since last persist (debounced).
+     * Call this periodically (e.g., on every tool event) to ensure
+     * state is saved without excessive I/O.
+     *
+     * @param intervalMs - Minimum interval between persists (default: 30000ms)
+     */
+    persistIfStale(intervalMs?: number): void;
+    /**
+     * Load a ContextManager from persisted state (for session resume).
+     * Loads both summary.json and artifacts.json from the .agent/ directory.
+     */
+    static load(worktreeRoot: string): ContextManager;
+}
+//# sourceMappingURL=context-manager.d.ts.map

package/dist/src/orchestrator/context-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-manager.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/context-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAI1D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAA;IACpB,6DAA6D;IAC7D,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,aAAa,CAAQ;gBAEjB,MAAM,EAAE,oBAAoB;IAUxC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAkBrC;;;;OAIG;IACH,gBAAgB,IAAI,IAAI;IAyBxB;;;OAGG;IACH,iBAAiB,IAAI,MAAM;IAQ3B;;OAEG;IACH,UAAU,IAAI,iBAAiB,GAAG,IAAI;IAItC;;OAEG;IACH,gBAAgB,IAAI,aAAa;IAIjC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAQf;;;;;;OAMG;IACH,cAAc,CAAC,UAAU,GAAE,MAAc,GAAG,IAAI;IAOhD;;;OAGG;IACH,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc;CAMlD"}