@minionry/minion 0.7.36

package/dist/server/cli/eta-estimator.js

@@ -0,0 +1,278 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+const ELAPSED_CHECKPOINTS_MS = [
+    0,
+    10_000,
+    30_000,
+    60_000,
+    120_000,
+    300_000,
+    600_000,
+    900_000,
+    1_500_000,
+    2_400_000,
+    3_600_000,
+];
+const MAX_SAMPLE_FILES = 200;
+const MIN_SAMPLES = 30;
+const SANITY_FLOOR_MS = 1_000;
+const SANITY_CEILING_MS = 6 * 60 * 60_000;
+const SPEED_FACTORS = {
+    'claude-code': {
+        unknownModel: 1.0,
+        models: { opus: 1.0, fable: 1.05, sonnet: 0.85, haiku: 0.65 },
+    },
+    codex: {
+        unknownModel: 0.95,
+        models: { 'gpt-5.1-codex-max': 0.95, 'gpt-5-codex': 0.9 },
+    },
+    hermes: {
+        unknownModel: 1.1,
+        models: {
+            'z-ai/glm-5.2': 1.0,
+            'moonshotai/kimi-k3': 1.3,
+            'anthropic/claude-fable-5.1': 1.15,
+            'anthropic/claude-fable-5': 1.1,
+            'anthropic/claude-opus-5': 1.1,
+            'anthropic/claude-opus-4.8': 1.1,
+            'anthropic/claude-sonnet-5': 0.9,
+            'anthropic/claude-haiku-4.5': 0.7,
+            'openai/gpt-5.6-sol': 1.05,
+            'openai/gpt-5.6-sol-pro': 1.35,
+            'openai/gpt-5.6-terra': 1.0,
+            'openai/gpt-5.6-terra-pro': 1.3,
+            'openai/gpt-5.6-luna': 0.75,
+            'openai/gpt-5.6-luna-pro': 1.0,
+            'openai/gpt-5.5': 1.15,
+            'openai/gpt-5.5-pro': 1.5,
+            'openai/gpt-5.4-mini': 0.7,
+            'google/gemini-3.1-pro-preview': 0.85,
+            'google/gemini-3.7-flash': 0.7,
+            'x-ai/grok-4.6': 1.0,
+            'deepseek/deepseek-v4-pro': 1.0,
+            'deepseek/deepseek-v4-pro-0813': 1.0,
+            'deepseek/deepseek-v4-flash': 0.8,
+            'deepseek/deepseek-v4-flash-0731': 0.8,
+            'qwen/qwen3.8-max': 1.25,
+            'qwen/qwen3.8-flash': 0.8,
+            'minimax/minimax-m3': 1.05,
+            'z-ai/glm-5.3': 1.05,
+            'z-ai/glm-5.3-flash': 0.75,
+            'xiaomi/mimo-v2.5-pro': 1.05,
+            'tencent/hy4-preview': 1.1,
+            'tencent/hy3': 0.9,
+            'stepfun/step-3.7-flash': 0.8,
+            'nvidia/nemotron-3-super-120b-a12b': 0.85,
+            'sakana/fugu-ultra': 1.6,
+        },
+    },
+};
+const FAST_MODE_FACTOR = 0.75;
+function resolveModelKey(engine, model) {
+    const table = SPEED_FACTORS[engine];
+    if (!table)
+        return '*';
+    if (engine === 'claude-code') {
+        const m = (model ?? 'default').toLowerCase();
+        if (/haiku/.test(m))
+            return 'haiku';
+        if (/sonnet/.test(m))
+            return 'sonnet';
+        if (/fable|mythos/.test(m))
+            return 'fable';
+        return 'opus';
+    }
+    const key = (model ?? '').toLowerCase();
+    return key in table.models ? key : '*';
+}
+export function durationFactor(target) {
+    if (!target)
+        return 1;
+    const engine = target.engine && SPEED_FACTORS[target.engine] ? target.engine : 'claude-code';
+    const table = SPEED_FACTORS[engine];
+    const key = resolveModelKey(engine, target.model);
+    const base = table.models[key] ?? table.unknownModel;
+    return target.fastMode && engine === 'claude-code' ? base * FAST_MODE_FACTOR : base;
+}
+export function etaTargetKey(target) {
+    const engine = target?.engine && SPEED_FACTORS[target.engine] ? target.engine : 'claude-code';
+    const fast = target?.fastMode && engine === 'claude-code';
+    return `${engine}::${resolveModelKey(engine, target?.model)}${fast ? '::fast' : ''}`;
+}
+export async function buildEtaProfile(historyDir, opts = {}) {
+    const maxFiles = opts.maxFiles ?? MAX_SAMPLE_FILES;
+    const samples = await collectRecentSamples(historyDir, maxFiles);
+    return buildProfileFromSamples(samples, opts.target);
+}
+const SAMPLES_CACHE_TTL_MS = 5 * 60_000;
+const samplesCache = new Map();
+export async function getEtaProfileCached(historyDir, target) {
+    const samples = await getSamplesCached(historyDir);
+    const profile = buildProfileFromSamples(samples, target);
+    return profile ?? scaleProfile(BASELINE_ETA_PROFILE, durationFactor(target));
+}
+async function getSamplesCached(historyDir) {
+    const now = Date.now();
+    const hit = samplesCache.get(historyDir);
+    if (hit && hit.expiresAt > now && hit.samples)
+        return hit.samples;
+    if (hit?.pending)
+        return hit.pending;
+    const pending = collectRecentSamples(historyDir, MAX_SAMPLE_FILES).then(samples => {
+        samplesCache.set(historyDir, { samples, expiresAt: Date.now() + SAMPLES_CACHE_TTL_MS });
+        return samples;
+    }).catch(() => {
+        samplesCache.set(historyDir, { samples: [], expiresAt: Date.now() + SAMPLES_CACHE_TTL_MS });
+        return [];
+    });
+    samplesCache.set(historyDir, { samples: hit?.samples ?? null, expiresAt: hit?.expiresAt ?? 0, pending });
+    return pending;
+}
+export function _clearEtaCache() { samplesCache.clear(); }
+export const BASELINE_ETA_PROFILE = {
+    buckets: [
+        { elapsedMs: 0, p50TotalMs: 108_000, p90TotalMs: 768_000, n: 379 },
+        { elapsedMs: 10_000, p50TotalMs: 117_000, p90TotalMs: 769_000, n: 368 },
+        { elapsedMs: 30_000, p50TotalMs: 155_000, p90TotalMs: 860_000, n: 328 },
+        { elapsedMs: 60_000, p50TotalMs: 245_000, p90TotalMs: 1_013_000, n: 252 },
+        { elapsedMs: 120_000, p50TotalMs: 392_000, p90TotalMs: 1_171_000, n: 182 },
+        { elapsedMs: 300_000, p50TotalMs: 605_000, p90TotalMs: 1_412_000, n: 116 },
+        { elapsedMs: 600_000, p50TotalMs: 945_000, p90TotalMs: 1_679_000, n: 58 },
+        { elapsedMs: 900_000, p50TotalMs: 1_265_000, p90TotalMs: 1_845_000, n: 30 },
+        { elapsedMs: 1_500_000, p50TotalMs: 1_728_000, p90TotalMs: 1_986_000, n: 10 },
+    ],
+    sampleSize: 379,
+    computedAt: '2026-05-06T00:00:00.000Z',
+};
+export function scaleProfile(profile, factor) {
+    if (Math.abs(factor - 1) < 1e-9)
+        return profile;
+    return {
+        buckets: profile.buckets.map(b => ({
+            elapsedMs: Math.round(b.elapsedMs * factor),
+            p50TotalMs: Math.round(b.p50TotalMs * factor),
+            p90TotalMs: Math.round(b.p90TotalMs * factor),
+            n: b.n,
+        })),
+        sampleSize: profile.sampleSize,
+        computedAt: profile.computedAt,
+    };
+}
+export function buildProfileFromSamples(samples, target) {
+    const usable = samples.filter(s => Number.isFinite(s.durationMs) && s.durationMs >= SANITY_FLOOR_MS && s.durationMs <= SANITY_CEILING_MS);
+    const key = etaTargetKey(target);
+    const segment = usable.filter(s => etaTargetKey(s) === key).map(s => s.durationMs);
+    if (segment.length >= MIN_SAMPLES)
+        return orNullIfEmpty(buildProfileFromDurations(segment));
+    if (usable.length >= MIN_SAMPLES) {
+        const normalized = usable.map(s => s.durationMs / durationFactor(s));
+        return orNullIfEmpty(scaleProfile(buildProfileFromDurations(normalized), durationFactor(target)));
+    }
+    return null;
+}
+function orNullIfEmpty(profile) {
+    return profile.buckets.length > 0 ? profile : null;
+}
+export function buildProfileFromDurations(durationsMs) {
+    const cleaned = durationsMs
+        .filter(d => Number.isFinite(d) && d >= SANITY_FLOOR_MS && d <= SANITY_CEILING_MS)
+        .sort((a, b) => a - b);
+    const buckets = [];
+    for (const elapsedMs of ELAPSED_CHECKPOINTS_MS) {
+        const stillRunning = cleaned.filter(d => d > elapsedMs);
+        if (stillRunning.length === 0)
+            break;
+        buckets.push({
+            elapsedMs,
+            p50TotalMs: quantile(stillRunning, 0.5),
+            p90TotalMs: quantile(stillRunning, 0.9),
+            n: stillRunning.length,
+        });
+    }
+    return {
+        buckets,
+        sampleSize: cleaned.length,
+        computedAt: new Date().toISOString(),
+    };
+}
+export function predictEta(profile, elapsedMs) {
+    if (profile.buckets.length === 0)
+        return null;
+    let bucket = profile.buckets[0];
+    for (const b of profile.buckets) {
+        if (b.elapsedMs <= elapsedMs)
+            bucket = b;
+        else
+            break;
+    }
+    const p50TotalMs = Math.max(bucket.p50TotalMs, elapsedMs);
+    const p90TotalMs = Math.max(bucket.p90TotalMs, p50TotalMs);
+    return { p50TotalMs, p90TotalMs, n: bucket.n };
+}
+async function collectRecentSamples(historyDir, maxFiles) {
+    let entries;
+    try {
+        entries = (await fsp.readdir(historyDir)).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    if (entries.length === 0)
+        return [];
+    const stats = await Promise.all(entries.map(async (name) => {
+        try {
+            const full = join(historyDir, name);
+            const s = await fsp.stat(full);
+            return { full, mtime: s.mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    }));
+    const ordered = stats
+        .filter((x) => x !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, maxFiles);
+    const samples = [];
+    for (const { full } of ordered) {
+        let raw;
+        try {
+            raw = await fsp.readFile(full, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        collectSessionSamples(data, samples);
+    }
+    return samples;
+}
+function collectSessionSamples(data, out) {
+    if (!Array.isArray(data.movements))
+        return;
+    for (const m of data.movements) {
+        const d = m.durationMs;
+        if (typeof d !== 'number' || !Number.isFinite(d))
+            continue;
+        out.push({
+            durationMs: d,
+            engine: m.engine ?? data.engine ?? 'claude-code',
+            model: m.model,
+            fastMode: m.fastMode,
+        });
+    }
+}
+function quantile(sortedAsc, q) {
+    if (sortedAsc.length === 0)
+        return 0;
+    const idx = Math.min(sortedAsc.length - 1, Math.floor(sortedAsc.length * q));
+    return sortedAsc[idx];
+}

package/dist/server/cli/headless/background-activity.js

@@ -0,0 +1,109 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const WAKEUP_MIN_DELAY_S = 60;
+const WAKEUP_MAX_DELAY_S = 3600;
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'killed', 'stopped', 'error', 'cancelled']);
+export function createBackgroundActivityState() {
+    return {
+        pendingTasks: new Map(),
+        wakeup: null,
+        lastEvidenceAt: 0,
+        waitNoticeEmitted: false,
+        waitStartedAt: null,
+        lastWaitNoticeAt: 0,
+    };
+}
+function trackWaitEpisode(state, now) {
+    if (state.pendingTasks.size > 0) {
+        if (state.waitStartedAt === null)
+            state.waitStartedAt = now;
+    }
+    else {
+        state.waitStartedAt = null;
+    }
+}
+export function applyStreamEventToBackground(state, event) {
+    if (event.type !== 'system' || !event.subtype || !event.task_id)
+        return;
+    const now = Date.now();
+    switch (event.subtype) {
+        case 'task_started':
+            state.pendingTasks.set(event.task_id, {
+                taskId: event.task_id,
+                description: event.description,
+                taskType: event.task_type,
+                startedAt: now,
+            });
+            state.lastEvidenceAt = now;
+            state.waitNoticeEmitted = false;
+            trackWaitEpisode(state, now);
+            return;
+        case 'task_progress':
+            state.lastEvidenceAt = now;
+            return;
+        case 'task_updated': {
+            const status = event.patch?.status;
+            if (status && TERMINAL_TASK_STATUSES.has(status)) {
+                state.pendingTasks.delete(event.task_id);
+            }
+            state.lastEvidenceAt = now;
+            trackWaitEpisode(state, now);
+            return;
+        }
+        case 'task_notification':
+            state.pendingTasks.delete(event.task_id);
+            state.lastEvidenceAt = now;
+            trackWaitEpisode(state, now);
+            return;
+    }
+}
+export function applyToolEventToBackground(state, event) {
+    if (event.type !== 'tool_complete' || event.toolName !== 'ScheduleWakeup' || !event.completeInput)
+        return;
+    const delaySeconds = event.completeInput.delaySeconds;
+    if (typeof delaySeconds !== 'number' || !Number.isFinite(delaySeconds))
+        return;
+    const clamped = Math.min(WAKEUP_MAX_DELAY_S, Math.max(WAKEUP_MIN_DELAY_S, delaySeconds));
+    const prompt = typeof event.completeInput.prompt === 'string' ? event.completeInput.prompt : undefined;
+    const reason = typeof event.completeInput.reason === 'string' ? event.completeInput.reason : undefined;
+    state.wakeup = { fireAtMs: Date.now() + clamped * 1000, prompt, reason };
+    state.waitNoticeEmitted = false;
+}
+export function backgroundIdleDeadline(state, now, graceMs, capMs, absoluteCapMs = Number.POSITIVE_INFINITY) {
+    let deadline = null;
+    if (state.wakeup) {
+        const wakeupDeadline = state.wakeup.fireAtMs + graceMs;
+        if (now <= wakeupDeadline)
+            deadline = wakeupDeadline;
+    }
+    if (state.pendingTasks.size > 0) {
+        const absoluteDeadline = state.waitStartedAt !== null ? state.waitStartedAt + absoluteCapMs : Number.POSITIVE_INFINITY;
+        const taskDeadline = Math.min(state.lastEvidenceAt + capMs, absoluteDeadline);
+        if (now <= taskDeadline)
+            deadline = Math.max(deadline ?? 0, taskDeadline);
+    }
+    return deadline;
+}
+export function backgroundWaitExceededAbsoluteCap(state, now, absoluteCapMs) {
+    if (state.pendingTasks.size === 0 || state.waitStartedAt === null)
+        return false;
+    return now >= state.waitStartedAt + absoluteCapMs;
+}
+export function hasPendingBackgroundWork(state, now) {
+    return state.pendingTasks.size > 0 || (state.wakeup !== null && state.wakeup.fireAtMs > now);
+}
+export function describeBackgroundWait(state, now) {
+    const parts = [];
+    if (state.pendingTasks.size > 0) {
+        const names = Array.from(state.pendingTasks.values())
+            .slice(0, 3)
+            .map(t => t.description || t.taskType || t.taskId)
+            .join(', ');
+        parts.push(`${state.pendingTasks.size} background task(s) running (${names})`);
+    }
+    if (state.wakeup && state.wakeup.fireAtMs > now) {
+        const inMin = Math.max(1, Math.round((state.wakeup.fireAtMs - now) / 60_000));
+        parts.push(`next scheduled self-check in ~${inMin} min${state.wakeup.reason ? ` (${state.wakeup.reason})` : ''}`);
+    }
+    return parts.join('; ');
+}