@exaudeus/workrail 3.44.0 → 3.46.0

package/dist/coordinators/modes/implement.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.touchesUI = touchesUI;
+exports.runImplementPipeline = runImplementPipeline;
+const adaptive_pipeline_js_1 = require("../adaptive-pipeline.js");
+const implement_shared_js_1 = require("./implement-shared.js");
+const PR_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const UI_KEYWORDS = [
+    'ui', 'screen', 'view', 'layout', 'component', 'design', 'ux', 'frontend',
+];
+function touchesUI(goal) {
+    const lower = goal.toLowerCase();
+    return UI_KEYWORDS.some((kw) => lower.includes(kw));
+}
+async function runImplementPipeline(deps, opts, pitchPath, coordinatorStartMs) {
+    deps.stderr(`[implement] Starting IMPLEMENT pipeline for workspace=${opts.workspace}`);
+    const archiveDir = opts.workspace + '/.workrail/used-pitches';
+    const archiveTimestamp = deps.nowIso().replace(/[:.]/g, '-');
+    const archivePath = archiveDir + '/pitch-' + archiveTimestamp + '.md';
+    let outcome;
+    try {
+        outcome = await runImplementCore(deps, opts, pitchPath, coordinatorStartMs);
+    }
+    finally {
+        try {
+            await deps.mkdir(archiveDir, { recursive: true });
+            await deps.archiveFile(pitchPath, archivePath);
+            deps.stderr(`[implement] Pitch archived to ${archivePath}`);
+        }
+        catch (e) {
+            deps.stderr(`[WARN implement] Failed to archive pitch.md: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return outcome;
+}
+async function runImplementCore(deps, opts, pitchPath, coordinatorStartMs) {
+    if (touchesUI(opts.goal)) {
+        deps.stderr(`[implement] UX signals detected in goal, dispatching ui-ux-design-workflow`);
+        const cutoffCheck = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'ux-gate');
+        if (cutoffCheck)
+            return cutoffCheck;
+        const uxSpawnResult = await deps.spawnSession('ui-ux-design-workflow', opts.goal, opts.workspace, {
+            pitchPath,
+        });
+        if (uxSpawnResult.kind === 'err') {
+            deps.stderr(`[implement] UX gate spawn failed: ${uxSpawnResult.error}`);
+            return {
+                kind: 'escalated',
+                escalationReason: { phase: 'ux-gate', reason: `UX gate spawn failed: ${uxSpawnResult.error}` },
+            };
+        }
+        const uxHandle = uxSpawnResult.value;
+        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(`[implement] UX design session completed`);
+    }
+    const cutoffCheck = (0, adaptive_pipeline_js_1.checkSpawnCutoff)(coordinatorStartMs, deps.now(), 'coding');
+    if (cutoffCheck)
+        return cutoffCheck;
+    deps.stderr(`[implement] Spawning coding-task-workflow-agentic`);
+    const codingSpawnResult = await deps.spawnSession('coding-task-workflow-agentic', opts.goal, opts.workspace, {
+        pitchPath,
+    });
+    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 (zombie detection)' },
+        };
+    }
+    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(`[implement] Coding session completed (${Math.round((codingResult.durationMs ?? 0) / 1000)}s)`);
+    const branchPattern = `worktrain/${codingHandle.slice(0, 16)}`;
+    deps.stderr(`[implement] 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(`[implement] PR detected: ${prUrl}`);
+    return (0, implement_shared_js_1.runReviewAndVerdictCycle)(deps, opts, prUrl, coordinatorStartMs, 0);
+}

package/dist/coordinators/modes/quick-review.d.ts

@@ -0,0 +1,3 @@
+import type { AdaptiveCoordinatorDeps, AdaptivePipelineOpts, PipelineOutcome } from '../adaptive-pipeline.js';
+export declare function runQuickReviewPipeline(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, prNumbers: readonly number[], _coordinatorStartMs: number): Promise<PipelineOutcome>;
+export declare function buildDepBumpGoal(prNumbers: readonly number[], originalGoal: string): string;

package/dist/coordinators/modes/quick-review.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQuickReviewPipeline = runQuickReviewPipeline;
+exports.buildDepBumpGoal = buildDepBumpGoal;
+const pr_review_js_1 = require("../pr-review.js");
+async function runQuickReviewPipeline(deps, opts, prNumbers, _coordinatorStartMs) {
+    deps.stderr(`[quick-review] Dep-bump review for PR(s) [${prNumbers.join(', ')}]`);
+    const depBumpGoal = buildDepBumpGoal(prNumbers, opts.goal);
+    deps.stderr(`[quick-review] Goal: "${depBumpGoal.slice(0, 100)}"`);
+    const result = await (0, pr_review_js_1.runPrReviewCoordinator)(deps, {
+        workspace: opts.workspace,
+        prs: prNumbers.length > 0 ? [...prNumbers] : undefined,
+        dryRun: opts.dryRun ?? false,
+        port: opts.port,
+    });
+    if (result.hasErrors || result.escalated > 0) {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'review',
+                reason: result.hasErrors
+                    ? `dep-bump review coordinator reported errors (escalated=${result.escalated})`
+                    : `${result.escalated} dep-bump PR(s) escalated during review`,
+            },
+        };
+    }
+    return {
+        kind: 'merged',
+        prUrl: result.mergedPrs.length > 0 ? `PR #${result.mergedPrs[0]}` : null,
+    };
+}
+function buildDepBumpGoal(prNumbers, originalGoal) {
+    const firstPr = prNumbers[0];
+    const prRef = firstPr !== undefined ? `PR #${firstPr}` : 'dep-bump PR';
+    const prTitle = originalGoal.slice(0, 80);
+    return `[DEP BUMP] Review ${prRef}: ${prTitle} -- skip architecture audit, verify version compatibility and test coverage only`;
+}

package/dist/coordinators/modes/review-only.d.ts

@@ -0,0 +1,2 @@
+import type { AdaptiveCoordinatorDeps, AdaptivePipelineOpts, PipelineOutcome } from '../adaptive-pipeline.js';
+export declare function runReviewOnlyPipeline(deps: AdaptiveCoordinatorDeps, opts: AdaptivePipelineOpts, prNumbers: readonly number[], _coordinatorStartMs: number): Promise<PipelineOutcome>;

package/dist/coordinators/modes/review-only.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReviewOnlyPipeline = runReviewOnlyPipeline;
+const pr_review_js_1 = require("../pr-review.js");
+async function runReviewOnlyPipeline(deps, opts, prNumbers, _coordinatorStartMs) {
+    deps.stderr(`[review-only] Delegating to runPrReviewCoordinator() for ${prNumbers.length > 0 ? `PR(s) [${prNumbers.join(', ')}]` : 'all open PRs'}`);
+    const result = await (0, pr_review_js_1.runPrReviewCoordinator)(deps, {
+        workspace: opts.workspace,
+        prs: prNumbers.length > 0 ? [...prNumbers] : undefined,
+        dryRun: opts.dryRun ?? false,
+        port: opts.port,
+    });
+    if (result.hasErrors || result.escalated > 0) {
+        return {
+            kind: 'escalated',
+            escalationReason: {
+                phase: 'review',
+                reason: result.hasErrors
+                    ? `review coordinator reported errors (escalated=${result.escalated})`
+                    : `${result.escalated} PR(s) escalated during review`,
+            },
+        };
+    }
+    return {
+        kind: 'merged',
+        prUrl: result.mergedPrs.length > 0 ? `PR #${result.mergedPrs[0]}` : null,
+    };
+}

package/dist/coordinators/routing/route-task.d.ts

@@ -0,0 +1,21 @@
+export type PipelineMode = {
+    readonly kind: 'QUICK_REVIEW';
+    readonly prNumbers: readonly number[];
+} | {
+    readonly kind: 'REVIEW_ONLY';
+    readonly prNumbers: readonly number[];
+} | {
+    readonly kind: 'IMPLEMENT';
+    readonly pitchPath: string;
+} | {
+    readonly kind: 'FULL';
+    readonly goal: string;
+} | {
+    readonly kind: 'ESCALATE';
+    readonly reason: string;
+};
+export interface RoutingDeps {
+    readonly fileExists: (path: string) => boolean;
+}
+export declare function extractPrNumbers(goal: string): number[];
+export declare function routeTask(goal: string, workspace: string, deps: RoutingDeps, triggerProvider?: string): PipelineMode;

package/dist/coordinators/routing/route-task.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPrNumbers = extractPrNumbers;
+exports.routeTask = routeTask;
+const DEP_BUMP_KEYWORDS = [
+    'bump',
+    'chore:',
+    'dependabot',
+    'dependency upgrade',
+];
+const PR_REGEX = /\bPR\s*#\d+\b/i;
+const MR_REGEX = /\bMR\s*!?\d+\b/i;
+const PITCH_FILE_PATH = '.workrail/current-pitch.md';
+function extractPrNumbers(goal) {
+    const numbers = [];
+    const prMatches = goal.matchAll(/\bPR\s*#(\d+)\b/gi);
+    for (const match of prMatches) {
+        const n = parseInt(match[1], 10);
+        if (!isNaN(n))
+            numbers.push(n);
+    }
+    const mrMatches = goal.matchAll(/\bMR\s*!?#?(\d+)\b/gi);
+    for (const match of mrMatches) {
+        const n = parseInt(match[1], 10);
+        if (!isNaN(n))
+            numbers.push(n);
+    }
+    return numbers;
+}
+function hasDependencyBumpKeywords(goal) {
+    const lower = goal.toLowerCase();
+    return DEP_BUMP_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function hasPrOrMrReference(goal) {
+    return PR_REGEX.test(goal) || MR_REGEX.test(goal);
+}
+function routeTask(goal, workspace, deps, triggerProvider) {
+    const prNumbers = extractPrNumbers(goal);
+    const hasDepBump = hasDependencyBumpKeywords(goal);
+    const hasPrRef = hasPrOrMrReference(goal);
+    const isGithubPrsPoll = triggerProvider === 'github_prs_poll';
+    if (hasDepBump && hasPrRef) {
+        return { kind: 'QUICK_REVIEW', prNumbers };
+    }
+    if (hasPrRef || isGithubPrsPoll) {
+        return { kind: 'REVIEW_ONLY', prNumbers };
+    }
+    const pitchPath = workspace.endsWith('/')
+        ? workspace + PITCH_FILE_PATH
+        : workspace + '/' + PITCH_FILE_PATH;
+    if (deps.fileExists(pitchPath)) {
+        return { kind: 'IMPLEMENT', pitchPath };
+    }
+    return { kind: 'FULL', goal };
+}

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

@@ -24,6 +24,8 @@ export interface WorkflowTrigger {
         readonly maxSessionMinutes?: number;
         readonly maxTurns?: number;
         readonly maxSubagentDepth?: number;
+        readonly stuckAbortPolicy?: 'abort' | 'notify_only';
+        readonly noProgressAbortEnabled?: boolean;
     };
     readonly _preAllocatedStartResponse?: import('zod').infer<typeof V2StartWorkflowOutputSchema>;
     readonly parentSessionId?: string;
@@ -60,14 +62,22 @@ export interface WorkflowRunTimeout {
     readonly message: string;
     readonly stopReason: string;
 }
+export interface WorkflowRunStuck {
+    readonly _tag: 'stuck';
+    readonly workflowId: string;
+    readonly reason: 'repeated_tool_call' | 'no_progress';
+    readonly message: string;
+    readonly stopReason: string;
+    readonly issueSummaries?: readonly string[];
+}
 export interface WorkflowDeliveryFailed {
     readonly _tag: 'delivery_failed';
     readonly workflowId: string;
     readonly stopReason: string;
     readonly deliveryError: string;
 }
-export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowDeliveryFailed;
-export type ChildWorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout;
+export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowRunStuck | WorkflowDeliveryFailed;
+export type ChildWorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowRunStuck;
 export type SteerRegistry = Map<string, (text: string) => void>;
 export interface OrphanedSession {
     readonly sessionId: string;

package/dist/daemon/workflow-runner.js

@@ -1081,6 +1081,16 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
                     notes: childResult.message,
                 };
             }
+            else if (childResult._tag === 'stuck') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'stuck',
+                    notes: childResult.message,
+                    ...(childResult.issueSummaries !== undefined
+                        ? { issueSummaries: childResult.issueSummaries }
+                        : {}),
+                };
+            }
             else {
                 (0, assert_never_js_1.assertNever)(childResult);
             }
@@ -1093,6 +1103,31 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
         },
     };
 }
+async function writeStuckOutboxEntry(opts) {
+    try {
+        const outboxPath = path.join(os.homedir(), '.workrail', 'outbox.jsonl');
+        await fs.mkdir(path.dirname(outboxPath), { recursive: true });
+        const entry = JSON.stringify({
+            id: (0, node_crypto_1.randomUUID)(),
+            kind: 'stuck',
+            message: `Session stuck (${opts.reason}): workflowId=${opts.workflowId}` +
+                (opts.issueSummaries && opts.issueSummaries.length > 0
+                    ? ` -- issues: ${opts.issueSummaries.join('; ')}`
+                    : ''),
+            timestamp: new Date().toISOString(),
+            workflowId: opts.workflowId,
+            reason: opts.reason,
+            ...(opts.issueSummaries && opts.issueSummaries.length > 0
+                ? { issueSummaries: opts.issueSummaries }
+                : {}),
+        });
+        await fs.appendFile(outboxPath, entry + '\n');
+    }
+    catch (err) {
+        console.warn(`[WorkflowRunner] Could not write stuck outbox entry: ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 async function appendIssueAsync(issuesDir, sessionId, record) {
     await fs.mkdir(issuesDir, { recursive: true });
     const filePath = path.join(issuesDir, `${sessionId}.jsonl`);
@@ -1449,19 +1484,6 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     if (startContinueToken) {
         await persistTokens(sessionId, startContinueToken, startCheckpointToken);
     }
-    if (trigger.botIdentity) {
-        try {
-            await execFileAsync('git', ['-C', trigger.workspacePath, 'config', 'user.name', trigger.botIdentity.name]);
-            await execFileAsync('git', ['-C', trigger.workspacePath, 'config', 'user.email', trigger.botIdentity.email]);
-            console.log(`[WorkflowRunner] Bot identity set: sessionId=${sessionId} ` +
-                `name=${trigger.botIdentity.name} email=${trigger.botIdentity.email}`);
-        }
-        catch (identityErr) {
-            console.warn(`[WorkflowRunner] WARNING: Failed to set bot identity for sessionId=${sessionId}: ` +
-                `${identityErr instanceof Error ? identityErr.message : String(identityErr)}. ` +
-                `Commits will use default git config.`);
-        }
-    }
     let sessionWorkspacePath = trigger.workspacePath;
     let sessionWorktreePath;
     if (trigger.branchStrategy === 'worktree') {
@@ -1497,6 +1519,19 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             };
         }
     }
+    if (trigger.botIdentity) {
+        try {
+            await execFileAsync('git', ['-C', sessionWorkspacePath, 'config', 'user.name', trigger.botIdentity.name]);
+            await execFileAsync('git', ['-C', sessionWorkspacePath, 'config', 'user.email', trigger.botIdentity.email]);
+            console.log(`[WorkflowRunner] Bot identity set: sessionId=${sessionId} ` +
+                `name=${trigger.botIdentity.name} email=${trigger.botIdentity.email}`);
+        }
+        catch (identityErr) {
+            console.warn(`[WorkflowRunner] WARNING: Failed to set bot identity for sessionId=${sessionId}: ` +
+                `${identityErr instanceof Error ? identityErr.message : String(identityErr)}. ` +
+                `Commits will use default git config.`);
+        }
+    }
     if (firstStep.isComplete) {
         await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
         emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(workrailSessionId) });
@@ -1588,7 +1623,10 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     });
     const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
     const maxTurns = trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS;
+    const sessionStartMs = Date.now();
+    void sessionStartMs;
     let timeoutReason = null;
+    let stuckReason = null;
     let turnCount = 0;
     const unsubscribe = agent.subscribe(async (event) => {
         if (event.type !== 'turn_end')
@@ -1623,6 +1661,17 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 argsSummary: lastNToolCalls[0]?.argsSummary,
                 ...withWorkrailSession(workrailSessionId),
             });
+            void writeStuckOutboxEntry({
+                workflowId: trigger.workflowId,
+                reason: 'repeated_tool_call',
+                ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+            });
+            const stuckPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
+            if (stuckPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
+                stuckReason = 'repeated_tool_call';
+                agent.abort();
+                return;
+            }
         }
         if (maxTurns > 0 &&
             turnCount >= Math.floor(maxTurns * 0.8) &&
@@ -1634,6 +1683,20 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 detail: `${turnCount} turns used, 0 step advances (${maxTurns} turn limit)`,
                 ...withWorkrailSession(workrailSessionId),
             });
+            const noProgressAbortEnabled = trigger.agentConfig?.noProgressAbortEnabled ?? false;
+            if (noProgressAbortEnabled) {
+                void writeStuckOutboxEntry({
+                    workflowId: trigger.workflowId,
+                    reason: 'no_progress',
+                    ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+                });
+                const noProgressPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
+                if (noProgressPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
+                    stuckReason = 'no_progress';
+                    agent.abort();
+                    return;
+                }
+            }
         }
         if (timeoutReason !== null) {
             emitter?.emit({
@@ -1693,6 +1756,26 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         }
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
+    if (stuckReason !== null) {
+        emitter?.emit({
+            kind: 'session_completed',
+            sessionId,
+            workflowId: trigger.workflowId,
+            outcome: 'timeout',
+            detail: stuckReason,
+            ...withWorkrailSession(workrailSessionId),
+        });
+        if (workrailSessionId !== null)
+            daemonRegistry?.unregister(workrailSessionId, 'failed');
+        return {
+            _tag: 'stuck',
+            workflowId: trigger.workflowId,
+            reason: stuckReason,
+            message: `Session aborted: stuck heuristic fired (${stuckReason})`,
+            stopReason: 'aborted',
+            ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+        };
+    }
     if (timeoutReason !== null) {
         emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'timeout', detail: timeoutReason, ...withWorkrailSession(workrailSessionId) });
         if (workrailSessionId !== null)