@exaudeus/workrail 3.44.0 → 3.46.0

package/dist/coordinators/adaptive-pipeline.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COORDINATOR_MAX_MS = exports.COORDINATOR_SPAWN_CUTOFF_MS = exports.REVIEW_TIMEOUT_MS = exports.CODING_TIMEOUT_MS = exports.SHAPING_TIMEOUT_MS = exports.DISCOVERY_TIMEOUT_MS = void 0;
+exports.checkSpawnCutoff = checkSpawnCutoff;
+exports.runAdaptivePipeline = runAdaptivePipeline;
+const route_task_js_1 = require("./routing/route-task.js");
+exports.DISCOVERY_TIMEOUT_MS = 35 * 60 * 1000;
+exports.SHAPING_TIMEOUT_MS = 35 * 60 * 1000;
+exports.CODING_TIMEOUT_MS = 65 * 60 * 1000;
+exports.REVIEW_TIMEOUT_MS = 25 * 60 * 1000;
+exports.COORDINATOR_SPAWN_CUTOFF_MS = 100 * 60 * 1000;
+exports.COORDINATOR_MAX_MS = 120 * 60 * 1000;
+function checkSpawnCutoff(coordinatorStartMs, now, phase) {
+    if (now - coordinatorStartMs > exports.COORDINATOR_SPAWN_CUTOFF_MS) {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase,
+                reason: `coordinator elapsed > ${exports.COORDINATOR_SPAWN_CUTOFF_MS / 60000} minutes, refusing new spawns`,
+            },
+        };
+    }
+    return null;
+}
+async function runAdaptivePipeline(deps, opts, executors) {
+    const coordinatorStartMs = deps.now();
+    const triggerProvider = opts.taskCandidate !== undefined
+        ? 'github_prs_poll'
+        : opts.triggerProvider;
+    let pipelineMode;
+    if (opts.modeOverride) {
+        pipelineMode = buildModeFromOverride(opts.modeOverride, opts.goal, opts.workspace);
+    }
+    else {
+        pipelineMode = (0, route_task_js_1.routeTask)(opts.goal, opts.workspace, deps, triggerProvider);
+    }
+    const logEntry = {
+        timestamp: deps.nowIso(),
+        mode: pipelineMode.kind,
+        goal: opts.goal,
+        workspace: opts.workspace,
+        signals: {
+            depBumpKeyword: hasDepBumpKeyword(opts.goal),
+            prReference: hasPrReference(opts.goal),
+            pitchFilePresent: pipelineMode.kind === 'IMPLEMENT',
+            githubPrsPollProvider: triggerProvider === 'github_prs_poll',
+            modeOverride: opts.modeOverride ?? null,
+        },
+    };
+    const runsDir = opts.workspace + '/.workrail/pipeline-runs';
+    const logPath = runsDir + '/' + deps.nowIso().replace(/[:.]/g, '-') + '-' + pipelineMode.kind + '.json';
+    try {
+        await deps.mkdir(runsDir, { recursive: true });
+        await deps.writeFile(logPath, JSON.stringify(logEntry, null, 2) + '\n');
+    }
+    catch (e) {
+        deps.stderr(`[WARN adaptive-pipeline] Failed to write routing log: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    deps.stderr(`[adaptive-pipeline] Routing: mode=${pipelineMode.kind} goal="${opts.goal.slice(0, 80)}"`);
+    if (opts.dryRun) {
+        deps.stderr(`[adaptive-pipeline] Dry run: would execute ${pipelineMode.kind} pipeline`);
+        return { kind: 'dry_run', mode: pipelineMode.kind };
+    }
+    switch (pipelineMode.kind) {
+        case 'QUICK_REVIEW':
+            return executors.runQuickReview(deps, opts, pipelineMode.prNumbers, coordinatorStartMs);
+        case 'REVIEW_ONLY':
+            return executors.runReviewOnly(deps, opts, pipelineMode.prNumbers, coordinatorStartMs);
+        case 'IMPLEMENT':
+            return executors.runImplement(deps, opts, pipelineMode.pitchPath, coordinatorStartMs);
+        case 'FULL':
+            return executors.runFull(deps, opts, coordinatorStartMs);
+        case 'ESCALATE': {
+            const reason = pipelineMode.reason;
+            deps.stderr(`[adaptive-pipeline] Routing escalation: ${reason}`);
+            await deps.postToOutbox(`Adaptive pipeline escalated during routing: ${reason}`, { goal: opts.goal, workspace: opts.workspace, phase: 'routing' });
+            return {
+                kind: 'escalated',
+                escalationReason: { phase: 'routing', reason },
+            };
+        }
+    }
+}
+function buildModeFromOverride(override, goal, workspace) {
+    const prNumbers = (0, route_task_js_1.extractPrNumbers)(goal);
+    const pitchPath = workspace + '/.workrail/current-pitch.md';
+    switch (override) {
+        case 'QUICK_REVIEW':
+            return { kind: 'QUICK_REVIEW', prNumbers };
+        case 'REVIEW_ONLY':
+            return { kind: 'REVIEW_ONLY', prNumbers };
+        case 'IMPLEMENT':
+            return { kind: 'IMPLEMENT', pitchPath };
+        case 'FULL':
+            return { kind: 'FULL', goal };
+    }
+}
+function hasDepBumpKeyword(goal) {
+    const lower = goal.toLowerCase();
+    return ['bump', 'chore:', 'dependabot', 'dependency upgrade'].some((kw) => lower.includes(kw));
+}
+function hasPrReference(goal) {
+    return /\bPR\s*#\d+\b/i.test(goal) || /\bMR\s*!?\d+\b/i.test(goal);
+}

package/dist/coordinators/modes/full-pipeline.d.ts

@@ -0,0 +1,4 @@
+import type { AdaptiveCoordinatorDeps, AdaptivePipelineOpts, PipelineOutcome } from '../adaptive-pipeline.js';
+import { type DiscoveryHandoffArtifactV1 } from '../../v2/durable-core/schemas/artifacts/discovery-handoff.js';
+export declare function renderHandoff(artifact: DiscoveryHandoffArtifactV1): string;
+export declare function runFullPipeline(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, coordinatorStartMs: number): Promise<PipelineOutcome>;

package/dist/coordinators/modes/full-pipeline.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHandoff = renderHandoff;
+exports.runFullPipeline = runFullPipeline;
+const adaptive_pipeline_js_1 = require("../adaptive-pipeline.js");
+const discovery_handoff_js_1 = require("../../v2/durable-core/schemas/artifacts/discovery-handoff.js");
+const implement_shared_js_1 = require("./implement-shared.js");
+const implement_js_1 = require("./implement.js");
+const PR_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const UX_GATE_ACK_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+const MIN_NOTES_LENGTH_FOR_FALLBACK = 50;
+function renderHandoff(artifact) {
+    const lines = [
+        `## Discovery Handoff`,
+        ``,
+        `**Selected Direction:** ${artifact.selectedDirection}`,
+        `**Confidence:** ${artifact.confidenceBand}`,
+    ];
+    if (artifact.designDocPath) {
+        lines.push(`**Design Doc:** ${artifact.designDocPath}`);
+    }
+    if (artifact.keyInvariants.length > 0) {
+        lines.push(``, `**Key Invariants:**`);
+        for (const invariant of artifact.keyInvariants) {
+            lines.push(`- ${invariant}`);
+        }
+    }
+    return lines.join('\n');
+}
+function readDiscoveryHandoffArtifact(artifacts, sessionHandle, stderrFn) {
+    const handlePrefix = sessionHandle.slice(0, 16);
+    for (const raw of artifacts) {
+        if (!(0, discovery_handoff_js_1.isDiscoveryHandoffArtifact)(raw))
+            continue;
+        const result = discovery_handoff_js_1.DiscoveryHandoffArtifactV1Schema.safeParse(raw);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((i) => `${i.path.join('.')}: ${i.message}`)
+                .join('; ');
+            stderrFn(`[WARN full-pipeline handle=${handlePrefix}] discovery handoff schema validation failed: ${issues}`);
+            continue;
+        }
+        return result.data;
+    }
+    return null;
+}
+async function runFullPipeline(deps, opts, coordinatorStartMs) {
+    deps.stderr(`[full-pipeline] Starting FULL pipeline for workspace=${opts.workspace}`);
+    const pitchPath = opts.workspace + '/.workrail/current-pitch.md';
+    const archiveDir = opts.workspace + '/.workrail/used-pitches';
+    const archiveTimestamp = deps.nowIso().replace(/[:.]/g, '-');
+    const archivePath = archiveDir + '/pitch-' + archiveTimestamp + '.md';
+    let outcome;
+    try {
+        outcome = await runFullPipelineCore(deps, opts, coordinatorStartMs);
+    }
+    finally {
+        try {
+            await deps.mkdir(archiveDir, { recursive: true });
+            await deps.archiveFile(pitchPath, archivePath);
+            deps.stderr(`[full-pipeline] Pitch archived to ${archivePath}`);
+        }
+        catch (e) {
+            deps.stderr(`[WARN full-pipeline] Failed to archive pitch.md: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return outcome;
+}
+async function runFullPipelineCore(deps, opts, coordinatorStartMs) {
+    const discoveryCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'discovery');
+    if (discoveryCutoff)
+        return discoveryCutoff;
+    deps.stderr(`[full-pipeline] Spawning wr.discovery session`);
+    const discoverySpawnResult = await deps.spawnSession('wr.discovery', opts.goal, opts.workspace);
+    if (discoverySpawnResult.kind === 'err') {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'discovery',
+                reason: `discovery session spawn failed: ${discoverySpawnResult.error}`,
+            },
+        };
+    }
+    const discoveryHandle = discoverySpawnResult.value;
+    if (!discoveryHandle) {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'discovery', reason: 'discovery session returned empty handle' },
+        };
+    }
+    const discoveryAwait = await deps.awaitSessions([discoveryHandle], adaptive_pipeline_js_1.DISCOVERY_TIMEOUT_MS);
+    const discoveryResult = discoveryAwait.results[0];
+    if (!discoveryResult || discoveryResult.outcome !== 'success') {
+        const outcome = discoveryResult?.outcome ?? 'not_found';
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'discovery', reason: `discovery session ${outcome}` },
+        };
+    }
+    deps.stderr(`[full-pipeline] Discovery session completed`);
+    const discoveryAgentResult = await deps.getAgentResult(discoveryHandle);
+    const handoffArtifact = readDiscoveryHandoffArtifact(discoveryAgentResult.artifacts, discoveryHandle, deps.stderr);
+    let shapingContext;
+    if (handoffArtifact !== null) {
+        deps.stderr(`[full-pipeline] Discovery handoff artifact found -- injecting structured context`);
+        shapingContext = {
+            selectedDirection: handoffArtifact.selectedDirection,
+            designDocPath: handoffArtifact.designDocPath,
+            assembledContextSummary: renderHandoff(handoffArtifact),
+        };
+    }
+    else {
+        const notes = discoveryAgentResult.recapMarkdown;
+        if (notes !== null && notes.trim().length > MIN_NOTES_LENGTH_FOR_FALLBACK) {
+            deps.stderr(`[full-pipeline] No handoff artifact -- using lastStepNotes as context (length=${notes.trim().length})`);
+            shapingContext = { assembledContextSummary: notes.trim() };
+        }
+        else {
+            const reason = notes === null ? 'null' : `length=${notes.trim().length} <= ${MIN_NOTES_LENGTH_FOR_FALLBACK}`;
+            deps.stderr(`[full-pipeline] No handoff artifact and notes too short (${reason}) -- proceeding without context`);
+            shapingContext = {};
+        }
+    }
+    const shapingCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'shaping');
+    if (shapingCutoff)
+        return shapingCutoff;
+    deps.stderr(`[full-pipeline] Spawning wr.shaping session`);
+    const shapingSpawnResult = await deps.spawnSession('wr.shaping', opts.goal, opts.workspace, shapingContext);
+    if (shapingSpawnResult.kind === 'err') {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'shaping',
+                reason: `shaping session spawn failed: ${shapingSpawnResult.error}`,
+            },
+        };
+    }
+    const shapingHandle = shapingSpawnResult.value;
+    if (!shapingHandle) {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'shaping', reason: 'shaping session returned empty handle' },
+        };
+    }
+    const shapingAwait = await deps.awaitSessions([shapingHandle], adaptive_pipeline_js_1.SHAPING_TIMEOUT_MS);
+    const shapingResult = shapingAwait.results[0];
+    if (!shapingResult || shapingResult.outcome !== 'success') {
+        const outcome = shapingResult?.outcome ?? 'not_found';
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'shaping', reason: `shaping session ${outcome}` },
+        };
+    }
+    deps.stderr(`[full-pipeline] Shaping session completed`);
+    if ((0, implement_js_1.touchesUI)(opts.goal)) {
+        deps.stderr(`[full-pipeline] UX signals detected -- dispatching ui-ux-design-workflow`);
+        const uxCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'ux-gate');
+        if (uxCutoff)
+            return uxCutoff;
+        const uxSpawnResult = await deps.spawnSession('ui-ux-design-workflow', opts.goal, opts.workspace, { shapingComplete: true });
+        if (uxSpawnResult.kind === 'err') {
+            return {
+                kind: 'escalated',
+                escalationReason: {
+                    phase: 'ux-gate',
+                    reason: `UX design workflow spawn failed: ${uxSpawnResult.error}`,
+                },
+            };
+        }
+        const uxHandle = uxSpawnResult.value;
+        if (!uxHandle) {
+            return {
+                kind: 'escalated',
+                escalationReason: { phase: 'ux-gate', reason: 'UX design session returned empty handle' },
+            };
+        }
+        const uxAwait = await deps.awaitSessions([uxHandle], adaptive_pipeline_js_1.REVIEW_TIMEOUT_MS);
+        const uxResult = uxAwait.results[0];
+        if (!uxResult || uxResult.outcome !== 'success') {
+            const outcome = uxResult?.outcome ?? 'not_found';
+            return {
+                kind: 'escalated',
+                escalationReason: { phase: 'ux-gate', reason: `UX design session ${outcome}` },
+            };
+        }
+        deps.stderr(`[full-pipeline] UX design session completed -- requesting human acknowledgment`);
+        const ackRequestId = deps.generateId();
+        await deps.postToOutbox(`UX design complete for "${opts.goal}" -- please review and acknowledge before coding starts`, {
+            requestId: ackRequestId,
+            goal: opts.goal,
+            workspace: opts.workspace,
+            phase: 'ux-gate',
+            uxSessionHandle: uxHandle,
+            note: 'Acknowledge this message to allow coding to begin. No response in 24h = escalation.',
+        });
+        const ackResult = await deps.pollOutboxAck(ackRequestId, UX_GATE_ACK_TIMEOUT_MS);
+        if (ackResult === 'timeout') {
+            await deps.postToOutbox(`UX gate timed out: no acknowledgment received within 24 hours for "${opts.goal}"`, { requestId: ackRequestId, goal: opts.goal, phase: 'ux-gate-timeout' });
+            return {
+                kind: 'escalated',
+                escalationReason: {
+                    phase: 'ux-gate',
+                    reason: 'no human acknowledgment received within 24 hours',
+                },
+            };
+        }
+        deps.stderr(`[full-pipeline] UX gate acknowledged -- proceeding to coding`);
+    }
+    const codingCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'coding');
+    if (codingCutoff)
+        return codingCutoff;
+    deps.stderr(`[full-pipeline] Spawning coding-task-workflow-agentic`);
+    const codingSpawnResult = await deps.spawnSession('coding-task-workflow-agentic', opts.goal, opts.workspace, {
+        pitchPath: opts.workspace + '/.workrail/current-pitch.md',
+    });
+    if (codingSpawnResult.kind === 'err') {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'coding',
+                reason: `coding session spawn failed: ${codingSpawnResult.error}`,
+            },
+        };
+    }
+    const codingHandle = codingSpawnResult.value;
+    if (!codingHandle) {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'coding', reason: 'coding session returned empty handle' },
+        };
+    }
+    const codingAwait = await deps.awaitSessions([codingHandle], adaptive_pipeline_js_1.CODING_TIMEOUT_MS);
+    const codingResult = codingAwait.results[0];
+    if (!codingResult || codingResult.outcome !== 'success') {
+        const outcome = codingResult?.outcome ?? 'not_found';
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'coding', reason: `coding session ${outcome}` },
+        };
+    }
+    deps.stderr(`[full-pipeline] Coding session completed`);
+    const branchPattern = `worktrain/${codingHandle.slice(0, 16)}`;
+    deps.stderr(`[full-pipeline] Polling for PR on branch pattern: ${branchPattern}`);
+    const prUrl = await deps.pollForPR(branchPattern, PR_POLL_TIMEOUT_MS);
+    if (!prUrl) {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'pr-detection',
+                reason: `no PR found matching ${branchPattern} within ${PR_POLL_TIMEOUT_MS / 60000} minutes`,
+            },
+        };
+    }
+    deps.stderr(`[full-pipeline] PR detected: ${prUrl}`);
+    return (0, implement_shared_js_1.runReviewAndVerdictCycle)(deps, opts, prUrl, coordinatorStartMs, 0);
+}

package/dist/coordinators/modes/implement-shared.d.ts

@@ -0,0 +1,4 @@
+import type { AdaptiveCoordinatorDeps, AdaptivePipelineOpts, PipelineOutcome } from '../adaptive-pipeline.js';
+export declare const MAX_FIX_ITERATIONS = 2;
+export declare function runReviewAndVerdictCycle(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, prUrl: string, coordinatorStartMs: number, iteration: number): Promise<PipelineOutcome>;
+export declare function runAuditChain(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, prUrl: string, coordinatorStartMs: number, severity: 'blocking' | 'unknown'): Promise<PipelineOutcome>;

package/dist/coordinators/modes/implement-shared.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_FIX_ITERATIONS = void 0;
+exports.runReviewAndVerdictCycle = runReviewAndVerdictCycle;
+exports.runAuditChain = runAuditChain;
+const adaptive_pipeline_js_1 = require("../adaptive-pipeline.js");
+const pr_review_js_1 = require("../pr-review.js");
+exports.MAX_FIX_ITERATIONS = 2;
+async function runReviewAndVerdictCycle(deps, opts, prUrl, coordinatorStartMs, iteration) {
+    const cutoffCheck = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'review');
+    if (cutoffCheck)
+        return cutoffCheck;
+    const reviewGoal = iteration === 0
+        ? `Review PR for merge: ${prUrl}`
+        : `Re-review PR after fixes (iteration ${iteration}): ${prUrl}`;
+    deps.stderr(`[review-cycle] Spawning review session (iteration=${iteration}): ${reviewGoal.slice(0, 80)}`);
+    const reviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', reviewGoal, opts.workspace, { prUrl });
+    if (reviewSpawnResult.kind === 'err') {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: `review session spawn failed: ${reviewSpawnResult.error}` },
+        };
+    }
+    const reviewHandle = reviewSpawnResult.value;
+    if (!reviewHandle) {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: 'review session returned empty handle' },
+        };
+    }
+    const reviewAwait = await deps.awaitSessions([reviewHandle], adaptive_pipeline_js_1.REVIEW_TIMEOUT_MS);
+    const reviewResult = reviewAwait.results[0];
+    if (!reviewResult || reviewResult.outcome !== 'success') {
+        const outcome = reviewResult?.outcome ?? 'not_found';
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: `review session ${outcome}` },
+        };
+    }
+    const agentResult = await deps.getAgentResult(reviewHandle);
+    const verdictFromArtifact = (0, pr_review_js_1.readVerdictArtifact)(agentResult.artifacts, reviewHandle);
+    const findingsResult = verdictFromArtifact !== null
+        ? { kind: 'ok', value: verdictFromArtifact }
+        : (0, pr_review_js_1.parseFindingsFromNotes)(agentResult.recapMarkdown);
+    if (findingsResult.kind === 'err') {
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: `review verdict parse failed: ${findingsResult.error}` },
+        };
+    }
+    const findings = findingsResult.value;
+    deps.stderr(`[review-cycle] Verdict: ${findings.severity} (iteration=${iteration})`);
+    switch (findings.severity) {
+        case 'clean':
+            deps.stderr(`[review-cycle] Verdict clean -- merging PR`);
+            return { kind: 'merged', prUrl };
+        case 'minor': {
+            if (iteration >= exports.MAX_FIX_ITERATIONS) {
+                deps.stderr(`[review-cycle] ${exports.MAX_FIX_ITERATIONS} fix iterations exhausted -- escalating`);
+                await deps.postToOutbox(`Adaptive pipeline escalated: fix loop exhausted after ${exports.MAX_FIX_ITERATIONS} iterations`, { prUrl, phase: 'fix-loop', reason: 'max iterations reached', findingSummaries: findings.findingSummaries });
+                return {
+                    kind: 'escalated',
+                    escalationReason: { phase: 'fix-loop', reason: `${exports.MAX_FIX_ITERATIONS} fix iterations exhausted` },
+                };
+            }
+            deps.stderr(`[review-cycle] Verdict minor -- running fix iteration ${iteration + 1}/${exports.MAX_FIX_ITERATIONS}`);
+            const fixCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'fix-agent');
+            if (fixCutoff)
+                return fixCutoff;
+            const fixGoal = `Fix review findings: ${findings.findingSummaries.slice(0, 3).join('; ')}`;
+            const fixSpawnResult = await deps.spawnSession('coding-task-workflow-agentic', fixGoal, opts.workspace, { prUrl, findings: findings.findingSummaries });
+            if (fixSpawnResult.kind === 'err') {
+                return {
+                    kind: 'escalated',
+                    escalationReason: { phase: 'fix-agent', reason: `fix agent spawn failed: ${fixSpawnResult.error}` },
+                };
+            }
+            const fixHandle = fixSpawnResult.value;
+            if (!fixHandle) {
+                return {
+                    kind: 'escalated',
+                    escalationReason: { phase: 'fix-agent', reason: 'fix agent returned empty handle' },
+                };
+            }
+            const fixAwait = await deps.awaitSessions([fixHandle], adaptive_pipeline_js_1.CODING_TIMEOUT_MS);
+            const fixResult = fixAwait.results[0];
+            if (!fixResult || fixResult.outcome !== 'success') {
+                const outcome = fixResult?.outcome ?? 'not_found';
+                return {
+                    kind: 'escalated',
+                    escalationReason: { phase: 'fix-agent', reason: `fix agent ${outcome}` },
+                };
+            }
+            deps.stderr(`[review-cycle] Fix iteration ${iteration + 1} complete -- re-reviewing`);
+            return runReviewAndVerdictCycle(deps, opts, prUrl, coordinatorStartMs, iteration + 1);
+        }
+        case 'blocking':
+        case 'unknown': {
+            return runAuditChain(deps, opts, prUrl, coordinatorStartMs, findings.severity);
+        }
+    }
+}
+async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity) {
+    deps.stderr(`[audit-chain] ${severity.toUpperCase()} finding -- running audit chain`);
+    const auditCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'audit');
+    if (auditCutoff)
+        return auditCutoff;
+    const auditWorkflow = 'production-readiness-audit';
+    const auditSpawnResult = await deps.spawnSession(auditWorkflow, `Audit PR before merge: ${prUrl}`, opts.workspace, { prUrl, severity });
+    if (auditSpawnResult.kind === 'err') {
+        await deps.postToOutbox(`Adaptive pipeline escalated: audit workflow failed to spawn`, { prUrl, phase: 'audit', reason: auditSpawnResult.error, severity });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'audit', reason: `audit spawn failed: ${auditSpawnResult.error}` },
+        };
+    }
+    const auditHandle = auditSpawnResult.value;
+    if (!auditHandle) {
+        await deps.postToOutbox(`Adaptive pipeline escalated: audit returned empty handle`, { prUrl, phase: 'audit', severity });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'audit', reason: 'audit returned empty handle' },
+        };
+    }
+    const auditAwait = await deps.awaitSessions([auditHandle], adaptive_pipeline_js_1.REVIEW_TIMEOUT_MS);
+    const auditResult = auditAwait.results[0];
+    if (!auditResult || auditResult.outcome !== 'success') {
+        const outcome = auditResult?.outcome ?? 'not_found';
+        await deps.postToOutbox(`Adaptive pipeline escalated: audit session ${outcome}`, { prUrl, phase: 'audit', auditOutcome: outcome, severity });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'audit', reason: `audit session ${outcome}` },
+        };
+    }
+    deps.stderr(`[audit-chain] Audit complete -- re-reviewing PR`);
+    const reReviewCutoff = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 're-review-after-audit');
+    if (reReviewCutoff)
+        return reReviewCutoff;
+    const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', `Re-review after audit: ${prUrl}`, opts.workspace, { prUrl, auditComplete: true });
+    if (reReviewSpawnResult.kind === 'err') {
+        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit failed to spawn`, { prUrl, phase: 're-review-after-audit', reason: reReviewSpawnResult.error });
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 're-review-after-audit',
+                reason: `re-review spawn failed: ${reReviewSpawnResult.error}`,
+            },
+        };
+    }
+    const reReviewHandle = reReviewSpawnResult.value;
+    if (!reReviewHandle) {
+        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit returned empty handle`, { prUrl, phase: 're-review-after-audit' });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 're-review-after-audit', reason: 're-review returned empty handle' },
+        };
+    }
+    const reReviewAwait = await deps.awaitSessions([reReviewHandle], adaptive_pipeline_js_1.REVIEW_TIMEOUT_MS);
+    const reReviewResult = reReviewAwait.results[0];
+    if (!reReviewResult || reReviewResult.outcome !== 'success') {
+        const outcome = reReviewResult?.outcome ?? 'not_found';
+        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit session ${outcome}`, { prUrl, phase: 're-review-after-audit', reReviewOutcome: outcome });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 're-review-after-audit', reason: `re-review session ${outcome}` },
+        };
+    }
+    const reAgentResult = await deps.getAgentResult(reReviewHandle);
+    const reVerdictFromArtifact = (0, pr_review_js_1.readVerdictArtifact)(reAgentResult.artifacts, reReviewHandle);
+    const reFindingsResult = reVerdictFromArtifact !== null
+        ? { kind: 'ok', value: reVerdictFromArtifact }
+        : (0, pr_review_js_1.parseFindingsFromNotes)(reAgentResult.recapMarkdown);
+    if (reFindingsResult.kind === 'err') {
+        await deps.postToOutbox(`Adaptive pipeline escalated: re-review verdict unparseable after audit`, { prUrl, phase: 're-review-after-audit' });
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 're-review-after-audit', reason: `re-review verdict parse failed` },
+        };
+    }
+    const reFindings = reFindingsResult.value;
+    deps.stderr(`[audit-chain] Post-audit re-review verdict: ${reFindings.severity}`);
+    if (reFindings.severity === 'clean' || reFindings.severity === 'minor') {
+        deps.stderr(`[audit-chain] Post-audit verdict acceptable (${reFindings.severity}) -- merging`);
+        return { kind: 'merged', prUrl };
+    }
+    deps.stderr(`[audit-chain] Post-audit verdict still ${reFindings.severity} -- escalating to Human Outbox`);
+    await deps.postToOutbox(`PR requires human review: still ${reFindings.severity} after production-readiness audit`, {
+        prUrl,
+        phase: 'audit-chain-complete',
+        severity: reFindings.severity,
+        findingSummaries: reFindings.findingSummaries,
+        note: 'Do NOT auto-merge. Human review required.',
+    });
+    return {
+        kind: 'escalated',
+        escalationReason: {
+            phase: 'audit-chain',
+            reason: `PR still ${reFindings.severity} after audit -- posted to Human Outbox, do NOT merge`,
+        },
+    };
+}

package/dist/coordinators/modes/implement.d.ts

@@ -0,0 +1,3 @@
+import type { AdaptiveCoordinatorDeps, AdaptivePipelineOpts, PipelineOutcome } from '../adaptive-pipeline.js';
+export declare function touchesUI(goal: string): boolean;
+export declare function runImplementPipeline(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, pitchPath: string, coordinatorStartMs: number): Promise<PipelineOutcome>;