@exaudeus/workrail 1.13.2 → 1.14.0

package/dist/infrastructure/session/HttpServer.d.ts

@@ -1,3 +1,4 @@
+import { Application } from 'express';
 import { SessionManager } from './SessionManager.js';
 import type { ProcessLifecyclePolicy } from '../../runtime/process-lifecycle-policy.js';
 import type { ProcessSignals } from '../../runtime/ports/process-signals.js';
@@ -48,6 +49,8 @@ export declare class HttpServer {
     private printBanner;
     openDashboard(sessionId?: string): Promise<string>;
     stop(): Promise<void>;
+    mountRoutes(installer: (app: Application) => void): void;
+    finalize(): void;
     getBaseUrl(): string;
     getPort(): number;
     private quickCleanup;

package/dist/infrastructure/session/HttpServer.js

@@ -337,13 +337,6 @@ let HttpServer = class HttpServer {
                 port: this.port
             });
         });
-        this.app.use((req, res) => {
-            res.status(404).json({
-                success: false,
-                error: 'Not found',
-                path: req.path
-            });
-        });
     }
     async start() {
         await this.quickCleanup();
@@ -646,6 +639,18 @@ let HttpServer = class HttpServer {
             this.isPrimary = false;
         }
     }
+    mountRoutes(installer) {
+        installer(this.app);
+    }
+    finalize() {
+        this.app.use((req, res) => {
+            res.status(404).json({
+                success: false,
+                error: 'Not found',
+                path: req.path,
+            });
+        });
+    }
     getBaseUrl() {
         return this.baseUrl;
     }

package/dist/manifest.json

@@ -442,12 +442,12 @@
       "bytes": 818
     },
     "infrastructure/session/HttpServer.d.ts": {
-      "sha256": "0e4a40f22a66ab4f1a41aad2899d5ce89ca12e1b52598eb82b105ec8ecf37592",
-      "bytes": 1852
+      "sha256": "986dd1ed28ec846d432af0bacd01980aca162c18c383aa77698d47a79cf1fdab",
+      "bytes": 1975
     },
     "infrastructure/session/HttpServer.js": {
-      "sha256": "76508602e5d7ee9337ff64c7dffa5153347ef754e1252d191b4ee6243ea24f1b",
-      "bytes": 32446
+      "sha256": "1be0cec5c7bd1204f86f77fe01985ed4906fa2432b22a44b7b01b3aa179a4803",
+      "bytes": 32534
     },
     "infrastructure/session/SessionDataNormalizer.d.ts": {
       "sha256": "c89bb5e00d7d01fb4aa6d0095602541de53c425c6b99b67fa8367eb29cb63e9e",
@@ -738,12 +738,12 @@
       "bytes": 11969
     },
     "mcp/handlers/v2-execution/start.d.ts": {
-      "sha256": "59de3fb71608b19e6a81a63ff3c74f9be92b90c8e07817e9248e3ee7e4654367",
-      "bytes": 2789
+      "sha256": "333f9f36756d2ce55249c6af45198a17b51aa9c6448e063f7621fcd61879f2bf",
+      "bytes": 2684
     },
     "mcp/handlers/v2-execution/start.js": {
-      "sha256": "aeee2ba6b1cc0d461d2421eed0f99ca22f4006baa7f5663cc28855d00c950d87",
-      "bytes": 15015
+      "sha256": "4e21cd7739860fbb2349fdde6e83225001dd06345acfdd66607f733901c20cdd",
+      "bytes": 14067
     },
     "mcp/handlers/v2-resume.d.ts": {
       "sha256": "d88f6c35bcaf946666c837b72fda3702a2ebab5e478eb90f7b4b672a0e5fa24f",
@@ -814,8 +814,8 @@
       "bytes": 168
     },
     "mcp/server.js": {
-      "sha256": "fd9e264c759db2d5446d88eafce14ec27ce9b73756e62ef10351b2fca52c7c7c",
-      "bytes": 11892
+      "sha256": "c29e4ad8a9ed43304654f59725a7dd50a6fe5cd4cde9e7db2678ae9a7ccd0557",
+      "bytes": 12643
     },
     "mcp/tool-description-provider.d.ts": {
       "sha256": "1d46abc3112e11b68e57197e846f5708293ec9b2281fa71a9124ee2aad71e41b",
@@ -890,12 +890,12 @@
       "bytes": 3119
     },
     "mcp/v2/tools.d.ts": {
-      "sha256": "567938a5c153159b7792600cbe2326ce446a28f46d5f49e34dc1663cf826427e",
-      "bytes": 6737
+      "sha256": "f789303c98e8b3d53c9b8c22b0cf99548c54907cfde3c5c67ca4036fab7d156c",
+      "bytes": 6567
     },
     "mcp/v2/tools.js": {
-      "sha256": "49d00fe392c526ce5f7e287ba98180cc82574b0c85ff0b550f3f01a216ac5dbf",
-      "bytes": 7938
+      "sha256": "0d55830445ed414f31f52fc2775ea631fe1cb3f91b04e4dda33850dd2d8572cd",
+      "bytes": 7506
     },
     "mcp/validation/bounded-json.d.ts": {
       "sha256": "82203ac6123d5c6989606c3b5405aaea99ab829c8958835f9ae3ba45b8bc8fd5",
@@ -2177,6 +2177,30 @@
       "sha256": "36a9c3f0faf71c49fc9624f41c26c452e276f4ac15190f2d22d89a003a2bb099",
       "bytes": 2678
     },
+    "v2/usecases/console-routes.d.ts": {
+      "sha256": "ccdf824d2c7872b3d588994ebefa15a7771de5ad1abefeb602528b4ca232ae62",
+      "bytes": 204
+    },
+    "v2/usecases/console-routes.js": {
+      "sha256": "d437f8fee37c016533e78259a1f5ce14017a746371c0c77e9519d445f784c988",
+      "bytes": 2192
+    },
+    "v2/usecases/console-service.d.ts": {
+      "sha256": "787b1e01e7e30354f56203822142e825069bd42fba476797df6672c96dd5b555",
+      "bytes": 1083
+    },
+    "v2/usecases/console-service.js": {
+      "sha256": "e3df9ceaf0fcca2e55f7625f4610a053629b360638f469446ab8f576d32be8a9",
+      "bytes": 7183
+    },
+    "v2/usecases/console-types.d.ts": {
+      "sha256": "84c4c839b5285f5a29d85b7b4188e7948f92be1f34e44618cc0c9c85a1c11a18",
+      "bytes": 1799
+    },
+    "v2/usecases/console-types.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/usecases/enumerate-sessions.d.ts": {
       "sha256": "46da8960bdeb154f79dee443425260f3ce18c50a0db01e7ab60700432d864857",
       "bytes": 699

package/dist/mcp/handlers/v2-execution/start.d.ts

@@ -31,7 +31,6 @@ export declare function buildInitialEvents(args: {
     readonly workflowSourceKind: 'bundled' | 'user' | 'project' | 'remote' | 'plugin';
     readonly workflowSourceRef: string;
     readonly snapshotRef: import('../../../v2/durable-core/ids/index.js').SnapshotRef;
-    readonly context: import('../../../v2/durable-core/canonical/json-types.js').JsonObject | undefined;
     readonly observations: readonly ObservationEventData[];
     readonly idFactory: {
         readonly mintEventId: () => string;

package/dist/mcp/handlers/v2-execution/start.js

@@ -20,7 +20,6 @@ const v2_workspace_resolution_js_1 = require("../v2-workspace-resolution.js");
 const v2_token_ops_js_1 = require("../v2-token-ops.js");
 const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const v2_execution_helpers_js_2 = require("../v2-execution-helpers.js");
-const v2_context_budget_js_1 = require("../v2-context-budget.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const index_js_2 = require("./index.js");
 function loadAndPinWorkflow(args) {
@@ -69,7 +68,7 @@ function loadAndPinWorkflow(args) {
     });
 }
 function buildInitialEvents(args) {
-    const { sessionId, runId, nodeId, workflowId, workflowHash, workflowSourceKind, workflowSourceRef, snapshotRef, context, observations, idFactory, } = args;
+    const { sessionId, runId, nodeId, workflowId, workflowHash, workflowSourceKind, workflowSourceRef, snapshotRef, observations, idFactory, } = args;
     const evtSessionCreated = idFactory.mintEventId();
     const evtRunStarted = idFactory.mintEventId();
     const evtNodeCreated = idFactory.mintEventId();
@@ -138,24 +137,6 @@ function buildInitialEvents(args) {
         },
     ];
     const mutableEvents = [...baseEvents];
-    if (context) {
-        const evtContextSet = idFactory.mintEventId();
-        const contextId = idFactory.mintEventId();
-        mutableEvents.push({
-            v: 1,
-            eventId: evtContextSet,
-            eventIndex: mutableEvents.length,
-            sessionId,
-            kind: constants_js_1.EVENT_KIND.CONTEXT_SET,
-            dedupeKey: `context_set:${sessionId}:${runId}:${contextId}`,
-            scope: { runId },
-            data: {
-                contextId,
-                context: context,
-                source: 'initial',
-            },
-        });
-    }
     for (const obs of observations) {
         const obsEventId = idFactory.mintEventId();
         mutableEvents.push({
@@ -220,9 +201,6 @@ function mintStartTokens(args) {
 }
 function executeStartWorkflow(input, ctx) {
     const { gate, sessionStore, snapshotStore, pinnedStore, crypto, tokenCodecPorts, idFactory } = ctx.v2;
-    const ctxCheck = (0, v2_context_budget_js_1.checkContextBudget)({ tool: 'start_workflow', context: input.context });
-    if (!ctxCheck.ok)
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ctxCheck.error });
     return loadAndPinWorkflow({
         workflowId: input.workflowId,
         workflowService: ctx.workflowService,
@@ -270,7 +248,6 @@ function executeStartWorkflow(input, ctx) {
                     workflowSourceKind: (0, v2_state_conversion_js_1.mapWorkflowSourceKind)(workflow.source.kind),
                     workflowSourceRef,
                     snapshotRef,
-                    context: input.context,
                     observations,
                     idFactory,
                 });

package/dist/mcp/server.js

@@ -137,6 +137,18 @@ function toMcpTool(tool) {
 async function startServer() {
     await (0, container_js_1.bootstrap)({ runtimeMode: { kind: 'production' } });
     const ctx = await createToolContext();
+    if (ctx.v2 && ctx.httpServer && ctx.v2.dataDir && ctx.v2.directoryListing) {
+        const { ConsoleService } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/console-service.js')));
+        const { mountConsoleRoutes } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/console-routes.js')));
+        const consoleService = new ConsoleService({
+            directoryListing: ctx.v2.directoryListing,
+            dataDir: ctx.v2.dataDir,
+            sessionStore: ctx.v2.sessionStore,
+        });
+        ctx.httpServer.mountRoutes((app) => mountConsoleRoutes(app, consoleService));
+        console.error('[Console] v2 Console API routes mounted at /api/v2/');
+    }
+    ctx.httpServer?.finalize();
     const descriptionProvider = container_js_1.container.resolve(tokens_js_1.DI.Mcp.DescriptionProvider);
     const buildTool = (0, tool_factory_js_1.createToolFactory)(descriptionProvider);
     const workflowEdition = (0, workflow_tool_edition_selector_js_1.selectWorkflowToolEdition)(ctx.featureFlags, buildTool);

package/dist/mcp/v2/tools.d.ts

@@ -15,15 +15,12 @@ export declare const V2InspectWorkflowInput: z.ZodObject<{
 export type V2InspectWorkflowInput = z.infer<typeof V2InspectWorkflowInput>;
 export declare const V2StartWorkflowInput: z.ZodObject<{
     workflowId: z.ZodString;
-    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     workspacePath: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strip", z.ZodTypeAny, {
     workflowId: string;
-    context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
 }, {
     workflowId: string;
-    context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
 }>;
 export type V2StartWorkflowInput = z.infer<typeof V2StartWorkflowInput>;

package/dist/mcp/v2/tools.js

@@ -9,7 +9,6 @@ exports.V2InspectWorkflowInput = zod_1.z.object({
 });
 exports.V2StartWorkflowInput = zod_1.z.object({
     workflowId: zod_1.z.string().min(1).regex(/^[A-Za-z0-9_-]+$/, 'Workflow ID must contain only letters, numbers, hyphens, and underscores').describe('The workflow ID to start'),
-    context: zod_1.z.record(zod_1.z.unknown()).optional().describe('Structured context for this workflow — must be a JSON OBJECT with string keys, NOT a string. For design/analysis workflows: {"problem":"describe the problem","constraints":"...","goals":"..."}. For coding workflows: {"ticketId":"ACEI-1234","branch":"main"}. WorkRail injects these into step prompts. Pass once at start; re-pass only values that have CHANGED.'),
     workspacePath: zod_1.z.string()
         .refine((p) => p.startsWith('/'), 'workspacePath must be an absolute path (starting with /)')
         .optional()

package/dist/v2/usecases/console-routes.d.ts

@@ -0,0 +1,3 @@
+import type { Application } from 'express';
+import type { ConsoleService } from './console-service.js';
+export declare function mountConsoleRoutes(app: Application, consoleService: ConsoleService): void;

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountConsoleRoutes = mountConsoleRoutes;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function resolveConsoleDist() {
+    const fromDist = path_1.default.join(__dirname, '../../../console/dist');
+    if (fs_1.default.existsSync(fromDist))
+        return fromDist;
+    const fromSrc = path_1.default.join(__dirname, '../../../console/dist');
+    if (fs_1.default.existsSync(fromSrc))
+        return fromSrc;
+    return null;
+}
+function mountConsoleRoutes(app, consoleService) {
+    app.get('/api/v2/sessions', async (_req, res) => {
+        const result = await consoleService.getSessionList();
+        result.match((data) => res.json({ success: true, data }), (error) => res.status(500).json({ success: false, error: error.message }));
+    });
+    app.get('/api/v2/sessions/:sessionId', async (req, res) => {
+        const { sessionId } = req.params;
+        const result = await consoleService.getSessionDetail(sessionId);
+        result.match((data) => res.json({ success: true, data }), (error) => {
+            const status = error.code === 'SESSION_LOAD_FAILED' ? 404 : 500;
+            res.status(status).json({ success: false, error: error.message });
+        });
+    });
+    const consoleDist = resolveConsoleDist();
+    if (consoleDist) {
+        app.use('/console', express_1.default.static(consoleDist));
+        app.get('/console/*', (_req, res) => {
+            res.sendFile(path_1.default.join(consoleDist, 'index.html'));
+        });
+        console.error(`[Console] UI serving from ${consoleDist}`);
+    }
+    else {
+        app.get('/console', (_req, res) => {
+            res.status(503).json({
+                error: 'Console not built',
+                message: 'Run "cd console && npm run build" to build the Console UI.',
+            });
+        });
+        console.error('[Console] UI not found (run: cd console && npm run build)');
+    }
+}

package/dist/v2/usecases/console-service.d.ts

@@ -0,0 +1,22 @@
+import type { ResultAsync } from 'neverthrow';
+import type { DirectoryListingPortV2 } from '../ports/directory-listing.port.js';
+import type { DataDirPortV2 } from '../ports/data-dir.port.js';
+import type { SessionEventLogReadonlyStorePortV2 } from '../ports/session-event-log-store.port.js';
+import type { ConsoleSessionListResponse, ConsoleSessionDetail } from './console-types.js';
+export interface ConsoleServicePorts {
+    readonly directoryListing: DirectoryListingPortV2;
+    readonly dataDir: DataDirPortV2;
+    readonly sessionStore: SessionEventLogReadonlyStorePortV2;
+}
+export declare class ConsoleService {
+    private readonly ports;
+    constructor(ports: ConsoleServicePorts);
+    getSessionList(): ResultAsync<ConsoleSessionListResponse, ConsoleServiceError>;
+    getSessionDetail(sessionIdStr: string): ResultAsync<ConsoleSessionDetail, ConsoleServiceError>;
+    private collectSessionSummaries;
+    private loadSessionSummary;
+}
+export interface ConsoleServiceError {
+    readonly code: 'ENUMERATION_FAILED' | 'SESSION_LOAD_FAILED';
+    readonly message: string;
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleService = void 0;
+const neverthrow_1 = require("neverthrow");
+const enumerate_sessions_js_1 = require("./enumerate-sessions.js");
+const session_health_js_1 = require("../projections/session-health.js");
+const run_dag_js_1 = require("../projections/run-dag.js");
+const run_status_signals_js_1 = require("../projections/run-status-signals.js");
+const gaps_js_1 = require("../projections/gaps.js");
+const node_outputs_js_1 = require("../projections/node-outputs.js");
+const constants_js_1 = require("../durable-core/constants.js");
+const index_js_1 = require("../durable-core/ids/index.js");
+const MAX_SESSIONS_TO_SCAN = 50;
+class ConsoleService {
+    constructor(ports) {
+        this.ports = ports;
+    }
+    getSessionList() {
+        return (0, enumerate_sessions_js_1.enumerateSessions)({
+            directoryListing: this.ports.directoryListing,
+            dataDir: this.ports.dataDir,
+        })
+            .mapErr((fsErr) => ({
+            code: 'ENUMERATION_FAILED',
+            message: `Failed to enumerate sessions: ${fsErr.message}`,
+        }))
+            .andThen((sessionIds) => this.collectSessionSummaries(sessionIds.slice(0, MAX_SESSIONS_TO_SCAN)));
+    }
+    getSessionDetail(sessionIdStr) {
+        const sessionId = (0, index_js_1.asSessionId)(sessionIdStr);
+        return this.ports.sessionStore
+            .load(sessionId)
+            .mapErr((storeErr) => ({
+            code: 'SESSION_LOAD_FAILED',
+            message: `Failed to load session ${sessionIdStr}: ${storeErr.message}`,
+        }))
+            .map((truth) => projectSessionDetail(sessionId, truth));
+    }
+    collectSessionSummaries(sessionIds) {
+        return sessionIds.reduce((acc, sessionId) => acc.andThen((summaries) => this.loadSessionSummary(sessionId).map((summary) => summary !== null ? [...summaries, summary] : summaries)), (0, neverthrow_1.okAsync)([])).map((sessions) => ({ sessions, totalCount: sessions.length }));
+    }
+    loadSessionSummary(sessionId) {
+        return this.ports.sessionStore
+            .load(sessionId)
+            .map((truth) => projectSessionSummary(sessionId, truth))
+            .orElse(() => (0, neverthrow_1.okAsync)(null));
+    }
+}
+exports.ConsoleService = ConsoleService;
+function projectSessionSummary(sessionId, truth) {
+    const { events } = truth;
+    const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
+    if (health.isErr())
+        return null;
+    const sessionHealth = health.value.kind === 'healthy' ? 'healthy' : 'corrupt';
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
+    if (dagRes.isErr())
+        return null;
+    const dag = dagRes.value;
+    const statusRes = (0, run_status_signals_js_1.projectRunStatusSignalsV2)(events);
+    const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
+    const runs = Object.values(dag.runsById);
+    const run = runs[0];
+    if (!run) {
+        return {
+            sessionId,
+            workflowId: null,
+            workflowHash: null,
+            runId: null,
+            status: 'in_progress',
+            health: sessionHealth,
+            nodeCount: 0,
+            edgeCount: 0,
+            tipCount: 0,
+            hasUnresolvedGaps: false,
+            recapSnippet: null,
+        };
+    }
+    const workflow = run.workflow;
+    const workflowId = workflow.kind === 'with_workflow' ? workflow.workflowId : null;
+    const workflowHash = workflow.kind === 'with_workflow' ? workflow.workflowHash : null;
+    const statusSignals = statusRes.isOk() ? statusRes.value.byRunId[run.runId] : undefined;
+    const status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false);
+    const hasUnresolvedGaps = gapsRes.isOk()
+        ? Object.keys(gapsRes.value.unresolvedCriticalByRunId).length > 0
+        : false;
+    const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(events);
+    let recapSnippet = null;
+    if (outputsRes.isOk() && run.preferredTipNodeId) {
+        const tipOutputs = outputsRes.value.nodesById[run.preferredTipNodeId];
+        if (tipOutputs) {
+            const recaps = tipOutputs.currentByChannel[constants_js_1.OUTPUT_CHANNEL.RECAP];
+            const latest = recaps?.at(-1);
+            if (latest && latest.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES) {
+                recapSnippet = latest.payload.notesMarkdown;
+            }
+        }
+    }
+    return {
+        sessionId,
+        workflowId,
+        workflowHash,
+        runId: run.runId,
+        status,
+        health: sessionHealth,
+        nodeCount: Object.keys(run.nodesById).length,
+        edgeCount: run.edges.length,
+        tipCount: run.tipNodeIds.length,
+        hasUnresolvedGaps,
+        recapSnippet,
+    };
+}
+function projectSessionDetail(sessionId, truth) {
+    const { events } = truth;
+    const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
+    const sessionHealth = health.isOk() && health.value.kind === 'healthy' ? 'healthy' : 'corrupt';
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
+    if (dagRes.isErr()) {
+        return { sessionId, health: sessionHealth, runs: [] };
+    }
+    const statusRes = (0, run_status_signals_js_1.projectRunStatusSignalsV2)(events);
+    const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
+    const runs = Object.values(dagRes.value.runsById).map((run) => {
+        const statusSignals = statusRes.isOk() ? statusRes.value.byRunId[run.runId] : undefined;
+        const status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false);
+        const tipSet = new Set(run.tipNodeIds);
+        const nodes = Object.values(run.nodesById).map((node) => ({
+            nodeId: node.nodeId,
+            nodeKind: node.nodeKind,
+            parentNodeId: node.parentNodeId,
+            createdAtEventIndex: node.createdAtEventIndex,
+            isPreferredTip: node.nodeId === run.preferredTipNodeId,
+            isTip: tipSet.has(node.nodeId),
+        }));
+        const edges = run.edges.map((edge) => ({
+            edgeKind: edge.edgeKind,
+            fromNodeId: edge.fromNodeId,
+            toNodeId: edge.toNodeId,
+            createdAtEventIndex: edge.createdAtEventIndex,
+        }));
+        const workflow = run.workflow;
+        return {
+            runId: run.runId,
+            workflowId: workflow.kind === 'with_workflow' ? workflow.workflowId : null,
+            workflowHash: workflow.kind === 'with_workflow' ? workflow.workflowHash : null,
+            preferredTipNodeId: run.preferredTipNodeId,
+            nodes,
+            edges,
+            tipNodeIds: [...run.tipNodeIds],
+            status,
+            hasUnresolvedCriticalGaps: gapsRes.isOk()
+                ? (gapsRes.value.unresolvedCriticalByRunId[run.runId]?.length ?? 0) > 0
+                : false,
+        };
+    });
+    return { sessionId, health: sessionHealth, runs };
+}
+function deriveRunStatus(isBlocked, hasUnresolvedCriticalGaps) {
+    if (isBlocked)
+        return 'blocked';
+    if (hasUnresolvedCriticalGaps)
+        return 'complete_with_gaps';
+    return 'in_progress';
+}

package/dist/v2/usecases/console-types.d.ts

@@ -0,0 +1,49 @@
+export type ConsoleRunStatus = 'in_progress' | 'complete' | 'complete_with_gaps' | 'blocked';
+export type ConsoleSessionHealth = 'healthy' | 'corrupt';
+export interface ConsoleSessionSummary {
+    readonly sessionId: string;
+    readonly workflowId: string | null;
+    readonly workflowHash: string | null;
+    readonly runId: string | null;
+    readonly status: ConsoleRunStatus;
+    readonly health: ConsoleSessionHealth;
+    readonly nodeCount: number;
+    readonly edgeCount: number;
+    readonly tipCount: number;
+    readonly hasUnresolvedGaps: boolean;
+    readonly recapSnippet: string | null;
+}
+export interface ConsoleSessionListResponse {
+    readonly sessions: readonly ConsoleSessionSummary[];
+    readonly totalCount: number;
+}
+export interface ConsoleDagNode {
+    readonly nodeId: string;
+    readonly nodeKind: 'step' | 'checkpoint' | 'blocked_attempt';
+    readonly parentNodeId: string | null;
+    readonly createdAtEventIndex: number;
+    readonly isPreferredTip: boolean;
+    readonly isTip: boolean;
+}
+export interface ConsoleDagEdge {
+    readonly edgeKind: 'acked_step' | 'checkpoint';
+    readonly fromNodeId: string;
+    readonly toNodeId: string;
+    readonly createdAtEventIndex: number;
+}
+export interface ConsoleDagRun {
+    readonly runId: string;
+    readonly workflowId: string | null;
+    readonly workflowHash: string | null;
+    readonly preferredTipNodeId: string | null;
+    readonly nodes: readonly ConsoleDagNode[];
+    readonly edges: readonly ConsoleDagEdge[];
+    readonly tipNodeIds: readonly string[];
+    readonly status: ConsoleRunStatus;
+    readonly hasUnresolvedCriticalGaps: boolean;
+}
+export interface ConsoleSessionDetail {
+    readonly sessionId: string;
+    readonly health: ConsoleSessionHealth;
+    readonly runs: readonly ConsoleDagRun[];
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,10 @@
     "web"
   ],
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});\" && tsc -p tsconfig.build.json",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});\" && tsc -p tsconfig.build.json && npm run console:build",
+    "console:build": "cd console && npm install && npm run build",
+    "console:dev": "cd console && npm run dev",
+    "build:all": "npm run build",
     "docs:workflows": "node scripts/generate-workflow-docs.js",
     "generate:locks": "npx ts-node scripts/generate-lock-coverage.ts && npx ts-node scripts/generate-lock-coverage.ts --json",
     "verify:generated": "npm run generate:locks && git diff --exit-code -- docs/generated/v2-lock-coverage.json docs/generated/v2-lock-coverage.md docs/generated/v2-lock-closure-plan.md",