@minionry/minion 0.7.36

package/dist/server/cli/headless/claude-invoker-tools.js

@@ -0,0 +1,148 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { applyToolEventToBackground, hasPendingBackgroundWork } from './background-activity.js';
+import { HUMAN_WAIT_TOOLS } from './claude-invoker-stall.js';
+import { verboseLog } from './claude-invoker-stream.js';
+import { killProcessGroup } from './runner.js';
+import { assessToolTimeout } from './stall-assessor.js';
+import { ToolWatchdog } from './tool-watchdog.js';
+function summarizeToolInput(input) {
+    try {
+        if (input.description)
+            return String(input.description).slice(0, 200);
+        if (input.prompt)
+            return String(input.prompt).slice(0, 200);
+        if (input.command)
+            return String(input.command).slice(0, 200);
+        if (input.pattern)
+            return `pattern: ${String(input.pattern).slice(0, 100)}`;
+        return JSON.stringify(input).slice(0, 200);
+    }
+    catch {
+        return undefined;
+    }
+}
+const INPUT_STREAMING_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'Bash']);
+function hasToolResult(id, s) {
+    if (s.completedToolIds.has(id))
+        return true;
+    return s.ctx.accumulatedToolUse.find((t) => t.toolId === id)?.result !== undefined;
+}
+function onToolStart(event, s) {
+    const id = event.toolId;
+    const toolName = event.toolName;
+    s.pendingTools.set(id, toolName);
+    s.counters.totalToolCalls++;
+    s.toolIdToName.set(id, toolName);
+    if (s.watchdog && !HUMAN_WAIT_TOOLS.has(toolName) && !INPUT_STREAMING_TOOLS.has(toolName)) {
+        s.watchdog.startWatch(id, toolName, {}, () => { s.onTimeout(id); });
+    }
+}
+function onToolComplete(event, s) {
+    const id = event.toolId;
+    const input = event.completeInput ?? {};
+    s.counters.lastToolInputSummary = summarizeToolInput(input);
+    s.toolIdToInput.set(id, input);
+    if (!s.watchdog)
+        return;
+    if (hasToolResult(id, s))
+        return;
+    const toolName = s.toolIdToName.get(id);
+    if (toolName && !HUMAN_WAIT_TOOLS.has(toolName)) {
+        s.watchdog.startWatch(id, toolName, input, () => { s.onTimeout(id); });
+    }
+}
+function onToolResult(event, s) {
+    const id = event.toolId;
+    s.pendingTools.delete(id);
+    s.completedToolIds.add(id);
+    s.stallState.stallWarningEmitted = false;
+    s.stallState.lastActivityTime = Date.now();
+    s.ctx.lastTokenActivityTime = Date.now();
+    if (!s.watchdog)
+        return;
+    s.watchdog.clearWatch(id);
+    const toolEntry = s.ctx.accumulatedToolUse.find(t => t.toolId === id);
+    const toolName = s.toolIdToName.get(id);
+    if (toolEntry && toolName && toolEntry.duration) {
+        s.watchdog.recordCompletion(toolName, toolEntry.duration);
+    }
+}
+function resolveToolUrl(toolInput) {
+    if (toolInput.url)
+        return String(toolInput.url);
+    if (toolInput.query)
+        return String(toolInput.query);
+    return undefined;
+}
+function executeToolTimeout(hungToolId, watchdog, killCtx, s, config, prompt, sessionCapture, perfStart) {
+    const checkpoint = watchdog.buildCheckpoint(prompt, s.ctx.accumulatedAssistantResponse, s.ctx.accumulatedThinking, s.ctx.accumulatedToolUse, hungToolId, sessionCapture.claudeSessionId, perfStart);
+    const toolName = s.toolIdToName.get(hungToolId) || 'unknown';
+    const toolInput = s.toolIdToInput.get(hungToolId) || {};
+    const timeoutMs = watchdog.getActiveWatch(hungToolId)?.timeoutMs ?? watchdog.getTimeout(toolName);
+    const url = resolveToolUrl(toolInput);
+    config.outputCallback?.(`\n[[MINIONRY_TOOL_TIMEOUT]] ${toolName} timed out after ${Math.round(timeoutMs / 1000)}s${url ? ` fetching: ${url.slice(0, 100)}` : ''}. ${s.ctx.accumulatedToolUse.filter(t => t.result !== undefined).length} completed results preserved.\n`);
+    if (checkpoint) {
+        config.onToolTimeout?.(checkpoint);
+    }
+    verboseLog(config.verbose, `[WATCHDOG] Killing process due to ${toolName} timeout`);
+    watchdog.clearAll();
+    clearInterval(killCtx.stallCheckInterval);
+    if (killCtx.claudeProcess.pid)
+        killProcessGroup(killCtx.claudeProcess.pid, 'SIGTERM');
+    const proc = killCtx.claudeProcess;
+    setTimeout(() => { if (!proc.killed && proc.pid)
+        killProcessGroup(proc.pid, 'SIGKILL'); }, 5000);
+}
+export function setupToolTracking(config, stallState, ctx, sessionCapture, prompt, perfStart) {
+    const pendingTools = new Map();
+    const counters = { lastToolInputSummary: undefined, totalToolCalls: 0 };
+    const toolWatchdogActive = config.enableToolWatchdog !== false;
+    const watchdog = toolWatchdogActive
+        ? new ToolWatchdog({
+            profiles: config.toolTimeoutProfiles,
+            verbose: config.verbose,
+            onTiebreaker: async (toolName, toolInput, elapsedMs, tokenSilenceMs, declaredTimeoutMs) => {
+                const backgroundWorkPending = hasPendingBackgroundWork(ctx.backgroundActivity, Date.now());
+                return assessToolTimeout(toolName, toolInput, elapsedMs, config.claudeCommand, config.verbose, tokenSilenceMs, backgroundWorkPending, declaredTimeoutMs);
+            },
+            getTokenSilenceMs: () => {
+                const last = ctx.lastTokenActivityTime;
+                return last > 0 ? Date.now() - last : undefined;
+            },
+            shouldDeferKill: () => hasPendingBackgroundWork(ctx.backgroundActivity, Date.now()) ? 'background tasks pending' : null,
+        })
+        : null;
+    let killCtx = null;
+    const trackingState = {
+        pendingTools, counters,
+        toolIdToName: new Map(), toolIdToInput: new Map(),
+        completedToolIds: new Set(),
+        watchdog, stallState, ctx,
+        onTimeout: (hungToolId) => {
+            if (!watchdog || !killCtx)
+                return;
+            executeToolTimeout(hungToolId, watchdog, killCtx, trackingState, config, prompt, sessionCapture, perfStart);
+        },
+    };
+    const origToolUseCallback = config.toolUseCallback;
+    config.toolUseCallback = (event) => {
+        applyToolEventToBackground(ctx.backgroundActivity, event);
+        if (event.type === 'tool_start' && event.toolName && event.toolId) {
+            onToolStart(event, trackingState);
+        }
+        else if (event.type === 'tool_complete' && event.completeInput && event.toolId) {
+            onToolComplete(event, trackingState);
+        }
+        else if (event.type === 'tool_result' && event.toolId) {
+            onToolResult(event, trackingState);
+        }
+        origToolUseCallback?.(event);
+    };
+    return {
+        pendingTools, watchdog, toolWatchdogActive, counters,
+        setKillContext: (claudeProcess, stallCheckInterval) => {
+            killCtx = { claudeProcess, stallCheckInterval };
+        },
+    };
+}

package/dist/server/cli/headless/claude-invoker.js

@@ -0,0 +1,151 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createBackgroundActivityState } from './background-activity.js';
+import { buildCloseResult, handleSpawnError, spawnAndRegister, spawnProvedEngineAvailable } from './claude-invoker-process.js';
+import { runStallCheckTick } from './claude-invoker-stall.js';
+import { classifyUnmatchedStderr, processStreamLines, verboseLog } from './claude-invoker-stream.js';
+import { setupToolTracking } from './claude-invoker-tools.js';
+import { engineAvailability } from './engine-availability.js';
+import { NativeTimeoutDetector } from './native-timeout-detector.js';
+import { detectErrorInStderr } from './output-utils.js';
+import { killProcessGroup } from './runner.js';
+import { emptyTokenUsage } from './types.js';
+export async function executeClaudeCommand(prompt, _movementId, _sessionNumber, options) {
+    const { config, runningProcesses } = options;
+    const perfStart = Date.now();
+    verboseLog(config.verbose, '[PERF] executeMovement started');
+    const hasImageAttachments = config.imageAttachments && config.imageAttachments.length > 0;
+    const useStreamJson = hasImageAttachments || config.thinkingCallback || config.outputCallback || config.toolUseCallback;
+    const claudeProcess = await spawnAndRegister(config, prompt, !!hasImageAttachments, !!useStreamJson, runningProcesses, perfStart);
+    let stdout = '';
+    let stderr = '';
+    let thinkingBuffer = '';
+    let firstStdoutReceived = false;
+    let errorAlreadySurfaced = false;
+    const sessionCapture = {};
+    const isResumeMode = !!(config.continueSession && config.claudeSessionId);
+    const ctx = {
+        config,
+        accumulatedAssistantResponse: '',
+        accumulatedThinking: '',
+        accumulatedToolUse: [],
+        toolInputBuffers: new Map(),
+        nativeTimeoutDetector: new NativeTimeoutDetector(),
+        resumeAssessmentActive: isResumeMode,
+        resumeAssessmentBuffer: '',
+        apiTokenUsage: emptyTokenUsage(),
+        seenMessageIds: new Set(),
+        currentStepOutputTokens: 0,
+        lastTokenActivityTime: Date.now(),
+        hasReceivedTextDeltas: false,
+        hasReceivedThinkingDeltas: false,
+        sessionNotFound: false,
+        resultInterrupted: false,
+        backgroundActivity: createBackgroundActivityState(),
+    };
+    const stallState = {
+        lastActivityTime: Date.now(),
+        stallWarningEmitted: false,
+        assessmentInProgress: false,
+        extensionsGranted: 0,
+        currentKillDeadline: Date.now() + (config.stallKillMs ?? 1_800_000),
+        nextWarningAfter: 0,
+    };
+    const toolTracking = setupToolTracking(config, stallState, ctx, sessionCapture, prompt, perfStart);
+    const { pendingTools, watchdog, toolWatchdogActive } = toolTracking;
+    const toolCounters = toolTracking.counters;
+    ctx.onEngineAbort = () => watchdog?.clearAll();
+    options.onLiveContext?.({ ctx, sessionCapture });
+    const firstEventDeadlineMs = config.firstEventDeadlineMs ?? 90_000;
+    const spawnedAt = Date.now();
+    const firstEventTimer = firstEventDeadlineMs > 0
+        ? setTimeout(() => {
+            if (firstStdoutReceived || claudeProcess.exitCode !== null)
+                return;
+            ctx.startupTimedOut = true;
+            const seconds = Math.round((Date.now() - spawnedAt) / 1000);
+            verboseLog(config.verbose, `[STARTUP] No stream event within ${seconds}s of spawn — terminating attempt`);
+            config.outputCallback?.(`\n[[MINIONRY_ERROR:ENGINE_NO_OUTPUT]] The engine produced no output within ${seconds}s of starting. Stopping this attempt.\n`);
+            if (claudeProcess.pid)
+                killProcessGroup(claudeProcess.pid, 'SIGTERM');
+            const proc = claudeProcess;
+            setTimeout(() => { if (!proc.killed && proc.pid && proc.exitCode === null)
+                killProcessGroup(proc.pid, 'SIGKILL'); }, 5000);
+        }, firstEventDeadlineMs)
+        : null;
+    claudeProcess.stdout.on('data', (data) => {
+        stallState.lastActivityTime = Date.now();
+        stallState.stallWarningEmitted = false;
+        stallState.nextWarningAfter = 0;
+        const killMs = config.stallKillMs ?? 1_800_000;
+        stallState.currentKillDeadline = Date.now() + killMs;
+        if (!firstStdoutReceived) {
+            firstStdoutReceived = true;
+            if (firstEventTimer)
+                clearTimeout(firstEventTimer);
+            verboseLog(config.verbose, `[PERF] First stdout data: ${Date.now() - perfStart}ms`);
+        }
+        const chunk = data.toString();
+        stdout += chunk;
+        if (useStreamJson) {
+            thinkingBuffer = processStreamLines(thinkingBuffer + chunk, sessionCapture, ctx);
+        }
+    });
+    claudeProcess.stderr.on('data', async (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        if (errorAlreadySurfaced)
+            return;
+        const error = detectErrorInStderr(stderr);
+        if (error) {
+            errorAlreadySurfaced = true;
+            if (config.outputCallback) {
+                config.outputCallback(`\n[[MINIONRY_ERROR:${error.errorCode}]] ${error.message}\n`);
+            }
+        }
+    });
+    const stallWarningMs = config.stallWarningMs ?? 300_000;
+    const stallHardCapMs = config.stallHardCapMs ?? 14_400_000;
+    const maxExtensions = config.stallMaxExtensions ?? 3;
+    const stallAssessEnabled = config.stallAssessEnabled !== false;
+    let stallCheckInterval;
+    stallCheckInterval = setInterval(() => {
+        runStallCheckTick(stallState, {
+            perfStart, stallWarningMs, stallHardCapMs, maxExtensions, stallAssessEnabled,
+            toolWatchdogActive, prompt, pendingTools, lastToolInputSummary: toolCounters.lastToolInputSummary, totalToolCalls: toolCounters.totalToolCalls,
+            claudeProcess, stallCheckInterval, config, lastTokenActivityTime: ctx.lastTokenActivityTime,
+            backgroundActivity: ctx.backgroundActivity,
+        });
+    }, 10_000);
+    toolTracking.setKillContext(claudeProcess, stallCheckInterval);
+    return new Promise((resolve, reject) => {
+        claudeProcess.on('close', async (code, signal) => {
+            clearInterval(stallCheckInterval);
+            if (firstEventTimer)
+                clearTimeout(firstEventTimer);
+            watchdog?.clearAll();
+            await classifyUnmatchedStderr(stderr, errorAlreadySurfaced, code, config);
+            if (claudeProcess.pid)
+                runningProcesses.delete(claudeProcess.pid);
+            const result = buildCloseResult(ctx, stdout, stderr, code, signal, sessionCapture, spawnedAt);
+            if (ctx.startupTimedOut) {
+                result.error = `The engine produced no output within ${Math.round(firstEventDeadlineMs / 1000)}s of starting.`;
+            }
+            if (spawnProvedEngineAvailable(result)) {
+                engineAvailability.noteSuccessfulSpawn();
+            }
+            options.onLiveContext?.(null);
+            resolve(result);
+        });
+        claudeProcess.on('error', (error) => {
+            clearInterval(stallCheckInterval);
+            if (firstEventTimer)
+                clearTimeout(firstEventTimer);
+            watchdog?.clearAll();
+            if (claudeProcess.pid)
+                runningProcesses.delete(claudeProcess.pid);
+            options.onLiveContext?.(null);
+            handleSpawnError(error, config, reject);
+        });
+    });
+}

package/dist/server/cli/headless/engine-availability.js

@@ -0,0 +1,92 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { EventEmitter } from 'node:events';
+import { describeParkUntil } from './engine-notice.js';
+export class EngineAvailability extends EventEmitter {
+    clock;
+    parkedUntil = null;
+    parkNotice = null;
+    authNotice = null;
+    constructor(clock = Date.now) {
+        super();
+        this.clock = clock;
+    }
+    observe(notice, now = this.clock()) {
+        if (notice.kind === 'limit') {
+            this.park(notice.resetAt ?? now, notice, now);
+        }
+        else if (notice.kind === 'auth') {
+            this.blockAuth(notice, now);
+        }
+    }
+    park(until, notice, now = this.clock()) {
+        if (this.parkedUntil !== null && this.parkedUntil >= until)
+            return;
+        this.parkedUntil = until;
+        this.parkNotice = notice;
+        this.emit('changed', this.snapshot(now));
+    }
+    blockAuth(notice, now = this.clock()) {
+        this.authNotice = notice;
+        this.emit('changed', this.snapshot(now));
+    }
+    noteSuccessfulSpawn() {
+        if (this.authNotice === null && this.parkedUntil === null)
+            return;
+        this.authNotice = null;
+        this.parkedUntil = null;
+        this.parkNotice = null;
+        this.emit('changed', this.snapshot());
+    }
+    clearPark() {
+        if (this.parkedUntil === null)
+            return;
+        this.parkedUntil = null;
+        this.parkNotice = null;
+        this.emit('changed', this.snapshot());
+    }
+    clearAuthBlock() {
+        if (this.authNotice === null)
+            return;
+        this.authNotice = null;
+        this.emit('changed', this.snapshot());
+    }
+    reset() {
+        this.parkedUntil = null;
+        this.parkNotice = null;
+        this.authNotice = null;
+        this.emit('changed', this.snapshot());
+    }
+    isParked(now = this.clock()) {
+        return this.activePark(now) !== null;
+    }
+    isAuthBlocked() {
+        return this.authNotice !== null;
+    }
+    automaticDispatchBlocker(now = this.clock()) {
+        if (this.authNotice)
+            return { kind: 'auth', notice: this.authNotice };
+        const park = this.activePark(now);
+        return park ? { kind: 'limit', notice: park.notice, until: park.until } : null;
+    }
+    snapshot(now = this.clock()) {
+        const park = this.activePark(now);
+        return {
+            ...(park ? { parkedUntil: park.until } : {}),
+            authBlocked: this.authNotice !== null,
+            ...(this.authNotice ? { notice: this.authNotice } : park ? { notice: park.notice } : {}),
+        };
+    }
+    activePark(now) {
+        if (this.parkedUntil === null || this.parkNotice === null || now >= this.parkedUntil)
+            return null;
+        return { until: this.parkedUntil, notice: this.parkNotice };
+    }
+}
+export function describeDispatchBlocker(blocker, now = Date.now()) {
+    if (blocker.kind === 'limit') {
+        return `usage limit reached — resets ${blocker.until !== undefined ? describeParkUntil(blocker.until, now) : 'later'}`;
+    }
+    return `Claude Code is not authenticated (${blocker.notice.text.slice(0, 120)}) — run \`claude login\``;
+}
+export const engineAvailability = new EngineAvailability();

package/dist/server/cli/headless/engine-notice.js

@@ -0,0 +1,185 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const NOTICE_TEXT_MAX = 600;
+export const LIMIT_DEFAULT_PARK_MS = 15 * 60_000;
+export const LIMIT_SESSION_PARK_MAX_MS = 6 * 60 * 60_000;
+export const LIMIT_WEEKLY_PARK_MAX_MS = 8 * 24 * 60 * 60_000;
+const LIMIT_PARK_MIN_MS = 60_000;
+const LIMIT_PATTERNS = [
+    /you(?:'|’)?ve (?:hit|reached) your (?:[\w .-]{0,40}?)?limit/i,
+    /(?:session|weekly|daily|monthly|usage) limit (?:reached|hit|exceeded)/i,
+    /\/usage-credits/i,
+    /usage[- ]limit/i,
+    /quota (?:exceeded|reached)/i,
+    /out of (?:usage )?credits/i,
+];
+const AUTH_PATTERNS = [
+    /not logged in/i,
+    /please run \/login/i,
+    /failed to authenticate/i,
+    /authentication[_ ](?:error|failed|required)/i,
+    /oauth (?:token|session)[\w ]{0,20}expired/i,
+    /invalid (?:api[- ]?key|credentials)/i,
+    /organization has (?:been )?disabled/i,
+    /\b(?:401|403)\b[^\n]{0,60}(?:unauthorized|forbidden|permission|authenticat)/i,
+    /api error:\s*(?:401|403)\b/i,
+];
+const SERVER_ERROR_PATTERNS = [
+    /api error:\s*5\d\d\b/i,
+    /\b(?:500|502|503|504|529)\b[^\n]{0,60}(?:internal server error|bad gateway|service unavailable|gateway timeout|overloaded)/i,
+    /(?:internal server error|bad gateway|service unavailable|gateway timeout|overloaded)[^\n]{0,60}\b(?:500|502|503|504|529)\b/i,
+    /\boverloaded_error\b/i,
+    /\brate_limit_error\b/i,
+    /api error:\s*429\b/i,
+    /too many requests/i,
+];
+export const SYNTHETIC_MODEL = '<synthetic>';
+export function isSyntheticModel(model) {
+    return model === SYNTHETIC_MODEL;
+}
+function matchesAny(patterns, text) {
+    return patterns.some((re) => re.test(text));
+}
+export function classifyEngineNotice(raw, source, now = Date.now()) {
+    if (!raw)
+        return null;
+    const text = raw.trim().slice(0, NOTICE_TEXT_MAX);
+    if (!text)
+        return null;
+    if (matchesAny(LIMIT_PATTERNS, text)) {
+        const parsed = parseLimitResetAt(text, now);
+        return {
+            kind: 'limit',
+            text,
+            source,
+            resetAt: parsed ?? now + LIMIT_DEFAULT_PARK_MS,
+            resetParsed: parsed !== undefined,
+        };
+    }
+    if (matchesAny(AUTH_PATTERNS, text))
+        return { kind: 'auth', text, source };
+    if (matchesAny(SERVER_ERROR_PATTERNS, text))
+        return { kind: 'server_error', text, source };
+    return null;
+}
+export function toEngineNoticeRecord(notice) {
+    return {
+        kind: notice.kind,
+        text: notice.text,
+        source: notice.source,
+        ...(notice.resetAt !== undefined ? { resetAt: new Date(notice.resetAt).toISOString() } : {}),
+    };
+}
+export function describeParkUntil(resetAt, now = Date.now()) {
+    const minutes = Math.max(1, Math.round((resetAt - now) / 60_000));
+    const when = new Date(resetAt).toISOString().replace('T', ' ').slice(0, 16);
+    return `${when} UTC (~${minutes} min)`;
+}
+const MONTHS = {
+    jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, sept: 8, oct: 9, nov: 10, dec: 11,
+};
+const RESET_RE = /resets?\s+(?:at\s+)?(?:(?:on\s+)?([A-Za-z]{3,9})\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\)|([A-Z]{2,5})\b)?/i;
+const WEEKLY_RE = /weekly limit|resets?\s+(?:on\s+)?[A-Za-z]{3,9}\s+\d{1,2}/i;
+export function parseLimitResetAt(text, now = Date.now()) {
+    const match = RESET_RE.exec(text);
+    if (!match)
+        return undefined;
+    const [, monthName, dayStr, hourStr, minuteStr, meridiem, zoneParen, zoneBare] = match;
+    const clock = parseClockTime(hourStr, minuteStr, meridiem);
+    if (!clock)
+        return undefined;
+    const zone = normalizeZone(zoneParen ?? zoneBare);
+    const nowParts = zonedParts(now, zone);
+    const calendar = resolveCalendarDay(monthName, dayStr, nowParts);
+    if (!calendar)
+        return undefined;
+    const resetAt = rollForward(zonedToUtc(nowParts.year, calendar.month, calendar.day, clock.hour, clock.minute, zone), { ...calendar, ...clock, year: nowParts.year, zone, named: calendar.named }, now);
+    const maxPark = WEEKLY_RE.test(text) ? LIMIT_WEEKLY_PARK_MAX_MS : LIMIT_SESSION_PARK_MAX_MS;
+    return Math.min(Math.max(resetAt, now + LIMIT_PARK_MIN_MS), now + maxPark);
+}
+function parseClockTime(hourStr, minuteStr, meridiem) {
+    let hour = Number.parseInt(hourStr, 10);
+    const minute = minuteStr ? Number.parseInt(minuteStr, 10) : 0;
+    if (!Number.isFinite(hour) || hour > 23 || minute > 59)
+        return undefined;
+    if (meridiem) {
+        const pm = meridiem.toLowerCase() === 'pm';
+        if (hour === 12)
+            hour = pm ? 12 : 0;
+        else if (pm)
+            hour += 12;
+    }
+    return { hour, minute };
+}
+function resolveCalendarDay(monthName, dayStr, nowParts) {
+    if (!monthName || !dayStr)
+        return { month: nowParts.month, day: nowParts.day, named: false };
+    const month = MONTHS[monthName.toLowerCase().slice(0, 4)] ?? MONTHS[monthName.toLowerCase().slice(0, 3)];
+    const day = Number.parseInt(dayStr, 10);
+    if (month === undefined || !Number.isFinite(day) || day < 1 || day > 31)
+        return undefined;
+    return { month, day, named: true };
+}
+function rollForward(resetAt, at, now) {
+    if (at.named) {
+        return resetAt < now - 24 * 60 * 60_000 ? zonedToUtc(at.year + 1, at.month, at.day, at.hour, at.minute, at.zone) : resetAt;
+    }
+    return resetAt <= now ? zonedToUtc(at.year, at.month, at.day + 1, at.hour, at.minute, at.zone) : resetAt;
+}
+function normalizeZone(zone) {
+    if (!zone)
+        return 'UTC';
+    const trimmed = zone.trim();
+    if (/^(utc|gmt|z)$/i.test(trimmed))
+        return 'UTC';
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: trimmed });
+        return trimmed;
+    }
+    catch {
+        return 'UTC';
+    }
+}
+function zonedParts(utcMs, zone) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: zone,
+        hourCycle: 'h23',
+        year: 'numeric', month: 'numeric', day: 'numeric',
+        hour: 'numeric', minute: 'numeric', second: 'numeric',
+    }).formatToParts(new Date(utcMs));
+    const get = (type) => Number.parseInt(parts.find((p) => p.type === type)?.value ?? '0', 10);
+    return { year: get('year'), month: get('month') - 1, day: get('day'), hour: get('hour') % 24, minute: get('minute'), second: get('second') };
+}
+function zoneOffsetMs(utcMs, zone) {
+    const p = zonedParts(utcMs, zone);
+    return Date.UTC(p.year, p.month, p.day, p.hour, p.minute, p.second) - utcMs;
+}
+function zonedToUtc(year, month, day, hour, minute, zone) {
+    const guess = Date.UTC(year, month, day, hour, minute);
+    const first = guess - zoneOffsetMs(guess, zone);
+    return guess - zoneOffsetMs(first, zone);
+}
+const BENIGN_STDERR_PATTERNS = [
+    /ignoring \d+ permissions\.allow entr(?:y|ies)/i,
+    /this workspace has not been trusted/i,
+    /^\s*\[?(?:deprecat|warn(?:ing)?)\]?[:\s]/i,
+    /punycode/i,
+    /ExperimentalWarning/i,
+    /^\s*\(Use `node --trace/i,
+];
+export function filterBenignStderr(stderr) {
+    if (!stderr)
+        return '';
+    return stderr
+        .split('\n')
+        .filter((line) => line.trim().length > 0 && !BENIGN_STDERR_PATTERNS.some((re) => re.test(line)))
+        .join('\n')
+        .trim();
+}
+export const STDERR_TAIL_MAX = 2_000;
+export function stderrTailOf(stderr) {
+    const trimmed = (stderr ?? '').trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > STDERR_TAIL_MAX ? trimmed.slice(-STDERR_TAIL_MAX) : trimmed;
+}