@cat-factory/executor-harness 1.31.0 → 1.31.4

package/dist/conflict-resolver.js

@@ -1,138 +0,0 @@
-import { cloneRepo, commitAll, conflictDiff, headCommit, mergeBranch, pushBranch, unmergedPaths, } from './git.js';
-import { agentNeverActed, agentOutputTail, NEVER_ACTED_CAUSE, runAgentInWorkspace, withWorkspace, } from './pi-workspace.js';
-import { log } from './logger.js';
-// Async job execution for the merge-conflict resolver. When a PR cannot be merged
-// because it conflicts with its base, the engine dispatches this: clone the PR head
-// branch (full history), merge the base branch into it to surface the conflicts,
-// run Pi to resolve them, complete the merge commit and push back onto the SAME
-// branch (no new branch / PR) so the PR becomes mergeable and CI re-runs.
-//
-// Shares the thin workspace/Pi base (withWorkspace + runAgentInWorkspace) with the
-// other agents; it diverges only in needing a full clone, a base→branch merge to
-// produce the conflicts, and a guard that refuses to push a half-resolved tree.
-/** Run one conflict-resolver job: clone → merge base → Pi resolves → push (same branch). */
-export async function handleConflictResolver(job, opts = {}) {
-    const { signal } = opts;
-    const trace = { jobId: job.jobId, repo: `${job.repo.owner}/${job.repo.name}`, branch: job.branch };
-    return withWorkspace('conflict', async (dir) => {
-        log.info('conflict: cloning PR branch (full history)', trace);
-        // Full clone so the merge base + `origin/<base>` are present for the merge.
-        await cloneRepo({
-            repo: { ...job.repo, baseBranch: job.branch },
-            ghToken: job.ghToken,
-            dir,
-            signal,
-            full: true,
-        });
-        const prTip = await headCommit(dir, signal);
-        log.info('conflict: merging base into PR branch', { ...trace, base: job.repo.baseBranch });
-        const clean = await mergeBranch(dir, job.repo.baseBranch, signal);
-        // No conflicts to resolve. If base brought new commits the merge advanced the
-        // branch, so push it; otherwise the branch is already up to date — a no-op we
-        // leave alone (re-dispatching it never changes the PR, so a gate that keeps
-        // seeing GitHub report this branch as "conflicting" is a base-resolution problem,
-        // not the agent's — logged here so that loop is diagnosable).
-        if (clean) {
-            if ((await headCommit(dir, signal)) === prTip) {
-                log.info('conflict: base merged clean and branch already up to date — nothing to push', {
-                    ...trace,
-                    base: job.repo.baseBranch,
-                });
-                return {
-                    resolved: true,
-                    summary: 'No conflicts: the branch is already up to date with its base.',
-                    stats: { toolCalls: 0, assistantChars: 0 },
-                };
-            }
-            log.info('conflict: base merged clean — pushing the merge commit', trace);
-            await pushBranch(dir, job.branch, job.ghToken, signal);
-            return {
-                resolved: true,
-                summary: 'Merged the base in cleanly (no conflicts to resolve).',
-                stats: { toolCalls: 0, assistantChars: 0 },
-            };
-        }
-        // The merge left conflicts in the working tree. Surface the EXACT files + hunks
-        // to the agent: the generic task prompt alone never told it which files conflict
-        // (or even that there were conflicts), so it would drift onto the original feature
-        // task. Lead with the conflict; keep the task only as trailing reference.
-        const conflicted = await unmergedPaths(dir, signal);
-        log.info('conflict: resolving conflicts with agent', { ...trace, conflicted });
-        const diff = await conflictDiff(dir, conflicted, signal);
-        const userPrompt = buildConflictPrompt(job.repo.baseBranch, job.branch, conflicted, diff, job.userPrompt);
-        const { summary, stats, stderrTail, usage } = await runAgentInWorkspace({
-            dir,
-            systemPrompt: job.systemPrompt,
-            userPrompt,
-            model: job.model,
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-        }, opts);
-        // Never push a half-resolved tree: if any conflict markers / unmerged paths
-        // remain, the PR would still be broken. Fail so the engine can retry / notify.
-        const unresolved = await unmergedPaths(dir, signal);
-        if (unresolved.length > 0) {
-            log.error('conflict: unresolved conflicts remain — refusing to push', {
-                ...trace,
-                unresolved: unresolved.length,
-            });
-            return {
-                resolved: false,
-                summary,
-                stats,
-                error: unresolvedReason(unresolved, stats, stderrTail),
-                ...(usage ? { usage } : {}),
-            };
-        }
-        // Complete the merge commit with the agent's resolution staged, then push.
-        await commitAll(dir, `Merge ${job.repo.baseBranch} into ${job.branch}`, signal);
-        log.info('conflict: pushing resolved branch', { ...trace, ...stats });
-        await pushBranch(dir, job.branch, job.ghToken, signal);
-        return { resolved: true, summary, stats, ...(usage ? { usage } : {}) };
-    });
-}
-/**
- * The conflict-focused user prompt: lead with the exact conflicted files and their
- * hunks (so the model acts on the real conflict, not the original feature task), then
- * carry the task only as trailing reference. The role/system prompt frames it as a
- * merge-conflict resolution; this gives it the concrete material.
- */
-function buildConflictPrompt(baseBranch, prBranch, conflicted, diff, taskReference) {
-    const fileList = conflicted.map((p) => `- ${p}`).join('\n');
-    const parts = [
-        `The base branch \`${baseBranch}\` was merged into this pull-request branch ` +
-            `\`${prBranch}\` and left Git merge conflicts in the following ${conflicted.length} ` +
-            `file(s):`,
-        '',
-        fileList,
-        '',
-        'Resolve EVERY conflict in these files: open each one, understand both sides of each ' +
-            '`<<<<<<<` / `=======` / `>>>>>>>` region, and edit it to a correct result that ' +
-            "preserves the intent of BOTH the base changes and this PR's changes — never just " +
-            'discard one side. Remove every conflict marker and leave the project building. Do ' +
-            'not create a new branch or PR; the harness completes the merge commit and pushes once ' +
-            'no conflict markers remain.',
-        '',
-        'Conflict hunks (`git diff` of the conflicted files):',
-        '',
-        '```diff',
-        diff,
-        '```',
-    ];
-    const ref = taskReference.trim();
-    if (ref) {
-        parts.push('', 'For reference, the task this pull request implements:', '', ref);
-    }
-    return parts.join('\n');
-}
-/** Human-readable reason the agent failed to fully resolve the conflicts. */
-function unresolvedReason(unresolved, stats, stderrTail) {
-    const cause = agentNeverActed(stats) ? NEVER_ACTED_CAUSE : '';
-    const sample = unresolved.slice(0, 10).join(', ');
-    return (`The agent did not resolve all merge conflicts ` +
-        `(${unresolved.length} file(s) still conflicted: ${sample}).${cause}` +
-        agentOutputTail(stderrTail));
-}

package/dist/explore.js

@@ -1,74 +0,0 @@
-import { join } from 'node:path';
-import { mkdir } from 'node:fs/promises';
-import { cloneRepo } from './git.js';
-import { agentNeverActed, agentOutputTail, runAgentInWorkspace, withWorkspace, } from './pi-workspace.js';
-import { log } from './logger.js';
-// The shared read-only container agent: clone a branch, run Pi to EXPLORE the
-// checkout (read-only), and return its prose report/proposal. Both the architect
-// (proposes a design after reading the code) and the tech-debt analysis agent use
-// this one path. Unlike the coding agents (`/run`, `/ci-fix`) it pushes nothing and
-// opens no PR, and — like the merger — it makes no edits, so an edit-free run is the
-// expected, correct outcome rather than a "no changes" failure. The only failure
-// mode is producing no text at all (the agent never reached the model).
-/** Run one read-only exploration job end to end: clone branch → Pi explores → return prose. */
-export async function handleExplore(job, opts = {}) {
-    const trace = {
-        jobId: job.jobId,
-        kind: job.label ?? 'explore',
-        repo: `${job.repo.owner}/${job.repo.name}`,
-        branch: job.branch,
-    };
-    return withWorkspace(job.label ?? 'explore', async (dir) => {
-        log.info('explore: cloning', trace);
-        await cloneRepo({
-            repo: { ...job.repo, baseBranch: job.branch },
-            ghToken: job.ghToken,
-            dir,
-            signal: opts.signal,
-        });
-        // In a monorepo the service lives in a subdirectory: run Pi with its cwd set
-        // there (created if missing, mirroring the coding agent) so a service-scoped
-        // exploration sees the right subtree.
-        const serviceDirectory = job.repo.serviceDirectory;
-        const workDir = serviceDirectory ? join(dir, serviceDirectory) : dir;
-        if (serviceDirectory)
-            await mkdir(workDir, { recursive: true });
-        log.info('explore: running agent', { ...trace, serviceDirectory });
-        const { summary, stats, stderrTail, usage } = await runAgentInWorkspace({
-            dir: workDir,
-            systemPrompt: job.systemPrompt,
-            userPrompt: job.userPrompt,
-            model: job.model,
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-            serviceDirectory,
-            // Read-only: it inspects and reports, making no edits — so the no-progress
-            // guard's no-edit bound must not fire on its legitimately edit-free run.
-            expectsEdits: false,
-            webToolsGuidance: job.webToolsGuidance,
-            webSearchProxy: job.webSearch,
-        }, opts);
-        // The prose report IS the deliverable; an edit-free run is success. The only
-        // failure is producing no text at all (the signature of never reaching the model).
-        if (!summary.trim()) {
-            return {
-                summary,
-                stats,
-                error: noOutputReason(stats, stderrTail),
-                ...(usage ? { usage } : {}),
-            };
-        }
-        log.info('explore: done', { ...trace, ...stats });
-        return { summary, stats, ...(usage ? { usage } : {}) };
-    });
-}
-/** Human-readable reason a read-only run produced no usable output. */
-function noOutputReason(stats, stderrTail) {
-    const cause = agentNeverActed(stats)
-        ? ' (the agent never acted — it most likely could not reach the model)'
-        : '';
-    return `Read-only agent produced no report${cause}.${agentOutputTail(stderrTail)}`;
-}

package/dist/fixer.js

@@ -1,44 +0,0 @@
-import { noChangesReason, runCodingAgent } from './coding-agent.js';
-// Async job execution for the test Fixer. When a Tester withholds its greenlight the
-// engine dispatches this: clone the PR HEAD branch, run Pi to fix the concerns in the
-// Tester's report (folded into the user prompt by the backend), then commit + push
-// back onto the SAME branch (no new branch, no new PR) so the Tester can re-run. The
-// engine re-dispatches the Tester after the push and loops up to the attempt budget.
-//
-// The clone/Pi/push mechanics are shared with implementation + the CI-fixer via
-// runCodingAgent; the Fixer only differs in working ON the existing PR branch.
-/** Run one Fixer job end to end: clone branch → Pi fixes → push (same branch). */
-export async function handleFixer(job, opts = {}) {
-    const { summary, stats, stderrTail, pushed, usage } = await runCodingAgent({
-        kind: 'fix-tests',
-        jobId: job.jobId,
-        repo: job.repo,
-        // Work directly on the PR head branch — no new branch, no new PR.
-        cloneBranch: job.branch,
-        pushBranch: job.branch,
-        ghToken: job.ghToken,
-        systemPrompt: job.systemPrompt,
-        userPrompt: job.userPrompt,
-        model: job.model,
-        harness: job.harness,
-        subscriptionToken: job.subscriptionToken,
-        subscriptionBaseUrl: job.subscriptionBaseUrl,
-        proxyBaseUrl: job.proxyBaseUrl,
-        sessionToken: job.sessionToken,
-        commitMessage: 'Fix issues found by the tester',
-        webToolsGuidance: job.webToolsGuidance,
-        webSearchProxy: job.webSearch,
-    }, opts);
-    // Not an error: the engine re-runs the Tester regardless. Report `pushed: false`
-    // so the (unused) result is still meaningful.
-    if (!pushed) {
-        return {
-            pushed: false,
-            summary,
-            stats,
-            error: noChangesReason('No test fix produced', stats, stderrTail),
-            ...(usage ? { usage } : {}),
-        };
-    }
-    return { pushed: true, summary, stats, ...(usage ? { usage } : {}) };
-}

package/dist/merger.js

@@ -1,135 +0,0 @@
-import { cloneRepo, hasDiffAgainstBase } from './git.js';
-import { extractJsonObject } from './blueprint.js';
-import { agentNeverActed, agentOutputTail, NEVER_ACTED_CAUSE, runAgentInWorkspace, withWorkspace, } from './pi-workspace.js';
-import { diagnosticsSuffix, resolveStructuredOutput, } from './structured-output.js';
-import { log } from './logger.js';
-/** Compact description of the merge-assessment shape, fed to the JSON repair call. */
-const ASSESSMENT_SHAPE_HINT = 'Expected a merge assessment: {"complexity": number 0..1, "risk": number 0..1, ' +
-    '"impact": number 0..1, "rationale": string}.';
-/** Clamp a value to a 0..1 number, defaulting to `fallback` when not finite. */
-function clamp01(value, fallback) {
-    const n = typeof value === 'number' ? value : Number(value);
-    if (!Number.isFinite(n))
-        return fallback;
-    return Math.min(1, Math.max(0, n));
-}
-/**
- * Coerce the agent's JSON into a well-formed assessment. Missing/garbage scores
- * default to a CONSERVATIVE 1 (treat as severe → routes to human review rather
- * than a silent auto-merge); the rationale falls back to the raw summary.
- */
-function coerceAssessment(raw, summary) {
-    const o = (typeof raw === 'object' && raw !== null ? raw : {});
-    return {
-        complexity: clamp01(o.complexity, 1),
-        risk: clamp01(o.risk, 1),
-        impact: clamp01(o.impact, 1),
-        rationale: typeof o.rationale === 'string' && o.rationale ? o.rationale : summary.slice(0, 2000),
-    };
-}
-/** Build the merger task prompt: assess the PR branch against the base. */
-function buildUserPrompt(job) {
-    const pr = job.prNumber !== undefined ? ` (PR #${job.prNumber})` : '';
-    return [
-        job.instructions,
-        '',
-        `The pull request${pr} is on branch \`${job.branch}\`; the base branch is ` +
-            `\`${job.repo.baseBranch}\`. Inspect the change (e.g. \`git fetch origin ${job.repo.baseBranch}\` ` +
-            `then \`git diff origin/${job.repo.baseBranch}...HEAD\`) and score complexity, risk and impact.`,
-        '',
-        'Respond with ONLY a JSON object {"complexity":0.0,"risk":0.0,"impact":0.0,"rationale":"…"}.',
-    ].join('\n');
-}
-/** Run one merger job end to end: clone branch → Pi assesses → return scores (no commit). */
-export async function handleMerger(job, opts = {}) {
-    const trace = { jobId: job.jobId, repo: `${job.repo.owner}/${job.repo.name}`, branch: job.branch };
-    return withWorkspace('merge', async (dir) => {
-        log.info('merge: cloning PR branch', trace);
-        await cloneRepo({
-            repo: { ...job.repo, baseBranch: job.branch },
-            ghToken: job.ghToken,
-            dir,
-            // Full clone: scoring the PR means diffing it against the base, which needs the
-            // base branch's remote-tracking ref (origin/<base>) AND the merge base present. A
-            // shallow single-branch clone has neither, so `git diff origin/<base>...HEAD` fails
-            // with "branch not found" and the agent is left to GUESS scores (it tends to emit
-            // 0/0/0, which then auto-merges). The full clone gives the merger a real diff.
-            full: true,
-            signal: opts.signal,
-        });
-        // Guard the auto-merge path: confirm a real diff against the base is examinable. If
-        // it is not (missing base ref / empty diff), the agent's scores can't be trusted —
-        // we force a CONSERVATIVE assessment below so the engine routes to human review
-        // rather than auto-merging on bogus low scores.
-        const diffExaminable = await hasDiffAgainstBase(dir, job.repo.baseBranch, opts.signal);
-        if (!diffExaminable) {
-            log.warn('merge: no examinable diff against base; will assess conservatively', trace);
-        }
-        log.info('merge: running agent', trace);
-        const { summary, stats, stderrTail, usage } = await runAgentInWorkspace({
-            dir,
-            systemPrompt: job.systemPrompt,
-            userPrompt: buildUserPrompt(job),
-            model: job.model,
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-            // The merger only assesses (no commits/edits), so the no-edit guard must
-            // not fire on its legitimately edit-free run.
-            expectsEdits: false,
-        }, opts);
-        // Parse the agent's assessment; on a malformed reply, make ONE structured repair
-        // call (see structured-output) before giving up. `coerceAssessment` only yields
-        // null when no JSON object could be extracted at all (it defaults conservatively
-        // otherwise), so a usable-but-vague reply still routes to human review as before.
-        const { value: assessment, diagnostics } = await resolveStructuredOutput({
-            label: 'merger',
-            shapeHint: ASSESSMENT_SHAPE_HINT,
-            parse: (text) => coerceAssessment(extractJsonObject(text), text),
-        }, summary, {
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-            model: job.model,
-            jobId: job.jobId,
-            signal: opts.signal,
-        });
-        if (!assessment) {
-            return {
-                summary,
-                stats,
-                error: noAssessmentReason(stats, stderrTail, diagnostics),
-                ...(usage ? { usage } : {}),
-            };
-        }
-        // The agent could not actually examine the change: its scores are not trustworthy
-        // (a failed diff retrieval typically yields a bogus 0/0/0 that would auto-merge).
-        // Return a CONSERVATIVE assessment (max on every axis) so the engine's threshold
-        // check fails and the PR is routed to a human merge review instead.
-        if (!diffExaminable) {
-            const conservative = {
-                complexity: 1,
-                risk: 1,
-                impact: 1,
-                rationale: `Could not examine a real diff of \`${job.branch}\` against \`${job.repo.baseBranch}\` ` +
-                    `(the base ref was missing or the diff was empty), so this PR was NOT auto-assessed ` +
-                    `and needs a human merge review.`,
-            };
-            log.info('merge: assessed conservatively (no examinable diff)', { ...trace, ...conservative });
-            return { assessment: conservative, summary, stats, ...(usage ? { usage } : {}) };
-        }
-        log.info('merge: assessed', { ...trace, ...assessment });
-        return { assessment, summary, stats, ...(usage ? { usage } : {}) };
-    });
-}
-/** Human-readable reason a merger run produced no usable assessment. */
-function noAssessmentReason(stats, stderrTail, diagnostics) {
-    const cause = agentNeverActed(stats)
-        ? NEVER_ACTED_CAUSE
-        : ' The agent did not return a parseable JSON assessment.';
-    return `Merger produced no assessment.${cause}${diagnostics ? diagnosticsSuffix(diagnostics) : ''}${agentOutputTail(stderrTail)}`;
-}

package/dist/on-call.js

@@ -1,126 +0,0 @@
-import { cloneRepo } from './git.js';
-import { extractJsonObject } from './blueprint.js';
-import { agentNeverActed, agentOutputTail, NEVER_ACTED_CAUSE, runAgentInWorkspace, withWorkspace, } from './pi-workspace.js';
-import { diagnosticsSuffix, resolveStructuredOutput, } from './structured-output.js';
-import { log } from './logger.js';
-// Async job execution for the on-call agent. The engine dispatches this when the
-// post-release-health gate detects a Datadog regression. The released PR has already
-// merged and its work branch was deleted, so we clone the BASE branch (which contains
-// the merged change), have Pi locate the merged commit (via the PR number / the
-// now-historical head branch) and correlate its diff with the regression evidence
-// (handed in via the user prompt), then return ONLY a JSON assessment of whether THIS
-// change is the likely culprit. The on-call agent makes NO commits and reverts nothing —
-// the engine raises a `release_regression` notification carrying this assessment.
-const ASSESSMENT_SHAPE_HINT = 'Expected an on-call assessment: {"culpritConfidence": number 0..1, "recommendation": ' +
-    '"revert"|"hold"|"monitor", "rationale": string, "evidence": string[]}.';
-function clamp01(value, fallback) {
-    const n = typeof value === 'number' ? value : Number(value);
-    if (!Number.isFinite(n))
-        return fallback;
-    return Math.min(1, Math.max(0, n));
-}
-function coerceRecommendation(value) {
-    return value === 'revert' || value === 'monitor' ? value : 'hold';
-}
-/**
- * Coerce the agent's JSON into a well-formed assessment. A missing confidence defaults
- * to a CONSERVATIVE 0 (don't imply the PR is at fault without evidence); a missing
- * recommendation defaults to `hold` (human decides). Returns null only when no JSON
- * object could be extracted at all.
- */
-function coerceAssessment(raw, summary) {
-    if (typeof raw !== 'object' || raw === null)
-        return null;
-    const o = raw;
-    const evidence = Array.isArray(o.evidence)
-        ? o.evidence.filter((e) => typeof e === 'string')
-        : [];
-    return {
-        culpritConfidence: clamp01(o.culpritConfidence, 0),
-        recommendation: coerceRecommendation(o.recommendation),
-        rationale: typeof o.rationale === 'string' && o.rationale ? o.rationale : summary.slice(0, 2000),
-        evidence,
-    };
-}
-function buildUserPrompt(job) {
-    const pr = job.prNumber !== undefined ? `#${job.prNumber}` : '';
-    // The PR has already merged into the base branch and its work branch was deleted, so the
-    // checkout is the base branch. Point the agent at how to find the merged commit.
-    const locate = job.prNumber
-        ? `It merged as a commit referencing ${pr} — find it with ` +
-            `\`git log --oneline -n 50\` (squash/merge commits include \`(${pr})\`; a merge commit ` +
-            `mentions \`#${job.prNumber}\`), then inspect it with \`git show <sha>\`.`
-        : job.headBranch
-            ? `Its work branch was \`${job.headBranch}\` (now deleted) — find the merged commit in ` +
-                `\`git log --oneline -n 50\` and inspect it with \`git show <sha>\`.`
-            : `Find the most recent merge/feature commit with \`git log --oneline -n 50\` and inspect ` +
-                `it with \`git show <sha>\`.`;
-    return [
-        job.userPrompt,
-        '',
-        `You are on the base branch \`${job.repo.baseBranch}\`, which already contains the released ` +
-            `pull request ${pr}. ${locate} Correlate that change with the regression evidence above. ` +
-            `Beware correlation vs causation.`,
-        '',
-        'Respond with ONLY a JSON object {"culpritConfidence":0.0,"recommendation":"revert"|"hold"|"monitor","rationale":"…","evidence":["…"]}.',
-    ].join('\n');
-}
-/** Run one on-call job: clone branch → Pi investigates → return the assessment (no commit). */
-export async function handleOnCall(job, opts = {}) {
-    const trace = { jobId: job.jobId, repo: `${job.repo.owner}/${job.repo.name}`, branch: job.branch };
-    return withWorkspace('on-call', async (dir) => {
-        log.info('on-call: cloning base branch', trace);
-        await cloneRepo({
-            repo: { ...job.repo, baseBranch: job.branch },
-            ghToken: job.ghToken,
-            dir,
-            // Full clone so the agent has the history to locate + diff the merged commit.
-            full: true,
-            signal: opts.signal,
-        });
-        log.info('on-call: running agent', trace);
-        const { summary, stats, stderrTail, usage } = await runAgentInWorkspace({
-            dir,
-            systemPrompt: job.systemPrompt,
-            userPrompt: buildUserPrompt(job),
-            model: job.model,
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-            // Investigation only — no commits/edits, so the no-edit guard must not fire.
-            expectsEdits: false,
-        }, opts);
-        const { value: assessment, diagnostics } = await resolveStructuredOutput({
-            label: 'on-call',
-            shapeHint: ASSESSMENT_SHAPE_HINT,
-            parse: (text) => coerceAssessment(extractJsonObject(text), text),
-        }, summary, {
-            harness: job.harness,
-            subscriptionToken: job.subscriptionToken,
-            subscriptionBaseUrl: job.subscriptionBaseUrl,
-            proxyBaseUrl: job.proxyBaseUrl,
-            sessionToken: job.sessionToken,
-            model: job.model,
-            jobId: job.jobId,
-            signal: opts.signal,
-        });
-        if (!assessment) {
-            return {
-                summary,
-                stats,
-                error: noAssessmentReason(stats, stderrTail, diagnostics),
-                ...(usage ? { usage } : {}),
-            };
-        }
-        log.info('on-call: assessed', { ...trace, ...assessment });
-        return { onCallAssessment: assessment, summary, stats, ...(usage ? { usage } : {}) };
-    });
-}
-function noAssessmentReason(stats, stderrTail, diagnostics) {
-    const cause = agentNeverActed(stats)
-        ? NEVER_ACTED_CAUSE
-        : ' The agent did not return a parseable JSON assessment.';
-    return `On-call produced no assessment.${cause}${diagnostics ? diagnosticsSuffix(diagnostics) : ''}${agentOutputTail(stderrTail)}`;
-}