@ashlr/hub 3.2.7 → 3.3.2

package/dist/core/types.d.ts

@@ -730,6 +730,15 @@ export interface AshlrConfig {
         kimi?: {
             maxConcurrent?: number;
             costPerMTokenOut?: number;
+            /**
+             * M270: high-level convenience override that promotes the 'kimi' engine
+             * spec's tier (engine-registry.ts:405 applyKimiConfig — e.g.
+             * `foundry.kimi = { tier: 'frontier' }` grants WORK-ASSIGNMENT frontier
+             * eligibility without touching the builtin registry). Previously read
+             * only via an untyped `(cfg?.foundry as Record<string, unknown>)?.['kimi']`
+             * cast; live in ~/.ashlr/config.json (tier: 'frontier') as of this audit.
+             */
+            tier?: EngineTier;
         };
         /**
          * M248: guarantee fleet sandboxed engines inherit ashlr-plugin MCP tools.
@@ -1074,12 +1083,12 @@ export interface AshlrConfig {
             maxAutomergeFiles?: number;
             /** Max changed lines permitted in an auto-merge diff (default 150, hard maximum 300). */
             maxAutomergeLines?: number;
-            /** Also merge/push on the remote (gh pr merge) when applying (default false). */
+            /** Stage/push a reviewed branch and open a protected PR handoff; never merges the hosted PR (default false). */
             pushToRemote?: boolean;
             /**
              * Remote-main policy expectation. This configuration is never
              * authority by itself: live GitHub protection must match it immediately
-             * before evidence capture, remote handoff, PR creation, and host auto-merge.
+             * before evidence capture, remote handoff, and PR creation.
              */
             protectedRemote?: {
                 /** Operator expects live branch protection; autonomous remote-main delivery requires true. */
@@ -1310,6 +1319,47 @@ export interface AshlrConfig {
             /** Ollama base URL (default 'http://localhost:11434'). */
             baseUrl?: string;
         };
+        /**
+         * M151: opt-in EDV (independent/external) verification signal folded into
+         * backlog item scoring. DEFAULT false. Previously read only via an untyped
+         * `(cfg.foundry as Record<string, unknown>)?.['edvVerify']` cast in
+         * src/core/portfolio/backlog.ts — this only adds type safety/
+         * discoverability, no behavior change.
+         */
+        edvVerify?: boolean;
+        /**
+         * M185: gate for the `ashlrcode` (ac) autonomous executor path. DEFAULT
+         * false (opt-in). Previously read only via an untyped
+         * `(cfg.foundry as Record<string, unknown>)?.['ashlrcodeExecutor']` cast
+         * in src/core/run/ashlrcode-engine.ts.
+         */
+        ashlrcodeExecutor?: boolean;
+        /**
+         * Spec-contract acceptance-criteria checking gate. DEFAULT false
+         * (disabled — emptyDetail short-circuit). Previously read only via an
+         * untyped `(cfg?.foundry as Record<string, unknown>)?.['specContract']`
+         * cast in src/core/run/spec-contract.ts.
+         */
+        specContract?: boolean;
+        /**
+         * Inject a lightweight repo map into sandboxed-engine prompts. DEFAULT
+         * false. Previously read only via an untyped
+         * `(cfg.foundry as Record<string, unknown>)?.['repoMap']` cast in
+         * src/core/run/sandboxed-engine.ts (sibling to `localization`, which
+         * remains untyped/out of scope for this pass).
+         */
+        repoMap?: boolean;
+        /**
+         * Repair-treatment maintenance pass toggle. DEFAULT true (opt-out via
+         * false). Discovered live in ~/.ashlr/config.json during the M340b type
+         * audit — previously read only via untyped
+         * `(liveCfg.foundry as Record<string, unknown>)?.['proposalRepair']`
+         * casts in src/core/daemon/loop.ts (3 sites) and src/core/fleet/status.ts.
+         * NOT YET present in KNOWN_FOUNDRY_KEYS (src/core/effective-config.ts),
+         * so a live config setting it currently trips a false-positive "unknown
+         * foundry key" warning — flagged separately for that file's owner.
+         */
+        proposalRepair?: boolean;
     };
     /**
      * M24: optional autonomous-operator (daemon) tuning. When unset, the daemon
@@ -2778,6 +2828,18 @@ export interface DashboardSnapshot {
      * making a second request. READ-ONLY and never carries secrets.
      */
     fleet?: import('./fleet/status.js').FleetStatus;
+    /**
+     * Perf: OPTIONAL freshness marker for `fleet`. `buildFleetStatus` is now
+     * served from a shared cache (see web/fleet-status-cache.ts) so concurrent
+     * requests never trigger duplicate full recomputes. `stale: true` means
+     * `fleet` is the last good value (still honestly reported, never silently
+     * presented as current) while a background refresh is in flight; `ageMs`
+     * is how old it is. Absent when the fleet section itself is absent.
+     */
+    fleetFreshness?: {
+        stale: boolean;
+        ageMs: number;
+    };
     /**
      * M29: OPTIONAL org-level portfolio roll-up. ABSENT on existing producers /
      * tests (so they stay valid); populated by buildSnapshot when the v2 sources
@@ -2839,6 +2901,28 @@ export interface ProductionSummary {
         harmful: number;
         total: number;
     };
+    /**
+     * Judge calls over the last 24h that produced NO real verdict — a parse
+     * failure (unparseable LLM response, even after the one-shot retry) or a
+     * network failure (the API call itself threw). judgeProposal() returns via
+     * its `fallback()` helper BEFORE recordJudgeTrace() runs on either path
+     * (see fleet/manager.ts), so these calls write no judge-trace row and are
+     * invisible to judgeVerdicts24h — without this field a failed judge call
+     * looks identical to a judge call that never happened.
+     *
+     * Sourced from the decisions ledger's distinct 'judge-parse-failure' /
+     * 'judge-network-failure' judgeReasonCode (fleet/judge-decision-metadata.ts),
+     * NOT from judge-trace — fallback verdicts are deliberately never written
+     * to judge-trace because their synthetic all-3 scores would corrupt
+     * judge-calibration.ts (darkCurrent/kappa/degradation-harness all read
+     * every trace unconditionally). The decisions ledger already records both
+     * failure kinds distinctly and separately from calibration's read path.
+     */
+    judgeFailures24h: {
+        parse: number;
+        network: number;
+        total: number;
+    };
     /** Auto-merges today: proposals that reached status 'applied' today. */
     autoMergesToday: {
         count: number;
@@ -3561,6 +3645,18 @@ export interface ProposalVerifyResult {
     passed: boolean;
     failed?: string[];
     detail?: string;
+    /**
+     * Present only when passed:false. Distinguishes WHY verification failed:
+     * Only explicit 'code' means the verifier ran and found a real problem with
+     * the diff. An absent category is legacy/unknown and cannot authorize
+     * permanent rejection. 'tool' means the verifier itself
+     * could not be executed (missing binary, exit 127, spawn ENOENT — a
+     * verifier-unavailable outcome, not a judgment on the diff). 'timeout' and
+     * 'infra' are likewise infrastructure signals, not code signals. Consumers
+     * that gate permanent rejection/auto-archival on verification failure MUST
+     * check this before treating a failure as fatal to the proposal.
+     */
+    failureCategory?: 'code' | 'tool' | 'timeout' | 'infra' | 'cancelled' | 'invalid-command';
     ran?: Array<{
         id?: string;
         kind: 'typecheck' | 'lint' | 'build' | 'test';
@@ -5097,7 +5193,11 @@ export interface RunEstimate {
  * M119: One entry in the append-only decisions ledger
  * (~/.ashlr/decisions/YYYY-MM-DD.jsonl).
  */
-export type JudgeDecisionReasonCode = 'judge-ship-would-merge' | 'judge-ship-review-required' | 'judge-review' | 'judge-noise' | 'judge-harmful' | 'judge-verdict-unrecognized';
+export type JudgeDecisionReasonCode = 'judge-ship-would-merge' | 'judge-ship-review-required' | 'judge-review' | 'judge-noise' | 'judge-harmful' | 'judge-verdict-unrecognized'
+/** Judge responded but its output could not be parsed as a verdict (after retry). NOT a considered judgment. */
+ | 'judge-parse-failure'
+/** The judge call itself failed (network/API/spawn error) — no model response was obtained. NOT a considered judgment. */
+ | 'judge-network-failure';
 export interface DecisionEntry {
     /** ISO timestamp. */
     ts: string;

package/dist/core/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA2zIH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAw5IH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,CAAC"}

package/dist/core/web/api.d.ts

@@ -46,6 +46,8 @@ import type { AshlrConfig } from '../types.js';
  * Each cleanup clears the interval and ends the response.
  */
 export declare function drainSseConnections(): void;
+/** Revoke only streams authenticated by one exact browser session. */
+export declare function drainSseSession(sessionId: string): void;
 /**
  * Handle a single request if its URL matches an /api/* route.
  *
@@ -57,4 +59,8 @@ export declare function drainSseConnections(): void;
 export declare function handleApi(req: IncomingMessage, res: ServerResponse, cfg: AshlrConfig, ctx: {
     token: string;
     allowDispatch: boolean;
+    readSession?: {
+        id: string;
+        expiresAt: number;
+    };
 }): Promise<boolean>;

package/dist/core/web/api.js

@@ -72,6 +72,7 @@ import { readPublicDaemonObservation, } from '../daemon/public-observation.js';
 import { serviceStatus } from '../daemon/service.js';
 import { daemonServiceInstallOptions } from '../daemon/service-config.js';
 import { buildFleetStatus, readFleetDaemonStatus } from '../fleet/status.js';
+import { getCachedFleetStatus, primeFleetStatusCache } from './fleet-status-cache.js';
 // M61: Mission Control aggregator.
 import { buildControlSnapshot } from './control.js';
 // M90: Fleet-Activity panel.
@@ -93,9 +94,9 @@ const _sseCleanups = new Map();
  * Register a cleanup callback for an SSE connection.
  * Returns the id so it can be deregistered on close.
  */
-function registerSse(cleanup) {
+function registerSse(cleanup, sessionId) {
     const id = randomBytes(8).toString('hex');
-    _sseCleanups.set(id, cleanup);
+    _sseCleanups.set(id, { cleanup, sessionId });
     return id;
 }
 /** Remove a registered SSE cleanup. */
@@ -107,7 +108,7 @@ function deregisterSse(id) {
  * Each cleanup clears the interval and ends the response.
  */
 export function drainSseConnections() {
-    for (const cleanup of _sseCleanups.values()) {
+    for (const { cleanup } of _sseCleanups.values()) {
         try {
             cleanup();
         }
@@ -118,6 +119,18 @@ export function drainSseConnections() {
     _sseCleanups.clear();
     sseHistoryProjection = null;
 }
+/** Revoke only streams authenticated by one exact browser session. */
+export function drainSseSession(sessionId) {
+    for (const [id, entry] of _sseCleanups) {
+        if (entry.sessionId !== sessionId)
+            continue;
+        try {
+            entry.cleanup();
+        }
+        catch { /* best effort */ }
+        _sseCleanups.delete(id);
+    }
+}
 // ---------------------------------------------------------------------------
 // SSE poll interval — bounded, not configurable by callers.
 // ---------------------------------------------------------------------------
@@ -557,7 +570,10 @@ async function buildVisionMissionSnapshot(cfg) {
 /** Write a JSON response. Never throws. */
 function sendJson(res, status, body) {
     try {
-        const payload = JSON.stringify(sanitizePublicJson(body) ?? null);
+        const boundedBody = body && typeof body === 'object' && 'error' in body
+            ? { ...body, error: String(body.error).slice(0, 512) }
+            : body;
+        const payload = JSON.stringify(sanitizePublicJson(boundedBody) ?? null);
         res.writeHead(status, {
             'Content-Type': 'application/json',
             'Cache-Control': 'no-store',
@@ -579,7 +595,8 @@ function sendJson(res, status, body) {
 }
 /** Write a 500 JSON error. Never throws. */
 function send500(res, msg = 'internal error') {
-    sendJson(res, 500, { error: msg });
+    void msg; // retained at call sites for private diagnostics; never disclose it.
+    sendJson(res, 500, { code: 'INTERNAL_ERROR', error: 'internal server error' });
 }
 /**
  * Constant-time string comparison to defend against timing attacks.
@@ -743,12 +760,18 @@ function cachedSseHistoryProjection() {
  * Concurrent connections are capped (SSE_MAX_CONNECTIONS) to bound timer/
  * socket growth; excess connections get a 503.
  */
-function handleSseEvents(req, res, cfg, allowDispatch) {
+function handleSseEvents(req, res, cfg, allowDispatch, readSession) {
     // Cap concurrent SSE connections to bound timer/socket growth.
     if (_sseCleanups.size >= SSE_MAX_CONNECTIONS) {
         sendJson(res, 503, { error: 'too many live connections' });
         return;
     }
+    // Install the response error listener before the first header/body write.
+    // The indirection observes the fully wired cleanup once registration is
+    // complete, while also preventing an early EventEmitter 'error' crash.
+    let cleanup = () => { };
+    if (typeof res.on === 'function')
+        res.on('error', () => cleanup());
     // SSE headers — no buffering, keep-alive.
     res.writeHead(200, {
         'Content-Type': 'text/event-stream',
@@ -764,10 +787,26 @@ function handleSseEvents(req, res, cfg, allowDispatch) {
         return; // Socket already gone.
     }
     // Helper: send one NAMED SSE event so the client's per-name listeners fire.
+    let backpressured = false;
+    let backpressureTimer;
+    let cleaned = false;
     function sendNamed(event, payload) {
+        if (cleaned || backpressured)
+            return;
         try {
             const line = `event: ${event}\ndata: ${JSON.stringify(sanitizePublicJson(payload))}\n\n`;
-            res.write(line);
+            if (!res.write(line)) {
+                backpressured = true;
+                // Resolve cleanup when the timer fires; the initial snapshot can
+                // backpressure before the fully-wired cleanup closure is assigned.
+                backpressureTimer = setTimeout(() => cleanup(), 10_000);
+                res.once('drain', () => {
+                    backpressured = false;
+                    if (backpressureTimer)
+                        clearTimeout(backpressureTimer);
+                    backpressureTimer = undefined;
+                });
+            }
         }
         catch {
             // Socket closed; cleanup will be triggered by 'close' event.
@@ -778,7 +817,7 @@ function handleSseEvents(req, res, cfg, allowDispatch) {
     let updateInFlight = false;
     // Emit one full update (runs, swarms, inbox, daemon slices).
     async function emitUpdate() {
-        if (updateInFlight)
+        if (updateInFlight || backpressured)
             return;
         updateInFlight = true;
         try {
@@ -809,7 +848,11 @@ function handleSseEvents(req, res, cfg, allowDispatch) {
             catch {
                 // Keep the event stream alive with explicit unavailable provenance.
             }
+            if (cleaned)
+                return;
             const daemon = await readFreshDaemonObservation();
+            if (cleaned)
+                return;
             sendNamed('daemon', legacyDaemonProjection(daemon));
             sendNamed('daemon-observation', daemon);
             // M90: fleet-activity liveness pulse — carry daemon tick count so the
@@ -856,8 +899,15 @@ function handleSseEvents(req, res, cfg, allowDispatch) {
         }
     }, SSE_POLL_MS);
     // Cleanup: clear the interval and end the response.
-    const cleanup = () => {
+    cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
         clearInterval(intervalId);
+        if (backpressureTimer)
+            clearTimeout(backpressureTimer);
+        if (expiryTimer)
+            clearTimeout(expiryTimer);
         deregisterSse(sseId);
         try {
             res.end();
@@ -866,7 +916,12 @@ function handleSseEvents(req, res, cfg, allowDispatch) {
             // Already ended.
         }
     };
-    const sseId = registerSse(cleanup);
+    const sseId = registerSse(cleanup, readSession.id);
+    const expiryDelay = readSession.expiresAt - Date.now();
+    const expiryTimer = setTimeout(() => {
+        sendNamed('session-expired', { expired: true });
+        cleanup();
+    }, Math.max(0, expiryDelay));
     // Clear on client disconnect.
     req.on('close', cleanup);
     req.on('error', cleanup);
@@ -1114,13 +1169,71 @@ export async function handleApi(req, res, cfg, ctx) {
             sendJson(res, 200, pack);
             return true;
         }
+        // Valid `?status=` values for GET /api/inbox — mirrors INBOX_STATUS_FILTERS
+        // in src/cli/inbox.ts exactly. `?limit=` beyond the default is capped at
+        // INBOX_LIST_HARD_MAX_LIMIT regardless of what the caller asks for.
+        const INBOX_STATUS_QUERY_VALUES = new Set([
+            'pending', 'approved', 'rejected', 'awaiting-host-merge', 'applied', 'failed', 'all',
+        ]);
+        const INBOX_LIST_DEFAULT_LIMIT = 200;
+        const INBOX_LIST_HARD_MAX_LIMIT = 1000;
         // ── GET /api/inbox ───────────────────────────────────────────────────────
-        // M23: read-only pending-proposals view. listProposals never throws.
+        // M23: read-only proposals view. Defaults to pending-only, byte-identical
+        // to the original response, unless an explicit status/since/limit opts
+        // into the "history" view — mirrors `ashlr inbox --status/--since/--limit`
+        // (src/cli/inbox.ts) so the web surface can finally browse rejected/
+        // approved/etc, not just pending. listProposals never throws; every param
+        // is validated against a fixed set / parsed strictly, and the history
+        // response is capped (INBOX_LIST_DEFAULT_LIMIT / hard max) so opting into
+        // filtering can never hand the browser an unbounded JSON payload.
         if (path === '/api/inbox' && method === 'GET') {
-            const proposals = listProposals({ status: 'pending' });
+            const statusParam = getQueryParam(req.url ?? '/', 'status');
+            const sinceParam = getQueryParam(req.url ?? '/', 'since');
+            const limitParam = getQueryParam(req.url ?? '/', 'limit');
+            if (statusParam !== undefined && !INBOX_STATUS_QUERY_VALUES.has(statusParam)) {
+                sendJson(res, 400, {
+                    error: `status must be one of: ${[...INBOX_STATUS_QUERY_VALUES].join(', ')}; got: ${statusParam}`,
+                });
+                return true;
+            }
+            let sinceMs;
+            if (sinceParam !== undefined) {
+                const parsed = Date.parse(sinceParam);
+                if (Number.isNaN(parsed)) {
+                    sendJson(res, 400, { error: `since must be an ISO timestamp or YYYY-MM-DD, got: ${sinceParam}` });
+                    return true;
+                }
+                sinceMs = parsed;
+            }
+            let limit;
+            if (limitParam !== undefined) {
+                const n = /^[0-9]+$/.test(limitParam) ? Number.parseInt(limitParam, 10) : NaN;
+                if (!Number.isFinite(n) || n <= 0) {
+                    sendJson(res, 400, { error: `limit must be a positive integer, got: ${limitParam}` });
+                    return true;
+                }
+                limit = Math.min(n, INBOX_LIST_HARD_MAX_LIMIT);
+            }
+            // No query params at all -> the exact original call/shape (pending
+            // only, unbounded). Any explicit status/since/limit opts into history.
+            const filtering = statusParam !== undefined || sinceMs !== undefined || limit !== undefined;
+            const effectiveStatus = statusParam ?? (sinceMs !== undefined ? 'all' : 'pending');
+            const all = listProposals(); // newest-first; same full-directory read the pending-only call already did.
+            let matched = effectiveStatus === 'all' ? all : all.filter((p) => p.status === effectiveStatus);
+            if (sinceMs !== undefined) {
+                const floor = sinceMs;
+                matched = matched.filter((p) => {
+                    const t = Date.parse(p.createdAt);
+                    return !Number.isNaN(t) && t >= floor;
+                });
+            }
+            const shown = filtering ? matched.slice(0, limit ?? INBOX_LIST_DEFAULT_LIMIT) : matched;
             sendJson(res, 200, {
-                pending: proposals.length,
-                proposals,
+                pending: filtering ? all.filter((p) => p.status === 'pending').length : shown.length,
+                total: all.length,
+                proposals: shown,
+                truncated: matched.length > shown.length,
+                filters: { status: effectiveStatus, since: sinceParam ?? null, limit: limit ?? null },
             });
             return true;
         }
@@ -1136,7 +1249,34 @@ export async function handleApi(req, res, cfg, ctx) {
                 sendJson(res, 404, { error: `proposal not found: ${id}` });
                 return true;
             }
-            sendJson(res, 200, proposal);
+            // Join the decisions ledger (read-only, additive) so the operator can
+            // see the judge's actual verdict/reasonCode for this proposal — a
+            // judge-parse-failure/judge-network-failure is an infra failure, NOT a
+            // considered judgment, and the ledger is the only place that
+            // distinction lives (Proposal itself never carries judgeReasonCode).
+            // Never invents a verdict: when the ledger read is degraded or no
+            // decision row matches this id, sourceQuality says exactly that so the
+            // UI's Epistemic primitive renders "unknown" instead of guessing.
+            let decisionEvidence;
+            try {
+                const { readDecisionsDetailed } = await import('../fleet/decisions-ledger.js');
+                const read = readDecisionsDetailed({ proposalId: id, limit: 25 });
+                decisionEvidence = {
+                    sourceQuality: {
+                        sourceState: read.sourceState,
+                        complete: read.complete,
+                        ...(read.stopReasons.length > 0 ? { reason: read.stopReasons.join(', ') } : {}),
+                    },
+                    decisions: read.decisions,
+                };
+            }
+            catch {
+                decisionEvidence = {
+                    sourceQuality: { sourceState: 'degraded', complete: false, reason: 'ledger read failed' },
+                    decisions: [],
+                };
+            }
+            sendJson(res, 200, { ...proposal, decisionEvidence });
             return true;
         }
         // ── POST /api/inbox/:id/approve|reject (M32) ─────────────────────────
@@ -1251,6 +1391,10 @@ export async function handleApi(req, res, cfg, ctx) {
                 const retryable = !unsafeStorage && !mutation.quiesced && (mutation.ok ||
                     /fence unavailable|has not quiesced|outward mutation.*active|\bbusy\b/i.test(mutation.reason));
                 const fleet = await buildFleetStatus(cfg);
+                // Prime the shared cache with this freshly-computed value so a
+                // GET /api/fleet right after this mutation observes it immediately
+                // instead of a pre-mutation cached value (see fleet-status-cache.ts).
+                primeFleetStatusCache(cfg, fleet);
                 sendJson(res, retryable ? 409 : 500, {
                     ok: false,
                     action: paused ? 'pause' : 'resume',
@@ -1266,6 +1410,8 @@ export async function handleApi(req, res, cfg, ctx) {
                 return true;
             }
             const fleet = await buildFleetStatus(cfg);
+            // See comment above — keep the shared cache in sync with the mutation.
+            primeFleetStatusCache(cfg, fleet);
             const service = serviceStatus(daemonServiceInstallOptions(cfg));
             sendJson(res, 200, {
                 ok: true,
@@ -1282,8 +1428,14 @@ export async function handleApi(req, res, cfg, ctx) {
         // proposals + merges + paused state). buildFleetStatus never throws; same
         // no-auth read class as /api/daemon and /api/pulse.
         if (path === '/api/fleet' && method === 'GET') {
-            const fleet = await buildFleetStatus(cfg);
-            sendJson(res, 200, fleet);
+            // M516: serve the cached FleetStatus VERBATIM. Freshness is deliberately
+            // NOT spread in here: test/build-identity.test.ts pins that this route
+            // performs no API-side recomposition, because a caller verifying
+            // buildIdentity must be able to trust that what it received is exactly
+            // what buildFleetStatus produced. Freshness is still reported on the
+            // snapshot and control payloads, where their builders attach it.
+            const cached = await getCachedFleetStatus(cfg);
+            sendJson(res, 200, cached.status);
             return true;
         }
         // ── GET /api/estimate ───────────────────────────────────────────────────
@@ -1345,7 +1497,11 @@ export async function handleApi(req, res, cfg, ctx) {
         }
         // ── GET /api/events (SSE) ────────────────────────────────────────────────
         if (path === '/api/events' && method === 'GET') {
-            handleSseEvents(req, res, cfg, ctx.allowDispatch);
+            if (!ctx.readSession || ctx.readSession.expiresAt <= Date.now()) {
+                sendJson(res, 401, { code: 'SESSION_REQUIRED', error: 'valid read session required' });
+                return true;
+            }
+            handleSseEvents(req, res, cfg, ctx.allowDispatch, ctx.readSession);
             return true;
         }
         // ── POST /api/run ────────────────────────────────────────────────────────