@exaudeus/workrail 3.72.0 → 3.72.2

package/dist/trigger/trigger-router.js

@@ -36,16 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerRouter = void 0;
 exports.interpolateGoalTemplate = interpolateGoalTemplate;
 const crypto = __importStar(require("node:crypto"));
-const fs = __importStar(require("node:fs/promises"));
-const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
-const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
 const assert_never_js_1 = require("../runtime/assert-never.js");
 const index_js_1 = require("../v2/infra/in-memory/keyed-async-queue/index.js");
 const delivery_client_js_1 = require("./delivery-client.js");
-const delivery_action_js_1 = require("./delivery-action.js");
+const delivery_pipeline_js_1 = require("./delivery-pipeline.js");
 const adaptive_pipeline_js_1 = require("../coordinators/adaptive-pipeline.js");
+const dispatch_deduplicator_js_1 = require("./dispatch-deduplicator.js");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 function interpolateGoalTemplate(template, staticGoal, payload, triggerId) {
     const TOKEN_RE = /\{\{([^}]+)\}\}/g;
@@ -123,68 +121,17 @@ function validateHmac(rawBody, secret, headerValue) {
 async function maybeRunDelivery(triggerId, trigger, result, execFn) {
     if (result._tag !== 'success')
         return;
-    if (trigger.autoCommit !== true) {
-        console.log(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- autoCommit not set for this trigger.`);
-        return;
-    }
     if (result.lastStepNotes === undefined) {
-        console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
-            `lastStepNotes is absent (agent did not provide notes on the final step). ` +
-            `Ensure the workflow produces a JSON handoff block in its final step notes.`);
+        if (trigger.autoCommit === true) {
+            console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
+                `lastStepNotes is absent (agent did not provide notes on the final step). ` +
+                `Ensure the workflow produces a JSON handoff block in its final step notes.`);
+        }
         return;
     }
-    const parseResult = (0, delivery_action_js_1.parseHandoffArtifact)(result.lastStepNotes);
-    if (parseResult.kind === 'err') {
-        console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
-            `handoff artifact not parseable: ${parseResult.error}. ` +
-            `Ensure the workflow's final step produces a JSON block with commitType, filesChanged, etc.`);
+    if (trigger.autoCommit !== true)
         return;
-    }
-    const deliveryCwd = result.sessionWorkspacePath ?? trigger.workspacePath;
-    const deliveryResult = await (0, delivery_action_js_1.runDelivery)(parseResult.value, deliveryCwd, {
-        autoCommit: trigger.autoCommit,
-        autoOpenPR: trigger.autoOpenPR,
-        secretScan: trigger.secretScan ?? true,
-        triggerId,
-        workflowId: trigger.workflowId,
-        ...(result.botIdentity !== undefined ? { botIdentity: result.botIdentity } : {}),
-        ...(trigger.branchStrategy === 'worktree' && result.sessionWorkspacePath
-            ? {
-                sessionId: result.sessionId ?? '',
-                branchPrefix: trigger.branchPrefix ?? 'worktrain/',
-            }
-            : {}),
-    }, execFn);
-    switch (deliveryResult._tag) {
-        case 'committed':
-            console.log(`[TriggerRouter] Delivery committed: triggerId=${triggerId} sha=${deliveryResult.sha}`);
-            break;
-        case 'pr_opened':
-            console.log(`[TriggerRouter] Delivery PR opened: triggerId=${triggerId} url=${deliveryResult.url}`);
-            break;
-        case 'skipped':
-            console.log(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} reason=${deliveryResult.reason}`);
-            break;
-        case 'error':
-            console.warn(`[TriggerRouter] Delivery error: triggerId=${triggerId} phase=${deliveryResult.phase} ` +
-                `details=${deliveryResult.details}`);
-            break;
-    }
-    if (trigger.branchStrategy === 'worktree' && result.sessionWorkspacePath) {
-        try {
-            await execFn('git', ['-C', trigger.workspacePath, 'worktree', 'remove', '--force', result.sessionWorkspacePath], { cwd: trigger.workspacePath, timeout: 60000 });
-            console.log(`[TriggerRouter] Worktree removed: triggerId=${triggerId} path=${result.sessionWorkspacePath}`);
-        }
-        catch (err) {
-            console.warn(`[TriggerRouter] Could not remove worktree: triggerId=${triggerId} ` +
-                `path=${result.sessionWorkspacePath}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        if (result.sessionId !== undefined) {
-            await fs.unlink(path.join(workflow_runner_js_1.DAEMON_SESSIONS_DIR, `${result.sessionId}.json`)).catch(() => { });
-            await fs.unlink(path.join(workflow_runner_js_1.DAEMON_SESSIONS_DIR, `${result.sessionId}-conversation.jsonl`)).catch(() => { });
-            console.log(`[TriggerRouter] Session sidecar removed: triggerId=${triggerId} sessionId=${result.sessionId}`);
-        }
-    }
+    await (0, delivery_pipeline_js_1.runDeliveryPipeline)(delivery_pipeline_js_1.DEFAULT_DELIVERY_PIPELINE, result, trigger, execFn, triggerId);
 }
 class Semaphore {
     constructor(max) {
@@ -216,20 +163,19 @@ class Semaphore {
 }
 const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter, notificationService, steerRegistry, abortRegistry, coordinatorDeps, modeExecutors) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter, notificationService, activeSessionSet, coordinatorDeps, modeExecutors, deduplicator) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
         this.runWorkflowFn = runWorkflowFn;
         this.queue = new index_js_1.KeyedAsyncQueue();
-        this._recentAdaptiveDispatches = new Map();
         this.execFn = execFn ?? execFileAsync;
         this.emitter = emitter;
         this.notificationService = notificationService;
-        this.steerRegistry = steerRegistry;
-        this.abortRegistry = abortRegistry;
+        this._activeSessionSet = activeSessionSet;
         this._coordinatorDeps = coordinatorDeps;
         this._modeExecutors = modeExecutors;
+        this._deduplicator = deduplicator ?? new dispatch_deduplicator_js_1.DispatchDeduplicator(TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS);
         const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
         const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
         if (cap < 1) {
@@ -324,18 +270,10 @@ class TriggerRouter {
         };
         {
             const dedupeKey = `${workflowTrigger.workflowId}::${workflowTrigger.goal}::${workflowTrigger.workspacePath}`;
-            const now = Date.now();
-            for (const [key, ts] of this._recentAdaptiveDispatches) {
-                if (now - ts >= TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
-                    this._recentAdaptiveDispatches.delete(key);
-                }
-            }
-            const lastDispatch = this._recentAdaptiveDispatches.get(dedupeKey);
-            if (lastDispatch !== undefined && now - lastDispatch < TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
+            if (this._deduplicator.checkAndRecord(dedupeKey)) {
                 console.log(`[TriggerRouter] Skipping duplicate route dispatch: workflowId=${workflowTrigger.workflowId} goal="${workflowTrigger.goal.slice(0, 60)}" (already dispatched within 30s)`);
                 return { _tag: 'enqueued', triggerId: trigger.id };
             }
-            this._recentAdaptiveDispatches.set(dedupeKey, now);
         }
         this.emitter?.emit({ kind: 'trigger_fired', triggerId: trigger.id, workflowId: trigger.workflowId });
         const queueKey = trigger.concurrencyMode === 'parallel'
@@ -351,7 +289,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter, this.steerRegistry, this.abortRegistry);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter, this._activeSessionSet);
             }
             finally {
                 this.semaphore.release();
@@ -406,21 +344,13 @@ class TriggerRouter {
         });
         return { _tag: 'enqueued', triggerId: trigger.id };
     }
-    dispatch(workflowTrigger) {
-        if (workflowTrigger._preAllocatedStartResponse === undefined) {
+    dispatch(workflowTrigger, source) {
+        if (source?.kind !== 'pre_allocated') {
             const dedupeKey = `${workflowTrigger.workflowId}::${workflowTrigger.goal}::${workflowTrigger.workspacePath}`;
-            const now = Date.now();
-            for (const [key, ts] of this._recentAdaptiveDispatches) {
-                if (now - ts >= TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
-                    this._recentAdaptiveDispatches.delete(key);
-                }
-            }
-            const lastDispatch = this._recentAdaptiveDispatches.get(dedupeKey);
-            if (lastDispatch !== undefined && now - lastDispatch < TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
+            if (this._deduplicator.checkAndRecord(dedupeKey)) {
                 console.log(`[TriggerRouter] Skipping duplicate dispatch: workflowId=${workflowTrigger.workflowId} goal="${workflowTrigger.goal.slice(0, 60)}" (already dispatched within 30s)`);
                 return workflowTrigger.workflowId;
             }
-            this._recentAdaptiveDispatches.set(dedupeKey, now);
         }
         else {
             console.log(`[TriggerRouter] Pre-allocated session dispatched: workflowId=${workflowTrigger.workflowId} goal="${workflowTrigger.goal.slice(0, 60)}"`);
@@ -434,7 +364,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter, this.steerRegistry, this.abortRegistry);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter, this._activeSessionSet, undefined, undefined, source);
             }
             finally {
                 this.semaphore.release();
@@ -485,14 +415,7 @@ class TriggerRouter {
             };
         }
         const dedupeKey = `${goal}::${workspace}`;
-        const now = Date.now();
-        for (const [key, ts] of this._recentAdaptiveDispatches) {
-            if (now - ts >= TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
-                this._recentAdaptiveDispatches.delete(key);
-            }
-        }
-        const lastDispatch = this._recentAdaptiveDispatches.get(dedupeKey);
-        if (lastDispatch !== undefined && now - lastDispatch < TriggerRouter.ADAPTIVE_DEDUPE_TTL_MS) {
+        if (this._deduplicator.checkAndRecord(dedupeKey)) {
             console.log(`[TriggerRouter] Skipping duplicate adaptive dispatch: goal="${goal.slice(0, 60)}" ` +
                 `(already dispatched within 30s)`);
             return {
@@ -503,7 +426,6 @@ class TriggerRouter {
                 },
             };
         }
-        this._recentAdaptiveDispatches.set(dedupeKey, now);
         const opts = {
             goal,
             workspace,

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

@@ -646,8 +646,16 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
         else {
             sessionHandle = workflowId;
         }
-        const trigger = { workflowId, goal, workspacePath, context, _preAllocatedStartResponse: startResponse };
-        void (0, workflow_runner_js_1.runWorkflow)(trigger, v2ToolContext, apiKey ?? '', undefined, undefined, undefined).then((result) => {
+        const trigger = { workflowId, goal, workspacePath, context };
+        const allocatedSession = {
+            continueToken: startResponse.continueToken ?? '',
+            checkpointToken: startResponse.checkpointToken,
+            firstStepPrompt: startResponse.pending?.prompt ?? '',
+            isComplete: startResponse.isComplete,
+            triggerSource: 'mcp',
+        };
+        const source = { kind: 'pre_allocated', trigger, session: allocatedSession };
+        void (0, workflow_runner_js_1.runWorkflow)(trigger, v2ToolContext, apiKey ?? '', undefined, undefined, undefined, undefined, undefined, source).then((result) => {
             if (result._tag === 'success') {
                 console.log(`[ConsoleRoutes] Auto dispatch completed: workflowId=${workflowId} stopReason=${result.stopReason}`);
             }

package/docs/ideas/backlog.md

@@ -74,6 +74,22 @@ Agent writes a complete handoff block (commitType, prTitle, prBody, filesChanged
 The autonomous workflow runner (`worktrain daemon`). Completely separate from the MCP server -- calls the engine directly in-process.
 
 
+### Daemon architecture: remaining migrations (Apr 29, 2026)
+
+**Status: partial** | A9 shipped Apr 29, 2026.
+
+Track A (A1-A9) shipped and the `SessionSource` migration is complete. `WorkflowTrigger._preAllocatedStartResponse` is gone.
+
+**Remaining items:**
+
+- `CriticalEffect<T>` / `ObservabilityEffect` type distinction -- categorize side effects in `runAgentLoop` and finalization as either crash-relevant or observability-only
+- `StateRef` mutation wrapper -- replace direct `state.pendingSteerParts.push()` mutations with an explicit mutation API
+- Zod tool param validation -- replace manual `typeof` checks in tool factories with Zod schema validation (requires `zodToJsonSchema` or maintaining two sources of truth for param schemas)
+- `createCoordinatorDeps` unit tests -- extraction in B3 improved testability; cover `spawnSession`, `awaitSessions`, `getAgentResult` at minimum
+- Wire `AllocatedSession.triggerSource` to the `run_started` event for session attribution (one-liner once the event schema field is added -- see "Session trigger source attribution" entry below)
+
+---
+
 ### `wr.refactoring` workflow (Apr 28, 2026)
 
 **Status: idea** | Priority: medium
@@ -103,59 +119,35 @@ The `wr.coding-task` workflow has too much overhead for pure refactors (design r
 
 ---
 
-### runWorkflow() functional core refactor -- Phase 2 (Apr 24, 2026)
+### runWorkflow() functional core refactor -- Phases 2-4 (Apr 24-29, 2026)
 
-**Status: done** | Shipped in PR #830 (Apr 29, 2026)
+**Status: done** | Phases 2-3 shipped Apr 29, 2026. Phase 4 (A1-A8) shipped Apr 29, 2026.
 
-Phase 1 landed in PR #818: extracted `tagToStatsOutcome`, `buildAgentClient`, `evaluateStuckSignals`, `SessionState`, and `finalizeSession`. Phase 2 landed in PR #830:
+Phase 1 (PR #818): `tagToStatsOutcome`, `buildAgentClient`, `evaluateStuckSignals`, `SessionState`, `finalizeSession`.
+Phase 2 (PR #830): `PreAgentSession`/`PreAgentSessionResult`, `buildPreAgentSession`, `constructTools`, `persistTokens` Result type, TDZ fix.
+Phase 3 (PRs #835, #837): `buildTurnEndSubscriber`, `buildAgentCallbacks`, `buildSessionResult`. runWorkflow() body: 539 → 308 lines.
 
-**What remains:**
+**Phase 4 (Track A, PRs #839-#861, Apr 29, 2026):**
+- A1: `runStartupRecovery` apiKey injected as parameter (removes process.env read)
+- A2: Turn-end collaborators extracted to `src/daemon/turn-end/` (`step-injector`, `detect-stuck`, `conversation-flusher`)
+- A3: `SessionScope` + `FileStateTracker` -- typed tool-layer contract, raw Map encapsulated (#843)
+- A4: All 11 tool factories extracted to `src/daemon/tools/` -- workflow-runner.ts -1,500 lines (#851)
+- A5: `ContextLoader` + `ContextBundle` -- two-phase context assembly, parallelized with pre-agent session setup (#855)
+- A6: `ActiveSessionSet` + `SessionHandle` -- replaces `SteerRegistry` + `AbortRegistry` dual Maps; closes TDZ hazard (#856)
+- A7: `buildAgentReadySession` + `runAgentLoop` extracted -- runWorkflow() body: 302 → 92 lines (#859)
+- A8: `SessionSource` discriminated union + `AllocatedSession` -- typed vocabulary for `_preAllocatedStartResponse` migration (#861)
+- A9: Full `SessionSource` migration -- `WorkflowTrigger._preAllocatedStartResponse` removed; all 4 call sites construct `SessionSource` directly; `runWorkflow()` accepts `source?: SessionSource` (#869)
 
-**Extract `buildSessionConfig(trigger, loadedCtx) -> SessionConfig`** -- a pure function that takes already-loaded context (soul content, workspace context string, session notes array -- all loaded by I/O before the call) and returns everything the agent loop needs: system prompt, tool list, session limits, model/client config. Currently this logic is scattered through the setup phase alongside the I/O calls that load the data.
+**Also shipped (Track B, PRs #846-#848):**
+- B1: `DispatchDeduplicator` -- compile-enforced dedup contract, replaces verbal MUST comment
+- B2: `DeliveryPipeline` + `DeliveryStage` -- staged delivery, preempts accretion in trigger-router.ts
+- B3: `createCoordinatorDeps` + `setDispatch` -- extracted from 900-line trigger-listener.ts; circular dep fixed
 
-```typescript
-interface SessionContext {
-  readonly systemPrompt: string;
-  readonly tools: readonly AgentTool[];
-  readonly sessionTimeoutMs: number;
-  readonly maxTurns: number;
-  readonly initialPrompt: string;
-  readonly agentCallbacks: AgentLoopCallbacks;
-}
+**Unit tests added (PRs #863-#865):** `DefaultFileStateTracker` (15), `DefaultContextLoader` (12), `ActiveSessionSet`/`SessionHandle` (11).
 
-function buildSessionContext(
-  trigger: WorkflowTrigger,
-  agentClient: AgentClientInterface,
-  modelId: string,
-  soulContent: string,           // already loaded by loadDaemonSoul()
-  workspaceContext: string | null, // already loaded by loadWorkspaceContext()
-  sessionNotes: readonly string[], // already loaded by loadSessionNotes()
-  state: SessionState,
-  // ... tool factories, schemas, etc.
-): SessionContext
-```
-
-The shell then does:
-1. All I/O in sequence: `loadDaemonSoul`, `loadWorkspaceContext`, `loadSessionNotes`, `git worktree add`, `executeStartWorkflow`, `parseContinueTokenOrFail`, `persistTokens`
-**What Phase 2 delivered (PR #830):**
-- `PreAgentSession` interface + `PreAgentSessionResult` discriminated union -- all early-exit paths type-enforced
-- `buildPreAgentSession()` -- all pre-agent I/O extracted; steer+daemon registries registered after all failing I/O (FM1 invariant)
-- `constructTools()` -- explicitly impure named function, `state` as explicit parameter
-- `persistTokens()` returns `Promise<Result<void, PersistTokensError>>` using `src/runtime/result.ts`
-- `sidecardLifecycleFor()` pure function with `assertNever` exhaustiveness
-- TDZ hazard fixed: `abortRegistry.set()` now registered after `const agent = new AgentLoop()`
+**Total workflow-runner.ts reduction: ~4,955 → ~2,800 lines (44%).**
 
-**Phase 3 (PRs #835, #837)** continued the refactor:
-- `buildTurnEndSubscriber()` extracted -- runWorkflow() body: 539 → 426 lines
-- Tool param validation at LLM boundary (8 tool factories)
-- `buildAgentCallbacks()` + `buildSessionResult()` pure functions -- body: 426 → 308 lines
-- Test flakiness fix: `settleFireAndForget()` + `retry: 2` in vitest config
-
-**Still deferred:**
-- `CriticalEffect<T>` / `ObservabilityEffect` type distinction
-- `StateRef` mutation wrapper
-- Zod tool param validation (replacing manual typeof checks -- requires zodToJsonSchema or two sources of truth)
-- `wr.refactoring` workflow (see backlog entry above)
+**Follow-on:** `wr.refactoring` workflow (see backlog entry above). Remaining items in "Daemon architecture: remaining migrations" entry below.
 
 ---
 
@@ -623,6 +615,29 @@ The stdio/HTTP MCP server that Claude Code (and other MCP clients) connect to. M
 
 ## Console
 
+### Task picker mode: browse and launch available work (Apr 29, 2026)
+
+**Status: idea** | Priority: high
+
+**Problem:** Once WorkTrain is configured (workspace set up, triggers.yml written, daemon running), there is still no easy way to say "run this workflow now" from the console. Dispatch requires knowing the API or writing a webhook. The console has a dispatch endpoint but no UI to drive it.
+
+**Vision:** A console panel that lists the triggers already configured in triggers.yml and lets the user click one to fire it immediately -- without leaving the browser, without touching the API, without writing YAML.
+
+**How it works:**
+1. Console calls `GET /api/v2/triggers` to list all triggers loaded by the daemon.
+2. User sees a list: trigger ID, workflow, goal, last-fired timestamp. Clicks "Run".
+3. Console POSTs to `/api/v2/auto/dispatch` (already implemented) with the trigger's workflowId + goal + workspace.
+4. New session appears in the session list immediately. User watches the DAG advance live.
+5. On completion: outcome, PR link (if opened), and step notes all visible in the same panel.
+
+**What this is not:** An onboarding wizard or zero-setup flow -- the daemon and environment must already be configured. This is a dispatch surface for *already-configured* users who want to trigger work without using the CLI or waiting for a webhook.
+
+**Why it matters:** Makes the console a control plane, not just a read-only viewer. The daemon gains a "run this now" button. Users get to watch the agent work in real time, which builds confidence before trusting it on unattended tasks.
+
+**Dependency:** `GET /api/v2/triggers` endpoint (returns the live trigger index -- may need to be added). `POST /api/v2/auto/dispatch` already exists. No new daemon work required.
+
+---
+
 ### Console interactivity and liveliness
 
 **Status: idea** | Priority: medium
@@ -733,6 +748,14 @@ A workflow that aggregates activity across git history, GitLab/GitHub MRs and re
 
 ## Platform Vision (longer-term)
 
+### Inspiration: openclaw (Apr 29, 2026)
+
+**Source:** https://github.com/openclaw/openclaw
+
+openclaw is worth studying deeply before building out the platform layer. Draw inspiration from it when designing: multi-agent orchestration patterns, coordinator architecture, context packaging for subagents, task queue and dispatch models, and the overall shape of an autonomous engineering platform. Review it before making architectural decisions on any of the Platform Vision items below.
+
+---
+
 ### Knowledge graph for agent context
 
 **Status: idea** | Priority: medium
@@ -1089,8 +1112,7 @@ WorkTrain is a persistent background daemon that initiates workflows autonomousl
 - Bot identity (`botIdentity`) and acting-as-user support
 - Dynamic model selection (`agentConfig.model`)
 - macOS notifications
-- SteerRegistry + mid-session injection
-- AbortRegistry + SIGTERM graceful shutdown
+- `ActiveSessionSet` + mid-session steer injection + SIGTERM graceful shutdown (replaces SteerRegistry + AbortRegistry)
 - `maxOutputTokens` per trigger, `maxQueueDepth` with HTTP 429
 - Crash recovery Phase B
 - `daemon-soul.md` / workspace context injection
@@ -1103,6 +1125,7 @@ WorkTrain is a persistent background daemon that initiates workflows autonomousl
 - Worktree orphan cleanup on delivery failure
 - runWorkflow() Phase 2 architecture (PR #830): `PreAgentSession`/`buildPreAgentSession`, `constructTools`, `persistTokens` Result type, `sidecardLifecycleFor` pure function, TDZ hazard fix for abort registry
 - runWorkflow() Phase 3 architecture (PRs #835, #837): `buildTurnEndSubscriber` (539→426 lines), tool param validation at LLM boundary (8 factories), `buildAgentCallbacks` + `buildSessionResult` pure functions (426→308 lines), test flakiness fix (settleFireAndForget + retry:2)
+- runWorkflow() Phase 4 / Track A+B architecture (PRs #839-#869, Apr 29, 2026): six-layer daemon decomposition -- `SessionScope`+`FileStateTracker`, tool extraction to `src/daemon/tools/`, `ContextLoader`+`ContextBundle`, `ActiveSessionSet`+`SessionHandle` (TDZ fix), `buildAgentReadySession`+`runAgentLoop`, `SessionSource`+`AllocatedSession`+full `_preAllocatedStartResponse` removal, `DispatchDeduplicator`, `DeliveryPipeline`, `createCoordinatorDeps`. workflow-runner.ts: 4,955 → 2,800 lines (44%). 38 new unit tests for new abstractions. `ActiveSessionSet` replaces `SteerRegistry`+`AbortRegistry`.
 
 ### WorkRail engine / MCP features
 
@@ -1165,3 +1188,14 @@ The agent is expensive, inconsistent, and slow. Scripts are free, deterministic,
 
 ---
 
+### Worktree and branch lifecycle management
+
+WorkTrain has no tooling to surface the state of worktrees and branches relative to main. Doing this manually today requires running git commands across every registered worktree, cross-referencing merged PR lists, and inspecting each branch's unique commits to determine if the work landed. Pain points observed in practice:
+
+- Worktrees persist after their branch's PR is squash-merged -- no signal that they are safe to delete
+- No inventory of which branches have genuinely unmerged work vs. fully superseded content
+- Abandoned in-progress branches have no attached context about why they were abandoned or what state they were in
+- Daemon-spawned worktrees under `~/.workrail/worktrees/` are opaque -- no indication of which session created them or whether cleanup is safe
+
+---
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.72.0",
+  "version": "3.72.2",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {
@@ -145,6 +145,7 @@
     "vitest": "^3.2.4"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20",
+    "npm": ">=11.11.1"
   }
 }