@exaudeus/workrail 1.14.2 → 1.15.0

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

@@ -2,29 +2,39 @@
 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 neverthrow_2 = require("neverthrow");
 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 advance_outcomes_js_1 = require("../projections/advance-outcomes.js");
+const artifacts_js_1 = require("../projections/artifacts.js");
+const run_context_js_1 = require("../projections/run-context.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;
+const MAX_SESSIONS_TO_LOAD = 500;
 class ConsoleService {
     constructor(ports) {
         this.ports = ports;
     }
     getSessionList() {
-        return (0, enumerate_sessions_js_1.enumerateSessions)({
-            directoryListing: this.ports.directoryListing,
-            dataDir: this.ports.dataDir,
-        })
+        return this.ports.directoryListing
+            .readdirWithMtime(this.ports.dataDir.sessionsDir())
             .mapErr((fsErr) => ({
             code: 'ENUMERATION_FAILED',
             message: `Failed to enumerate sessions: ${fsErr.message}`,
         }))
-            .andThen((sessionIds) => this.collectSessionSummaries(sessionIds.slice(0, MAX_SESSIONS_TO_SCAN)));
+            .andThen((entries) => {
+            const SESSION_DIR_PATTERN = /^sess_[a-zA-Z0-9_]+$/;
+            const validEntries = entries
+                .filter((e) => SESSION_DIR_PATTERN.test(e.name))
+                .sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name))
+                .slice(0, MAX_SESSIONS_TO_LOAD);
+            const mtimeBySessionId = new Map(validEntries.map((e) => [e.name, e.mtimeMs]));
+            const sessionIds = validEntries.map((e) => (0, index_js_1.asSessionId)(e.name));
+            return this.collectSessionSummaries(sessionIds, mtimeBySessionId);
+        });
     }
     getSessionDetail(sessionIdStr) {
         const sessionId = (0, index_js_1.asSessionId)(sessionIdStr);
@@ -34,20 +44,281 @@ class ConsoleService {
             code: 'SESSION_LOAD_FAILED',
             message: `Failed to load session ${sessionIdStr}: ${storeErr.message}`,
         }))
-            .map((truth) => projectSessionDetail(sessionId, truth));
+            .andThen((truth) => {
+            const dagRes = (0, run_dag_js_1.projectRunDagV2)(truth.events);
+            if (dagRes.isErr()) {
+                return resolveRunCompletion(truth.events, this.ports.snapshotStore)
+                    .map((completionMap) => projectSessionDetail(sessionId, truth, completionMap, {}, {}));
+            }
+            const dag = dagRes.value;
+            return neverthrow_1.ResultAsync.combine([
+                resolveRunCompletion(truth.events, this.ports.snapshotStore),
+                resolveStepLabels(dag, this.ports.snapshotStore, this.ports.pinnedWorkflowStore),
+                resolveWorkflowNames(dag, this.ports.pinnedWorkflowStore),
+            ]).map(([completionMap, stepLabels, workflowNames]) => projectSessionDetail(sessionId, truth, completionMap, stepLabels, workflowNames));
+        });
+    }
+    getNodeDetail(sessionIdStr, nodeId) {
+        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}`,
+        }))
+            .andThen((truth) => {
+            const dagRes = (0, run_dag_js_1.projectRunDagV2)(truth.events);
+            if (dagRes.isErr()) {
+                return (0, neverthrow_2.errAsync)({
+                    code: 'NODE_NOT_FOUND',
+                    message: `Node ${nodeId} not found in session ${sessionIdStr}`,
+                });
+            }
+            return resolveStepLabels(dagRes.value, this.ports.snapshotStore, this.ports.pinnedWorkflowStore)
+                .map((stepLabels) => {
+                const result = projectNodeDetail(truth.events, nodeId, stepLabels);
+                return result;
+            })
+                .andThen((result) => {
+                if (!result) {
+                    return (0, neverthrow_2.errAsync)({
+                        code: 'NODE_NOT_FOUND',
+                        message: `Node ${nodeId} not found in session ${sessionIdStr}`,
+                    });
+                }
+                return (0, neverthrow_2.okAsync)(result);
+            });
+        });
     }
-    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 }));
+    collectSessionSummaries(sessionIds, mtimeBySessionId) {
+        const tasks = sessionIds.map((id) => this.loadSessionSummary(id, mtimeBySessionId.get(id) ?? 0));
+        return neverthrow_1.ResultAsync.combine(tasks).map((results) => {
+            const sessions = results.filter((s) => s !== null);
+            return { sessions, totalCount: sessions.length };
+        });
     }
-    loadSessionSummary(sessionId) {
+    loadSessionSummary(sessionId, lastModifiedMs) {
         return this.ports.sessionStore
             .load(sessionId)
-            .map((truth) => projectSessionSummary(sessionId, truth))
-            .orElse(() => (0, neverthrow_1.okAsync)(null));
+            .andThen((truth) => {
+            const dagRes = (0, run_dag_js_1.projectRunDagV2)(truth.events);
+            const workflowNamesRA = dagRes.isOk()
+                ? resolveWorkflowNames(dagRes.value, this.ports.pinnedWorkflowStore)
+                : (0, neverthrow_2.okAsync)({});
+            return neverthrow_1.ResultAsync.combine([
+                resolveRunCompletion(truth.events, this.ports.snapshotStore),
+                workflowNamesRA,
+            ]).map(([completionMap, workflowNames]) => projectSessionSummary(sessionId, truth, completionMap, workflowNames, lastModifiedMs));
+        })
+            .orElse(() => (0, neverthrow_2.okAsync)(null));
     }
 }
 exports.ConsoleService = ConsoleService;
-function projectSessionSummary(sessionId, truth) {
+function resolveRunCompletion(events, snapshotStore) {
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
+    if (dagRes.isErr())
+        return (0, neverthrow_2.okAsync)({});
+    return resolveRunCompletionFromDag(dagRes.value, snapshotStore);
+}
+function resolveRunCompletionFromDag(dag, snapshotStore) {
+    const tipRefs = collectPreferredTipSnapshotRefs(dag);
+    if (tipRefs.length === 0)
+        return (0, neverthrow_2.okAsync)({});
+    const tasks = tipRefs.map(({ runId, snapshotRef }) => snapshotStore
+        .getExecutionSnapshotV1(snapshotRef)
+        .map((snapshot) => [
+        runId,
+        snapshot?.enginePayload.engineState.kind === 'complete',
+    ])
+        .orElse(() => (0, neverthrow_2.okAsync)([runId, false])));
+    return neverthrow_1.ResultAsync.combine(tasks).map((entries) => Object.fromEntries(entries));
+}
+function collectPreferredTipSnapshotRefs(dag) {
+    const refs = [];
+    for (const run of Object.values(dag.runsById)) {
+        if (!run.preferredTipNodeId)
+            continue;
+        const tip = run.nodesById[run.preferredTipNodeId];
+        if (tip)
+            refs.push({ runId: run.runId, snapshotRef: (0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(tip.snapshotRef)) });
+    }
+    return refs;
+}
+function resolveStepLabels(dag, snapshotStore, pinnedWorkflowStore) {
+    const allNodes = [];
+    for (const run of Object.values(dag.runsById)) {
+        allNodes.push(...Object.values(run.nodesById));
+    }
+    if (allNodes.length === 0)
+        return (0, neverthrow_2.okAsync)({});
+    const uniqueSnapshotRefs = [...new Set(allNodes.map((n) => n.snapshotRef))];
+    const snapshotTasks = uniqueSnapshotRefs.map((ref) => snapshotStore
+        .getExecutionSnapshotV1((0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(ref)))
+        .map((snap) => [ref, snap])
+        .orElse(() => (0, neverthrow_2.okAsync)([ref, null])));
+    return neverthrow_1.ResultAsync.combine(snapshotTasks).andThen((snapshotEntries) => {
+        const snapshotByRef = new Map(snapshotEntries);
+        const uniqueHashes = [...new Set(allNodes.map((n) => n.workflowHash))];
+        const workflowTasks = uniqueHashes.map((hash) => pinnedWorkflowStore
+            .get((0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(hash)))
+            .map((compiled) => [
+            hash,
+            compiled ? extractStepTitlesFromCompiled(compiled) : new Map(),
+        ])
+            .orElse(() => (0, neverthrow_2.okAsync)([hash, new Map()])));
+        return neverthrow_1.ResultAsync.combine(workflowTasks).map((workflowEntries) => {
+            const titlesByHash = new Map(workflowEntries);
+            const labels = {};
+            for (const node of allNodes) {
+                const snap = snapshotByRef.get(node.snapshotRef);
+                const stepId = snap ? extractPendingStepId(snap) : null;
+                if (!stepId)
+                    continue;
+                const titles = titlesByHash.get(node.workflowHash);
+                const title = titles?.get(stepId);
+                labels[node.nodeId] = title ?? stepId;
+            }
+            return labels;
+        });
+    });
+}
+function resolveWorkflowNames(dag, pinnedWorkflowStore) {
+    const hashSet = new Set();
+    for (const run of Object.values(dag.runsById)) {
+        if (run.workflow.kind === 'with_workflow') {
+            hashSet.add(run.workflow.workflowHash);
+        }
+    }
+    if (hashSet.size === 0)
+        return (0, neverthrow_2.okAsync)({});
+    const tasks = [...hashSet].map((hash) => pinnedWorkflowStore
+        .get((0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(hash)))
+        .map((compiled) => [hash, compiled?.name ?? null])
+        .orElse(() => (0, neverthrow_2.okAsync)([hash, null])));
+    return neverthrow_1.ResultAsync.combine(tasks).map((entries) => {
+        const names = {};
+        for (const [hash, name] of entries) {
+            if (name)
+                names[hash] = name;
+        }
+        return names;
+    });
+}
+function extractPendingStepId(snapshot) {
+    const state = snapshot.enginePayload.engineState;
+    if ((state.kind === 'running' || state.kind === 'blocked') && state.pending.kind === 'some') {
+        return String(state.pending.step.stepId);
+    }
+    return null;
+}
+function extractStepTitlesFromCompiled(compiled) {
+    const titles = new Map();
+    if (compiled.sourceKind === 'v1_preview') {
+        titles.set(compiled.preview.stepId, compiled.preview.title);
+        return titles;
+    }
+    const def = compiled.definition;
+    const steps = Array.isArray(def?.['steps']) ? def['steps'] : [];
+    for (const step of steps) {
+        if (typeof step['id'] === 'string' && typeof step['title'] === 'string') {
+            titles.set(step['id'], step['title']);
+        }
+        if (step['type'] === 'loop' && Array.isArray(step['body'])) {
+            for (const bodyStep of step['body']) {
+                if (typeof bodyStep['id'] === 'string' && typeof bodyStep['title'] === 'string') {
+                    titles.set(bodyStep['id'], bodyStep['title']);
+                }
+            }
+        }
+    }
+    return titles;
+}
+const TITLE_CONTEXT_KEYS = ['goal', 'taskDescription', 'mrTitle', 'prTitle', 'ticketTitle', 'problem'];
+function deriveSessionTitle(events) {
+    const contextRes = (0, run_context_js_1.projectRunContextV2)(events);
+    if (contextRes.isOk()) {
+        for (const runCtx of Object.values(contextRes.value.byRunId)) {
+            for (const key of TITLE_CONTEXT_KEYS) {
+                const val = runCtx.context[key];
+                if (typeof val === 'string' && val.trim().length > 0) {
+                    return truncateTitle(val.trim());
+                }
+            }
+        }
+    }
+    const title = extractTitleFromFirstRecap(events);
+    if (title)
+        return title;
+    return null;
+}
+function extractTitleFromFirstRecap(events) {
+    const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(events);
+    if (outputsRes.isErr())
+        return null;
+    let rootNodeId = null;
+    let minIndex = Infinity;
+    for (const e of events) {
+        if (e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.eventIndex < minIndex) {
+            minIndex = e.eventIndex;
+            rootNodeId = e.scope.nodeId;
+        }
+    }
+    if (!rootNodeId)
+        return null;
+    const nodeOutputs = outputsRes.value.nodesById[rootNodeId];
+    if (!nodeOutputs)
+        return null;
+    const recaps = nodeOutputs.currentByChannel[constants_js_1.OUTPUT_CHANNEL.RECAP];
+    const first = recaps?.[0];
+    if (!first || first.payload.payloadKind !== constants_js_1.PAYLOAD_KIND.NOTES)
+        return null;
+    return extractDescriptiveText(first.payload.notesMarkdown);
+}
+function extractDescriptiveText(markdown) {
+    const lines = markdown.split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
+    for (const line of lines) {
+        if (/^#{1,3}\s/.test(line))
+            continue;
+        if (/^[-_*]{3,}$/.test(line))
+            continue;
+        if (line.startsWith('|'))
+            continue;
+        const boldLabel = line.match(/^\*{2}[^*]+\*{2}:?\s*(.*)/);
+        if (boldLabel) {
+            const value = boldLabel[1]?.trim();
+            if (value && value.length > 10)
+                return truncateTitle(value);
+            continue;
+        }
+        const listBoldLabel = line.match(/^-\s+\*{2}[^*]+\*{2}:?\s*(.*)/);
+        if (listBoldLabel) {
+            const value = listBoldLabel[1]?.trim();
+            if (value && value.length > 10)
+                return truncateTitle(value);
+            continue;
+        }
+        if (line.length > 10) {
+            return truncateTitle(line);
+        }
+    }
+    return null;
+}
+function extractGitBranch(events) {
+    for (const e of events) {
+        if (e.kind !== constants_js_1.EVENT_KIND.OBSERVATION_RECORDED)
+            continue;
+        if (e.data.key === 'git_branch') {
+            return e.data.value.value;
+        }
+    }
+    return null;
+}
+function truncateTitle(text, maxLen = 120) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + '…';
+}
+function projectSessionSummary(sessionId, truth, completionByRunId, workflowNames, lastModifiedMs) {
     const { events } = truth;
     const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
     if (health.isErr())
@@ -59,12 +330,16 @@ function projectSessionSummary(sessionId, truth) {
     const dag = dagRes.value;
     const statusRes = (0, run_status_signals_js_1.projectRunStatusSignalsV2)(events);
     const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
+    const sessionTitle = deriveSessionTitle(events);
+    const gitBranch = extractGitBranch(events);
     const runs = Object.values(dag.runsById);
     const run = runs[0];
     if (!run) {
         return {
             sessionId,
+            sessionTitle,
             workflowId: null,
+            workflowName: null,
             workflowHash: null,
             runId: null,
             status: 'in_progress',
@@ -74,13 +349,16 @@ function projectSessionSummary(sessionId, truth) {
             tipCount: 0,
             hasUnresolvedGaps: false,
             recapSnippet: null,
+            gitBranch,
+            lastModifiedMs,
         };
     }
     const workflow = run.workflow;
     const workflowId = workflow.kind === 'with_workflow' ? workflow.workflowId : null;
     const workflowHash = workflow.kind === 'with_workflow' ? workflow.workflowHash : null;
+    const workflowName = workflowHash ? (workflowNames[workflowHash] ?? null) : null;
     const statusSignals = statusRes.isOk() ? statusRes.value.byRunId[run.runId] : undefined;
-    const status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false);
+    const status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false, completionByRunId[run.runId] ?? false);
     const hasUnresolvedGaps = gapsRes.isOk()
         ? Object.keys(gapsRes.value.unresolvedCriticalByRunId).length > 0
         : false;
@@ -98,7 +376,9 @@ function projectSessionSummary(sessionId, truth) {
     }
     return {
         sessionId,
+        sessionTitle,
         workflowId,
+        workflowName,
         workflowHash,
         runId: run.runId,
         status,
@@ -108,21 +388,24 @@ function projectSessionSummary(sessionId, truth) {
         tipCount: run.tipNodeIds.length,
         hasUnresolvedGaps,
         recapSnippet,
+        gitBranch,
+        lastModifiedMs,
     };
 }
-function projectSessionDetail(sessionId, truth) {
+function projectSessionDetail(sessionId, truth, completionByRunId, stepLabels, workflowNames) {
     const { events } = truth;
     const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
     const sessionHealth = health.isOk() && health.value.kind === 'healthy' ? 'healthy' : 'corrupt';
+    const sessionTitle = deriveSessionTitle(events);
     const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
     if (dagRes.isErr()) {
-        return { sessionId, health: sessionHealth, runs: [] };
+        return { sessionId, sessionTitle, 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 status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false, completionByRunId[run.runId] ?? false);
         const tipSet = new Set(run.tipNodeIds);
         const nodes = Object.values(run.nodesById).map((node) => ({
             nodeId: node.nodeId,
@@ -131,6 +414,7 @@ function projectSessionDetail(sessionId, truth) {
             createdAtEventIndex: node.createdAtEventIndex,
             isPreferredTip: node.nodeId === run.preferredTipNodeId,
             isTip: tipSet.has(node.nodeId),
+            stepLabel: stepLabels[node.nodeId] ?? null,
         }));
         const edges = run.edges.map((edge) => ({
             edgeKind: edge.edgeKind,
@@ -139,10 +423,12 @@ function projectSessionDetail(sessionId, truth) {
             createdAtEventIndex: edge.createdAtEventIndex,
         }));
         const workflow = run.workflow;
+        const wfHash = workflow.kind === 'with_workflow' ? workflow.workflowHash : null;
         return {
             runId: run.runId,
             workflowId: workflow.kind === 'with_workflow' ? workflow.workflowId : null,
-            workflowHash: workflow.kind === 'with_workflow' ? workflow.workflowHash : null,
+            workflowName: wfHash ? (workflowNames[wfHash] ?? null) : null,
+            workflowHash: wfHash,
             preferredTipNodeId: run.preferredTipNodeId,
             nodes,
             edges,
@@ -153,12 +439,124 @@ function projectSessionDetail(sessionId, truth) {
                 : false,
         };
     });
-    return { sessionId, health: sessionHealth, runs };
+    return { sessionId, sessionTitle, health: sessionHealth, runs };
 }
-function deriveRunStatus(isBlocked, hasUnresolvedCriticalGaps) {
+function deriveRunStatus(isBlocked, hasUnresolvedCriticalGaps, isComplete) {
     if (isBlocked)
         return 'blocked';
-    if (hasUnresolvedCriticalGaps)
-        return 'complete_with_gaps';
+    if (isComplete)
+        return hasUnresolvedCriticalGaps ? 'complete_with_gaps' : 'complete';
     return 'in_progress';
 }
+function projectNodeDetail(events, nodeId, stepLabels) {
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
+    if (dagRes.isErr())
+        return null;
+    const { node, run } = findNodeInDag(dagRes.value, nodeId) ?? {};
+    if (!node || !run)
+        return null;
+    const tipSet = new Set(run.tipNodeIds);
+    const recapMarkdown = extractRecapMarkdown(events, nodeId);
+    const artifacts = extractArtifacts(events, nodeId);
+    const advanceOutcome = extractAdvanceOutcome(events, nodeId);
+    const validations = extractValidations(events, nodeId);
+    const gaps = extractGaps(events, nodeId);
+    return {
+        nodeId: node.nodeId,
+        nodeKind: node.nodeKind,
+        parentNodeId: node.parentNodeId,
+        createdAtEventIndex: node.createdAtEventIndex,
+        isPreferredTip: node.nodeId === run.preferredTipNodeId,
+        isTip: tipSet.has(node.nodeId),
+        stepLabel: stepLabels[node.nodeId] ?? null,
+        recapMarkdown,
+        artifacts,
+        advanceOutcome,
+        validations,
+        gaps,
+    };
+}
+function findNodeInDag(dag, nodeId) {
+    for (const run of Object.values(dag.runsById)) {
+        const node = run.nodesById[nodeId];
+        if (node)
+            return { node, run };
+    }
+    return null;
+}
+function extractRecapMarkdown(events, nodeId) {
+    const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(events);
+    if (outputsRes.isErr())
+        return null;
+    const nodeOutputs = outputsRes.value.nodesById[nodeId];
+    if (!nodeOutputs)
+        return null;
+    const recaps = nodeOutputs.currentByChannel[constants_js_1.OUTPUT_CHANNEL.RECAP];
+    const latest = recaps?.at(-1);
+    if (latest && latest.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES) {
+        return latest.payload.notesMarkdown;
+    }
+    return null;
+}
+function extractArtifacts(events, nodeId) {
+    const artifactsRes = (0, artifacts_js_1.projectArtifactsV2)(events);
+    if (artifactsRes.isErr())
+        return [];
+    const nodeArtifacts = artifactsRes.value.byNodeId[nodeId];
+    if (!nodeArtifacts)
+        return [];
+    return nodeArtifacts.artifacts.map((a) => ({
+        sha256: a.sha256,
+        contentType: a.contentType,
+        byteLength: a.byteLength,
+        content: a.content,
+    }));
+}
+function extractAdvanceOutcome(events, nodeId) {
+    const outcomesRes = (0, advance_outcomes_js_1.projectAdvanceOutcomesV2)(events);
+    if (outcomesRes.isErr())
+        return null;
+    const outcome = outcomesRes.value.byNodeId[nodeId];
+    if (!outcome)
+        return null;
+    return {
+        attemptId: outcome.latestAttemptId,
+        kind: outcome.outcome.kind,
+        recordedAtEventIndex: outcome.recordedAtEventIndex,
+    };
+}
+function extractValidations(events, nodeId) {
+    const results = [];
+    for (const e of events) {
+        if (e.kind !== constants_js_1.EVENT_KIND.VALIDATION_PERFORMED)
+            continue;
+        if (e.scope.nodeId !== nodeId)
+            continue;
+        results.push({
+            validationId: e.data.validationId,
+            attemptId: e.data.attemptId,
+            contractRef: e.data.contractRef,
+            outcome: (e.data.result.valid ? 'pass' : 'fail'),
+            issues: [...e.data.result.issues],
+            suggestions: [...e.data.result.suggestions],
+        });
+    }
+    return results;
+}
+function extractGaps(events, nodeId) {
+    const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
+    if (gapsRes.isErr())
+        return [];
+    const gaps = [];
+    for (const gap of Object.values(gapsRes.value.byGapId)) {
+        if (gap.nodeId !== nodeId)
+            continue;
+        gaps.push({
+            gapId: gap.gapId,
+            severity: gap.severity,
+            summary: gap.summary,
+            isResolved: gapsRes.value.resolvedGapIds.has(gap.gapId),
+        });
+    }
+    return gaps;
+}

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

@@ -2,7 +2,9 @@ export type ConsoleRunStatus = 'in_progress' | 'complete' | 'complete_with_gaps'
 export type ConsoleSessionHealth = 'healthy' | 'corrupt';
 export interface ConsoleSessionSummary {
     readonly sessionId: string;
+    readonly sessionTitle: string | null;
     readonly workflowId: string | null;
+    readonly workflowName: string | null;
     readonly workflowHash: string | null;
     readonly runId: string | null;
     readonly status: ConsoleRunStatus;
@@ -12,6 +14,8 @@ export interface ConsoleSessionSummary {
     readonly tipCount: number;
     readonly hasUnresolvedGaps: boolean;
     readonly recapSnippet: string | null;
+    readonly gitBranch: string | null;
+    readonly lastModifiedMs: number;
 }
 export interface ConsoleSessionListResponse {
     readonly sessions: readonly ConsoleSessionSummary[];
@@ -24,6 +28,7 @@ export interface ConsoleDagNode {
     readonly createdAtEventIndex: number;
     readonly isPreferredTip: boolean;
     readonly isTip: boolean;
+    readonly stepLabel: string | null;
 }
 export interface ConsoleDagEdge {
     readonly edgeKind: 'acked_step' | 'checkpoint';
@@ -34,6 +39,7 @@ export interface ConsoleDagEdge {
 export interface ConsoleDagRun {
     readonly runId: string;
     readonly workflowId: string | null;
+    readonly workflowName: string | null;
     readonly workflowHash: string | null;
     readonly preferredTipNodeId: string | null;
     readonly nodes: readonly ConsoleDagNode[];
@@ -44,6 +50,48 @@ export interface ConsoleDagRun {
 }
 export interface ConsoleSessionDetail {
     readonly sessionId: string;
+    readonly sessionTitle: string | null;
     readonly health: ConsoleSessionHealth;
     readonly runs: readonly ConsoleDagRun[];
 }
+export type ConsoleValidationOutcome = 'pass' | 'fail';
+export interface ConsoleValidationResult {
+    readonly validationId: string;
+    readonly attemptId: string;
+    readonly contractRef: string;
+    readonly outcome: ConsoleValidationOutcome;
+    readonly issues: readonly string[];
+    readonly suggestions: readonly string[];
+}
+export type ConsoleAdvanceOutcomeKind = 'advanced' | 'blocked';
+export interface ConsoleAdvanceOutcome {
+    readonly attemptId: string;
+    readonly kind: ConsoleAdvanceOutcomeKind;
+    readonly recordedAtEventIndex: number;
+}
+export interface ConsoleNodeGap {
+    readonly gapId: string;
+    readonly severity: 'critical' | 'non_critical';
+    readonly summary: string;
+    readonly isResolved: boolean;
+}
+export interface ConsoleArtifact {
+    readonly sha256: string;
+    readonly contentType: string;
+    readonly byteLength: number;
+    readonly content: unknown;
+}
+export interface ConsoleNodeDetail {
+    readonly nodeId: string;
+    readonly nodeKind: 'step' | 'checkpoint' | 'blocked_attempt';
+    readonly parentNodeId: string | null;
+    readonly createdAtEventIndex: number;
+    readonly isPreferredTip: boolean;
+    readonly isTip: boolean;
+    readonly stepLabel: string | null;
+    readonly recapMarkdown: string | null;
+    readonly artifacts: readonly ConsoleArtifact[];
+    readonly advanceOutcome: ConsoleAdvanceOutcome | null;
+    readonly validations: readonly ConsoleValidationResult[];
+    readonly gaps: readonly ConsoleNodeGap[];
+}

package/package.json

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

package/spec/workflow.schema.json

@@ -332,7 +332,7 @@
                 "contractRef": { "type": "string", "minLength": 1 },
                 "loopId": { "type": "string", "minLength": 1 }
               },
-              "required": ["kind", "contractRef", "loopId"],
+              "required": ["kind", "contractRef"],
               "additionalProperties": false
             },
             {
@@ -351,10 +351,14 @@
       "allOf": [
         {
           "if": {
-            "properties": { "type": { "enum": ["while", "until"] } }
+            "properties": { "type": { "enum": ["while", "until"] } },
+            "required": ["type"]
           },
           "then": {
-            "required": ["condition"]
+            "anyOf": [
+              { "required": ["condition"] },
+              { "required": ["conditionSource"] }
+            ]
           }
         },
         {