opentasks 0.0.6 → 0.0.7

package/dist/sessionlog/agent/agents/claude-code.js

@@ -0,0 +1,759 @@
+/**
+ * Claude Code Agent
+ *
+ * Implementation of the Entire agent interface for Anthropic's Claude Code.
+ * Handles JSONL transcript format, Claude-specific hook installation,
+ * and session lifecycle management.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as crypto from 'node:crypto';
+import { AGENT_NAMES, AGENT_TYPES, EventType, emptyTokenUsage, } from '../../types.js';
+import { registerAgent } from '../registry.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const CLAUDE_DIR = '.claude';
+const CLAUDE_SETTINGS_FILE = '.claude/settings.json';
+const HOOK_NAMES = [
+    'session-start',
+    'session-end',
+    'stop',
+    'user-prompt-submit',
+    'pre-task',
+    'post-task',
+    'post-todo',
+];
+/** Tools that modify files (detected in transcript) */
+const FILE_MODIFICATION_TOOLS = new Set([
+    'Write',
+    'Edit',
+    'NotebookEdit',
+    'mcp__acp__Write',
+    'mcp__acp__Edit',
+]);
+/** Deny rule to prevent agents from reading metadata */
+const METADATA_DENY_RULE = 'Read(./.entire/metadata/**)';
+// ============================================================================
+// Claude Code Agent Implementation
+// ============================================================================
+class ClaudeCodeAgent {
+    name = AGENT_NAMES.CLAUDE_CODE;
+    type = AGENT_TYPES.CLAUDE_CODE;
+    description = 'Anthropic Claude Code CLI';
+    isPreview = false;
+    protectedDirs = [CLAUDE_DIR];
+    async detectPresence(cwd) {
+        const repoRoot = cwd ?? process.cwd();
+        const claudeDir = path.join(repoRoot, CLAUDE_DIR);
+        try {
+            const stat = await fs.promises.stat(claudeDir);
+            return stat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getSessionDir(repoPath) {
+        // Claude Code stores sessions in ~/.claude/projects/<sanitized-path>/
+        const sanitized = sanitizePathForClaude(repoPath);
+        return path.join(os.homedir(), '.claude', 'projects', sanitized);
+    }
+    getSessionID(input) {
+        return input.sessionID;
+    }
+    resolveSessionFile(sessionDir, agentSessionID) {
+        return path.join(sessionDir, `${agentSessionID}.jsonl`);
+    }
+    async readTranscript(sessionRef) {
+        return fs.promises.readFile(sessionRef);
+    }
+    formatResumeCommand(sessionID) {
+        return `claude --resume ${sessionID}`;
+    }
+    // ===========================================================================
+    // HookSupport
+    // ===========================================================================
+    hookNames() {
+        return [...HOOK_NAMES];
+    }
+    parseHookEvent(hookName, stdin) {
+        try {
+            const data = JSON.parse(stdin);
+            switch (hookName) {
+                case 'session-start':
+                    return {
+                        type: EventType.SessionStart,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        timestamp: new Date(),
+                    };
+                case 'user-prompt-submit':
+                    return {
+                        type: EventType.TurnStart,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        prompt: String(data.prompt ?? ''),
+                        timestamp: new Date(),
+                    };
+                case 'stop':
+                    return {
+                        type: EventType.TurnEnd,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        timestamp: new Date(),
+                    };
+                case 'session-end':
+                    return {
+                        type: EventType.SessionEnd,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        timestamp: new Date(),
+                    };
+                case 'pre-task':
+                    return {
+                        type: EventType.SubagentStart,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        toolUseID: String(data.tool_use_id ?? data.toolUseID ?? ''),
+                        toolInput: data.tool_input ?? data.toolInput,
+                        timestamp: new Date(),
+                    };
+                case 'post-task':
+                    return {
+                        type: EventType.SubagentEnd,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        toolUseID: String(data.tool_use_id ?? data.toolUseID ?? ''),
+                        subagentID: data.tool_response?.agentId,
+                        timestamp: new Date(),
+                    };
+                case 'post-todo':
+                    return {
+                        type: EventType.Compaction,
+                        sessionID: String(data.session_id ?? data.sessionID ?? ''),
+                        sessionRef: String(data.transcript_path ?? data.transcriptPath ?? ''),
+                        timestamp: new Date(),
+                    };
+                default:
+                    return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async installHooks(repoPath, force = false) {
+        const settingsPath = path.join(repoPath, CLAUDE_SETTINGS_FILE);
+        let settings = {};
+        // Read existing settings
+        try {
+            const content = await fs.promises.readFile(settingsPath, 'utf-8');
+            settings = JSON.parse(content);
+        }
+        catch {
+            // No existing settings
+        }
+        if (!settings.hooks)
+            settings.hooks = {};
+        let installed = 0;
+        // Install lifecycle hooks
+        const hookMappings = [
+            { settingsKey: 'SessionStart', hookName: 'session-start' },
+            { settingsKey: 'SessionEnd', hookName: 'session-end' },
+            { settingsKey: 'UserPromptSubmit', hookName: 'user-prompt-submit' },
+            { settingsKey: 'Stop', hookName: 'stop' },
+        ];
+        // Task hooks (pre/post tool use for Task tool)
+        const taskHookMappings = [
+            { settingsKey: 'PreToolUse', hookName: 'pre-task', matcher: 'Task' },
+            { settingsKey: 'PostToolUse', hookName: 'post-task', matcher: 'Task' },
+            { settingsKey: 'PostToolUse', hookName: 'post-todo', matcher: 'TodoWrite' },
+        ];
+        for (const { settingsKey, hookName } of hookMappings) {
+            const existing = settings.hooks[settingsKey] ?? [];
+            if (force) {
+                // Remove existing entire hooks
+                const filtered = existing.filter((m) => !m.hooks.some((h) => h.command.includes('entire ')));
+                settings.hooks[settingsKey] = filtered;
+            }
+            // Check if already installed
+            const hasEntireHook = (settings.hooks[settingsKey] ?? []).some((m) => m.hooks.some((h) => h.command.includes('entire ')));
+            if (!hasEntireHook) {
+                const matchers = settings.hooks[settingsKey] ?? [];
+                matchers.push({
+                    matcher: '',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `entire hooks claude-code ${hookName}`,
+                        },
+                    ],
+                });
+                settings.hooks[settingsKey] = matchers;
+                installed++;
+            }
+        }
+        for (const { settingsKey, hookName, matcher } of taskHookMappings) {
+            const existing = settings.hooks[settingsKey] ?? [];
+            if (force) {
+                const filtered = existing.filter((m) => !(m.matcher === matcher && m.hooks.some((h) => h.command.includes('entire '))));
+                settings.hooks[settingsKey] = filtered;
+            }
+            const hasEntireHook = (settings.hooks[settingsKey] ?? []).some((m) => m.matcher === matcher && m.hooks.some((h) => h.command.includes('entire ')));
+            if (!hasEntireHook) {
+                const matchers = settings.hooks[settingsKey] ?? [];
+                matchers.push({
+                    matcher,
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `entire hooks claude-code ${hookName}`,
+                        },
+                    ],
+                });
+                settings.hooks[settingsKey] = matchers;
+                installed++;
+            }
+        }
+        // Add metadata deny rule
+        if (!settings.permissions)
+            settings.permissions = {};
+        if (!settings.permissions.deny)
+            settings.permissions.deny = [];
+        if (!settings.permissions.deny.includes(METADATA_DENY_RULE)) {
+            settings.permissions.deny.push(METADATA_DENY_RULE);
+        }
+        // Write settings
+        const dir = path.dirname(settingsPath);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+        return installed;
+    }
+    async uninstallHooks(repoPath) {
+        const settingsPath = path.join(repoPath, CLAUDE_SETTINGS_FILE);
+        try {
+            const content = await fs.promises.readFile(settingsPath, 'utf-8');
+            const settings = JSON.parse(content);
+            if (settings.hooks) {
+                for (const key of Object.keys(settings.hooks)) {
+                    const matchers = settings.hooks[key];
+                    if (!matchers)
+                        continue;
+                    settings.hooks[key] = matchers.filter((m) => !m.hooks.some((h) => h.command.includes('entire ')));
+                    if (settings.hooks[key].length === 0) {
+                        delete settings.hooks[key];
+                    }
+                }
+                if (Object.keys(settings.hooks).length === 0) {
+                    delete settings.hooks;
+                }
+            }
+            // Remove deny rule
+            if (settings.permissions?.deny) {
+                settings.permissions.deny = settings.permissions.deny.filter((d) => d !== METADATA_DENY_RULE);
+                if (settings.permissions.deny.length === 0) {
+                    delete settings.permissions.deny;
+                }
+                if (Object.keys(settings.permissions).length === 0) {
+                    delete settings.permissions;
+                }
+            }
+            await fs.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+        }
+        catch {
+            // No settings to modify
+        }
+    }
+    async areHooksInstalled(repoPath) {
+        const settingsPath = path.join(repoPath, CLAUDE_SETTINGS_FILE);
+        try {
+            const content = await fs.promises.readFile(settingsPath, 'utf-8');
+            const settings = JSON.parse(content);
+            if (!settings.hooks)
+                return false;
+            // Check for at least the session-start hook
+            const sessionStart = settings.hooks.SessionStart ?? [];
+            return sessionStart.some((m) => m.hooks.some((h) => h.command.includes('entire ')));
+        }
+        catch {
+            return false;
+        }
+    }
+    // ===========================================================================
+    // TranscriptPreparer — wait for Claude Code's async transcript flush
+    // ===========================================================================
+    async prepareTranscript(sessionRef) {
+        await waitForTranscriptFlush(sessionRef);
+    }
+    // ===========================================================================
+    // TranscriptAnalyzer
+    // ===========================================================================
+    async getTranscriptPosition(transcriptPath) {
+        try {
+            const content = await fs.promises.readFile(transcriptPath, 'utf-8');
+            const lines = content.split('\n').filter(Boolean);
+            return lines.length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async extractModifiedFilesFromOffset(transcriptPath, startOffset) {
+        const content = await fs.promises.readFile(transcriptPath, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        const files = new Set();
+        for (let i = startOffset; i < lines.length; i++) {
+            try {
+                const line = JSON.parse(lines[i]);
+                if (line.type === 'assistant') {
+                    const contentBlocks = extractContentBlocks(line.message);
+                    for (const block of contentBlocks) {
+                        if (block.type === 'tool_use' && block.name && FILE_MODIFICATION_TOOLS.has(block.name)) {
+                            const filePath = block.input?.file_path;
+                            if (filePath)
+                                files.add(filePath);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        return { files: Array.from(files), currentPosition: lines.length };
+    }
+    async extractPrompts(sessionRef, fromOffset) {
+        const content = await fs.promises.readFile(sessionRef, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        const prompts = [];
+        for (let i = fromOffset; i < lines.length; i++) {
+            try {
+                const line = JSON.parse(lines[i]);
+                if (line.type === 'user') {
+                    const text = extractUserText(line.message);
+                    if (text)
+                        prompts.push(text);
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        return prompts;
+    }
+    async extractSummary(sessionRef) {
+        const prompts = await this.extractPrompts(sessionRef, 0);
+        if (prompts.length === 0)
+            return '';
+        // Return the first prompt as a summary, truncated
+        return prompts[0].slice(0, 200);
+    }
+    // ===========================================================================
+    // TokenCalculator
+    // ===========================================================================
+    async calculateTokenUsage(transcriptData, fromOffset) {
+        const content = transcriptData.toString('utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        // Deduplicate by message ID — streaming may produce multiple rows per message.
+        // Keep the entry with the highest output_tokens (final streaming state).
+        const usageByMessageID = new Map();
+        for (let i = fromOffset; i < lines.length; i++) {
+            try {
+                const raw = JSON.parse(lines[i]);
+                if (raw.type === 'assistant') {
+                    const msg = raw.message;
+                    const msgID = msg?.id;
+                    const msgUsage = msg?.usage;
+                    if (msgUsage && msgID) {
+                        const existing = usageByMessageID.get(msgID);
+                        if (!existing || (msgUsage.output_tokens ?? 0) > (existing.output_tokens ?? 0)) {
+                            usageByMessageID.set(msgID, msgUsage);
+                        }
+                    }
+                    else if (msgUsage) {
+                        // No message ID — count each occurrence
+                        usageByMessageID.set(`_anon_${i}`, msgUsage);
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        const usage = emptyTokenUsage();
+        usage.apiCallCount = usageByMessageID.size;
+        for (const u of usageByMessageID.values()) {
+            usage.inputTokens += u.input_tokens ?? 0;
+            usage.cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
+            usage.cacheReadTokens += u.cache_read_input_tokens ?? 0;
+            usage.outputTokens += u.output_tokens ?? 0;
+        }
+        return usage;
+    }
+    // ===========================================================================
+    // SubagentAwareExtractor
+    // ===========================================================================
+    async extractAllModifiedFiles(transcriptData, fromOffset, subagentsDir) {
+        if (transcriptData.length === 0)
+            return [];
+        const content = transcriptData.toString('utf-8');
+        const allLines = content.split('\n').filter(Boolean);
+        const sliced = allLines.slice(fromOffset);
+        const parsed = sliced.map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        }).filter((l) => l !== null);
+        // Collect modified files from main agent
+        const fileSet = new Set();
+        for (const f of extractModifiedFiles(parsed)) {
+            fileSet.add(f);
+        }
+        // Find spawned subagents and collect their modified files
+        const agentIDs = extractSpawnedAgentIDs(parsed);
+        if (subagentsDir) {
+            for (const agentID of agentIDs.keys()) {
+                const agentPath = path.join(subagentsDir, `agent-${agentID}.jsonl`);
+                try {
+                    const agentContent = await fs.promises.readFile(agentPath, 'utf-8');
+                    const agentLines = agentContent.split('\n').filter(Boolean).map(line => {
+                        try {
+                            return JSON.parse(line);
+                        }
+                        catch {
+                            return null;
+                        }
+                    }).filter((l) => l !== null);
+                    for (const f of extractModifiedFiles(agentLines)) {
+                        fileSet.add(f);
+                    }
+                }
+                catch {
+                    // Subagent transcript may not exist yet
+                }
+            }
+        }
+        return Array.from(fileSet);
+    }
+    async calculateTotalTokenUsage(transcriptData, fromOffset, subagentsDir) {
+        if (transcriptData.length === 0)
+            return emptyTokenUsage();
+        // Calculate main session token usage
+        const mainUsage = await this.calculateTokenUsage(transcriptData, fromOffset);
+        // Extract spawned agent IDs from the transcript
+        const content = transcriptData.toString('utf-8');
+        const allLines = content.split('\n').filter(Boolean);
+        const sliced = allLines.slice(fromOffset);
+        const parsed = sliced.map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        }).filter((l) => l !== null);
+        const agentIDs = extractSpawnedAgentIDs(parsed);
+        // Calculate subagent token usage
+        if (agentIDs.size > 0 && subagentsDir) {
+            const subagentUsage = emptyTokenUsage();
+            let hasSubagentUsage = false;
+            for (const agentID of agentIDs.keys()) {
+                const agentPath = path.join(subagentsDir, `agent-${agentID}.jsonl`);
+                try {
+                    const agentData = await fs.promises.readFile(agentPath);
+                    const agentUsage = await this.calculateTokenUsage(agentData, 0);
+                    subagentUsage.inputTokens += agentUsage.inputTokens;
+                    subagentUsage.cacheCreationTokens += agentUsage.cacheCreationTokens;
+                    subagentUsage.cacheReadTokens += agentUsage.cacheReadTokens;
+                    subagentUsage.outputTokens += agentUsage.outputTokens;
+                    subagentUsage.apiCallCount += agentUsage.apiCallCount;
+                    hasSubagentUsage = true;
+                }
+                catch {
+                    // Agent transcript may not exist yet
+                }
+            }
+            if (hasSubagentUsage && subagentUsage.apiCallCount > 0) {
+                mainUsage.subagentTokens = subagentUsage;
+            }
+        }
+        return mainUsage;
+    }
+    // ===========================================================================
+    // TranscriptChunker
+    // ===========================================================================
+    async chunkTranscript(content, maxSize) {
+        return chunkJSONL(content, maxSize);
+    }
+    async reassembleTranscript(chunks) {
+        return Buffer.concat(chunks);
+    }
+}
+// ============================================================================
+// Transcript Parsing Helpers
+// ============================================================================
+function extractContentBlocks(message) {
+    if (!message || typeof message !== 'object')
+        return [];
+    const msg = message;
+    const content = msg.content;
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
+}
+function extractUserText(message) {
+    if (typeof message === 'string')
+        return message;
+    if (!message || typeof message !== 'object')
+        return '';
+    const msg = message;
+    // Content can be string or array of blocks
+    if (typeof msg.content === 'string')
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((b) => b.type === 'text' && b.text)
+            .map((b) => b.text)
+            .join('\n');
+    }
+    return '';
+}
+/**
+ * Parse a JSONL transcript into structured lines
+ */
+export function parseTranscript(content) {
+    const lines = [];
+    for (const rawLine of content.split('\n').filter(Boolean)) {
+        try {
+            const parsed = JSON.parse(rawLine);
+            if (parsed.type === 'user' || parsed.type === 'assistant') {
+                lines.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return lines;
+}
+/**
+ * Extract all modified files from transcript lines
+ */
+export function extractModifiedFiles(lines) {
+    const files = new Set();
+    for (const line of lines) {
+        if (line.type !== 'assistant')
+            continue;
+        const blocks = extractContentBlocks(line.message);
+        for (const block of blocks) {
+            if (block.type === 'tool_use' && block.name && FILE_MODIFICATION_TOOLS.has(block.name)) {
+                const input = block.input;
+                const filePath = (input?.file_path ?? input?.notebook_path);
+                if (filePath)
+                    files.add(filePath);
+            }
+        }
+    }
+    return Array.from(files);
+}
+/**
+ * Extract the last user prompt from transcript lines
+ */
+export function extractLastUserPrompt(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (lines[i].type === 'user') {
+            return extractUserText(lines[i].message);
+        }
+    }
+    return '';
+}
+// ============================================================================
+// Subagent ID Extraction
+// ============================================================================
+/**
+ * Extract spawned agent IDs from Task tool results in a transcript.
+ * When a Task tool completes, the tool_result contains "agentId: <id>".
+ * Returns a map of agentID → toolUseID.
+ */
+export function extractSpawnedAgentIDs(lines) {
+    const agentIDs = new Map();
+    for (const line of lines) {
+        if (line.type !== 'user')
+            continue;
+        const msg = line.message;
+        if (!msg)
+            continue;
+        const content = msg.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block.type !== 'tool_result')
+                continue;
+            const toolUseID = String(block.tool_use_id ?? '');
+            let textContent = '';
+            // Content can be a string or array of text blocks
+            if (typeof block.content === 'string') {
+                textContent = block.content;
+            }
+            else if (Array.isArray(block.content)) {
+                for (const tb of block.content) {
+                    if (tb.type === 'text' && typeof tb.text === 'string') {
+                        textContent += tb.text + '\n';
+                    }
+                }
+            }
+            const agentID = extractAgentIDFromText(textContent);
+            if (agentID) {
+                agentIDs.set(agentID, toolUseID);
+            }
+        }
+    }
+    return agentIDs;
+}
+/**
+ * Extract an agent ID from text containing "agentId: <id>".
+ */
+function extractAgentIDFromText(text) {
+    const prefix = 'agentId: ';
+    const idx = text.indexOf(prefix);
+    if (idx === -1)
+        return '';
+    const start = idx + prefix.length;
+    let end = start;
+    while (end < text.length && /[a-zA-Z0-9]/.test(text[end])) {
+        end++;
+    }
+    return end > start ? text.slice(start, end) : '';
+}
+// ============================================================================
+// JSONL Chunking
+// ============================================================================
+function chunkJSONL(content, maxSize) {
+    if (content.length <= maxSize)
+        return [content];
+    const str = content.toString('utf-8');
+    const lines = str.split('\n');
+    const chunks = [];
+    let current = [];
+    let currentSize = 0;
+    for (const line of lines) {
+        const lineSize = Buffer.byteLength(line + '\n');
+        if (currentSize + lineSize > maxSize && current.length > 0) {
+            chunks.push(Buffer.from(current.join('\n') + '\n'));
+            current = [];
+            currentSize = 0;
+        }
+        current.push(line);
+        currentSize += lineSize;
+    }
+    if (current.length > 0) {
+        const remaining = current.join('\n');
+        if (remaining.trim()) {
+            chunks.push(Buffer.from(remaining + '\n'));
+        }
+    }
+    return chunks;
+}
+// ============================================================================
+// Transcript Flush Sentinel
+// ============================================================================
+/**
+ * String that appears in Claude Code's hook_progress entry when the stop hook
+ * has been invoked, indicating the transcript is fully flushed.
+ */
+const STOP_HOOK_SENTINEL = 'hooks claude-code stop';
+const FLUSH_MAX_WAIT_MS = 3000;
+const FLUSH_POLL_INTERVAL_MS = 50;
+const FLUSH_TAIL_BYTES = 4096;
+const FLUSH_MAX_SKEW_MS = 2000;
+/**
+ * Poll the transcript file for the stop hook sentinel.
+ * Falls back silently after a timeout.
+ */
+async function waitForTranscriptFlush(transcriptPath) {
+    const hookStartTime = Date.now();
+    const deadline = hookStartTime + FLUSH_MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        if (checkStopSentinel(transcriptPath, hookStartTime)) {
+            return;
+        }
+        await sleep(FLUSH_POLL_INTERVAL_MS);
+    }
+    // Timeout — proceed anyway
+}
+/**
+ * Read the tail of the transcript file and look for the stop hook sentinel
+ * with a timestamp within the acceptable skew window.
+ */
+function checkStopSentinel(filePath, hookStartTime) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'r');
+    }
+    catch {
+        return false;
+    }
+    try {
+        const stat = fs.fstatSync(fd);
+        const offset = Math.max(0, stat.size - FLUSH_TAIL_BYTES);
+        const buf = Buffer.alloc(stat.size - offset);
+        fs.readSync(fd, buf, 0, buf.length, offset);
+        const lines = buf.toString('utf-8').split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.includes(STOP_HOOK_SENTINEL))
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                if (!entry.timestamp)
+                    continue;
+                const ts = new Date(entry.timestamp).getTime();
+                if (isNaN(ts))
+                    continue;
+                const lowerBound = hookStartTime - FLUSH_MAX_SKEW_MS;
+                const upperBound = hookStartTime + FLUSH_MAX_SKEW_MS;
+                if (ts > lowerBound && ts < upperBound) {
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ============================================================================
+// Path Helpers
+// ============================================================================
+/**
+ * Sanitize a filesystem path for use as a Claude project directory name
+ */
+function sanitizePathForClaude(repoPath) {
+    // Claude uses a hash-based directory naming scheme
+    return crypto.createHash('sha256').update(repoPath).digest('hex').slice(0, 16);
+}
+// ============================================================================
+// Registration
+// ============================================================================
+/**
+ * Create and return a new Claude Code agent instance
+ */
+export function createClaudeCodeAgent() {
+    return new ClaudeCodeAgent();
+}
+// Auto-register when imported
+registerAgent(AGENT_NAMES.CLAUDE_CODE, () => new ClaudeCodeAgent());
+//# sourceMappingURL=claude-code.js.map