@minionry/minion 0.7.36

package/dist/server/cli/headless/haiku-assessments.js

@@ -0,0 +1,293 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { isDirectory } from '../../services/pathUtils.js';
+import { loadSkillPrompt } from '../../services/plan/agent-loader.js';
+import { engineAvailability } from './engine-availability.js';
+import { classifyEngineNotice } from './engine-notice.js';
+import { herror, hlog } from './headless-logger.js';
+const HAIKU_TIMEOUT_MS = 30_000;
+export class HaikuAssessmentError extends Error {
+    notice;
+    constructor(message, notice) {
+        super(message);
+        this.notice = notice;
+        this.name = 'HaikuAssessmentError';
+    }
+}
+const assessorHealth = { consecutiveFailures: 0, totalFailures: 0 };
+let assessorDownLogged = false;
+export function getAssessorHealth() {
+    return { ...assessorHealth };
+}
+export function resetAssessorHealth() {
+    assessorHealth.consecutiveFailures = 0;
+    assessorHealth.totalFailures = 0;
+    assessorHealth.lastError = undefined;
+    assessorHealth.lastFailureAt = undefined;
+    assessorDownLogged = false;
+}
+export function resolveAssessorCwd() {
+    const spaceRoot = process.env.MINIONRY_WORKING_DIR;
+    if (spaceRoot && isDirectory(spaceRoot))
+        return spaceRoot;
+    return homedir();
+}
+function recordAssessorFailure(label, message, verbose) {
+    assessorHealth.consecutiveFailures++;
+    assessorHealth.totalFailures++;
+    assessorHealth.lastError = message.slice(0, 300);
+    assessorHealth.lastFailureAt = Date.now();
+    if (!assessorDownLogged) {
+        assessorDownLogged = true;
+        herror(`[ASSESSOR-DOWN] ${label}: first Haiku assessment failure in this process — ${message.slice(0, 300)}`);
+    }
+    else if (verbose) {
+        hlog(`[${label}] Haiku assessment failed (${assessorHealth.consecutiveFailures} consecutive): ${message.slice(0, 200)}`);
+    }
+}
+function recordAssessorSuccess() {
+    assessorHealth.consecutiveFailures = 0;
+}
+export function spawnHaikuRaw(prompt, claudeCommand, verbose, label, options = {}) {
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const fail = (message) => {
+            const notice = classifyEngineNotice(`${stdout}\n${stderr}`, 'assessor') ?? undefined;
+            if (notice)
+                engineAvailability.observe(notice);
+            recordAssessorFailure(label, message, verbose);
+            reject(new HaikuAssessmentError(message, notice));
+        };
+        let proc;
+        try {
+            proc = spawn(claudeCommand, ['--print', '--model', 'haiku', prompt], { stdio: ['ignore', 'pipe', 'pipe'], cwd: options.cwd ?? resolveAssessorCwd() });
+        }
+        catch (err) {
+            settled = true;
+            fail(`Haiku spawn failed: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                proc.kill('SIGTERM');
+                fail('Haiku assessment timed out');
+            }
+        }, HAIKU_TIMEOUT_MS);
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+            if (verbose)
+                hlog(`[${label}] haiku stderr: ${data.toString().trim()}`);
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            if (code !== 0 || !stdout.trim()) {
+                fail(`Haiku exited with code ${code}, output: ${stdout.trim()}${stderr.trim() ? ` stderr: ${stderr.trim().slice(0, 200)}` : ''}`);
+                return;
+            }
+            recordAssessorSuccess();
+            if (verbose)
+                hlog(`[${label}] Haiku response: ${stdout.trim()}`);
+            resolve(stdout.trim());
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            fail(err instanceof Error ? err.message : String(err));
+        });
+    });
+}
+function noticeOf(err) {
+    return err instanceof HaikuAssessmentError ? err.notice : undefined;
+}
+export function parseVerdictResponse(raw) {
+    const lines = raw.split('\n');
+    let verdict = 'STALLED';
+    let reason = 'Assessment inconclusive';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('VERDICT:')) {
+            verdict = trimmed.slice('VERDICT:'.length).trim().toUpperCase();
+        }
+        else if (trimmed.startsWith('REASON:')) {
+            reason = trimmed.slice('REASON:'.length).trim();
+        }
+    }
+    return { verdict, reason };
+}
+export async function assessContextLoss(ctx, claudeCommand, verbose) {
+    const thinkingLine = ctx.thinkingOutputLength > 0 ? 'Extended thinking was active' : 'No extended thinking';
+    const writeLine = ctx.hasSuccessfulWrite ? 'At least one file write succeeded' : 'No file writes succeeded';
+    const responseTail = ctx.assistantResponse.slice(-500);
+    const prompt = loadSkillPrompt('detect-context-loss', {
+        effectiveTimeouts: String(ctx.effectiveTimeouts),
+        nativeTimeoutCount: String(ctx.nativeTimeoutCount),
+        successfulToolCalls: String(ctx.successfulToolCalls),
+        thinkingLine,
+        writeLine,
+        responseTail,
+    }) ?? [
+        'You are analyzing whether a Claude Code agent lost context after experiencing tool timeouts.',
+        '',
+        'Session signals:',
+        `- ${ctx.effectiveTimeouts} tool(s) timed out (${ctx.nativeTimeoutCount} native timeouts)`,
+        `- ${ctx.successfulToolCalls} tool calls completed successfully`,
+        `- ${thinkingLine}`,
+        `- ${writeLine}`,
+        '',
+        `Final response text (last 500 chars):`,
+        responseTail,
+        '',
+        'Respond in EXACTLY this format (2 lines, no extra text):',
+        'VERDICT: CONTEXT_LOST or CONTEXT_OK',
+        'REASON: <brief one-line explanation>',
+    ].join('\n');
+    try {
+        if (verbose)
+            hlog('[CONTEXT-ASSESS] Running Haiku assessment...');
+        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'CONTEXT-ASSESS');
+        const parsed = parseVerdictResponse(raw);
+        const contextLost = parsed.verdict.includes('LOST');
+        if (verbose)
+            hlog(`[CONTEXT-ASSESS] Verdict: ${contextLost ? 'LOST' : 'OK'} — ${parsed.reason}`);
+        return { contextLost, reason: parsed.reason, assessed: true };
+    }
+    catch (err) {
+        if (verbose)
+            hlog(`[CONTEXT-ASSESS] Haiku assessment failed: ${err}`);
+        return { contextLost: false, reason: `Assessment failed: ${err}`, assessed: false, notice: noticeOf(err) };
+    }
+}
+export async function assessApproval(userMessage, claudeCommand, verbose) {
+    const prompt = [
+        'You are classifying a user message in a multi-turn conversation with a coding assistant.',
+        'The assistant previously proposed a plan or asked a question, and the user is now responding.',
+        '',
+        `User's message: "${userMessage}"`,
+        '',
+        'Is this an approval/continuation (user agrees, says yes, wants to proceed) or a new task/question?',
+        '',
+        'APPROVAL signs: "yes", "sure", "go ahead", "sounds good", "do it", "yep", "option 2", "the first one", "proceed", references to previous proposal, short affirmative with modifications ("yes but use TypeScript").',
+        'NEW_TASK signs: asks a different question, gives new detailed instructions, changes topic, provides new requirements unrelated to any proposal.',
+        '',
+        'Respond in EXACTLY this format (2 lines, no extra text):',
+        'VERDICT: APPROVAL or NEW_TASK',
+        'REASON: <brief one-line explanation>',
+    ].join('\n');
+    try {
+        if (verbose)
+            hlog('[APPROVAL-ASSESS] Running Haiku assessment...');
+        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'APPROVAL-ASSESS');
+        const parsed = parseVerdictResponse(raw);
+        const isApproval = parsed.verdict.includes('APPROVAL');
+        if (verbose)
+            hlog(`[APPROVAL-ASSESS] Verdict: ${isApproval ? 'APPROVAL' : 'NEW_TASK'} — ${parsed.reason}`);
+        return { isApproval, reason: parsed.reason, assessed: true };
+    }
+    catch (err) {
+        if (verbose)
+            hlog(`[APPROVAL-ASSESS] Haiku assessment failed: ${err}`);
+        return { isApproval: false, reason: `Assessment failed: ${err}`, assessed: false };
+    }
+}
+export async function assessBestResult(ctx, claudeCommand, verbose) {
+    const promptPreview = ctx.originalPrompt.length > 300 ? `${ctx.originalPrompt.slice(0, 300)}...` : ctx.originalPrompt;
+    const prompt = [
+        'You are comparing two AI assistant responses from retry attempts to determine which made more meaningful progress on the user\'s task.',
+        '',
+        `Original task: ${promptPreview}`,
+        '',
+        `Response A: ${ctx.resultA.successfulToolCalls} successful tool calls, ${ctx.resultA.responseLength} chars, ${ctx.resultA.hasThinking ? 'has' : 'no'} thinking output`,
+        `Last 500 chars of A: ${ctx.resultA.responseTail}`,
+        '',
+        `Response B: ${ctx.resultB.successfulToolCalls} successful tool calls, ${ctx.resultB.responseLength} chars, ${ctx.resultB.hasThinking ? 'has' : 'no'} thinking output`,
+        `Last 500 chars of B: ${ctx.resultB.responseTail}`,
+        '',
+        'Which response made more meaningful progress? Consider:',
+        '- Did it actually work on the task (tool calls, code changes) vs just talking about it?',
+        '- Is it confused/lost context ("How can I help?") vs engaged with the original task?',
+        '- Quality of analysis and output, not just quantity.',
+        '',
+        'Respond in EXACTLY this format (2 lines, no extra text):',
+        'VERDICT: A or B',
+        'REASON: <brief one-line explanation>',
+    ].join('\n');
+    try {
+        if (verbose)
+            hlog('[BEST-RESULT] Running Haiku assessment...');
+        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'BEST-RESULT');
+        const parsed = parseVerdictResponse(raw);
+        const verdictLine = parsed.verdict.trim();
+        const winner = verdictLine.startsWith('B') ? 'B' : verdictLine.startsWith('A') ? 'A' : null;
+        if (winner === null) {
+            if (verbose)
+                hlog(`[BEST-RESULT] Inconclusive reply: ${raw.slice(0, 120)}`);
+            return { winner: null, reason: `Assessment inconclusive: ${parsed.reason}`, assessed: false };
+        }
+        if (verbose)
+            hlog(`[BEST-RESULT] Verdict: ${winner} — ${parsed.reason}`);
+        return { winner, reason: parsed.reason, assessed: true };
+    }
+    catch (err) {
+        if (verbose)
+            hlog(`[BEST-RESULT] Haiku assessment failed: ${err}`);
+        return { winner: null, reason: `Assessment failed: ${err}`, assessed: false, notice: noticeOf(err) };
+    }
+}
+export async function classifyError(stderrContent, claudeCommand, verbose) {
+    const tail = stderrContent.slice(-500);
+    if (!tail.trim())
+        return null;
+    const prompt = loadSkillPrompt('classify-error', {
+        tailLength: String(tail.length),
+        stderrTail: tail,
+    }) ?? [
+        'You are classifying an error message from the Claude Code CLI that did not match known patterns.',
+        '',
+        `stderr (last ${tail.length} chars):`,
+        tail,
+        '',
+        'Classify: AUTH_REQUIRED, API_KEY_INVALID, QUOTA_EXCEEDED, RATE_LIMITED, NETWORK_ERROR, SSL_ERROR, SERVICE_UNAVAILABLE, INTERNAL_ERROR, CONTEXT_TOO_LONG, SESSION_NOT_FOUND, or UNKNOWN.',
+        '',
+        'Respond in EXACTLY this format (2 lines, no extra text):',
+        'CATEGORY: <one of the above>',
+        'MESSAGE: <brief user-friendly description of the error>',
+    ].join('\n');
+    try {
+        if (verbose)
+            hlog('[ERROR-CLASSIFY] Running Haiku assessment...');
+        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'ERROR-CLASSIFY');
+        const lines = raw.split('\n');
+        let category = 'UNKNOWN';
+        let message = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('CATEGORY:')) {
+                category = trimmed.slice('CATEGORY:'.length).trim().toUpperCase();
+            }
+            else if (trimmed.startsWith('MESSAGE:')) {
+                message = trimmed.slice('MESSAGE:'.length).trim();
+            }
+        }
+        if (category === 'UNKNOWN' || !message)
+            return null;
+        if (verbose)
+            hlog(`[ERROR-CLASSIFY] Verdict: ${category} — ${message}`);
+        return { errorCode: category, message };
+    }
+    catch (err) {
+        if (verbose)
+            hlog(`[ERROR-CLASSIFY] Haiku assessment failed: ${err}`);
+        return null;
+    }
+}

package/dist/server/cli/headless/headless-logger.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createWriteStream, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { machinePath } from '../../../bin/machine-layout.js';
+const logContext = new AsyncLocalStorage();
+function formatArgs(args) {
+    return args.map(a => (typeof a === 'string' ? a : String(a))).join(' ');
+}
+export function hlog(...args) {
+    const target = logContext.getStore();
+    if (target) {
+        target.log(...args);
+    }
+    else {
+        console.log(...args);
+    }
+}
+export function herror(...args) {
+    const target = logContext.getStore();
+    if (target) {
+        target.error(...args);
+    }
+    else {
+        console.error(...args);
+    }
+}
+function headlessLogDir() {
+    return machinePath('logs', 'headless');
+}
+function rotateHeadlessLogs() {
+    try {
+        const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        const logDir = headlessLogDir();
+        for (const file of readdirSync(logDir)) {
+            if (!file.endsWith('.log'))
+                continue;
+            const filePath = join(logDir, file);
+            try {
+                const stat = statSync(filePath);
+                if (now - stat.mtimeMs > MAX_AGE_MS || stat.size === 0) {
+                    unlinkSync(filePath);
+                }
+            }
+            catch {   }
+        }
+    }
+    catch {   }
+}
+export async function runWithFileLogger(label, fn, logDir) {
+    const dir = logDir ?? headlessLogDir();
+    mkdirSync(dir, { recursive: true });
+    rotateHeadlessLogs();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const logPath = join(dir, `${label}-${timestamp}.log`);
+    const stream = createWriteStream(logPath, { flags: 'a' });
+    const target = {
+        log: (...args) => {
+            stream.write(`[${new Date().toISOString()}] ${formatArgs(args)}\n`);
+        },
+        error: (...args) => {
+            stream.write(`[${new Date().toISOString()}] ERROR: ${formatArgs(args)}\n`);
+        },
+    };
+    return logContext.run(target, async () => {
+        try {
+            return await fn();
+        }
+        finally {
+            await new Promise((resolve) => stream.end(() => resolve()));
+        }
+    });
+}

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

@@ -0,0 +1,9 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { executeClaudeCommand } from './claude-invoker.js';
+export { generateMcpConfig } from './mcp-config.js';
+export { detectErrorInStderr, ERROR_PATTERNS, estimateTokensFromOutput, extractCleanOutput, extractModifiedFiles } from './output-utils.js';
+export { buildMultimodalMessage, enrichPromptWithContext, isApprovalPrompt } from './prompt-utils.js';
+export { ResilientRunner } from './resilient-runner.js';
+export { HeadlessRunner } from './runner.js';
+export { ToolWatchdog } from './tool-watchdog.js';