@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/systemDirectories.js

@@ -1,51 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { logForDebugging } from './debug.js';
-import { getPlatform } from './platform.js';
-/**
- * Get cross-platform system directories
- * Handles differences between Windows, macOS, Linux, and WSL
- * @param options Optional overrides for testing (env, homedir, platform)
- */
-export function getSystemDirectories(options) {
-    const platform = options?.platform ?? getPlatform();
-    const homeDir = options?.homedir ?? homedir();
-    const env = options?.env ?? process.env;
-    // Default paths used by most platforms
-    const defaults = {
-        HOME: homeDir,
-        DESKTOP: join(homeDir, 'Desktop'),
-        DOCUMENTS: join(homeDir, 'Documents'),
-        DOWNLOADS: join(homeDir, 'Downloads'),
-    };
-    switch (platform) {
-        case 'windows': {
-            // Windows: Use USERPROFILE if available (handles localized folder names)
-            const userProfile = env.USERPROFILE || homeDir;
-            return {
-                HOME: homeDir,
-                DESKTOP: join(userProfile, 'Desktop'),
-                DOCUMENTS: join(userProfile, 'Documents'),
-                DOWNLOADS: join(userProfile, 'Downloads'),
-            };
-        }
-        case 'linux':
-        case 'wsl': {
-            // Linux/WSL: Check XDG Base Directory specification first
-            return {
-                HOME: homeDir,
-                DESKTOP: env.XDG_DESKTOP_DIR || defaults.DESKTOP,
-                DOCUMENTS: env.XDG_DOCUMENTS_DIR || defaults.DOCUMENTS,
-                DOWNLOADS: env.XDG_DOWNLOAD_DIR || defaults.DOWNLOADS,
-            };
-        }
-        case 'macos':
-        default: {
-            // macOS and unknown platforms use standard paths
-            if (platform === 'unknown') {
-                logForDebugging(`Unknown platform detected, using default paths`);
-            }
-            return defaults;
-        }
-    }
-}

package/dist/src/utils/systemPrompt.js

@@ -1,90 +0,0 @@
-import { feature } from '../recovery/bunBundleShim.js';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-import { logEvent, } from '../services/analytics/index.js';
-import { isBuiltInAgent } from '../tools/AgentTool/loadAgentsDir.js';
-import { isEnvTruthy } from './envUtils.js';
-import { asSystemPrompt } from './systemPromptType.js';
-export { asSystemPrompt } from './systemPromptType.js';
-// Dead code elimination: conditional import for proactive mode.
-// Same pattern as prompts.ts — lazy require to avoid pulling the module
-// into non-proactive builds.
-/* eslint-disable @typescript-eslint/no-require-imports */
-const proactiveModule = feature('PROACTIVE') || feature('KAIROS')
-    ? require('../proactive/index.js')
-    : null;
-/* eslint-enable @typescript-eslint/no-require-imports */
-function isProactiveActive_SAFE_TO_CALL_ANYWHERE() {
-    return proactiveModule?.isProactiveActive() ?? false;
-}
-/**
- * Builds the effective system prompt array based on priority:
- * 0. Override system prompt (if set, e.g., via loop mode - REPLACES all other prompts)
- * 1. Coordinator system prompt (if coordinator mode is active)
- * 2. Agent system prompt (if mainThreadAgentDefinition is set)
- *    - In proactive mode: agent prompt is APPENDED to default (agent adds domain
- *      instructions on top of the autonomous agent prompt, like teammates do)
- *    - Otherwise: agent prompt REPLACES default
- * 3. Custom system prompt (if specified via --system-prompt)
- * 4. Default system prompt (the standard Context Code prompt)
- *
- * Plus appendSystemPrompt is always added at the end if specified (except when override is set).
- */
-export function buildEffectiveSystemPrompt({ mainThreadAgentDefinition, toolUseContext, customSystemPrompt, defaultSystemPrompt, appendSystemPrompt, overrideSystemPrompt, }) {
-    if (overrideSystemPrompt) {
-        return asSystemPrompt([overrideSystemPrompt]);
-    }
-    // Coordinator mode: use coordinator prompt instead of default
-    // Use inline env check instead of coordinatorModule to avoid circular
-    // dependency issues during test module loading.
-    if (feature('COORDINATOR_MODE') &&
-        isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) &&
-        !mainThreadAgentDefinition) {
-        // Lazy require to avoid circular dependency at module load time
-        const { getCoordinatorSystemPrompt } = 
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        require('../coordinator/coordinatorMode.js');
-        return asSystemPrompt([
-            getCoordinatorSystemPrompt(),
-            ...(appendSystemPrompt ? [appendSystemPrompt] : []),
-        ]);
-    }
-    const agentSystemPrompt = mainThreadAgentDefinition
-        ? isBuiltInAgent(mainThreadAgentDefinition)
-            ? mainThreadAgentDefinition.getSystemPrompt({
-                toolUseContext: { options: toolUseContext.options },
-            })
-            : mainThreadAgentDefinition.getSystemPrompt()
-        : undefined;
-    // Log agent memory loaded event for main loop agents
-    if (mainThreadAgentDefinition?.memory) {
-        logEvent('tengu_agent_memory_loaded', {
-            ...(process.env.USER_TYPE === 'ant' && {
-                agent_type: mainThreadAgentDefinition.agentType,
-            }),
-            scope: mainThreadAgentDefinition.memory,
-            source: 'main-thread',
-        });
-    }
-    // In proactive mode, agent instructions are appended to the default prompt
-    // rather than replacing it. The proactive default prompt is already lean
-    // (autonomous agent identity + memory + env + proactive section), and agents
-    // add domain-specific behavior on top — same pattern as teammates.
-    if (agentSystemPrompt &&
-        (feature('PROACTIVE') || feature('KAIROS')) &&
-        isProactiveActive_SAFE_TO_CALL_ANYWHERE()) {
-        return asSystemPrompt([
-            ...defaultSystemPrompt,
-            `\n# Custom Agent Instructions\n${agentSystemPrompt}`,
-            ...(appendSystemPrompt ? [appendSystemPrompt] : []),
-        ]);
-    }
-    return asSystemPrompt([
-        ...(agentSystemPrompt
-            ? [agentSystemPrompt]
-            : customSystemPrompt
-                ? [customSystemPrompt]
-                : defaultSystemPrompt),
-        ...(appendSystemPrompt ? [appendSystemPrompt] : []),
-    ]);
-}

package/dist/src/utils/systemPromptType.js

@@ -1,9 +0,0 @@
-/**
- * Branded type for system prompt arrays.
- *
- * This module is intentionally dependency-free so it can be imported
- * from anywhere without risking circular initialization issues.
- */
-export function asSystemPrompt(value) {
-    return value;
-}

package/dist/src/utils/systemTheme.js

@@ -1,108 +0,0 @@
-/**
- * Terminal dark/light mode detection for the 'auto' theme setting.
- *
- * Detection is based on the terminal's actual background color (queried via
- * OSC 11 by systemThemeWatcher.ts) rather than the OS appearance setting —
- * a dark terminal on a light-mode OS should still resolve to 'dark'.
- *
- * The detected theme is cached module-level so callers can resolve 'auto'
- * without awaiting the async OSC round-trip. The cache is seeded from
- * $COLORFGBG (synchronous, set by some terminals at launch) and then
- * updated by the watcher once the OSC 11 response arrives.
- */
-let cachedSystemTheme;
-/**
- * Get the current terminal theme. Cached after first detection; the watcher
- * updates the cache on live changes.
- */
-export function getSystemThemeName() {
-    if (cachedSystemTheme === undefined) {
-        cachedSystemTheme = detectFromColorFgBg() ?? 'dark';
-    }
-    return cachedSystemTheme;
-}
-/**
- * Update the cached terminal theme. Called by the watcher when the OSC 11
- * query returns so non-React call sites stay in sync.
- */
-export function setCachedSystemTheme(theme) {
-    cachedSystemTheme = theme;
-}
-/**
- * Resolve a ThemeSetting (which may be 'auto') to a concrete ThemeName.
- */
-export function resolveThemeSetting(setting) {
-    if (setting === 'auto') {
-        return getSystemThemeName();
-    }
-    return setting;
-}
-/**
- * Parse an OSC color response data string into a theme.
- *
- * Accepts XParseColor formats returned by OSC 10/11 queries:
- * - `rgb:R/G/B` where each component is 1–4 hex digits (each scaled to
- *   [0, 16^n - 1] for n digits). This is what xterm, iTerm2, Terminal.app,
- *   Ghostty, kitty, Alacritty, etc. return.
- * - `#RRGGBB` / `#RRRRGGGGBBBB` (rare, but cheap to accept).
- *
- * Returns undefined for unrecognized formats so callers can fall back.
- */
-export function themeFromOscColor(data) {
-    const rgb = parseOscRgb(data);
-    if (!rgb)
-        return undefined;
-    // ITU-R BT.709 relative luminance. Midpoint split: > 0.5 is light.
-    const luminance = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
-    return luminance > 0.5 ? 'light' : 'dark';
-}
-function parseOscRgb(data) {
-    // rgb:RRRR/GGGG/BBBB — each component is 1–4 hex digits.
-    // Some terminals append an alpha component (rgba:…/…/…/…); ignore it.
-    const rgbMatch = /^rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i.exec(data);
-    if (rgbMatch) {
-        return {
-            r: hexComponent(rgbMatch[1]),
-            g: hexComponent(rgbMatch[2]),
-            b: hexComponent(rgbMatch[3]),
-        };
-    }
-    // #RRGGBB or #RRRRGGGGBBBB — split into three equal hex runs.
-    const hashMatch = /^#([0-9a-f]+)$/i.exec(data);
-    if (hashMatch && hashMatch[1].length % 3 === 0) {
-        const hex = hashMatch[1];
-        const n = hex.length / 3;
-        return {
-            r: hexComponent(hex.slice(0, n)),
-            g: hexComponent(hex.slice(n, 2 * n)),
-            b: hexComponent(hex.slice(2 * n)),
-        };
-    }
-    return undefined;
-}
-/** Normalize a 1–4 digit hex component to [0, 1]. */
-function hexComponent(hex) {
-    const max = 16 ** hex.length - 1;
-    return parseInt(hex, 16) / max;
-}
-/**
- * Read $COLORFGBG for a synchronous initial guess before the OSC 11
- * round-trip completes. Format is `fg;bg` (or `fg;other;bg`) where values
- * are ANSI color indices. rxvt convention: bg 0–6 or 8 are dark; bg 7
- * and 9–15 are light. Only set by some terminals (rxvt-family, Konsole,
- * iTerm2 with the option enabled), so this is a best-effort hint.
- */
-function detectFromColorFgBg() {
-    const colorfgbg = process.env['COLORFGBG'];
-    if (!colorfgbg)
-        return undefined;
-    const parts = colorfgbg.split(';');
-    const bg = parts[parts.length - 1];
-    if (bg === undefined || bg === '')
-        return undefined;
-    const bgNum = Number(bg);
-    if (!Number.isInteger(bgNum) || bgNum < 0 || bgNum > 15)
-        return undefined;
-    // 0–6 and 8 are dark ANSI colors; 7 (white) and 9–15 (bright) are light.
-    return bgNum <= 6 || bgNum === 8 ? 'dark' : 'light';
-}

package/dist/src/utils/systemThemeWatcher.js

@@ -1,16 +0,0 @@
-export default null;
-export const defaultExport = null;
-export async function daemonMain() { }
-export async function runDaemonWorker() { }
-export async function environmentRunnerMain() { }
-export async function selfHostedRunnerMain() { }
-export async function connectHeadless() { }
-export async function startServer() { }
-export async function launchAssistantInstallWizard() { return null; }
-export async function launchAssistantSessionChooser() { return null; }
-export async function discoverAssistantSessions() { return []; }
-export async function createSSHSession() { throw new Error('Recovery stub: createSSHSession not implemented'); }
-export function createLocalSSHSession() { throw new Error('Recovery stub: createLocalSSHSession not implemented'); }
-export class SSHSessionError extends Error {
-}
-export function clearSkillIndexCache() { }

package/dist/src/utils/taggedId.js

@@ -1,49 +0,0 @@
-/**
- * Tagged ID encoding compatible with the API's tagged_id.py format.
- *
- * Produces IDs like "user_01PaGUP2rbg1XDh7Z9W1CEpd" from a UUID string.
- * The format is: {tag}_{version}{base58(uuid_as_128bit_int)}
- *
- * This must stay in sync with api/api/common/utils/tagged_id.py.
- */
-const BASE_58_CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-const VERSION = '01';
-// ceil(128 / log2(58)) = 22
-const ENCODED_LENGTH = 22;
-/**
- * Encode a 128-bit unsigned integer as a fixed-length base58 string.
- */
-function base58Encode(n) {
-    const base = BigInt(BASE_58_CHARS.length);
-    const result = new Array(ENCODED_LENGTH).fill(BASE_58_CHARS[0]);
-    let i = ENCODED_LENGTH - 1;
-    let value = n;
-    while (value > 0n) {
-        const rem = Number(value % base);
-        result[i] = BASE_58_CHARS[rem];
-        value = value / base;
-        i--;
-    }
-    return result.join('');
-}
-/**
- * Parse a UUID string (with or without hyphens) into a 128-bit bigint.
- */
-function uuidToBigInt(uuid) {
-    const hex = uuid.replace(/-/g, '');
-    if (hex.length !== 32) {
-        throw new Error(`Invalid UUID hex length: ${hex.length}`);
-    }
-    return BigInt('0x' + hex);
-}
-/**
- * Convert an account UUID to a tagged ID in the API's format.
- *
- * @param tag - The tag prefix (e.g. "user", "org")
- * @param uuid - A UUID string (with or without hyphens)
- * @returns Tagged ID string like "user_01PaGUP2rbg1XDh7Z9W1CEpd"
- */
-export function toTaggedId(tag, uuid) {
-    const n = uuidToBigInt(uuid);
-    return `${tag}_${VERSION}${base58Encode(n)}`;
-}

package/dist/src/utils/task/TaskOutput.js

@@ -1,320 +0,0 @@
-import { unlink } from 'fs/promises';
-import { CircularBuffer } from '../CircularBuffer.js';
-import { logForDebugging } from '../debug.js';
-import { readFileRange, tailFile } from '../fsOperations.js';
-import { getMaxOutputLength } from '../shell/outputLimits.js';
-import { safeJoinLines } from '../stringUtils.js';
-import { DiskTaskOutput, getTaskOutputPath } from './diskOutput.js';
-const DEFAULT_MAX_MEMORY = 8 * 1024 * 1024; // 8MB
-const POLL_INTERVAL_MS = 1000;
-const PROGRESS_TAIL_BYTES = 4096;
-/**
- * Single source of truth for a shell command's output.
- *
- * For bash commands (file mode): both stdout and stderr go directly to
- * a file via stdio fds — neither enters JS. Progress is extracted by
- * polling the file tail. getStderr() returns '' since stderr is
- * interleaved in the output file.
- *
- * For hooks (pipe mode): data flows through writeStdout()/writeStderr()
- * and is buffered in memory, spilling to disk if it exceeds the limit.
- */
-export class TaskOutput {
-    taskId;
-    path;
-    /** True when stdout goes to a file fd (bypassing JS). False for pipe mode (hooks). */
-    stdoutToFile;
-    #stdoutBuffer = '';
-    #stderrBuffer = '';
-    #disk = null;
-    #recentLines = new CircularBuffer(1000);
-    #totalLines = 0;
-    #totalBytes = 0;
-    #maxMemory;
-    #onProgress;
-    /** Set by getStdout() — true when the file was fully read (≤ maxOutputLength). */
-    #outputFileRedundant = false;
-    /** Set by getStdout() — total file size in bytes. */
-    #outputFileSize = 0;
-    // --- Shared poller state ---
-    /** Registry of all file-mode TaskOutput instances with onProgress callbacks. */
-    static #registry = new Map();
-    /** Subset of #registry currently being polled (visibility-driven by React). */
-    static #activePolling = new Map();
-    static #pollInterval = null;
-    constructor(taskId, onProgress, stdoutToFile = false, maxMemory = DEFAULT_MAX_MEMORY) {
-        this.taskId = taskId;
-        this.path = getTaskOutputPath(taskId);
-        this.stdoutToFile = stdoutToFile;
-        this.#maxMemory = maxMemory;
-        this.#onProgress = onProgress;
-        // Register for polling when stdout goes to a file and progress is needed.
-        // Actual polling is started/stopped by React via startPolling/stopPolling.
-        if (stdoutToFile && onProgress) {
-            TaskOutput.#registry.set(taskId, this);
-        }
-    }
-    /**
-     * Begin polling the output file for progress. Called from React
-     * useEffect when the progress component mounts.
-     */
-    static startPolling(taskId) {
-        const instance = TaskOutput.#registry.get(taskId);
-        if (!instance || !instance.#onProgress) {
-            return;
-        }
-        TaskOutput.#activePolling.set(taskId, instance);
-        if (!TaskOutput.#pollInterval) {
-            TaskOutput.#pollInterval = setInterval(TaskOutput.#tick, POLL_INTERVAL_MS);
-            TaskOutput.#pollInterval.unref();
-        }
-    }
-    /**
-     * Stop polling the output file. Called from React useEffect cleanup
-     * when the progress component unmounts.
-     */
-    static stopPolling(taskId) {
-        TaskOutput.#activePolling.delete(taskId);
-        if (TaskOutput.#activePolling.size === 0 && TaskOutput.#pollInterval) {
-            clearInterval(TaskOutput.#pollInterval);
-            TaskOutput.#pollInterval = null;
-        }
-    }
-    /**
-     * Shared tick: reads the file tail for every actively-polled task.
-     * Non-async body (.then) to avoid stacking if I/O is slow.
-     */
-    static #tick() {
-        for (const [, entry] of TaskOutput.#activePolling) {
-            if (!entry.#onProgress) {
-                continue;
-            }
-            void tailFile(entry.path, PROGRESS_TAIL_BYTES).then(({ content, bytesRead, bytesTotal }) => {
-                if (!entry.#onProgress) {
-                    return;
-                }
-                // Always call onProgress even when content is empty, so the
-                // progress loop wakes up and can check for backgrounding.
-                // Commands like `git log -S` produce no output for long periods.
-                if (!content) {
-                    entry.#onProgress('', '', entry.#totalLines, bytesTotal, false);
-                    return;
-                }
-                // Count all newlines in the tail and capture slice points for the
-                // last 5 and last 100 lines. Uncapped so extrapolation stays accurate
-                // for dense output (short lines → >100 newlines in 4KB).
-                let pos = content.length;
-                let n5 = 0;
-                let n100 = 0;
-                let lineCount = 0;
-                while (pos > 0) {
-                    pos = content.lastIndexOf('\n', pos - 1);
-                    lineCount++;
-                    if (lineCount === 5)
-                        n5 = pos <= 0 ? 0 : pos + 1;
-                    if (lineCount === 100)
-                        n100 = pos <= 0 ? 0 : pos + 1;
-                }
-                // lineCount is exact when the whole file fits in PROGRESS_TAIL_BYTES.
-                // Otherwise extrapolate from the tail sample; monotone max keeps the
-                // counter from going backwards when the tail has longer lines on one tick.
-                const totalLines = bytesRead >= bytesTotal
-                    ? lineCount
-                    : Math.max(entry.#totalLines, Math.round((bytesTotal / bytesRead) * lineCount));
-                entry.#totalLines = totalLines;
-                entry.#totalBytes = bytesTotal;
-                entry.#onProgress(content.slice(n5), content.slice(n100), totalLines, bytesTotal, bytesRead < bytesTotal);
-            }, () => {
-                // File may not exist yet
-            });
-        }
-    }
-    /** Write stdout data (pipe mode only — used by hooks). */
-    writeStdout(data) {
-        this.#writeBuffered(data, false);
-    }
-    /** Write stderr data (always piped). */
-    writeStderr(data) {
-        this.#writeBuffered(data, true);
-    }
-    #writeBuffered(data, isStderr) {
-        this.#totalBytes += data.length;
-        this.#updateProgress(data);
-        // Write to disk if already overflowed
-        if (this.#disk) {
-            this.#disk.append(isStderr ? `[stderr] ${data}` : data);
-            return;
-        }
-        // Check if this chunk would exceed the in-memory limit
-        const totalMem = this.#stdoutBuffer.length + this.#stderrBuffer.length + data.length;
-        if (totalMem > this.#maxMemory) {
-            this.#spillToDisk(isStderr ? data : null, isStderr ? null : data);
-            return;
-        }
-        if (isStderr) {
-            this.#stderrBuffer += data;
-        }
-        else {
-            this.#stdoutBuffer += data;
-        }
-    }
-    /**
-     * Single backward pass: count all newlines (for totalLines) and extract
-     * the last few lines as flat copies (for the CircularBuffer / progress).
-     * Only used in pipe mode (hooks). File mode uses the shared poller.
-     */
-    #updateProgress(data) {
-        const MAX_PROGRESS_BYTES = 4096;
-        const MAX_PROGRESS_LINES = 100;
-        let lineCount = 0;
-        const lines = [];
-        let extractedBytes = 0;
-        let pos = data.length;
-        while (pos > 0) {
-            const prev = data.lastIndexOf('\n', pos - 1);
-            if (prev === -1) {
-                break;
-            }
-            lineCount++;
-            if (lines.length < MAX_PROGRESS_LINES &&
-                extractedBytes < MAX_PROGRESS_BYTES) {
-                const lineLen = pos - prev - 1;
-                if (lineLen > 0 && lineLen <= MAX_PROGRESS_BYTES - extractedBytes) {
-                    const line = data.slice(prev + 1, pos);
-                    if (line.trim()) {
-                        lines.push(Buffer.from(line).toString());
-                        extractedBytes += lineLen;
-                    }
-                }
-            }
-            pos = prev;
-        }
-        this.#totalLines += lineCount;
-        for (let i = lines.length - 1; i >= 0; i--) {
-            this.#recentLines.add(lines[i]);
-        }
-        if (this.#onProgress && lines.length > 0) {
-            const recent = this.#recentLines.getRecent(5);
-            this.#onProgress(safeJoinLines(recent, '\n'), safeJoinLines(this.#recentLines.getRecent(100), '\n'), this.#totalLines, this.#totalBytes, this.#disk !== null);
-        }
-    }
-    #spillToDisk(stderrChunk, stdoutChunk) {
-        this.#disk = new DiskTaskOutput(this.taskId);
-        // Flush existing buffers
-        if (this.#stdoutBuffer) {
-            this.#disk.append(this.#stdoutBuffer);
-            this.#stdoutBuffer = '';
-        }
-        if (this.#stderrBuffer) {
-            this.#disk.append(`[stderr] ${this.#stderrBuffer}`);
-            this.#stderrBuffer = '';
-        }
-        // Write the chunk that triggered overflow
-        if (stdoutChunk) {
-            this.#disk.append(stdoutChunk);
-        }
-        if (stderrChunk) {
-            this.#disk.append(`[stderr] ${stderrChunk}`);
-        }
-    }
-    /**
-     * Get stdout. In file mode, reads from the output file.
-     * In pipe mode, returns the in-memory buffer or tail from CircularBuffer.
-     */
-    async getStdout() {
-        if (this.stdoutToFile) {
-            return this.#readStdoutFromFile();
-        }
-        // Pipe mode (hooks) — use in-memory data
-        if (this.#disk) {
-            const recent = this.#recentLines.getRecent(5);
-            const tail = safeJoinLines(recent, '\n');
-            const sizeKB = Math.round(this.#totalBytes / 1024);
-            const notice = `\nOutput truncated (${sizeKB}KB total). Full output saved to: ${this.path}`;
-            return tail ? tail + notice : notice.trimStart();
-        }
-        return this.#stdoutBuffer;
-    }
-    async #readStdoutFromFile() {
-        const maxBytes = getMaxOutputLength();
-        try {
-            const result = await readFileRange(this.path, 0, maxBytes);
-            if (!result) {
-                this.#outputFileRedundant = true;
-                return '';
-            }
-            const { content, bytesRead, bytesTotal } = result;
-            // If the file fits, it's fully captured inline and can be deleted.
-            // If not, return what we read — processToolResultBlock handles
-            // the <persisted-output> formatting and persistence downstream.
-            this.#outputFileSize = bytesTotal;
-            this.#outputFileRedundant = bytesTotal <= bytesRead;
-            return content;
-        }
-        catch (err) {
-            // Surface the error instead of silently returning empty. An ENOENT here
-            // means the output file was deleted while the command was running
-            // (historically: cross-session startup cleanup in the same project dir).
-            // Returning a diagnostic string keeps the tool_result non-empty, which
-            // avoids reminder-only-at-tail confusion downstream and tells the model
-            // (and us, via the transcript) what actually happened.
-            const code = err instanceof Error && 'code' in err ? String(err.code) : 'unknown';
-            logForDebugging(`TaskOutput.#readStdoutFromFile: failed to read ${this.path} (${code}): ${err}`);
-            return `<bash output unavailable: output file ${this.path} could not be read (${code}). This usually means another Context Code process in the same project deleted it during startup cleanup.>`;
-        }
-    }
-    /** Sync getter for ExecResult.stderr */
-    getStderr() {
-        if (this.#disk) {
-            return '';
-        }
-        return this.#stderrBuffer;
-    }
-    get isOverflowed() {
-        return this.#disk !== null;
-    }
-    get totalLines() {
-        return this.#totalLines;
-    }
-    get totalBytes() {
-        return this.#totalBytes;
-    }
-    /**
-     * True after getStdout() when the output file was fully read.
-     * The file content is redundant (fully in ExecResult.stdout) and can be deleted.
-     */
-    get outputFileRedundant() {
-        return this.#outputFileRedundant;
-    }
-    /** Total file size in bytes, set after getStdout() reads the file. */
-    get outputFileSize() {
-        return this.#outputFileSize;
-    }
-    /** Force all buffered content to disk. Call when backgrounding. */
-    spillToDisk() {
-        if (!this.#disk) {
-            this.#spillToDisk(null, null);
-        }
-    }
-    async flush() {
-        await this.#disk?.flush();
-    }
-    /** Delete the output file (fire-and-forget safe). */
-    async deleteOutputFile() {
-        try {
-            await unlink(this.path);
-        }
-        catch {
-            // File may already be deleted or not exist
-        }
-    }
-    clear() {
-        this.#stdoutBuffer = '';
-        this.#stderrBuffer = '';
-        this.#recentLines.clear();
-        this.#onProgress = null;
-        this.#disk?.cancel();
-        TaskOutput.stopPolling(this.taskId);
-        TaskOutput.#registry.delete(this.taskId);
-    }
-}