@minionry/minion 0.7.36

package/dist/server/cli/headless/tool-watchdog.js

@@ -0,0 +1,447 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { hlog } from './headless-logger.js';
+const ALPHA = 0.125;
+const BETA = 0.25;
+const DEVIATION_MULTIPLIER = 4;
+export const WATCHDOG_HARD_CAP_MS = 14_400_000;
+const UNAVAILABLE_REASSESS_MS = 5 * 60_000;
+export function declaredToolTimeoutMs(toolInput) {
+    const raw = toolInput.timeout;
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0)
+        return undefined;
+    return Math.min(raw, WATCHDOG_HARD_CAP_MS);
+}
+const BROWSER_MCP_SERVER_NAME = 'minionry-browser';
+function browserProfileEntries(toolNames, profile) {
+    const entries = {};
+    for (const name of toolNames) {
+        entries[name] = profile;
+        entries[`mcp__${BROWSER_MCP_SERVER_NAME}__${name}`] = profile;
+        entries[`${BROWSER_MCP_SERVER_NAME}__${name}`] = profile;
+        entries[`${BROWSER_MCP_SERVER_NAME}.${name}`] = profile;
+    }
+    return entries;
+}
+const BROWSER_LONG_WAIT_PROFILE = {
+    coldStartMs: 180_000,
+    floorMs: 120_000,
+    ceilingMs: 300_000,
+    useAdaptive: false,
+    useHaikuTiebreaker: true,
+};
+export const BROWSER_LONG_WAIT_TOOL_NAMES = [
+    'browser_navigate',
+    'browser_wait_for',
+    'browser_handle_dialog',
+    'browser_file_upload',
+];
+const BROWSER_FAST_PROFILE = {
+    coldStartMs: 30_000,
+    floorMs: 15_000,
+    ceilingMs: 90_000,
+    useAdaptive: true,
+    useHaikuTiebreaker: true,
+};
+export const BROWSER_FAST_TOOL_NAMES = [
+    'browser_snapshot',
+    'browser_click',
+    'browser_type',
+    'browser_hover',
+    'browser_press_key',
+    'browser_select_option',
+    'browser_fill_form',
+    'browser_drag',
+    'browser_take_screenshot',
+    'browser_console_messages',
+    'browser_network_request',
+    'browser_network_requests',
+    'browser_back',
+    'browser_forward',
+    'browser_reload',
+    'browser_tabs',
+    'browser_tab_new',
+    'browser_tab_close',
+    'browser_tab_select',
+    'browser_evaluate',
+    'browser_run_code_unsafe',
+];
+export const DEFAULT_TOOL_TIMEOUT_PROFILES = {
+    WebFetch: {
+        coldStartMs: 180_000,
+        floorMs: 120_000,
+        ceilingMs: 300_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    WebSearch: {
+        coldStartMs: 90_000,
+        floorMs: 60_000,
+        ceilingMs: 180_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    Task: {
+        coldStartMs: 900_000,
+        floorMs: 900_000,
+        ceilingMs: 5_400_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    Agent: {
+        coldStartMs: 900_000,
+        floorMs: 900_000,
+        ceilingMs: 5_400_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    Workflow: {
+        coldStartMs: 1_800_000,
+        floorMs: 900_000,
+        ceilingMs: 5_400_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    Monitor: {
+        coldStartMs: 900_000,
+        floorMs: 600_000,
+        ceilingMs: 2_700_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    TaskOutput: {
+        coldStartMs: 900_000,
+        floorMs: 600_000,
+        ceilingMs: 2_700_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    Bash: {
+        coldStartMs: 300_000,
+        floorMs: 120_000,
+        ceilingMs: 600_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    Read: {
+        coldStartMs: 120_000,
+        floorMs: 60_000,
+        ceilingMs: 300_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    Grep: {
+        coldStartMs: 120_000,
+        floorMs: 60_000,
+        ceilingMs: 300_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    Glob: {
+        coldStartMs: 60_000,
+        floorMs: 30_000,
+        ceilingMs: 180_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    Edit: {
+        coldStartMs: 60_000,
+        floorMs: 30_000,
+        ceilingMs: 180_000,
+        useAdaptive: true,
+        useHaikuTiebreaker: true,
+    },
+    Write: {
+        coldStartMs: 300_000,
+        floorMs: 120_000,
+        ceilingMs: 600_000,
+        useAdaptive: false,
+        useHaikuTiebreaker: true,
+    },
+    ...browserProfileEntries(BROWSER_LONG_WAIT_TOOL_NAMES, BROWSER_LONG_WAIT_PROFILE),
+    ...browserProfileEntries(BROWSER_FAST_TOOL_NAMES, BROWSER_FAST_PROFILE),
+};
+const DEFAULT_TOOL_TIMEOUT_PROFILE = {
+    coldStartMs: 300_000,
+    floorMs: 120_000,
+    ceilingMs: 600_000,
+    useAdaptive: false,
+    useHaikuTiebreaker: true,
+};
+export class ToolWatchdog {
+    trackers = new Map();
+    profiles;
+    activeWatches = new Map();
+    verbose;
+    onTiebreaker;
+    getTokenSilenceMs;
+    shouldDeferKill;
+    constructor(options = {}) {
+        this.verbose = options.verbose ?? false;
+        this.onTiebreaker = options.onTiebreaker;
+        this.getTokenSilenceMs = options.getTokenSilenceMs;
+        this.shouldDeferKill = options.shouldDeferKill;
+        this.profiles = { ...DEFAULT_TOOL_TIMEOUT_PROFILES };
+        if (options.profiles) {
+            for (const [name, partial] of Object.entries(options.profiles)) {
+                const base = this.profiles[name] || DEFAULT_TOOL_TIMEOUT_PROFILE;
+                this.profiles[name] = { ...base, ...partial };
+            }
+        }
+    }
+    recordCompletion(toolName, durationMs) {
+        const profile = this.getProfile(toolName);
+        if (!profile.useAdaptive)
+            return;
+        const tracker = this.trackers.get(toolName);
+        if (!tracker) {
+            this.trackers.set(toolName, {
+                estimatedDuration: durationMs,
+                deviation: durationMs / 2,
+                sampleCount: 1,
+            });
+            if (this.verbose) {
+                hlog(`[WATCHDOG] ${toolName}: first sample ${durationMs}ms, initial timeout ${this.getTimeout(toolName)}ms`);
+            }
+            return;
+        }
+        tracker.deviation = (1 - BETA) * tracker.deviation + BETA * Math.abs(durationMs - tracker.estimatedDuration);
+        tracker.estimatedDuration = (1 - ALPHA) * tracker.estimatedDuration + ALPHA * durationMs;
+        tracker.sampleCount++;
+        if (this.verbose) {
+            hlog(`[WATCHDOG] ${toolName}: sample #${tracker.sampleCount} ${durationMs}ms, est=${Math.round(tracker.estimatedDuration)}ms, dev=${Math.round(tracker.deviation)}ms, timeout=${this.getTimeout(toolName)}ms`);
+        }
+    }
+    getTimeout(toolName) {
+        const profile = this.getProfile(toolName);
+        if (!profile.useAdaptive)
+            return profile.coldStartMs;
+        const tracker = this.trackers.get(toolName);
+        if (!tracker || tracker.sampleCount < 1)
+            return profile.coldStartMs;
+        const adaptive = tracker.estimatedDuration + DEVIATION_MULTIPLIER * tracker.deviation;
+        return Math.max(profile.floorMs, Math.min(profile.ceilingMs, adaptive));
+    }
+    getProfile(toolName) {
+        return this.profiles[toolName] || DEFAULT_TOOL_TIMEOUT_PROFILE;
+    }
+    startWatch(toolId, toolName, toolInput, onTimeout) {
+        this.clearWatch(toolId);
+        const profile = this.getProfile(toolName);
+        const declaredTimeoutMs = declaredToolTimeoutMs(toolInput);
+        const timeoutMs = Math.min(WATCHDOG_HARD_CAP_MS, Math.max(this.getTimeout(toolName), declaredTimeoutMs ?? 0));
+        const ceilingMs = Math.min(WATCHDOG_HARD_CAP_MS, Math.max(profile.ceilingMs, declaredTimeoutMs ?? 0));
+        if (this.verbose) {
+            hlog(`[WATCHDOG] Starting watch: ${toolName} (${toolId}), timeout=${Math.round(timeoutMs / 1000)}s${declaredTimeoutMs ? ` (declared ${Math.round(declaredTimeoutMs / 1000)}s)` : ''}`);
+        }
+        const timer = setTimeout(async () => {
+            const extended = await this.handleTimeoutWithTiebreaker(toolId, toolName, toolInput, profile, onTimeout);
+            if (!extended && this.activeWatches.has(toolId)) {
+                this.killOrDefer(toolId, toolName, toolInput, profile, onTimeout);
+            }
+        }, timeoutMs);
+        this.activeWatches.set(toolId, {
+            toolName,
+            toolInput,
+            startTime: Date.now(),
+            timer,
+            timeoutMs,
+            ceilingMs,
+            declaredTimeoutMs,
+            tiebreakerAttempted: false,
+        });
+    }
+    killOrDefer(toolId, toolName, toolInput, profile, onTimeout) {
+        const watch = this.activeWatches.get(toolId);
+        if (!watch)
+            return;
+        const elapsedMs = Date.now() - watch.startTime;
+        const deferReason = this.shouldDeferKill?.() ?? null;
+        if (deferReason && elapsedMs + UNAVAILABLE_REASSESS_MS <= WATCHDOG_HARD_CAP_MS) {
+            if (this.verbose) {
+                hlog(`[WATCHDOG] ${toolName} (${toolId}) kill deferred after ${Math.round(elapsedMs / 1000)}s — ${deferReason}; re-checking in ${UNAVAILABLE_REASSESS_MS / 60_000} min`);
+            }
+            watch.tiebreakerAttempted = false;
+            this.scheduleActivityGatedTimeout(watch, toolId, toolName, toolInput, profile, UNAVAILABLE_REASSESS_MS, onTimeout);
+            watch.timeoutMs = elapsedMs + UNAVAILABLE_REASSESS_MS;
+            return;
+        }
+        onTimeout();
+    }
+    async handleTimeoutWithTiebreaker(toolId, toolName, toolInput, profile, onTimeout) {
+        const watch = this.activeWatches.get(toolId);
+        if (!watch)
+            return true;
+        const elapsedMs = Date.now() - watch.startTime;
+        const tokenSilenceMs = this.getTokenSilenceMs?.();
+        if (tokenSilenceMs !== undefined && tokenSilenceMs < 60_000) {
+            const remainingToCeiling = watch.ceilingMs - elapsedMs;
+            if (remainingToCeiling > 0) {
+                const extensionMs = Math.min(5 * 60_000, remainingToCeiling);
+                if (this.verbose) {
+                    hlog(`[WATCHDOG] ${toolName} (${toolId}) hit timeout after ${Math.round(elapsedMs / 1000)}s, but stream active ${Math.round(tokenSilenceMs / 1000)}s ago — auto-extending ${Math.round(extensionMs / 1000)}s`);
+                }
+                this.scheduleActivityGatedTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout);
+                watch.timeoutMs = elapsedMs + extensionMs;
+                return true;
+            }
+        }
+        if (!profile.useHaikuTiebreaker || !this.onTiebreaker || watch.tiebreakerAttempted) {
+            if (this.verbose) {
+                hlog(`[WATCHDOG] ${toolName} (${toolId}) timed out after ${Math.round(elapsedMs / 1000)}s, killing`);
+            }
+            return false;
+        }
+        return this.runTiebreaker(watch, toolId, toolName, toolInput, profile, elapsedMs, onTimeout);
+    }
+    extendWhileUnavailable(watch, toolId, toolName, toolInput, profile, elapsedMs, reason, onTimeout) {
+        const extensionMs = Math.min(UNAVAILABLE_REASSESS_MS, WATCHDOG_HARD_CAP_MS - elapsedMs);
+        if (extensionMs <= 0) {
+            if (this.verbose)
+                hlog(`[WATCHDOG] ${toolName} (${toolId}): tiebreaker unavailable and hard cap reached — killing`);
+            return false;
+        }
+        if (this.verbose) {
+            hlog(`[WATCHDOG] ${toolName} (${toolId}): tiebreaker unavailable (${reason}) — extending ${Math.round(extensionMs / 1000)}s and re-assessing`);
+        }
+        watch.tiebreakerAttempted = false;
+        this.scheduleActivityGatedTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout);
+        watch.timeoutMs = elapsedMs + extensionMs;
+        return true;
+    }
+    async runTiebreaker(watch, toolId, toolName, toolInput, profile, elapsedMs, onTimeout) {
+        watch.tiebreakerAttempted = true;
+        if (this.verbose) {
+            hlog(`[WATCHDOG] ${toolName} (${toolId}) hit timeout after ${Math.round(elapsedMs / 1000)}s, running tiebreaker...`);
+        }
+        try {
+            const tokenSilenceMs = this.getTokenSilenceMs?.();
+            const verdict = await this.onTiebreaker(toolName, toolInput, elapsedMs, tokenSilenceMs, watch.declaredTimeoutMs);
+            if (verdict.assessed === false) {
+                return this.extendWhileUnavailable(watch, toolId, toolName, toolInput, profile, elapsedMs, verdict.reason, onTimeout);
+            }
+            if (verdict.action === 'extend') {
+                const extensionMs = Math.min(verdict.extensionMs, watch.ceilingMs - elapsedMs);
+                if (extensionMs <= 0) {
+                    if (this.verbose) {
+                        hlog(`[WATCHDOG] Tiebreaker: extend ${toolName} requested, but ceiling ${Math.round(watch.ceilingMs / 1000)}s already reached — killing`);
+                    }
+                    return false;
+                }
+                if (this.verbose) {
+                    hlog(`[WATCHDOG] Tiebreaker: extend ${toolName} by ${Math.round(extensionMs / 1000)}s — ${verdict.reason}`);
+                }
+                this.scheduleExtensionTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout);
+                watch.timeoutMs = elapsedMs + extensionMs;
+                return true;
+            }
+            if (this.verbose) {
+                hlog(`[WATCHDOG] Tiebreaker: kill ${toolName} — ${verdict.reason}`);
+            }
+            return false;
+        }
+        catch (err) {
+            return this.extendWhileUnavailable(watch, toolId, toolName, toolInput, profile, elapsedMs, String(err), onTimeout);
+        }
+    }
+    scheduleActivityGatedTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout) {
+        watch.timer = setTimeout(async () => {
+            const w = this.activeWatches.get(toolId);
+            if (!w)
+                return;
+            const extended = await this.handleTimeoutWithTiebreaker(toolId, toolName, toolInput, profile, onTimeout);
+            if (!extended && this.activeWatches.has(toolId)) {
+                this.killOrDefer(toolId, toolName, toolInput, profile, onTimeout);
+            }
+        }, extensionMs);
+    }
+    scheduleExtensionTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout) {
+        watch.timer = setTimeout(() => {
+            const w = this.activeWatches.get(toolId);
+            if (!w)
+                return;
+            if (this.verbose) {
+                hlog(`[WATCHDOG] ${toolName} (${toolId}) still running after extension, killing`);
+            }
+            this.killOrDefer(toolId, toolName, toolInput, profile, onTimeout);
+        }, extensionMs);
+    }
+    onEngineEvent(event, onTimeout) {
+        if (event.kind === 'tool.start') {
+            this.startWatch(event.toolCallId, event.toolName, event.input, () => onTimeout(event.toolCallId));
+            return;
+        }
+        if (event.kind === 'tool.end') {
+            this.clearWatch(event.toolCallId);
+            if (typeof event.durationMs === 'number' && event.durationMs >= 0) {
+                this.recordCompletion(event.toolName, event.durationMs);
+            }
+        }
+    }
+    clearWatch(toolId) {
+        const watch = this.activeWatches.get(toolId);
+        if (watch) {
+            clearTimeout(watch.timer);
+            this.activeWatches.delete(toolId);
+        }
+    }
+    clearAll() {
+        for (const [_id, watch] of this.activeWatches) {
+            clearTimeout(watch.timer);
+        }
+        this.activeWatches.clear();
+    }
+    getActiveWatch(toolId) {
+        return this.activeWatches.get(toolId);
+    }
+    getActiveWatches() {
+        return this.activeWatches;
+    }
+    buildCheckpoint(originalPrompt, assistantText, thinkingText, accumulatedToolUse, hungToolId, claudeSessionId, processStartTime) {
+        const hungWatch = this.activeWatches.get(hungToolId);
+        if (!hungWatch)
+            return null;
+        const hungToolEntry = accumulatedToolUse.find(t => t.toolId === hungToolId);
+        const completedTools = accumulatedToolUse
+            .filter(t => t.toolId !== hungToolId && t.result !== undefined)
+            .map(t => ({
+            toolName: t.toolName,
+            toolId: t.toolId,
+            input: t.toolInput,
+            result: t.result || '',
+            isError: t.isError || false,
+            durationMs: t.duration || 0,
+        }));
+        const inProgressTools = accumulatedToolUse
+            .filter(t => t.toolId !== hungToolId && t.result === undefined)
+            .map(t => ({
+            toolName: t.toolName,
+            toolId: t.toolId,
+            input: t.toolInput,
+        }));
+        let url;
+        const toolInput = hungToolEntry?.toolInput || hungWatch.toolInput;
+        if (toolInput.url) {
+            url = String(toolInput.url);
+        }
+        else if (toolInput.query) {
+            url = String(toolInput.query);
+        }
+        return {
+            originalPrompt,
+            assistantText,
+            thinkingText,
+            completedTools,
+            inProgressTools,
+            hungTool: {
+                toolName: hungWatch.toolName,
+                toolId: hungToolId,
+                input: toolInput,
+                timeoutMs: hungWatch.timeoutMs,
+                url,
+            },
+            claudeSessionId,
+            elapsedMs: Date.now() - processStartTime,
+        };
+    }
+}

package/dist/server/cli/headless/types.js

@@ -0,0 +1,18 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const emptyTokenUsage = () => ({
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    currentTurnInputTokens: 0,
+});
+export const addTokenUsage = (a, b) => ({
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheCreationTokens: a.cacheCreationTokens + b.cacheCreationTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    currentTurnInputTokens: b.currentTurnInputTokens || a.currentTurnInputTokens,
+    isFinal: a.isFinal === true && b.isFinal === true ? true : undefined,
+});
+export const totalTokens = (u) => u.inputTokens + u.outputTokens + u.cacheCreationTokens + u.cacheReadTokens;

package/dist/server/cli/history-portability.js

@@ -0,0 +1,85 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { hostname } from 'node:os';
+import { getClientId } from '../services/client-id.js';
+import { CLI_VERSION } from '../services/platform-credentials.js';
+import { originMatches } from './engine-resume.js';
+import { normalizeSessionHistory } from './improvisation-history-store.js';
+import { SESSION_HISTORY_FORMAT_VERSION, } from './improvisation-types.js';
+export const SESSION_EXPORT_KIND = 'minionry.session-history';
+export const SESSION_EXPORT_EXTENSION = '.minionry-session.json';
+export function currentSessionOrigin(workingDir) {
+    return { clientId: getClientId(), workingDir, hostname: hostname(), cliVersion: CLI_VERSION };
+}
+export function exportSessionHistory(history, now = new Date()) {
+    return {
+        kind: SESSION_EXPORT_KIND,
+        formatVersion: SESSION_HISTORY_FORMAT_VERSION,
+        exportedAt: now.toISOString(),
+        session: normalizeSessionHistory(JSON.parse(JSON.stringify(history))),
+    };
+}
+export function parseSessionHistoryImport(raw) {
+    const record = typeof raw === 'object' && raw !== null ? raw : null;
+    if (!record)
+        return { ok: false, error: 'Not a JSON object' };
+    let candidate = record;
+    let exportedAt;
+    if (record.kind !== undefined || record.session !== undefined) {
+        if (record.kind !== SESSION_EXPORT_KIND)
+            return { ok: false, error: `Not a Minionry session export (kind: ${String(record.kind)})` };
+        if (typeof record.session !== 'object' || record.session === null)
+            return { ok: false, error: 'Export carries no session' };
+        candidate = record.session;
+        if (typeof record.exportedAt === 'string')
+            exportedAt = record.exportedAt;
+    }
+    if (!Array.isArray(candidate.movements))
+        return { ok: false, error: 'No movements array — not a session transcript' };
+    const malformed = candidate.movements.findIndex((movement) => !isMovementLike(movement));
+    if (malformed !== -1)
+        return { ok: false, error: `Movement ${malformed + 1} is not a transcript movement` };
+    return { ok: true, session: normalizeSessionHistory(candidate), ...(exportedAt ? { exportedAt } : {}) };
+}
+export function importSessionHistory(parsed, options) {
+    const now = options.now ?? new Date();
+    const source = parsed.session;
+    const warnings = [];
+    const settled = source.movements.filter((movement) => (movement.durationMs ?? 0) > 0);
+    if (settled.length < source.movements.length) {
+        warnings.push(`${source.movements.length - settled.length} unfinished movement(s) were dropped`);
+    }
+    const sameOrigin = source.origin !== undefined && originMatches(source.origin, options.local);
+    if (!sameOrigin && source.engineSessions && Object.keys(source.engineSessions).length > 0) {
+        warnings.push('Engine session handles from the source machine were dropped; the first prompt will carry the conversation so far');
+    }
+    const history = {
+        ...source,
+        sessionId: `improv-${now.getTime()}`,
+        formatVersion: SESSION_HISTORY_FORMAT_VERSION,
+        movements: settled,
+        lastActivityAt: now.toISOString(),
+        origin: options.local,
+        sharedFrom: {
+            sessionId: source.sessionId,
+            ...(source.origin ? { origin: source.origin } : {}),
+            ...(parsed.exportedAt ? { exportedAt: parsed.exportedAt } : {}),
+            importedAt: now.toISOString(),
+        },
+    };
+    if (sameOrigin) {
+        history.engineSessions = source.engineSessions;
+        history.claudeSessionId = source.claudeSessionId;
+    }
+    else {
+        delete history.engineSessions;
+        delete history.claudeSessionId;
+    }
+    return { history, warnings };
+}
+function isMovementLike(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const movement = value;
+    return typeof movement.userPrompt === 'string' && typeof movement.sequenceNumber === 'number';
+}

package/dist/server/cli/improvisation-attachments.js

@@ -0,0 +1,99 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { spacePath } from '../services/space-layout.js';
+import { herror } from './headless/headless-logger.js';
+const SUPPORTED_IMAGE_MIMES = new Set([
+    'image/jpeg', 'image/png', 'image/gif', 'image/webp',
+]);
+export function hydrateAndFilterAttachments(attachments) {
+    for (const attachment of attachments) {
+        const preUploaded = attachment._preUploaded;
+        if (preUploaded && attachment.isImage && !attachment.content && existsSync(attachment.filePath)) {
+            try {
+                attachment.content = readFileSync(attachment.filePath).toString('base64');
+            }
+            catch (err) {
+                herror(`Failed to read pre-uploaded image ${attachment.filePath}:`, err);
+                attachment.isImage = false;
+            }
+        }
+        if (attachment.isImage) {
+            const mime = (attachment.mimeType || '').toLowerCase();
+            if (mime && !SUPPORTED_IMAGE_MIMES.has(mime)) {
+                attachment.isImage = false;
+            }
+        }
+    }
+}
+export function buildPromptWithAttachments(userPrompt, attachments, diskPaths) {
+    if ((!attachments || attachments.length === 0) && (!diskPaths || diskPaths.length === 0)) {
+        return userPrompt;
+    }
+    const parts = [];
+    if (attachments) {
+        const textFiles = attachments.filter(a => !a.isImage);
+        for (const file of textFiles) {
+            parts.push(`@${file.filePath}\n\`\`\`\n${file.content}\n\`\`\``);
+        }
+    }
+    if (diskPaths && diskPaths.length > 0) {
+        parts.push(`Attached files saved to disk:\n${diskPaths.map(p => `- ${p}`).join('\n')}`);
+    }
+    if (parts.length === 0) {
+        return userPrompt;
+    }
+    return `${parts.join('\n\n')}\n\n${userPrompt}`;
+}
+export function persistAttachments(attachments, workingDir, sessionId) {
+    if (attachments.length === 0)
+        return [];
+    const attachDir = spacePath(workingDir, 'tmp', 'attachments', sessionId);
+    if (!existsSync(attachDir)) {
+        mkdirSync(attachDir, { recursive: true });
+    }
+    const paths = [];
+    for (const attachment of attachments) {
+        if (attachment._preUploaded) {
+            if (existsSync(attachment.filePath)) {
+                paths.push(attachment.filePath);
+            }
+            continue;
+        }
+        const filePath = join(attachDir, attachment.fileName);
+        try {
+            writeFileSync(filePath, Buffer.from(attachment.content, 'base64'));
+            paths.push(filePath);
+        }
+        catch (err) {
+            herror(`Failed to persist attachment ${attachment.fileName}:`, err);
+        }
+    }
+    return paths;
+}
+export function cleanupAttachments(workingDir, sessionId) {
+    const attachDir = spacePath(workingDir, 'tmp', 'attachments', sessionId);
+    if (existsSync(attachDir)) {
+        try {
+            rmSync(attachDir, { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+}
+export function preparePromptAndAttachments(userPrompt, attachments, workingDir, sessionId, onWarning) {
+    if (attachments) {
+        hydrateAndFilterAttachments(attachments);
+    }
+    const diskPaths = attachments ? persistAttachments(attachments, workingDir, sessionId) : [];
+    const prompt = buildPromptWithAttachments(userPrompt, attachments, diskPaths);
+    const MAX_IMAGE_ATTACHMENTS = 20;
+    const allImages = attachments?.filter(a => a.isImage && a.content);
+    let imageAttachments = allImages;
+    if (allImages && allImages.length > MAX_IMAGE_ATTACHMENTS) {
+        imageAttachments = allImages.slice(-MAX_IMAGE_ATTACHMENTS);
+        onWarning?.(`\n[[MINIONRY_ERROR:TOO_MANY_IMAGES]] ${allImages.length} images attached, limit is ${MAX_IMAGE_ATTACHMENTS}. Using the ${MAX_IMAGE_ATTACHMENTS} most recent.\n`);
+    }
+    return { prompt, imageAttachments };
+}