@exaudeus/workrail 3.38.0 → 3.40.0

package/dist/coordinators/pr-review.js

@@ -0,0 +1,575 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFindingsFromNotes = parseFindingsFromNotes;
+exports.readVerdictArtifact = readVerdictArtifact;
+exports.buildFixGoal = buildFixGoal;
+exports.formatElapsed = formatElapsed;
+exports.discoverConsolePort = discoverConsolePort;
+exports.runPrReviewCoordinator = runPrReviewCoordinator;
+const result_js_1 = require("../runtime/result.js");
+const review_verdict_js_1 = require("../v2/durable-core/schemas/artifacts/review-verdict.js");
+const MAX_FIX_PASSES = 3;
+const CHILD_SESSION_TIMEOUT_MS = 15 * 60 * 1000;
+const COORDINATOR_MAX_MS = 90 * 60 * 1000;
+const COORDINATOR_SPAWN_CUTOFF_MS = COORDINATOR_MAX_MS - 20 * 60 * 1000;
+const REVIEW_AWAIT_TIMEOUT_MS = 20 * 60 * 1000;
+function parseFindingsFromNotes(notes) {
+    if (notes === null || notes.trim() === '') {
+        return (0, result_js_1.err)('notes is null or empty');
+    }
+    const jsonBlockRe = /```json\s*\n([\s\S]*?)\n```/g;
+    for (const blockMatch of notes.matchAll(jsonBlockRe)) {
+        const blockContent = blockMatch[1];
+        if (!blockContent)
+            continue;
+        try {
+            const parsed = JSON.parse(blockContent);
+            if (typeof parsed['recommendation'] === 'string' &&
+                ['clean', 'minor', 'blocking'].includes(parsed['recommendation'])) {
+                const severity = parsed['recommendation'];
+                const findings = Array.isArray(parsed['findings'])
+                    ? parsed['findings']
+                        .filter((f) => typeof f === 'object' && f !== null)
+                        .map((f) => typeof f['summary'] === 'string' ? f['summary'] : JSON.stringify(f))
+                    : [];
+                return (0, result_js_1.ok)({ severity, findingSummaries: findings, raw: notes });
+            }
+        }
+        catch {
+        }
+    }
+    const upperNotes = notes.toUpperCase();
+    const NEGATION_BLOCKING_RE = /\b(?:not|no|without)\b.{0,30}\bblocking\b/i;
+    const NEGATION_CRITICAL_RE = /\b(?:not|no|without)\b.{0,30}\bcritical\b/i;
+    const NEGATION_REQUEST_CHANGES_RE = /\b(?:not|no|without)\b.{0,30}\brequest[\s_]changes\b/i;
+    const hasBlockingKeyword = (upperNotes.includes('BLOCKING') && !NEGATION_BLOCKING_RE.test(notes)) ||
+        (upperNotes.includes('CRITICAL') && !NEGATION_CRITICAL_RE.test(notes)) ||
+        (upperNotes.includes('REQUEST CHANGES') && !NEGATION_REQUEST_CHANGES_RE.test(notes));
+    if (hasBlockingKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'blocking',
+            findingSummaries: extractFindingSummaries(notes),
+            raw: notes,
+            source: 'keyword_scan',
+        });
+    }
+    const hasCleanKeyword = upperNotes.includes('APPROVE') ||
+        upperNotes.includes('LGTM') ||
+        upperNotes.includes('NO FINDINGS') ||
+        upperNotes.includes('NO ISSUES') ||
+        /\bCLEAN\b/.test(upperNotes);
+    const hasMinorKeyword = upperNotes.includes('MINOR') ||
+        upperNotes.includes('NIT') ||
+        upperNotes.includes('NITPICK') ||
+        upperNotes.includes('SUGGESTION');
+    if (hasCleanKeyword && !hasMinorKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'clean',
+            findingSummaries: [],
+            raw: notes,
+            source: 'keyword_scan',
+        });
+    }
+    if (hasMinorKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'minor',
+            findingSummaries: extractFindingSummaries(notes),
+            raw: notes,
+            source: 'keyword_scan',
+        });
+    }
+    return (0, result_js_1.ok)({
+        severity: 'unknown',
+        findingSummaries: [],
+        raw: notes,
+        source: 'keyword_scan',
+    });
+}
+function readVerdictArtifact(artifacts, sessionHandle) {
+    const handlePrefix = sessionHandle ? sessionHandle.slice(0, 16) : 'unknown';
+    for (const raw of artifacts) {
+        if (!(0, review_verdict_js_1.isReviewVerdictArtifact)(raw))
+            continue;
+        const result = review_verdict_js_1.ReviewVerdictArtifactV1Schema.safeParse(raw);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((i) => `${i.path.join('.')}: ${i.message}`)
+                .join('; ');
+            process.stderr.write(`[WARN coord:reason=artifact_parse_failed handle=${handlePrefix}] readVerdictArtifact: wr.review_verdict schema validation failed: ${issues}\n`);
+            continue;
+        }
+        const v = result.data;
+        return {
+            severity: v.verdict,
+            findingSummaries: v.findings.map((f) => f.summary),
+            raw: JSON.stringify(v),
+            source: 'artifact',
+        };
+    }
+    return null;
+}
+function extractFindingSummaries(notes) {
+    const summaries = [];
+    const lines = notes.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^[-*]\s+.{10,}/.test(trimmed) || /^\d+\.\s+.{10,}/.test(trimmed)) {
+            const upper = trimmed.toUpperCase();
+            if (upper.includes('RECOMMEND') ||
+                upper.includes('CONFIDENCE') ||
+                upper.includes('COVERAGE') ||
+                upper.includes('SUMMARY')) {
+                continue;
+            }
+            const summary = trimmed.replace(/^[-*]\s+/, '').replace(/^\d+\.\s+/, '');
+            summaries.push(summary.slice(0, 120));
+            if (summaries.length >= 5)
+                break;
+        }
+    }
+    return summaries;
+}
+function buildFixGoal(prNumber, findings) {
+    const findingList = findings.findingSummaries.length > 0
+        ? ': ' + findings.findingSummaries.slice(0, 3).join('; ')
+        : '';
+    return `Fix review findings in PR #${prNumber}${findingList}`;
+}
+function formatElapsed(ms) {
+    const totalSeconds = Math.round(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+}
+const LOCK_FILE_NAMES = ['daemon-console.lock', 'dashboard.lock'];
+const DEFAULT_CONSOLE_PORT = 3456;
+async function discoverConsolePort(deps, portOverride) {
+    if (portOverride !== undefined && portOverride > 0) {
+        return portOverride;
+    }
+    for (const lockFileName of LOCK_FILE_NAMES) {
+        const lockPath = deps.joinPath(deps.homedir(), '.workrail', lockFileName);
+        try {
+            const raw = await deps.readFile(lockPath);
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.port === 'number' && parsed.port > 0) {
+                return parsed.port;
+            }
+        }
+        catch {
+        }
+    }
+    return DEFAULT_CONSOLE_PORT;
+}
+async function runPrReviewCoordinator(deps, opts) {
+    const coordinatorStartMs = deps.now();
+    const today = new Date(deps.now()).toISOString().slice(0, 10);
+    const reportPath = opts.workspace + `/coordinator-pr-review-${today}.md`;
+    const reportLines = [];
+    function log(line) {
+        deps.stderr(line);
+        reportLines.push(line);
+    }
+    log('[1/3] Gathering open PRs...');
+    const stageStart = deps.now();
+    let prs;
+    if (opts.prs && opts.prs.length > 0) {
+        prs = opts.prs.map((n) => ({ number: n, title: `PR #${n}`, headRef: '' }));
+    }
+    else if (opts.dryRun) {
+        prs = [];
+        log('  [dry-run] would call gh pr list');
+    }
+    else {
+        prs = await deps.listOpenPRs(opts.workspace);
+    }
+    log(`  done (${formatElapsed(deps.now() - stageStart)}) -- ${prs.length} PR(s) found`);
+    if (prs.length === 0) {
+        const result = {
+            reviewed: 0,
+            approved: 0,
+            escalated: 0,
+            mergedPrs: [],
+            reportPath,
+            hasErrors: false,
+        };
+        await writeReport(deps, reportPath, reportLines, result);
+        return result;
+    }
+    log(`[2/3] Running reviews (${prs.length} parallel)...`);
+    const reviewStart = deps.now();
+    if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+        log('  WARNING: coordinator elapsed > 70 minutes, refusing to spawn new sessions');
+        const result = {
+            reviewed: 0,
+            approved: 0,
+            escalated: prs.length,
+            mergedPrs: [],
+            reportPath,
+            hasErrors: true,
+        };
+        await writeReport(deps, reportPath, reportLines, result);
+        return result;
+    }
+    const reviewHandles = new Map();
+    const spawnErrors = new Map();
+    for (const pr of prs) {
+        const goal = `Review PR #${pr.number} "${pr.title}" before merge`;
+        if (opts.dryRun) {
+            log(`      PR #${pr.number} [dry-run] would spawn mr-review-workflow-agentic`);
+            continue;
+        }
+        const spawnResult = await deps.spawnSession('mr-review-workflow-agentic', goal, opts.workspace);
+        if (spawnResult.kind === 'err') {
+            spawnErrors.set(pr.number, spawnResult.error);
+            log(`      PR #${pr.number} spawn failed: ${spawnResult.error}`);
+        }
+        else {
+            const handle = spawnResult.value;
+            if (!handle) {
+                spawnErrors.set(pr.number, 'spawn returned empty session handle (zombie detection)');
+                log(`      PR #${pr.number} spawn returned empty handle -- zombie detection triggered`);
+            }
+            else {
+                reviewHandles.set(pr.number, handle);
+            }
+        }
+    }
+    const outcomes = new Map();
+    if (!opts.dryRun && reviewHandles.size > 0) {
+        const awaitResult = await deps.awaitSessions([...reviewHandles.values()], REVIEW_AWAIT_TIMEOUT_MS);
+        const handleToPr = new Map();
+        for (const [prNum, handle] of reviewHandles) {
+            handleToPr.set(handle, prNum);
+        }
+        for (const sessionResult of awaitResult.results) {
+            const prNum = handleToPr.get(sessionResult.handle);
+            if (prNum === undefined)
+                continue;
+            const elapsedMs = sessionResult.durationMs;
+            const handle = sessionResult.handle;
+            let notes = null;
+            let artifacts = [];
+            if (sessionResult.outcome === 'success') {
+                const agentResult = await deps.getAgentResult(handle);
+                notes = agentResult.recapMarkdown;
+                artifacts = agentResult.artifacts;
+            }
+            const verdictFromArtifact = readVerdictArtifact(artifacts, handle);
+            const findingsResult = verdictFromArtifact !== null
+                ? (() => {
+                    deps.stderr(`[INFO coord:source=artifact handle=${handle.slice(0, 16)}] readVerdictArtifact succeeded`);
+                    return (0, result_js_1.ok)(verdictFromArtifact);
+                })()
+                : (() => {
+                    const keywordResult = parseFindingsFromNotes(notes);
+                    if (keywordResult.kind === 'ok') {
+                        const reason = artifacts.length > 0 ? 'no_valid_artifact' : 'no_artifacts';
+                        deps.stderr(`[INFO coord:source=keyword_scan reason=${reason} artifactCount=${artifacts.length} handle=${handle.slice(0, 16)}]`);
+                    }
+                    return keywordResult;
+                })();
+            const severity = findingsResult.kind === 'ok'
+                ? findingsResult.value.severity
+                : 'unknown';
+            const traceBlock = JSON.stringify({
+                childSessionId: handle,
+                outcome: sessionResult.outcome,
+                elapsedMs,
+                severity,
+            });
+            deps.stderr(`[TRACE] ${traceBlock}`);
+            reportLines.push(`\n<!-- TRACE: ${traceBlock} -->`);
+            const pr = prs.find((p) => p.number === prNum);
+            const severityLabel = severity.toUpperCase();
+            log(`      PR #${pr.number} ${pr.title}    done (${formatElapsed(elapsedMs)})  ${severityLabel}`);
+            const findings = findingsResult.kind === 'ok' ? findingsResult.value : null;
+            const outcome = {
+                prNumber: prNum,
+                severity,
+                merged: false,
+                escalated: sessionResult.outcome !== 'success' || severity === 'blocking' || severity === 'unknown',
+                escalationReason: sessionResult.outcome !== 'success'
+                    ? `session ${sessionResult.outcome}`
+                    : severity === 'blocking' || severity === 'unknown'
+                        ? `severity: ${severity}`
+                        : null,
+                passCount: 0,
+                sessionHandles: [handle],
+            };
+            if (severity === 'minor' && findings && sessionResult.outcome === 'success') {
+                const processedOutcome = await runFixAgentLoop(deps, opts, pr, findings, outcome, coordinatorStartMs, log);
+                outcomes.set(prNum, processedOutcome);
+            }
+            else {
+                outcomes.set(prNum, outcome);
+            }
+        }
+    }
+    for (const [prNum, errorMsg] of spawnErrors) {
+        outcomes.set(prNum, {
+            prNumber: prNum,
+            severity: 'unknown',
+            merged: false,
+            escalated: true,
+            escalationReason: `spawn error: ${errorMsg}`,
+            passCount: 0,
+            sessionHandles: [],
+        });
+    }
+    log('[3/3] Processing results...');
+    const mergeQueue = [];
+    const escalated = [];
+    for (const outcome of outcomes.values()) {
+        if (!outcome.escalated && outcome.severity === 'clean') {
+            mergeQueue.push(outcome.prNumber);
+            log(`      PR #${outcome.prNumber}  ->  queued for merge`);
+        }
+        else {
+            escalated.push(outcome);
+            const reason = outcome.escalationReason ?? outcome.severity;
+            log(`      PR #${outcome.prNumber}  ->  escalated (${reason})`);
+        }
+    }
+    const mergedPrs = [];
+    for (const prNum of mergeQueue) {
+        if (opts.dryRun) {
+            log(`      PR #${prNum}  ->  [dry-run] would merge`);
+            mergedPrs.push(prNum);
+            continue;
+        }
+        const mergeResult = await deps.mergePR(prNum, opts.workspace);
+        if (mergeResult.kind === 'ok') {
+            mergedPrs.push(prNum);
+            log(`      PR #${prNum}  ->  merged`);
+        }
+        else {
+            log(`      PR #${prNum}  ->  merge failed: ${mergeResult.error} (escalated)`);
+            escalated.push({
+                prNumber: prNum,
+                severity: 'clean',
+                merged: false,
+                escalated: true,
+                escalationReason: `merge failed: ${mergeResult.error}`,
+                passCount: 0,
+                sessionHandles: [],
+            });
+        }
+    }
+    const result = {
+        reviewed: outcomes.size - spawnErrors.size,
+        approved: mergedPrs.length,
+        escalated: escalated.length,
+        mergedPrs,
+        reportPath,
+        hasErrors: spawnErrors.size > 0 || escalated.some((o) => o.escalationReason?.startsWith('spawn error') || o.escalationReason?.startsWith('session ') === true),
+    };
+    const mergedStr = mergedPrs.length > 0 ? `PR #${mergedPrs.join(', PR #')}` : 'none';
+    log('');
+    log(`RESULT: ${result.reviewed} PRs reviewed, ${result.approved} approved, ${result.escalated} escalated`);
+    log(`Merged: ${mergedStr}`);
+    log(`Full report: ${reportPath}`);
+    log(`\nTotal time: ${formatElapsed(deps.now() - reviewStart)}`);
+    await writeReport(deps, reportPath, reportLines, result);
+    return result;
+}
+async function runFixAgentLoop(deps, opts, pr, initialFindings, initialOutcome, coordinatorStartMs, log) {
+    let passCount = 0;
+    let currentFindings = initialFindings;
+    let sessionHandles = [...initialOutcome.sessionHandles];
+    while (passCount < MAX_FIX_PASSES) {
+        if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+            log(`      PR #${pr.number}  ->  coordinator elapsed > 70 minutes, escalating`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: 'coordinator elapsed > 70 minutes',
+            };
+        }
+        passCount++;
+        const fixGoal = buildFixGoal(pr.number, currentFindings);
+        if (opts.dryRun) {
+            log(`      PR #${pr.number}  ->  [dry-run] would spawn fix agent (pass ${passCount}): ${fixGoal}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                severity: 'clean',
+                merged: false,
+                escalated: false,
+                escalationReason: null,
+            };
+        }
+        log(`      PR #${pr.number}  ->  spawning fix agent (pass ${passCount})...`);
+        const fixSpawnResult = await deps.spawnSession('coding-task-workflow-agentic', fixGoal, opts.workspace);
+        if (fixSpawnResult.kind === 'err') {
+            log(`      PR #${pr.number}  ->  fix agent spawn failed: ${fixSpawnResult.error}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent spawn error (pass ${passCount}): ${fixSpawnResult.error}`,
+            };
+        }
+        const fixHandle = fixSpawnResult.value;
+        if (!fixHandle) {
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent returned empty handle (zombie, pass ${passCount})`,
+            };
+        }
+        sessionHandles = [...sessionHandles, fixHandle];
+        const fixAwait = await deps.awaitSessions([fixHandle], CHILD_SESSION_TIMEOUT_MS);
+        const fixResult = fixAwait.results[0];
+        if (!fixResult || fixResult.outcome !== 'success') {
+            const outcome = fixResult?.outcome ?? 'not_found';
+            log(`      PR #${pr.number}  ->  fix agent ${outcome} (pass ${passCount})`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent ${outcome} (pass ${passCount})`,
+            };
+        }
+        log(`      PR #${pr.number}  ->  fix done (pass ${passCount}), re-reviewing...`);
+        if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+            log(`      PR #${pr.number}  ->  coordinator elapsed > 70 minutes, skipping re-review spawn`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: 'coordinator elapsed > 70 minutes (re-review cutoff)',
+            };
+        }
+        const reReviewGoal = `Re-review PR #${pr.number} after fixes (pass ${passCount})`;
+        const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', reReviewGoal, opts.workspace);
+        if (reReviewSpawnResult.kind === 'err') {
+            log(`      PR #${pr.number}  ->  re-review spawn failed: ${reReviewSpawnResult.error}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review spawn error (pass ${passCount}): ${reReviewSpawnResult.error}`,
+            };
+        }
+        const reReviewHandle = reReviewSpawnResult.value;
+        if (!reReviewHandle) {
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review returned empty handle (zombie, pass ${passCount})`,
+            };
+        }
+        sessionHandles = [...sessionHandles, reReviewHandle];
+        const reReviewAwait = await deps.awaitSessions([reReviewHandle], REVIEW_AWAIT_TIMEOUT_MS);
+        const reReviewResult = reReviewAwait.results[0];
+        if (!reReviewResult || reReviewResult.outcome !== 'success') {
+            const outcome = reReviewResult?.outcome ?? 'not_found';
+            log(`      PR #${pr.number}  ->  re-review ${outcome} (pass ${passCount})`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review ${outcome} (pass ${passCount})`,
+            };
+        }
+        const reAgentResult = await deps.getAgentResult(reReviewHandle);
+        const reVerdictFromArtifact = readVerdictArtifact(reAgentResult.artifacts, reReviewHandle);
+        const reFindingsResult = reVerdictFromArtifact !== null
+            ? (() => {
+                deps.stderr(`[INFO coord:source=artifact handle=${reReviewHandle.slice(0, 16)}] readVerdictArtifact succeeded (re-review pass ${passCount})`);
+                return (0, result_js_1.ok)(reVerdictFromArtifact);
+            })()
+            : (() => {
+                const reason = reAgentResult.artifacts.length > 0 ? 'no_valid_artifact' : 'no_artifacts';
+                deps.stderr(`[INFO coord:source=keyword_scan reason=${reason} artifactCount=${reAgentResult.artifacts.length} handle=${reReviewHandle.slice(0, 16)}]`);
+                return parseFindingsFromNotes(reAgentResult.recapMarkdown);
+            })();
+        const reSeverity = reFindingsResult.kind === 'ok'
+            ? reFindingsResult.value.severity
+            : 'unknown';
+        const traceBlock = JSON.stringify({
+            childSessionId: reReviewHandle,
+            outcome: reReviewResult.outcome,
+            elapsedMs: reReviewResult.durationMs,
+            severity: reSeverity,
+        });
+        deps.stderr(`[TRACE] ${traceBlock}`);
+        log(`      PR #${pr.number}  ->  re-review result: ${reSeverity.toUpperCase()} (pass ${passCount})`);
+        if (reSeverity === 'clean') {
+            return {
+                prNumber: pr.number,
+                severity: 'clean',
+                merged: false,
+                escalated: false,
+                escalationReason: null,
+                passCount,
+                sessionHandles,
+            };
+        }
+        if (reSeverity === 'blocking' || reSeverity === 'unknown') {
+            return {
+                prNumber: pr.number,
+                severity: reSeverity,
+                merged: false,
+                escalated: true,
+                escalationReason: `severity: ${reSeverity} after fix (pass ${passCount})`,
+                passCount,
+                sessionHandles,
+            };
+        }
+        currentFindings = reFindingsResult.kind === 'ok'
+            ? reFindingsResult.value
+            : { severity: 'minor', findingSummaries: [], raw: reAgentResult.recapMarkdown ?? '' };
+    }
+    log(`      PR #${pr.number}  ->  ${MAX_FIX_PASSES} fix passes exhausted, escalating`);
+    return {
+        prNumber: pr.number,
+        severity: 'minor',
+        merged: false,
+        escalated: true,
+        escalationReason: `${MAX_FIX_PASSES} fix passes exhausted`,
+        passCount: MAX_FIX_PASSES,
+        sessionHandles,
+    };
+}
+async function writeReport(deps, reportPath, logLines, result) {
+    const today = new Date(deps.now()).toISOString().slice(0, 19).replace('T', ' ');
+    const content = [
+        `# PR Review Coordinator Report`,
+        ``,
+        `Generated: ${today}`,
+        ``,
+        `## Summary`,
+        ``,
+        `- PRs reviewed: ${result.reviewed}`,
+        `- Approved and merged: ${result.approved}`,
+        `- Escalated: ${result.escalated}`,
+        result.mergedPrs.length > 0 ? `- Merged PRs: ${result.mergedPrs.map((n) => `#${n}`).join(', ')}` : `- Merged PRs: none`,
+        ``,
+        `## Run Log`,
+        ``,
+        `\`\`\``,
+        ...logLines,
+        `\`\`\``,
+        ``,
+    ].join('\n');
+    try {
+        await deps.writeFile(reportPath, content);
+    }
+    catch {
+        deps.stderr(`Warning: could not write report to ${reportPath}`);
+    }
+}

package/dist/daemon/workflow-runner.d.ts

@@ -29,6 +29,7 @@ export interface WorkflowRunSuccess {
     readonly workflowId: string;
     readonly stopReason: string;
     readonly lastStepNotes?: string;
+    readonly lastStepArtifacts?: readonly unknown[];
 }
 export interface WorkflowRunError {
     readonly _tag: 'error';
@@ -64,8 +65,8 @@ export declare function readDaemonSessionState(sessionId: string): Promise<{
 } | null>;
 export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
 export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
-export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeCompleteStepTool(sessionId: string, ctx: V2ToolContext, getCurrentToken: () => string, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, onTokenUpdate: (t: string) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeCompleteStepTool(sessionId: string, ctx: V2ToolContext, getCurrentToken: () => string, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, onTokenUpdate: (t: string) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
 export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
 export declare function makeSpawnAgentTool(sessionId: string, ctx: V2ToolContext, apiKey: string, thisWorkrailSessionId: string, currentDepth: number, maxDepth: number, runWorkflowFn: typeof runWorkflow, schemas: Record<string, any>, emitter?: DaemonEventEmitter): AgentTool;
 export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, issuesDirOverride?: string, onIssueSummary?: (summary: string) => void): AgentTool;

package/dist/daemon/workflow-runner.js

@@ -479,7 +479,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
                 };
             }
             if (out.isComplete) {
-                onComplete(params.notesMarkdown);
+                onComplete(params.notesMarkdown, Array.isArray(params.artifacts) ? params.artifacts : undefined);
                 return {
                     content: [{ type: 'text', text: 'Workflow complete. All steps have been executed.' }],
                     details: out,
@@ -581,7 +581,7 @@ function makeCompleteStepTool(sessionId, ctx, getCurrentToken, onAdvance, onComp
                 };
             }
             if (out.isComplete) {
-                onComplete(notes);
+                onComplete(notes, Array.isArray(params.artifacts) ? params.artifacts : undefined);
                 return {
                     content: [{ type: 'text', text: JSON.stringify({ status: 'complete' }) }],
                     details: out,
@@ -1004,6 +1004,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     let isComplete = false;
     let pendingSteerText = null;
     let lastStepNotes;
+    let lastStepArtifacts;
     let stepAdvanceCount = 0;
     const lastNToolCalls = [];
     const STUCK_REPEAT_THRESHOLD = 3;
@@ -1017,9 +1018,10 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
             daemonRegistry?.heartbeat(workrailSessionId);
         emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(workrailSessionId) });
     };
-    const onComplete = (notes) => {
+    const onComplete = (notes, artifacts) => {
         isComplete = true;
         lastStepNotes = notes;
+        lastStepArtifacts = artifacts;
     };
     let firstStep;
     if (trigger._preAllocatedStartResponse !== undefined) {
@@ -1286,5 +1288,6 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         workflowId: trigger.workflowId,
         stopReason,
         ...(lastStepNotes !== undefined ? { lastStepNotes } : {}),
+        ...(lastStepArtifacts !== undefined ? { lastStepArtifacts } : {}),
     };
 }