codehere 1.0.1 → 1.0.3

package/dist/application/use-cases/export-aat.js

@@ -1,107 +0,0 @@
-/**
- * export-aat — map codehere's hash-chained audit log to the IETF
- * draft-sharif-agent-audit-trail-00 (AAT) record structure, JSONL (the
- * draft's RECOMMENDED primary export format).
- *
- * Why: the 2026 wave-4 swarm discourse converged on audit-trail
- * standardization (EU AI Act Art. 12 logging lands Aug 2026; the AAT draft
- * maps to SOC 2 / ISO 42001). codehere's chain already carries the
- * substance — agent identity, action, outcome, risk, hash-chained
- * SHA-256 linking — so speaking the emerging standard is a mapping, not a
- * rebuild.
- *
- * HONEST MAPPING NOTES (each also stated in the export header record):
- *  - trust_level is "L0" for every record: AAT's levels describe the
- *    AGENT's cryptographic identity, and codehere agents carry none (the
- *    DAEMON's keystore signs the chain tip — that is recorder identity,
- *    not agent identity; claiming L1 would overstate).
- *  - prev_hash/record hashing is codehere's sorted-key JSON canon over the
- *    original entries — same SHA-256 chain idea as the draft, but NOT
- *    RFC 8785 JCS, and the hashes commit to the ORIGINAL codehere entries,
- *    not to the AAT projection. Verify against the source chain.
- *  - input_hash is SHA-256 of the recorded toolInput; the raw input stays
- *    local (the draft's privacy-by-design posture).
- *  - record_id is the entry's own content hash formatted as a UUID-shaped id —
- *    deterministic, no invented identity (UUID-shaped, not an RFC 4122 UUID).
- */
-import { createHash } from 'crypto';
-import { existsSync, readFileSync } from 'fs';
-function hashToUuid(hexHash) {
-    const h = hexHash.padEnd(32, '0').slice(0, 32);
-    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
-}
-function agentOf(entry) {
-    try {
-        const ti = JSON.parse(entry.toolInput);
-        if (typeof ti.agent === 'string' && ti.agent)
-            return ti.agent;
-    }
-    catch {
-        /* non-JSON toolInput */
-    }
-    return 'unrecorded';
-}
-export function exportAat(auditFile, now = new Date().toISOString()) {
-    const out = {
-        header: {
-            format: 'codehere-aat-export',
-            source_format: 'draft-sharif-agent-audit-trail-00',
-            exported_at: now,
-            record_count: 0,
-            notes: [
-                'trust_level is L0 for all records: AAT trust levels describe the AGENT’s cryptographic identity and codehere agents carry none — the daemon’s keystore signs the chain tip (recorder identity, not agent identity).',
-                'prev_hash values are codehere’s SHA-256 chain over the ORIGINAL entries (sorted-key JSON canonicalization, not RFC 8785 JCS); verify against the source chain, not this projection.',
-                'input_hash is SHA-256 of the recorded tool input; raw inputs stay local (privacy by design).',
-                'record_id is the source entry’s content hash formatted as a UUID-shaped id — deterministic, not an invented identity.',
-            ],
-        },
-        records: [],
-        skippedLegacy: 0,
-    };
-    if (!existsSync(auditFile))
-        return out;
-    for (const line of readFileSync(auditFile, 'utf-8').split('\n')) {
-        const raw = line.trim();
-        if (!raw)
-            continue;
-        let e;
-        try {
-            e = JSON.parse(raw);
-        }
-        catch {
-            out.skippedLegacy++;
-            continue;
-        }
-        if (typeof e.seq !== 'number' || typeof e.entryHash !== 'string' || typeof e.prevHash !== 'string') {
-            out.skippedLegacy++; // pre-chain legacy — no hash-chained position to export
-            continue;
-        }
-        const rec = {
-            record_id: hashToUuid(e.entryHash),
-            timestamp: e.timestamp,
-            agent_id: `urn:agent:${agentOf(e)}.codehere.local`,
-            session_id: e.sessionId,
-            action_type: e.toolName === 'pre_prompt' ? 'decision' : 'tool_call',
-            action_detail: {
-                tool_name: e.toolName,
-                input_hash: createHash('sha256')
-                    .update(e.toolInput ?? '')
-                    .digest('hex'),
-                ...(e.writer ? { writer: e.writer } : {}),
-            },
-            outcome: e.blocked ? 'blocked' : 'success',
-            trust_level: 'L0',
-            prev_hash: e.prevHash,
-            ...(typeof e.riskScore === 'number' && e.riskScore > 0 ? { risk_score: Math.min(1, e.riskScore / 100) } : {}),
-        };
-        out.records.push(rec);
-    }
-    out.header.record_count = out.records.length;
-    return out;
-}
-/** Serialize per the draft's recommended JSONL: header line first, then one
- *  record per line. */
-export function aatToJsonl(exp) {
-    return [JSON.stringify(exp.header), ...exp.records.map((r) => JSON.stringify(r))].join('\n') + '\n';
-}
-//# sourceMappingURL=export-aat.js.map

package/dist/application/use-cases/generate-acceptance-criteria.js

@@ -1,223 +0,0 @@
-/**
- * Acceptance-criteria agent — REQUEST_METHOD.md stage 2 (the Contract), the
- * keystone of the request method.
- *
- * Before an agent runs, derive 2-5 testable acceptance criteria from the
- * request: the up-front, checkable definition of "done" that verify (stage 5)
- * later grades AGAINST, instead of judging the result post-hoc. This is the one
- * change that turns "route a prompt and audit it after" into "make the agent
- * work to a contract and prove it met it."
- *
- * Mirrors generate-thread-title.ts: single-shot, no streaming, `claude --bare`,
- * ~1 cheap call, degrades SILENTLY to [] when no provider responds (a request
- * with no contract still runs — the method is additive, never a hard gate here).
- */
-import { spawn } from 'child_process';
-import { isMockMode } from '../../infrastructure/orchestration/mocks/resolve-agent-spawn.js';
-const CRITERIA_TIMEOUT_MS = 15_000;
-const MAX_CRITERIA = 5;
-const PROMPT_TEMPLATE = (firstPrompt, cwd) => `Generate 2 to 5 acceptance criteria for this coding request. Each criterion is one short, testable statement of what "done" means — something a reviewer could check pass/fail.
-
-Working directory: ${cwd}
-Request: ${firstPrompt}
-
-Rules:
-- 2 to 5 criteria, ONE per line
-- Each is a checkable OUTCOME (e.g. "greet() throws a TypeError when name is not a string"), not a step and not a vibe
-- Ground each in the request only; do not invent scope
-- No numbering, no bullets, no preamble, no trailing period
-- Output ONLY the criteria, one per line
-
-Criteria:`;
-/**
- * Parse model output into criteria. Rejects refusal/error-shaped lines (the
- * `claude --bare` call can return rate-limit / auth text on stdout with exit 0,
- * same failure mode the title agent guards against).
- */
-export function sanitizeCriteria(raw) {
-    const bad = /\b(i cannot|i can'?t|i apologi[sz]e|i'?m sorry|as an ai|rate.?limit|unauthorized|request id|api key)\b/i;
-    return String(raw || '')
-        .split('\n')
-        .map((l) => l.replace(/^[\s\-*•–>#\d.)\]]+/, '').trim())
-        .filter((l) => l.length >= 3 && l.length <= 140 && !bad.test(l))
-        .slice(0, MAX_CRITERIA)
-        .map((text) => ({ text, met: null }));
-}
-/**
- * The scaling principle (REQUEST_METHOD §"no ceremony tax"): a trivial ask gets
- * no contract. Trivial = very short, or a short read-only lookup. Everything
- * else earns a contract. Keeps "just type and go" free for simple requests and
- * skips the per-request LLM call where it would only be noise.
- */
-export function isTrivialRequest(prompt) {
-    const p = String(prompt || '')
-        .trim()
-        .toLowerCase();
-    if (!p)
-        return true;
-    const words = p.split(/\s+/).filter(Boolean).length;
-    if (words <= 3)
-        return true;
-    if (words <= 6 && /^(list|ls|show|cat|print|echo|pwd|help|read|open|what is|what'?s)\b/.test(p))
-        return true;
-    return false;
-}
-/** Deterministic mock: grounded-enough criteria for demos + tests, no LLM. */
-export function mockCriteria(firstPrompt) {
-    const p = String(firstPrompt || '').toLowerCase();
-    const out = [];
-    if (/rate.?limit|throttle/.test(p))
-        out.push('The rate limit is enforced under load');
-    if (/throw|error|validation|validate|guard|invalid/.test(p))
-        out.push('Invalid input is rejected with a clear error');
-    if (/test/.test(p))
-        out.push('Tests are added and pass');
-    if (!out.length)
-        out.push('The change does what the request asked', 'No existing behaviour regresses');
-    return out.slice(0, MAX_CRITERIA).map((text) => ({ text, met: null }));
-}
-function selectProviderBinary() {
-    const override = process.env.CODEHERE_CRITERIA_BINARY;
-    if (override)
-        return [override];
-    return ['claude'];
-}
-const GRADE_PROMPT = (criteria, ctx) => `You are grading whether a coding task met its acceptance criteria. For EACH criterion, answer strictly MET or UNMET based only on the evidence. If the evidence does not clearly show a criterion was met, answer UNMET (never guess "met").
-
-Request: ${ctx.prompt}
-Result summary: ${ctx.reportSummary || '(none)'}
-Files changed: ${(ctx.files || []).join(', ') || '(none)'}
-
-Criteria (one per line):
-${criteria.map((c, i) => `${i + 1}. ${c.text}`).join('\n')}
-
-Output exactly one line per criterion, in order, each "MET" or "UNMET" — nothing else.`;
-/** Parse "MET/UNMET" lines back onto the criteria, in order. */
-export function applyGrades(criteria, raw) {
-    const verdicts = String(raw || '')
-        .split('\n')
-        .map((l) => l.trim().toUpperCase())
-        .filter((l) => l === 'MET' || l === 'UNMET');
-    return criteria.map((c, i) => {
-        const v = verdicts[i];
-        return { text: c.text, met: v === 'MET' ? true : v === 'UNMET' ? false : (c.met ?? null) };
-    });
-}
-/**
- * Deterministic mock grade — honest by the same rule as the real one: a
- * criterion is met ONLY if the run was verified AND the criterion's salient
- * terms show up in the result; otherwise unmet. No fake green.
- */
-export function mockGrade(criteria, ctx) {
-    const hay = ((ctx.reportSummary || '') + ' ' + (ctx.files || []).join(' ')).toLowerCase();
-    return criteria.map((c) => {
-        if (!ctx.verdictGreen)
-            return { text: c.text, met: false };
-        const terms = c.text
-            .toLowerCase()
-            .split(/\s+/)
-            .filter((w) => w.length > 4);
-        const hit = terms.filter((t) => hay.includes(t)).length;
-        return { text: c.text, met: hit >= Math.max(1, Math.ceil(terms.length * 0.3)) };
-    });
-}
-/**
- * Grade the contract against the result (REQUEST_METHOD stage 5). Runs at
- * completion. Real path is a small single-shot assessment; folding this into
- * the existing final-report call (truly no new call) is a noted follow-up.
- * Returns the criteria unchanged (all pending) if grading can't run — never
- * marks met without evidence.
- */
-export async function gradeAcceptanceCriteria(criteria, ctx) {
-    if (!Array.isArray(criteria) || !criteria.length)
-        return criteria || [];
-    if (isMockMode())
-        return mockGrade(criteria, ctx);
-    const prompt = GRADE_PROMPT(criteria, ctx);
-    for (const binary of selectProviderBinary()) {
-        const raw = await new Promise((resolve) => {
-            let out = '';
-            let settled = false;
-            const done = (r) => {
-                if (!settled) {
-                    settled = true;
-                    resolve(r);
-                }
-            };
-            const child = spawn(binary, ['--bare', '-p', prompt], { stdio: ['ignore', 'pipe', 'pipe'] });
-            const to = setTimeout(() => {
-                child.kill('SIGTERM');
-                done(null);
-            }, CRITERIA_TIMEOUT_MS);
-            child.on('error', () => {
-                clearTimeout(to);
-                done(null);
-            });
-            child.stdout?.on('data', (c) => {
-                out += c.toString('utf-8');
-            });
-            child.on('exit', (code) => {
-                clearTimeout(to);
-                done(code === 0 ? out : null);
-            });
-        });
-        if (raw)
-            return applyGrades(criteria, raw);
-    }
-    return criteria; // no grade available → stay pending, never fake a green
-}
-function tryProvider(binary, prompt) {
-    return new Promise((resolve) => {
-        let stdout = '';
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(result);
-        };
-        const child = spawn(binary, ['--bare', '-p', prompt], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        const timeout = setTimeout(() => {
-            child.kill('SIGTERM');
-            if (process.env.CODEHERE_DEBUG === '1') {
-                console.error(`[criteria-agent] ${binary} timeout after ${CRITERIA_TIMEOUT_MS}ms`);
-            }
-            finish(null);
-        }, CRITERIA_TIMEOUT_MS);
-        child.on('error', () => {
-            clearTimeout(timeout);
-            finish(null);
-        });
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString('utf-8');
-        });
-        child.on('exit', (code) => {
-            clearTimeout(timeout);
-            if (code !== 0) {
-                finish(null);
-                return;
-            }
-            const criteria = sanitizeCriteria(stdout);
-            finish(criteria.length ? criteria : null);
-        });
-    });
-}
-/**
- * The contract. Returns [] (not null) when no provider responds so callers can
- * store the field unconditionally; an empty contract simply means the request
- * ran without one (never blocks the run).
- */
-export async function generateAcceptanceCriteria(firstPrompt, cwd) {
-    if (isMockMode())
-        return mockCriteria(firstPrompt);
-    const prompt = PROMPT_TEMPLATE(firstPrompt, cwd);
-    for (const binary of selectProviderBinary()) {
-        const result = await tryProvider(binary, prompt);
-        if (result)
-            return result;
-    }
-    return [];
-}
-//# sourceMappingURL=generate-acceptance-criteria.js.map

package/dist/application/use-cases/generate-final-report.js

@@ -1,259 +0,0 @@
-/**
- * Final Report — the headline deliverable. At task exit, produce a plain-English
- * summary of what the agent did.
- *
- * Engine (locked 2026-06-03, after the real dogfood found NO report on a real
- * conductor run): REUSE THE AGENT SESSION. The agent already narrates what it
- * did (kind:'say' steps — e.g. "Added subtract(a,b) to utils.js:5"); we use that
- * directly. No fresh summarizer spawn.
- *
- * Why the old path was replaced: it spawned a SEPARATE provider binary chain
- * (`claude-free` → `claude`) to summarize. `claude-free` (the FCC/NIM proxy
- * binary) is on PATH but its proxy was down → 30s hang → null; the `claude`
- * fallback also returned null in the conductor exit-handler. Net: a completed
- * real task showed "⚠ Final Report unavailable" — the headline deliverable
- * missing. Reusing the agent's own words is cheaper, has full context, and can't
- * be taken down by an external proxy.
- *
- * Fallback (locked): when the agent left no usable summary (or it looks like a
- * provider failure), build a DETERMINISTIC report from the recorded steps +
- * artifacts. It states ONLY verified facts, says plainly that no written summary
- * was available, and NEVER implies success — so a completed task always shows a
- * deliverable, and it's honest about which kind it is (see `source`).
- */
-// Generous cap — the old 1600 clipped reports mid-code-block (a code fence +
-// prose easily exceeds it). High enough to never trim a real report's code,
-// still bounded against a runaway agent dump.
-const MAX_SUMMARY_CHARS = 20000;
-/**
- * UAT-003 — patterns indicating the agent's own text is actually a network /
- * auth / quota failure, not a real summary. Such "summaries" must NOT be shown
- * as the report; they fall through to the deterministic fallback.
- */
-const NETWORK_FAILURE_PATTERNS = /(?:all connection attempts failed|ECONNREFUSED|ENOTFOUND|fetch failed|network error|request id:\s*req_|connection timed out|getaddrinfo)/i;
-function isLikelyNetworkFailureSummary(text) {
-    return NETWORK_FAILURE_PATTERNS.test(text);
-}
-/**
- * UAT (real-mode dogfood 2026-06-13) — some CLIs (aider) have no narration
- * channel; their captured "say" text is setup/housekeeping chatter, not a
- * summary of the work ("You can skip this check with --no-gitignore", the
- * `.gitignore` housekeeping, the version banner). Shown as the report it reads
- * as broken — and it buries the honest deterministic facts (files changed +
- * trust score). Strip the housekeeping; if nothing real is left, fall through.
- */
-const TOOL_NOISE_PATTERNS = [
-    /you can skip this check with --no-gitignore/gi,
-    /added\s+\.?aider\*?\s+to\s+\.?gitignore/gi,
-    /\baider v[\d.]+(?:\s*\([^)]*\))?/gi,
-    /\binitialized empty git repository[^\n]*/gi,
-    // aider session-banner lines (loop-1 sweep 2026-07-06: real runs whose whole
-    // "summary" was this chatter passed the length bar and rendered as the report)
-    /\bnote: in-chat filenames are always relative to[^\n.]*\.?/gi,
-    /\bcur working dir:[^\n]*/gi,
-    /\bgit working dir:[^\n]*/gi,
-    /\brepo-map can't include[^\n]*/gi,
-    /\bhas it been deleted from the file system but not from git\?/gi,
-];
-function stripToolNoise(text) {
-    let t = text;
-    for (const re of TOOL_NOISE_PATTERNS)
-        t = t.replace(re, ' ');
-    return t.replace(/\s+/g, ' ').trim();
-}
-/**
- * ENGINE: the agent's own narration. kind:'say' steps are the words the agent
- * already emitted (reasoning + wrap-up). Joined newest-context-last, they ARE
- * the summary — no extra spawn. Returns null if the agent said nothing usable.
- */
-function extractAgentSummary(steps) {
-    const says = steps
-        .filter((s) => s.kind === 'say' && typeof s.label === 'string' && s.label.trim().length > 0)
-        .map((s) => s.label.trim());
-    if (!says.length)
-        return null;
-    // Inverted pyramid (loop-1 lesson 2026-07-06): agents narrate chronologically,
-    // so joined-in-order reports LEAD with opening narration ("Let me check…")
-    // while the finding sits at the end — and every summary-of-the-summary
-    // downstream (glance, cards, search snippets) inherits the wrong lead. The
-    // agent's LAST say is its wrap-up: put it first, keep the earlier narration
-    // below under an honest label. Content intact, order presented, not invented.
-    const ordered = says.length > 1 ? [says[says.length - 1], 'Earlier notes:', ...says.slice(0, -1)] : says;
-    const text = ordered.join('\n\n').slice(0, MAX_SUMMARY_CHARS);
-    // A "summary" that is only tool housekeeping (no real prose left after
-    // stripping it) is NOT a summary → let the deterministic fallback give the
-    // honest facts (files changed + trust score) instead of chatter.
-    if (stripToolNoise(text).length < 12)
-        return null;
-    // Too short to be a real summary (e.g. a one-word ack) → let the fallback give facts.
-    return text.length >= 12 ? text : null;
-}
-/**
- * FALLBACK: deterministic, honest. Facts only, from steps + artifacts. Says
- * plainly that no written summary was available. Never implies success.
- */
-function buildDeterministicReport(input) {
-    const files = input.artifacts?.files ?? [];
-    const toolSteps = input.steps.filter((s) => s.kind !== 'say');
-    const noGit = input.artifacts?.noGitTracking;
-    const agentName = input.agent === 'conductor' ? 'the agent codehere chose' : input.agent;
-    const parts = [
-        `No written summary for this run. ${agentName} didn't leave one, and codehere doesn't fabricate one. Here are the recorded facts.`,
-        `The session ran ${input.steps.length} step${input.steps.length === 1 ? '' : 's'}` +
-            (toolSteps.length
-                ? ` (${toolSteps
-                    .slice(0, 5)
-                    .map((s) => s.label)
-                    .join(', ')}${toolSteps.length > 5 ? ', …' : ''})`
-                : '') +
-            `.`,
-    ];
-    if (noGit) {
-        parts.push(`This folder isn't a git repository, so codehere couldn't track which files changed — check the working tree yourself.`);
-    }
-    else if (files.length) {
-        parts.push(`Files changed: ` +
-            files
-                .map((f) => `${f.path} (+${f.added}/-${f.removed}${f.trust !== undefined ? `, trust ${f.trust}` : ''})`)
-                .join('; ') +
-            `.`);
-    }
-    else {
-        parts.push(`No files were changed.`);
-    }
-    return { summary: parts.join('\n\n'), generatedAt: Date.now(), durationMs: 0, source: 'deterministic' };
-}
-/** Per-vendor recovery hints — the SPECIFIC auth/quota fix for EACH agent, so a
- *  failure report names the right login command + provider, not a claude-centric
- *  or generic guess. Commands/URLs mirror the readiness authHints (Phase 1):
- *  codex→`codex login`/platform.openai.com, gemini→AI-Studio free tier, aider→its
- *  LiteLLM model provider (free Gemini path), opencode→`opencode auth`. */
-const VENDOR_FIX = {
-    'claude-code': {
-        label: 'Claude',
-        auth: 'codehere runs Claude through your *subscription* (your `claude` login) — it ignores `ANTHROPIC_API_KEY` on purpose. Open a terminal, run `claude`, complete `/login`, then rerun.',
-        quota: "If you authenticate with an API key, top up at console.anthropic.com; if you're on a Claude subscription, check your plan's usage limits — then rerun.",
-    },
-    codex: {
-        label: 'Codex',
-        auth: 'Run `codex login` with a ChatGPT Plus/Pro account (flat, no per-token charge), or set `OPENAI_API_KEY` — then rerun.',
-        quota: 'OpenAI quota exhausted — top up at platform.openai.com, or switch to a free agent (gemini / opencode).',
-    },
-    gemini: {
-        label: 'Gemini',
-        auth: 'Set `GEMINI_API_KEY` from the free tier (https://aistudio.google.com/apikey), then rerun.',
-        quota: "Gemini's free-tier limit was hit — wait for it to reset, raise your AI Studio limits, or switch agents.",
-    },
-    aider: {
-        label: 'Aider',
-        // Provider-neutral on purpose: codehere can't know WHICH provider aider was
-        // pointed at, so name the credential for each path rather than leading with one.
-        auth: 'Aider needs a model + a matching provider key. Set the key for whatever provider you point it at — a billed `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` (with credit), or a free `GEMINI_API_KEY` run as `--model gemini/gemini-2.5-flash` — then rerun.',
-        quota: 'The provider key aider is using has no credit — top up that provider, or switch aider to a free one (e.g. a Gemini key with `--model gemini/…`, or a local Ollama model).',
-    },
-    opencode: {
-        label: 'OpenCode',
-        auth: 'Run `opencode auth` once to add a provider (a local Ollama model or a free endpoint = $0), then rerun.',
-        quota: 'The provider OpenCode is using hit its limit — run `opencode auth` to switch providers, or point at a local Ollama model.',
-    },
-};
-const GENERIC_FIX = {
-    label: 'The agent',
-    auth: "Sign in to the agent's provider — run `codehere health` to see which agent and how — then rerun.",
-    quota: "Top up or switch the agent's provider; `codehere health` shows the per-agent status. codehere is vendor-neutral.",
-};
-/** Read the captured error/output text and name the SPECIFIC failure + the fix
- *  FOR THIS AGENT, instead of a generic "network hiccup" or a claude-only guess.
- *  Uses input.errorText (codehere:error events) + steps' errorText/output. The
- *  detection patterns are vendor-neutral (each adapter forwards the provider's
- *  native auth/quota/rate words); the RECOVERY text is selected per input.agent.
- *  Returns null when the text doesn't clearly indicate a known failure — honest:
- *  we don't fabricate a specific cause we can't see. */
-function diagnoseFailure(input) {
-    const blob = (input.errorText ? [input.errorText] : [])
-        .concat((input.steps || []).map((s) => `${s.errorText || ''} ${s.output || ''} ${s.kind === 'say' ? s.label : ''}`))
-        .join(' ')
-        .toLowerCase();
-    if (!blob.trim())
-        return null;
-    // Prefer the direct agent's fix; for a conductor task, fall back to the
-    // specialist it delegated to (so a conductor→codex failure names codex's fix,
-    // not the generic one); only then the vendor-neutral generic.
-    const fix = VENDOR_FIX[input.agent] ?? (input.delegatedTo ? VENDOR_FIX[input.delegatedTo] : undefined) ?? GENERIC_FIX;
-    if (/not logged in|please run.{0,6}\/login|\/login|no valid session|unauthorized|invalid api key|api key not valid|401\b/.test(blob)) {
-        return `**${fix.label} isn't logged in.** ${fix.auth}`;
-    }
-    if (/credit balance is too low|insufficient.{0,12}credit|out of credit|quota|billing/.test(blob)) {
-        return `**Out of credits / quota.** ${fix.quota}`;
-    }
-    if (/rate.?limit|\b429\b|too many requests/.test(blob)) {
-        return `**Rate limited by the provider.** Wait a minute and rerun, or switch agents — codehere is vendor-neutral.`;
-    }
-    return null;
-}
-function buildErrorRecoveryReport(input, durationMs) {
-    const agentName = input.agent === 'conductor' ? 'the agent codehere chose' : input.agent;
-    const specific = diagnoseFailure(input);
-    // When we can't classify the failure but the agent TOLD us why, show its real
-    // words — not a generic three-way guess. A product whose pitch is "show the
-    // truth" should surface "You've hit your usage limit — try again Jul 14", not
-    // "this usually means a network hiccup, an expired login, or a rate limit".
-    const realReason = (input.errorText || '').trim();
-    // NEVER claim "no files changed" without checking. A failed run that still
-    // edited files must say so — claiming otherwise is a lie the dogfood caught
-    // (opencode edited the file, codehere reported "no files were changed").
-    const files = (input.artifacts?.files || []).filter(Boolean);
-    const filesTail = files.length
-        ? `Note: ${files.length} file${files.length === 1 ? '' : 's'} ${files.length === 1 ? 'was' : 'were'} already changed before it stopped (${files.slice(0, 5).join(', ')}${files.length > 5 ? ', …' : ''}) — review before retrying.`
-        : `codehere couldn't confirm any file changes from this attempt.`;
-    const summary = specific
-        ? `The ${agentName} session couldn't complete.\n\n${specific}\n\n${filesTail}`
-        : realReason
-            ? `The ${agentName} session couldn't complete. It reported:\n\n${realReason}\n\n${filesTail}`
-            : `The ${agentName} session ended without completing the task. ` +
-                `This usually means a network hiccup, an expired login, or a rate limit on the provider.\n\n` +
-                `What to try: check your internet, run \`codehere health\` to confirm reachability + auth, ` +
-                `or wait a minute and rerun the same prompt. If it keeps happening, try a different agent ` +
-                `from the dropdown — codehere is vendor-neutral on purpose.\n\n${filesTail}`;
-    return { summary, generatedAt: Date.now(), durationMs, source: 'error-recovery' };
-}
-/**
- * Generate a Final Report. Reuses the agent's own summary; falls back to a
- * deterministic, honest facts report. A completed task ALWAYS gets a report
- * (never null for non-error terminal states) — no external dependency.
- */
-export async function generateFinalReport(input) {
-    // No mock short-circuit: under CODEHERE_MOCK the SAME engine runs, so the
-    // narration gap is reproduced faithfully — claude/aider (emit `say`) get a
-    // rich agent-summary; codex/gemini/opencode (no `say`) get the honest
-    // deterministic report, exactly as on a real run. (A prior mock-only
-    // short-circuit synthesized a report from steps for every agent, hiding the
-    // cross-vendor gap — you couldn't dogfood "codex's report is thin" under mock.)
-    // Errored session — deterministic recovery hint, no summarization of nothing.
-    if (input.status === 'error') {
-        return buildErrorRecoveryReport(input, 0);
-    }
-    // ENGINE: reuse the agent's own narration (no fresh spawn).
-    const agentSummary = extractAgentSummary(input.steps);
-    if (agentSummary && !isLikelyNetworkFailureSummary(agentSummary)) {
-        return { summary: agentSummary, generatedAt: Date.now(), durationMs: 0, source: 'agent-summary' };
-    }
-    // FALLBACK: deterministic, honest — always a deliverable, never a fake ✓.
-    return buildDeterministicReport(input);
-}
-/**
- * Pretty-print to terminal. Used by session-manager when a spawned task exits.
- * Wrapped in try/catch upstream — never let a print failure surface.
- */
-export function printFinalReportToTerminal(input, output) {
-    const banner = '─'.repeat(60);
-    process.stdout.write('\n');
-    process.stdout.write(`${banner}\n`);
-    process.stdout.write(`Final Report · ${input.agent} · ${input.sessionId.slice(0, 8)}\n`);
-    process.stdout.write(`${banner}\n`);
-    process.stdout.write(`${output.summary}\n`);
-    process.stdout.write(`${banner}\n`);
-    process.stdout.write(`(generated in ${output.durationMs}ms)\n`);
-    process.stdout.write('\n');
-}
-//# sourceMappingURL=generate-final-report.js.map