@exaudeus/workrail 3.59.5 → 3.59.7

package/dist/daemon/workflow-runner.js

@@ -142,7 +142,7 @@ async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR)
     }
     const sessions = [];
     for (const entry of entries) {
-        if (!entry.endsWith('.json'))
+        if (!entry.endsWith('.json') || entry.startsWith('queue-issue-'))
             continue;
         const sessionId = entry.slice(0, -5);
         const filePath = path.join(sessionsDir, entry);

package/dist/manifest.json

@@ -238,8 +238,8 @@
       "bytes": 31
     },
     "cli-worktrain.js": {
-      "sha256": "34c2a2d4596a1f1b4c385366c601391cc329fd85abccdebce5d74a9bd1631aac",
-      "bytes": 60787
+      "sha256": "cc970333db8fec7bcccec57e901bcde86f1671d1efa039d7abc9119593870bef",
+      "bytes": 59518
     },
     "cli.d.ts": {
       "sha256": "43e818adf60173644896298637f47b01d5819b17eda46eaa32d0c7d64724d012",
@@ -481,16 +481,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-Ctoxo1z6.js": {
-      "sha256": "fc11e753539cbb514c0c3c37189f2fbe2abca848fa005c5bcae09e5c88b78bd9",
-      "bytes": 760528
-    },
     "console-ui/assets/index-DGj8EsFR.css": {
       "sha256": "3bdb55ec0957928e0ebbb86a7d6b36d28f7ba7d5c0f3e236fd8f2e2aacee2fa4",
       "bytes": 60631
     },
+    "console-ui/assets/index-RXJXvJ8T.js": {
+      "sha256": "2d32ed2f503a4eaf9d9c4868d8bd7906df0ab8635c6d24c1f8eb333a50ac442d",
+      "bytes": 760528
+    },
     "console-ui/index.html": {
-      "sha256": "df586c53f8a105ad224d418e70c2dd98e7be4725dfb1c194baf45eff810ff6b5",
+      "sha256": "546a59bc2b573a0d127fd10eb6ef2b39ed98d4bb38ea432610d831d5dd288bfb",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -546,8 +546,8 @@
       "bytes": 462
     },
     "coordinators/modes/full-pipeline.js": {
-      "sha256": "a03cf485201d23b0ddf75ca36ea10741bb9d0373479e7df3350401653229ef8b",
-      "bytes": 12850
+      "sha256": "945d726d728235f8f31f03f33fbde8f6614472b38921a44fba42da959875f37d",
+      "bytes": 13201
     },
     "coordinators/modes/implement-shared.d.ts": {
       "sha256": "fbad9d91d84d2112b273175618686489a7f106385e0e62d6cab80804d6d0f2d7",
@@ -582,8 +582,8 @@
       "bytes": 1198
     },
     "coordinators/pr-review.d.ts": {
-      "sha256": "a8886a3c83a31e869522812d1342a301e9bfae92d8e5e694594c3c50912035d9",
-      "bytes": 3833
+      "sha256": "d46e4923995a0b43aefee25da298b86235fae0ad105e548b3174c0eea9c1f8d0",
+      "bytes": 3947
     },
     "coordinators/pr-review.js": {
       "sha256": "84b51f931eb55d908de8c60f90b4d4b66540054791a28ce2f07426a841fed386",
@@ -650,8 +650,8 @@
       "bytes": 7307
     },
     "daemon/workflow-runner.js": {
-      "sha256": "2184d5202eadecff166aeb5371d84c1660a9b6cf3fdf7598d311172fdfdb910a",
-      "bytes": 95312
+      "sha256": "0d4991c3589e75679d4035d506d84ebe595df8328c6e632d352597c9e23ad741",
+      "bytes": 95348
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -1650,8 +1650,8 @@
       "bytes": 1363
     },
     "trigger/adapters/github-queue-poller.js": {
-      "sha256": "c1a4866ff7ead5b33439da2ff7842747e119bf411e8057b1a08d580816689dd1",
-      "bytes": 7935
+      "sha256": "b15f56cf0782a1eceb66ef6d58bb75b17e14f701f1e95d072fe7a71b5aa6a4f5",
+      "bytes": 8824
     },
     "trigger/adapters/gitlab-poller.d.ts": {
       "sha256": "f685490fafad77194fdd0f0bbaf80dbc56730aeb344853da365199a120fbe399",
@@ -1661,14 +1661,6 @@
       "sha256": "6728a2169f4007b9ea0414fade6b21500500d9c79d0b09296d92ef8bcabb9c79",
       "bytes": 2763
     },
-    "trigger/daemon-console.d.ts": {
-      "sha256": "a3b9a9f58482c6ea379c0e02c30f55a5820c7c37fa3fae55fc336cd518f35462",
-      "bytes": 1162
-    },
-    "trigger/daemon-console.js": {
-      "sha256": "f2f09c05e48b42ebf1c7be137fc6eced46673048471b7114434710b5691fe6f2",
-      "bytes": 5497
-    },
     "trigger/delivery-action.d.ts": {
       "sha256": "559e2b2645aa60528f73de351cd35ebf45c5b82f47797aa15ddd681319315d39",
       "bytes": 1759
@@ -1718,20 +1710,20 @@
       "bytes": 6968
     },
     "trigger/polling-scheduler.d.ts": {
-      "sha256": "60df456a31fa87ce71de76f5e31a6c460bfab588a24c8a2f06bf926fdcea550a",
-      "bytes": 1096
+      "sha256": "3c0865f9d21819c364575062745741405bc80006f4a0754d26ed4302253371c6",
+      "bytes": 1126
     },
     "trigger/polling-scheduler.js": {
-      "sha256": "ef1252ee4bc4592fc416e7a00aa4e7db297035a990231941ae9316cdf5fe5b9a",
-      "bytes": 21667
+      "sha256": "61b94e35aae2e9578a9e9cc32548791166b9ec98abb8f2cff58135fc6b3e5593",
+      "bytes": 23945
     },
     "trigger/trigger-listener.d.ts": {
       "sha256": "1eebb3d4829030b264c3798b0b0d55d7357d313ab83e3f344ad455eaafcedb44",
       "bytes": 1740
     },
     "trigger/trigger-listener.js": {
-      "sha256": "09b8bbcda1825a9314dc29ac7435ef703fb0cdad13fa54ffe45f68767f22fbc7",
-      "bytes": 25095
+      "sha256": "4aa62601aac5d3c7d1750ef839ee71a911dacbab346fb6dfdb3d7151e9e7d359",
+      "bytes": 25179
     },
     "trigger/trigger-router.d.ts": {
       "sha256": "b916f33cab64d491ab04bd13dd37599d33e687f7aea1e69e50f5fcea4b3b4624",
@@ -3074,8 +3066,8 @@
       "bytes": 880
     },
     "v2/usecases/console-routes.js": {
-      "sha256": "76e34345d329bfc8a998ebc50ef8bd6ead1b7914873f6350ba479909c9c097be",
-      "bytes": 31648
+      "sha256": "6e22d5ef4fce3d9bf2b2709d3fcfc35089b8c558d82372071ac7d22251c68ddb",
+      "bytes": 31748
     },
     "v2/usecases/console-service.d.ts": {
       "sha256": "fc8fe65427fa9f4f3535344b385b36f66ca06b7e3bfaea708931817a3edcad2b",

package/dist/trigger/adapters/github-queue-poller.js

@@ -148,6 +148,30 @@ function inferMaturity(body) {
     return 'idea';
 }
 async function checkIdempotency(issueNumber, sessionsDir = exports.DEFAULT_SESSIONS_DIR) {
+    const sidecarFilename = `queue-issue-${issueNumber}.json`;
+    const sidecarFilePath = path.join(sessionsDir, sidecarFilename);
+    try {
+        const sidecarContent = await fs.readFile(sidecarFilePath, 'utf8');
+        const sidecarParsed = JSON.parse(sidecarContent);
+        if (typeof sidecarParsed !== 'object' || sidecarParsed === null) {
+            return 'active';
+        }
+        const sidecar = sidecarParsed;
+        const dispatchedAt = sidecar['dispatchedAt'];
+        const ttlMs = sidecar['ttlMs'];
+        if (typeof dispatchedAt === 'number' && typeof ttlMs === 'number') {
+            if (dispatchedAt + ttlMs > Date.now()) {
+                return 'active';
+            }
+            return 'clear';
+        }
+        return 'active';
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            return 'active';
+        }
+    }
     let files;
     try {
         files = await fs.readdir(sessionsDir);
@@ -155,7 +179,7 @@ async function checkIdempotency(issueNumber, sessionsDir = exports.DEFAULT_SESSI
     catch {
         return 'clear';
     }
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
+    const jsonFiles = files.filter(f => f.endsWith('.json') && f !== sidecarFilename);
     for (const filename of jsonFiles) {
         try {
             const content = await fs.readFile(path.join(sessionsDir, filename), 'utf8');

package/dist/trigger/polling-scheduler.d.ts

@@ -29,4 +29,5 @@ export declare class PollingScheduler {
     private doPollGitHub;
     private dispatchAndRecord;
     private doPollGitHubQueue;
+    private applyGitHubLabel;
 }

package/dist/trigger/polling-scheduler.js

@@ -38,6 +38,7 @@ const gitlab_poller_js_1 = require("./adapters/gitlab-poller.js");
 const github_poller_js_1 = require("./adapters/github-poller.js");
 const github_queue_poller_js_1 = require("./adapters/github-queue-poller.js");
 const github_queue_config_js_1 = require("./github-queue-config.js");
+const adaptive_pipeline_js_1 = require("../coordinators/adaptive-pipeline.js");
 const fs = __importStar(require("node:fs/promises"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
@@ -312,15 +313,31 @@ class PollingScheduler {
         }
         this.dispatchingIssues.add(top.issue.number);
         console.log(`[QueuePoll] in-flight-add #${top.issue.number}`);
+        const sidecarPath = path.join(sessionsDir, `queue-issue-${top.issue.number}.json`);
+        const sidecarContent = JSON.stringify({
+            issueNumber: top.issue.number,
+            triggerId,
+            dispatchedAt: Date.now(),
+            ttlMs: adaptive_pipeline_js_1.DISCOVERY_TIMEOUT_MS + 60000,
+        }, null, 2);
+        void fs.writeFile(sidecarPath, sidecarContent, 'utf8').catch((e) => {
+            console.warn(`[QueuePoll] Failed to write sidecar for issue #${top.issue.number}: ${e instanceof Error ? e.message : String(e)}`);
+        });
         const dispatchP = this.router.dispatchAdaptivePipeline(workflowTrigger.goal, workflowTrigger.workspacePath, workflowTrigger.context);
+        const issueNumber = top.issue.number;
         void dispatchP
-            .then(() => {
-            this.dispatchingIssues.delete(top.issue.number);
-            console.log(`[QueuePoll] in-flight-clear #${top.issue.number} reason=completed`);
+            .then((outcome) => {
+            this.dispatchingIssues.delete(issueNumber);
+            console.log(`[QueuePoll] in-flight-clear #${issueNumber} reason=completed`);
+            if (outcome.kind === 'escalated' || outcome.kind === 'dry_run') {
+                void this.applyGitHubLabel(issueNumber, 'worktrain:in-progress', queueConfig.token, source.repo);
+            }
+            void fs.unlink(sidecarPath).catch(() => { });
         })
             .catch(() => {
-            this.dispatchingIssues.delete(top.issue.number);
-            console.log(`[QueuePoll] in-flight-clear #${top.issue.number} reason=error`);
+            this.dispatchingIssues.delete(issueNumber);
+            console.log(`[QueuePoll] in-flight-clear #${issueNumber} reason=error`);
+            void fs.unlink(sidecarPath).catch(() => { });
         });
         console.log(`[QueuePoll] dispatched via adaptivePipeline goal="${workflowTrigger.goal.slice(0, 80)}"`);
         for (let i = 1; i < candidates.length; i++) {
@@ -332,6 +349,32 @@ class PollingScheduler {
         console.log(`[QueuePoll] cycle complete selected=1 skipped=${skipped.length + candidates.length - 1} elapsed=${elapsed}ms`);
         await appendQueuePollLog({ event: 'poll_cycle_complete', selected: 1, skipped: skipped.length + candidates.length - 1, elapsed, ts: new Date().toISOString() });
     }
+    async applyGitHubLabel(issueNumber, label, token, repo) {
+        const fetchFn = this.fetchFn ?? globalThis.fetch;
+        const url = `https://api.github.com/repos/${repo}/issues/${issueNumber}/labels`;
+        try {
+            const response = await fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/vnd.github+json',
+                    'Content-Type': 'application/json',
+                    'X-GitHub-Api-Version': '2022-11-28',
+                },
+                body: JSON.stringify({ labels: [label] }),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                console.warn(`[QueuePoll] Failed to apply label '${label}' to issue #${issueNumber}: HTTP ${response.status} ${text.slice(0, 200)}`);
+            }
+            else {
+                console.log(`[QueuePoll] Applied label '${label}' to issue #${issueNumber}`);
+            }
+        }
+        catch (e) {
+            console.warn(`[QueuePoll] Failed to apply label '${label}' to issue #${issueNumber}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
 }
 exports.PollingScheduler = PollingScheduler;
 function buildGitLabWorkflowTrigger(trigger, mr) {
@@ -432,7 +475,7 @@ function extractDotPath(obj, rawPath) {
 async function countActiveSessions(sessionsDir) {
     try {
         const files = await fs.readdir(sessionsDir);
-        return files.filter((f) => f.endsWith('.json')).length;
+        return files.filter((f) => f.endsWith('.json') && !f.startsWith('queue-issue-')).length;
     }
     catch {
         return 0;

package/dist/trigger/trigger-listener.js

@@ -218,7 +218,7 @@ async function startTriggerListener(ctx, options) {
     }
     let routerRef;
     const coordinatorDeps = {
-        spawnSession: async (workflowId, goal, workspace, context) => {
+        spawnSession: async (workflowId, goal, workspace, context, agentConfig) => {
             if (routerRef === undefined) {
                 return { kind: 'err', error: 'in-process router not initialized -- coordinator deps not ready' };
             }
@@ -242,6 +242,7 @@ async function startTriggerListener(ctx, options) {
                 goal,
                 workspacePath: workspace,
                 context,
+                ...(agentConfig !== undefined ? { agentConfig } : {}),
                 _preAllocatedStartResponse: startResult.value.response,
             });
             return { kind: 'ok', value: sessionHandle };

package/dist/v2/usecases/console-routes.js

@@ -429,13 +429,11 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
                 repoRootsExpiresAt = Date.now() + REPO_ROOTS_TTL_MS;
             }
             const repoRoots = cachedRepoRoots;
-            const data = await Promise.race([
-                (0, worktree_service_js_1.getWorktreeList)(repoRoots, activeSessions).finally(() => {
-                    if (timeoutId !== null)
-                        clearTimeout(timeoutId);
-                }),
-                timeoutPromise,
-            ]);
+            const worktreeWork = (0, worktree_service_js_1.getWorktreeList)(repoRoots, activeSessions)
+                .finally(() => { if (timeoutId !== null)
+                clearTimeout(timeoutId); })
+                .catch(() => ({ repos: [] }));
+            const data = await Promise.race([worktreeWork, timeoutPromise]);
             if (timeoutId !== null)
                 clearTimeout(timeoutId);
             res.json({ success: true, data });
@@ -532,7 +530,7 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
     }
     app.post('/api/v2/auto/dispatch', express_1.default.json(), async (req, res) => {
         if (!v2ToolContext) {
-            res.status(503).json({ success: false, error: 'Autonomous dispatch requires v2 tools enabled.' });
+            res.status(503).json({ success: false, error: 'Autonomous dispatch requires the WorkTrain daemon. Run worktrain console alongside worktrain daemon to enable browser dispatch.' });
             return;
         }
         const body = req.body;

package/docs/ideas/backlog.md

@@ -7351,3 +7351,229 @@ An agent can die from: stream watchdog timeout (600s no progress), OOM kill, or
 ### Priority
 
 High. Agent crash recovery makes the overnight-autonomous bar achievable. Without it, any hung LLM call or tool timeout fails the entire pipeline silently. With it, transient failures are automatically retried and the pipeline continues.
+
+---
+
+## Workflow execution time tracking and prediction (Apr 21, 2026)
+
+**The problem:** WorkTrain has no data on how long workflows actually take. Timeouts are set by intuition (55 min for discovery, 35 for shaping, 65 for coding). We just discovered that discovery on a real workrail task takes ~16 minutes. The 55-minute timeout is 3x the actual time -- but we didn't know that until we ran a benchmark manually.
+
+### What to track
+
+For every completed session, record:
+- Workflow ID
+- Total wall-clock duration
+- Number of turns
+- Number of step advances
+- Outcome (success / timeout / stuck / error)
+- Task complexity signals (codebase size, number of files read, task type from context)
+
+Store in `~/.workrail/data/execution-stats.jsonl` -- one line per completed session, append-only.
+
+### What to do with it
+
+**Immediate use: calibrate timeouts automatically**
+
+Instead of hardcoded `DISCOVERY_TIMEOUT_MS = 55 * 60 * 1000`, read the p95 completion time from execution stats and set the timeout to `p95 * 1.5`. Start with the hardcoded values as seeds; refine after 10+ samples.
+
+**Medium-term use: predict duration before dispatch**
+
+Given: task description + workflow ID + codebase characteristics → predicted duration range.
+
+The coordinator could use this to:
+- Warn when a task is likely to exceed session limits before starting
+- Adjust timeout budgets per-dispatch based on predicted complexity
+- Surface "this type of task usually takes 45 minutes" in `worktrain trigger test` output
+
+**Longer-term use: quality/efficiency metrics**
+
+Track step-advance rate (steps per turn) as a proxy for workflow efficiency. A session with 50 turns and 2 step advances is spending too many turns between steps. This feeds into the workflow improvement loop.
+
+### Implementation notes
+
+- Append to `execution-stats.jsonl` in `runWorkflow()`'s finally block, same pattern as the daemon event log
+- Keep it simple: flat JSONL, no database, no schema migration
+- `worktrain status` can show recent timing stats: "Last 10 wr.discovery sessions: avg 18min, p95 31min"
+- `worktrain trigger validate` can warn if configured timeouts are well below historical p95
+
+### Priority
+
+Medium. The data collection is small (~5 lines in `runWorkflow()`). The prediction and calibration are more involved. Ship collection first, calibration second.
+
+---
+
+## WorkRail MCP server self-cleanup (Apr 21, 2026)
+
+**The problem:** The WorkRail MCP server accumulates stale state that never cleans itself up: old workflow copies in `~/.workrail/workflows/`, dead managed sources, git repo caches that can't pull, 500+ sessions in the store, stale remembered roots. None of it has a TTL or cleanup mechanism. Every server startup loads everything and logs validation errors for stale state.
+
+### Sources of stale state
+
+1. **`~/.workrail/workflows/`** -- manually copied or `worktrain init`-placed workflows that go stale when the repo updates. MCP server loads both repo copy and user copy; older one fails validation silently or noisily.
+
+2. **Managed sources** (`~/.workrail/data/managed-sources/`) -- paths that no longer exist stay registered. Server tries to load them on every startup.
+
+3. **Git workflow cache** (`~/.workrail/cache/git-*`) -- cloned repos whose remotes have changed, been deleted, or whose auth has expired. `git pull` fails; errors logged on every startup.
+
+4. **Session store** (`~/.workrail/data/sessions/`) -- sessions accumulate forever. No TTL, no archival. Console loads all 500+ on every `/api/v2/sessions` request (partially mitigated by mtime cache).
+
+5. **Remembered roots** (`~/.workrail/data/managed-sources/remembered-roots.json`) -- workspace paths from past sessions that no longer exist.
+
+### Fix: two layers
+
+**Layer 1: Defensive loading (mostly already done)**
+Every loader should already handle missing/broken sources gracefully. Audit: are all managed source failures caught and logged as warnings rather than errors? Are git cache failures non-fatal?
+
+**Layer 2: `workrail cleanup` command**
+```
+workrail cleanup [--yes] [--sessions --older-than <age>] [--sources] [--cache] [--roots]
+```
+- `--sources`: remove managed sources where path doesn't exist on disk
+- `--cache`: remove git caches where `git pull` fails (remote gone or auth expired)  
+- `--sessions --older-than 30d`: archive or delete sessions older than N days
+- `--roots`: remove remembered roots where path doesn't exist
+- Without `--yes`: show what would be removed and ask for confirmation
+- With `--yes`: remove without prompting (for CI / worktrain init)
+
+**Layer 3: Automatic startup cleanup (light)**
+On MCP server startup, silently remove managed sources where the filesystem path doesn't exist (non-destructive -- the path is already gone). Log a single "removed N stale sources" line. Do not auto-remove sessions or caches -- those require explicit user intent.
+
+**Layer 4: User workflow directory sync**
+`~/.workrail/workflows/` should not be a place users copy workflows to manually. It should either:
+- Be deprecated entirely (use managed sources / workspace roots instead)
+- Have a `workrail sync` command that updates it from the canonical sources
+- Auto-detect when a user workflow is an older version of a bundled workflow and skip loading it
+
+### Priority
+
+Medium for the cleanup command (quality of life, stops log noise). High for startup auto-cleanup of dead managed sources (prevents the `Invalid workflow` errors that have been confusing throughout this session). Low for session TTL/archival (the mtime cache handles the performance concern).
+
+---
+
+## Worktree orphan leak on delivery failure (Apr 21, 2026, from Audit 4)
+
+**The bug:** In `src/trigger/trigger-router.ts`, `maybeRunDelivery()` on the success path deletes the session sidecar file before attempting worktree removal. If worktree removal fails (network error, git command failure), the sidecar is already gone. `runStartupRecovery()` scans sidecar files to find orphan worktrees -- so the orphaned worktree is invisible and accumulates indefinitely.
+
+**Fix:** In the success path cleanup, delete the sidecar AFTER worktree removal, not before. Or better: always attempt worktree removal in a `try/finally` that deletes the sidecar regardless of whether removal succeeded.
+
+**File:** `src/trigger/trigger-router.ts`, `maybeRunDelivery()` success path.
+
+**Priority:** Medium. Worktrees are small, but the leak is permanent across daemon restarts.
+
+---
+
+## queue-poll.jsonl never rotated (Apr 21, 2026, from Audit 5)
+
+**The bug:** `~/.workrail/queue-poll.jsonl` grows indefinitely. `appendFile`-only, no rotation. At 5-minute poll intervals with 2-3 events per cycle, this is ~8-87 MB/month depending on activity. Disk exhaustion risk on long-running daemons.
+
+**Fix:** Add a size check before appending in `appendQueuePollLog()`. If file exceeds 10 MB, rotate it: rename to `queue-poll.jsonl.1`, start fresh. Keep at most 2 rotated files.
+
+**File:** `src/trigger/polling-scheduler.ts`, `appendQueuePollLog()` function.
+
+**Priority:** Medium. Not urgent but a production correctness issue.
+
+---
+
+## ReviewSeverity missing assertNever + stderr bypassing injected dep (Apr 21, 2026, from Audit 2)
+
+**Bug 1 (Major):** In `src/coordinators/modes/implement-shared.ts`, the `switch(findings.severity)` over `ReviewSeverity` has no `default: assertNever(findings.severity)`. Widening `ReviewSeverity` with a new variant compiles cleanly and falls through silently.
+
+**Fix:** Add `default: assertNever(findings.severity)` to the switch.
+
+**Bug 2 (Major):** In `src/coordinators/pr-review.ts`, `readVerdictArtifact()` calls `process.stderr.write(...)` directly instead of using the injected `deps.stderr`. Tests that inject a fake dep will miss this log.
+
+**Fix:** Replace `process.stderr.write(...)` with `deps.stderr(...)`.
+
+**Files:** `src/coordinators/modes/implement-shared.ts`, `src/coordinators/pr-review.ts`.
+
+**Priority:** Medium. Correctness issues that won't crash in production but make future refactors unsafe.
+
+---
+
+## Current state update (Apr 21, 2026)
+
+**npm version: v3.59.6** | Daemon PID: 54113 | Status: Running, pipeline active
+
+### What shipped in this session (Apr 19-21, 2026)
+
+**All five autonomous pipeline items (previously recorded) plus:**
+
+- ✅ **Discovery loop fix** (#748) -- three coupled fixes: thread `maxSessionMinutes` through `spawnSession` (sessions now get 55/35/65 min instead of 30 min default), inspect `PipelineOutcome` in polling-scheduler and apply `worktrain:in-progress` label on escalation, write issue-ownership sidecar for cross-restart idempotency
+- ✅ **In-process `awaitSessions` and `getAgentResult`** (#741) -- replaced HTTP calls to the daemon's own console with direct `ConsoleService` access
+- ✅ **Try/catch on all coordinator I/O** (#740) -- `getAgentResult`, `pollForPR`, `postToOutbox` all wrapped; coordinator no longer crashes on I/O failure
+- ✅ **Dispatch dedup prealloc bypass** (#744) -- `dispatch()` now bypasses dedup for pre-allocated sessions, fixing the zombie session bug that prevented discovery from starting
+- ✅ **Promise.race crash fix** (#733) -- worktrees scan timeout no longer crashes the daemon via unhandled rejection
+- ✅ **Trigger validator** (#690) -- `worktrain trigger validate` command, `validateTriggerStrict()` pure function
+- ✅ **`worktrain trigger poll`** (#697) -- force immediate poll cycle on any queue trigger
+- ✅ **`worktrain trigger test`** (#656) -- dry-run showing what would dispatch
+- ✅ **Auto-load ~/.workrail/.env** (#673) -- daemon reads secrets from .env automatically
+- ✅ **Daemon lifecycle events** (#674) -- `session_aborted` on SIGTERM, `daemon_heartbeat` every 30s
+- ✅ **Attribution signals** (#658) -- `[WT]` PR title prefix, `Co-authored-by: WorkTrain` commit trailers, `worktrain:generated` label
+- ✅ **Secret scan before push** (#660) -- pattern-based scan blocks commits with leaked credentials
+- ✅ **Unified logs stream** (#680) -- `worktrain logs` now merges daemon events, queue-poll.jsonl, and filtered stderr
+- ✅ **Stale lock file handling** (#705) -- validates lock file PID before trusting port discovery
+- ✅ **5 architectural audits** (docs/design/) -- coordinator access, error handling, testability, type bloat, memory management
+- ✅ **Stale user workflow cleanup** -- removed old copies from `~/.workrail/workflows/` that were causing ValidationError noise
+
+### Current pipeline state (live)
+
+Discovery session `ecf359d7` running: 77 turns, 11 step advances (active, making real progress on issue #393). Session `b7df0c8b` also running (just started). First clean run after all pipeline fixes landed.
+
+### Accurate limitations (v3.59.6)
+
+1. **Ghost sessions in event log** -- sessions killed by daemon crashes don't get `session_aborted` events from old daemon instances. New daemons emit it on shutdown, but historical sessions show as RUNNING.
+2. **Worktree orphan leak** -- if `maybeRunDelivery()` worktree removal fails after sidecar deletion, orphan is invisible to `runStartupRecovery`. See backlog.
+3. **`queue-poll.jsonl` never rotated** -- disk exhaustion risk on long-running daemons. See backlog.
+4. **`ReviewSeverity` missing `assertNever`** -- future variants silently fall through. See backlog.
+5. **`process.stderr.write` in `readVerdictArtifact`** -- bypasses injected dep, invisible to test fakes. See backlog.
+6. **WorkRail MCP stale state** -- `workrail cleanup` command doesn't exist yet. Manual cleanup needed for dead managed sources, old session accumulation.
+7. **Trigger validation static/runtime gap** -- some runtime checks not in static validator. See trigger-validation-gap-audit.md.
+8. **WorkflowTrigger type bloat** -- mixes trigger config, session runtime state, delivery config. See workflow-trigger-lifecycle-audit.md.
+9. **Conversation history not persisted** -- LLM conversation history is in-memory only. On crash, context is lost. See backlog.
+
+### Next priorities (groomed Apr 21)
+
+1. **Watch the current pipeline run** -- discovery `ecf359d7` is active at 77 turns/11 steps. If it completes, shaping and coding should fire automatically. First end-to-end validation.
+2. **Execution time tracking** -- add session timing to `execution-stats.jsonl` for timeout calibration. Small change in `runWorkflow()` finally block.
+3. **Three audit findings from above** -- worktree orphan leak, queue-poll rotation, assertNever fixes. All small, targeted.
+4. **`workrail cleanup` command** -- removes dead managed sources, rotates old session files, clears stale git caches. Stops ValidationError noise in MCP server logs.
+5. **Conversation history persistence** -- `conversation.jsonl` per session, append-only. Prerequisite for true crash recovery.
+6. **Autonomous crash recovery and interrupted-session resume** -- see full entry below (Apr 21).
+
+---
+
+## Autonomous crash recovery and interrupted-session resume (Apr 21, 2026)
+
+**The problem we hit today:** A daemon crash loop (console `worktrees scan` unhandled rejection) killed all in-flight sessions. The queue correctly detected the sidecar and skipped re-dispatch for 56 min (TTL), but when the sidecar expired the session was re-dispatched from scratch with zero context from the previous attempt. The agent had already spent ~10 min in Phase 0, read codebase files, and formed a plan -- all of that work was lost.
+
+**What we want:** WorkTrain should be able to detect orphaned sessions on startup and make an autonomous decision: resume if the session had meaningful progress, discard and re-dispatch from scratch if it was too early to be worth resuming.
+
+**Resumability decision criteria (heuristics):**
+- Session had >= 1 `continue_workflow` call (at least one step advance): worth resuming -- the agent made real progress.
+- Session is at step 0 with 0 advances but > 5 LLM turns: borderline -- context was accumulated but no checkpoint written. Resume is risky (stale context), discard is safer. Could surface to console for human decision.
+- Session is at step 0, < 5 turns, < 2 min: discard -- nothing was lost.
+- Session's worktree is missing or corrupted: discard -- can't resume cleanly.
+- Session is on a coding workflow and has uncommitted changes in the worktree: pause for human review before discarding (could have partial work).
+
+**Implementation sketch:**
+
+1. **On daemon startup**, `runStartupRecovery()` already scans `daemon-sessions/` for orphaned token files. Extend it to also inspect the session event log for each orphan:
+   - Count `continue_workflow` calls and LLM turns from `~/.workrail/events/<sessionId>.jsonl`
+   - Apply decision criteria above
+   - For resume candidates: call `continue_workflow` with the checkpoint token and a synthesized re-entry prompt: "You are resuming a session that was interrupted by a daemon crash. Your last known step was [stepLabel]. Continue from where you left off."
+   - For discard candidates: emit `session_aborted` event, delete the sidecar, re-add the issue to the queue (or just let the TTL expire and the queue re-select naturally)
+
+2. **Conversation history prerequisite**: Resume is only useful if the agent can reconstruct its context. Today, conversation history is in-memory only -- it is lost on crash. The `conversation.jsonl` per-session persistence (backlog item #5 above) is a prerequisite for high-quality resume. Without it, resume starts from the workflow system prompt plus the current step recap only. This is enough for mid-pipeline phases (shaping, coding) since they read artifacts from disk. It may be insufficient for early discovery phases.
+
+3. **`worktrain session resume <sessionId>` CLI** -- manual override for human-initiated resume. Useful when the daemon's automatic heuristic chose to discard but the user sees partial work worth keeping.
+
+4. **Queue sidecar TTL for resume vs. discard**: Today the sidecar TTL prevents re-dispatch during the entire pipeline window (56 min). With autonomous resume, the TTL for a discarded session should be much shorter (5 min) so the queue can quickly re-select. For a resumed session, keep the full TTL and extend it by the time already spent.
+
+**Files to change:**
+- `src/daemon/workflow-runner.ts` -- `runStartupRecovery()`: add event log inspection and conditional resume
+- `src/trigger/polling-scheduler.ts` -- `doPollGitHubQueue()`: accept a `ttlOverride` param so discard path uses short TTL
+- `src/trigger/adapters/github-queue-poller.ts` -- `checkIdempotency()`: handle expired sidecars with `ttlOverride`
+- New: `src/daemon/session-recovery-policy.ts` -- pure function `evaluateRecovery(orphan, eventLog) -> 'resume' | 'discard' | 'human_review'`
+
+**Priority:** High. Every daemon crash currently wastes all in-flight work and waits up to 56 min before retrying. With even basic resume (step > 0 → resume, step = 0 → discard + fast re-dispatch), we'd recover most of the lost work and reduce retry latency from 56 min to < 5 min.
+
+**Depends on:** Conversation history persistence (for high-quality resume context).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.59.5",
+  "version": "3.59.7",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {

package/dist/trigger/daemon-console.d.ts

@@ -1,28 +0,0 @@
-import 'reflect-metadata';
-import type { V2ToolContext } from '../mcp/types.js';
-import type { TriggerRouter } from './trigger-router.js';
-import type { PollingScheduler } from './polling-scheduler.js';
-import type { WorkflowService } from '../application/services/workflow-service.js';
-import type { SteerRegistry } from '../daemon/workflow-runner.js';
-import type { Result } from '../runtime/result.js';
-export interface DaemonConsoleHandle {
-    readonly port: number;
-    stop(): Promise<void>;
-}
-export type DaemonConsoleError = {
-    readonly kind: 'port_conflict';
-    readonly port: number;
-} | {
-    readonly kind: 'io_error';
-    readonly message: string;
-};
-export interface StartDaemonConsoleOptions {
-    readonly port?: number;
-    readonly triggerRouter?: TriggerRouter;
-    readonly serverVersion?: string;
-    readonly workflowService?: WorkflowService;
-    readonly lockFilePath?: string;
-    readonly steerRegistry?: SteerRegistry;
-    readonly pollingScheduler?: PollingScheduler;
-}
-export declare function startDaemonConsole(ctx: V2ToolContext, options?: StartDaemonConsoleOptions): Promise<Result<DaemonConsoleHandle, DaemonConsoleError>>;