@minionry/minion 0.7.36

package/dist/server/cli/improvisation-history-store.js

@@ -0,0 +1,121 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { spacePath } from '../services/space-layout.js';
+import { writeFileAtomic } from '../utils/file-store.js';
+import { herror } from './headless/headless-logger.js';
+import { SESSION_HISTORY_FORMAT_VERSION } from './improvisation-types.js';
+const HISTORY_FILE_MODE = 0o644;
+export function resolveHistoryPaths(workingDir, sessionId) {
+    const improviseDir = spacePath(workingDir, 'history');
+    const historyPath = join(improviseDir, `${sessionId.replace('improv-', '')}.json`);
+    return { improviseDir, historyPath };
+}
+export function ensureHistoryDir(improviseDir) {
+    if (!existsSync(improviseDir)) {
+        mkdirSync(improviseDir, { recursive: true });
+    }
+}
+function quarantineCorruptHistory(historyPath) {
+    const quarantinePath = `${historyPath}.corrupt-${Date.now()}`;
+    try {
+        renameSync(historyPath, quarantinePath);
+        herror(`Quarantined unreadable history to ${quarantinePath} — starting this session from an empty transcript`);
+    }
+    catch (error) {
+        herror('Failed to quarantine unreadable history:', error);
+    }
+}
+export function loadHistory(historyPath, sessionId) {
+    if (existsSync(historyPath)) {
+        try {
+            const data = readFileSync(historyPath, 'utf-8');
+            return normalizeSessionHistory(JSON.parse(data), sessionId);
+        }
+        catch (error) {
+            herror('Failed to load history:', error);
+            quarantineCorruptHistory(historyPath);
+        }
+    }
+    const now = new Date().toISOString();
+    return {
+        sessionId,
+        startedAt: now,
+        lastActivityAt: now,
+        totalTokens: 0,
+        movements: [],
+        engine: 'claude-code',
+    };
+}
+export function saveHistory(historyPath, history) {
+    history.lastActivityAt = new Date().toISOString();
+    history.formatVersion = SESSION_HISTORY_FORMAT_VERSION;
+    writeFileAtomic(historyPath, JSON.stringify(history, null, 2), { mode: HISTORY_FILE_MODE });
+}
+const PLACEHOLDER_HANDLE = 'pending';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function normalizeSessionHistory(raw, fallbackSessionId) {
+    const record = isRecord(raw) ? raw : {};
+    const now = new Date().toISOString();
+    const engine = typeof record.engine === 'string' && record.engine.length > 0 ? record.engine : 'claude-code';
+    const movements = Array.isArray(record.movements) ? record.movements : [];
+    const handles = {};
+    if (isRecord(record.engineSessions)) {
+        for (const [engineId, handle] of Object.entries(record.engineSessions)) {
+            if (isUsableHandle(handle))
+                handles[engineId] = handle;
+        }
+    }
+    if (isUsableHandle(record.claudeSessionId) && !handles[engine])
+        handles[engine] = record.claudeSessionId;
+    const history = {
+        ...record,
+        sessionId: typeof record.sessionId === 'string' && record.sessionId.length > 0
+            ? record.sessionId
+            : (fallbackSessionId ?? `improv-${Date.now()}`),
+        startedAt: typeof record.startedAt === 'string' ? record.startedAt : now,
+        lastActivityAt: typeof record.lastActivityAt === 'string' ? record.lastActivityAt : now,
+        totalTokens: typeof record.totalTokens === 'number' && Number.isFinite(record.totalTokens) ? record.totalTokens : 0,
+        movements,
+        engine,
+        formatVersion: SESSION_HISTORY_FORMAT_VERSION,
+        engineSessions: Object.keys(handles).length > 0 ? handles : undefined,
+        claudeSessionId: handles['claude-code'],
+    };
+    if (history.engineSessions === undefined)
+        delete history.engineSessions;
+    if (history.claudeSessionId === undefined)
+        delete history.claudeSessionId;
+    return normalizeDisallowedTools(history);
+}
+function isUsableHandle(value) {
+    return typeof value === 'string' && value.length > 0 && value !== PLACEHOLDER_HANDLE;
+}
+function normalizeDisallowedTools(history) {
+    const raw = history.disallowedTools;
+    const tools = Array.isArray(raw) ? [...new Set(raw.filter((tool) => typeof tool === 'string' && tool.length > 0))] : [];
+    if (tools.length > 0)
+        history.disallowedTools = tools;
+    else
+        delete history.disallowedTools;
+    return history;
+}
+export const ORPHANED_MOVEMENT_ERROR = 'The minion process exited while this prompt was running.';
+export function reconcileOrphanedMovements(history) {
+    let settled = 0;
+    const lastActivity = Date.parse(history.lastActivityAt);
+    for (const movement of history.movements) {
+        if ((movement.durationMs ?? 0) > 0)
+            continue;
+        const startedAt = Date.parse(movement.timestamp);
+        const elapsed = Number.isFinite(lastActivity) && Number.isFinite(startedAt) ? lastActivity - startedAt : 0;
+        movement.durationMs = Math.max(1, elapsed);
+        movement.errorOutput = movement.errorOutput || ORPHANED_MOVEMENT_ERROR;
+        movement.outcome = { ...(movement.outcome ?? {}), cancelOrigin: 'process-exit' };
+        settled++;
+    }
+    return settled;
+}

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

@@ -0,0 +1,137 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { formatErrorMarker, parseErrorMarker } from '../services/timeline/assembler.js';
+import { toEngineNoticeRecord } from './headless/engine-notice.js';
+import { summarizeRetryLog } from './headless/retry-strategies.js';
+export const CANCELLED_FALLBACK_RESULT = {
+    completed: false, needsHandoff: false, totalTokens: 0, sessionId: '',
+    output: '', exitCode: 1, signalName: 'SIGTERM',
+};
+export const CANCELLED_MOVEMENT_ERROR = 'Execution cancelled by user';
+export const LIFECYCLE_MOVEMENT_ERRORS = {
+    disconnect: 'Execution ended because the connection was lost',
+    restart: 'CLI restarted during execution',
+    shutdown: 'CLI shut down during execution',
+    destroy: 'Session was closed while this prompt was running',
+    'process-exit': 'The minion process exited while this prompt was running.',
+};
+function movementMeta(args) {
+    return {
+        ...(args.fastMode && { fastMode: true }),
+        ...(args.engine && { engine: args.engine }),
+        ...(args.model && { model: args.model }),
+        ...(args.attachments && args.attachments.length > 0 && { attachments: args.attachments }),
+        ...(args.msgId && { msgId: args.msgId }),
+        ...(args.isAutoContinue && { isAutoContinue: true }),
+    };
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+export function buildMovementOutcome(result, extra = {}) {
+    const fromResult = result
+        ? compact({
+            exitCode: result.exitCode,
+            signal: result.signalName,
+            resultSubtype: result.resultSubtype,
+            terminalReason: result.terminalReason,
+            isError: result.resultIsError,
+            stderrTail: result.stderrTail,
+            engineNotice: result.engineNotice ? toEngineNoticeRecord(result.engineNotice) : undefined,
+            attempts: result.attempts,
+            assessments: result.assessments && result.assessments.length > 0 ? result.assessments : undefined,
+            assessorFailed: result.assessorFailed || undefined,
+            firstEventLatencyMs: result.firstEventLatencyMs,
+            startupTimedOut: result.startupTimedOut || undefined,
+            usage: result.apiTokenUsage,
+            notices: result.notices && result.notices.length > 0 ? result.notices : undefined,
+            pendingBackgroundTasks: result.pendingBackgroundTasks && result.pendingBackgroundTasks.length > 0 ? result.pendingBackgroundTasks : undefined,
+        })
+        : {};
+    const outcome = compact({ ...fromResult, ...extra });
+    return Object.keys(outcome).length > 0 ? outcome : undefined;
+}
+function transcriptFields(result, retryLog) {
+    const log = retryLog && retryLog.length > 0 ? retryLog : result?.retryLog;
+    return {
+        assistantResponse: result?.assistantResponse,
+        thinkingOutput: result?.thinkingOutput,
+        toolUseHistory: result?.toolUseHistory?.map(t => ({
+            toolName: t.toolName, toolId: t.toolId, toolInput: t.toolInput,
+            result: t.result, isError: t.isError, duration: t.duration,
+        })),
+        outputTokens: result?.outputTokens,
+        retryLog: log && log.length > 0 ? log : undefined,
+        retrySummary: summarizeRetryLog(log),
+    };
+}
+export function buildSuccessMovement(result, args, retryLog) {
+    return {
+        id: `prompt-${args.sequenceNumber}`,
+        sequenceNumber: args.sequenceNumber,
+        userPrompt: args.userPrompt,
+        timestamp: new Date().toISOString(),
+        tokensUsed: result.totalTokens,
+        summary: '',
+        filesModified: [],
+        ...transcriptFields(result, retryLog),
+        errorOutput: result.error && result.errorCode && !parseErrorMarker(result.error)
+            ? formatErrorMarker(result.errorCode, result.error)
+            : result.error,
+        durationMs: Date.now() - args.execStart,
+        outcome: buildMovementOutcome(result, args.outcome),
+        ...(result.isAutoContinue && !args.isAutoContinue ? { isAutoContinue: true } : {}),
+        ...movementMeta(args),
+    };
+}
+export function buildCancelledMovement(result, args, options = {}) {
+    const origin = options.origin ?? 'user';
+    return {
+        id: `prompt-${args.sequenceNumber}`,
+        sequenceNumber: args.sequenceNumber,
+        userPrompt: args.userPrompt,
+        timestamp: new Date().toISOString(),
+        tokensUsed: result ? result.totalTokens : 0,
+        summary: '',
+        filesModified: [],
+        ...transcriptFields(result, options.retryLog),
+        errorOutput: origin === 'user' ? CANCELLED_MOVEMENT_ERROR : LIFECYCLE_MOVEMENT_ERRORS[origin],
+        durationMs: Date.now() - args.execStart,
+        outcome: buildMovementOutcome(result, { cancelOrigin: origin, ...args.outcome }),
+        ...movementMeta(args),
+    };
+}
+export function buildErrorMovement(errorMessage, args, result, retryLog) {
+    return {
+        id: `prompt-${args.sequenceNumber}`,
+        sequenceNumber: args.sequenceNumber,
+        userPrompt: args.userPrompt,
+        timestamp: new Date().toISOString(),
+        tokensUsed: result?.totalTokens ?? 0,
+        summary: '',
+        filesModified: [],
+        ...transcriptFields(result, retryLog),
+        errorOutput: errorMessage,
+        durationMs: Date.now() - args.execStart,
+        outcome: buildMovementOutcome(result, args.outcome),
+        ...movementMeta(args),
+    };
+}
+export function shouldAutoContinue(result, autoContinueCount, maxAutoContinues, cancelled) {
+    if (autoContinueCount >= maxAutoContinues)
+        return false;
+    if (cancelled)
+        return false;
+    if (!result.completed || result.signalName)
+        return false;
+    if (result.stopReason !== 'end_turn')
+        return false;
+    const thinkingLen = result.thinkingOutput?.length ?? 0;
+    const responseLen = result.assistantResponse?.length ?? 0;
+    const successfulToolCalls = result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+    if (thinkingLen < 500 || responseLen > 1000)
+        return false;
+    if (successfulToolCalls > 0 && responseLen > 200)
+        return false;
+    return thinkingLen >= responseLen * 3;
+}

package/dist/server/cli/improvisation-output-queue.js

@@ -0,0 +1,34 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const FLUSH_INTERVAL_MS = 50;
+export class OutputQueue {
+    onEmit;
+    queue = [];
+    timer = null;
+    constructor(onEmit) {
+        this.onEmit = onEmit;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => { this.flush(); }, FLUSH_INTERVAL_MS);
+    }
+    queue_(text) {
+        if (text.length === 0)
+            return;
+        this.queue.push(text);
+    }
+    flush() {
+        if (this.queue.length === 0)
+            return;
+        const merged = this.queue.join('');
+        this.queue.length = 0;
+        this.onEmit(merged);
+    }
+    destroy() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { selectBestResult } from './retry/retry-best-result.js';
+export { detectNativeTimeoutContextLoss, detectResumeContextLoss } from './retry/retry-context-loss.js';
+export { applyInterMovementRecovery, applyNativeTimeoutRecovery, applyToolTimeoutRetry, shouldRetryContextLoss, shouldRetryServerError, shouldRetrySessionNotFound, shouldRetrySignalCrash, } from './retry/retry-recovery-strategies.js';
+export { determineResumeStrategy } from './retry/retry-resume-strategy.js';
+export { buildStreamingCallbacks, createExecutionRunner } from './retry/retry-runner-factory.js';
+export { accumulateToolResults } from './retry/retry-tool-results.js';