@mingchuno/agent-workflows 0.4.0 → 0.5.0

package/dist/src/tui/monitor-navigation.d.ts

@@ -0,0 +1,76 @@
+import type { Key } from "ink";
+import type { RunRecord } from "../domain.js";
+import type { EventRecord, InvocationRecord, ProjectState } from "../store.js";
+import type { MonitorAction } from "./data.js";
+import type { LogSource } from "./log.js";
+type Focus = "runs" | "summary" | "sessions";
+type RunAction = "stop" | "retry" | "retry-refresh" | "recover";
+type Selection = {
+    projectId?: string;
+    runId?: string;
+};
+type Modal = {
+    type: "help";
+} | {
+    type: "confirmation";
+    kind: RunAction;
+    runId: string;
+    title: string;
+} | {
+    type: "logs";
+    sources: LogSource[];
+    initial: number;
+};
+export interface MonitorNavigation {
+    selection: Selection;
+    /** Actual displayed run, which may fall back from a requested selection. */
+    displayedRunId?: string;
+    screen: "dashboard" | "details";
+    focus: Focus;
+    sessionId?: string;
+    stepSequence?: number;
+    offset: number;
+    modal?: Modal;
+}
+export declare const initialNavigation: MonitorNavigation;
+interface NavigationContext {
+    terminalIsLargeEnough: boolean;
+    projects: ProjectState[];
+    project?: ProjectState;
+    runs: RunRecord[];
+    run?: RunRecord;
+    sessions: InvocationRecord[];
+    session?: InvocationRecord;
+    events: EventRecord[];
+    event?: EventRecord;
+    logSessions: InvocationRecord[];
+    logSession?: InvocationRecord;
+    available: Record<"stop" | "retry" | "recover", boolean>;
+    pending: boolean;
+    scrollMaximum: number;
+    pageSize: number;
+}
+export type NavigationEvent = {
+    type: "selection";
+    selection: Selection;
+} | {
+    type: "dismiss";
+} | {
+    type: "key";
+    input: string;
+    key: Key;
+    context: NavigationContext;
+};
+interface Transition {
+    state: MonitorNavigation;
+    effect?: {
+        type: "exit";
+    } | {
+        type: "command";
+        kind: MonitorAction;
+        target: string;
+    };
+}
+/** Pure navigation transitions; the monitor owns rendering and command effects. */
+export declare function transitionNavigation(state: MonitorNavigation, event: NavigationEvent): Transition;
+export {};

package/dist/src/tui/monitor-navigation.js

@@ -0,0 +1,187 @@
+export const initialNavigation = {
+    selection: {},
+    screen: "dashboard",
+    focus: "runs",
+    offset: 0,
+};
+const focuses = ["runs", "summary", "sessions"];
+/** Pure navigation transitions; the monitor owns rendering and command effects. */
+export function transitionNavigation(state, event) {
+    if (event.type === "dismiss")
+        return { state: { ...state, modal: undefined } };
+    if (event.type === "selection")
+        return { state: synchronizeSelection(state, event.selection) };
+    const { input, key, context } = event;
+    if (key.ctrl || key.meta || key.eventType === "release")
+        return { state };
+    // Dialogs/logs own keyboard input, except when hidden by the resize screen.
+    if (state.modal && context.terminalIsLargeEnough)
+        return { state };
+    if (input === "q")
+        return { state, effect: { type: "exit" } };
+    if (!context.terminalIsLargeEnough)
+        return { state };
+    if (key.escape)
+        return {
+            state: { ...state, screen: "dashboard", focus: "runs", offset: 0 },
+        };
+    if (input === "?")
+        return { state: { ...state, modal: { type: "help" } } };
+    if (key.upArrow || key.downArrow || key.pageUp || key.pageDown)
+        return { state: moveVertically(state, key, context) };
+    if (input === "l")
+        return { state: openAgentLog(state, context) };
+    if (input === "v" && context.run?.validation?.length)
+        return {
+            state: {
+                ...state,
+                modal: {
+                    type: "logs",
+                    sources: context.run.validation.map((check) => ({
+                        path: check.log,
+                        label: `${check.command} · exit ${check.exitCode}`,
+                    })),
+                    initial: 0,
+                },
+            },
+        };
+    const kind = input === "s"
+        ? "stop"
+        : input === "r"
+            ? "retry"
+            : input === "R"
+                ? "retry-refresh"
+                : input === "c"
+                    ? "recover"
+                    : undefined;
+    if (kind &&
+        context.run &&
+        context.available[kind === "retry-refresh" ? "retry" : kind])
+        return {
+            state: {
+                ...state,
+                modal: {
+                    type: "confirmation",
+                    kind,
+                    runId: context.run.id,
+                    title: `#${context.run.issue.number} ${context.run.issue.title}`,
+                },
+            },
+        };
+    if (state.screen === "details")
+        return { state };
+    return dashboardInput(state, input, key, context);
+}
+function synchronizeSelection(state, selection) {
+    const sameRun = state.displayedRunId === selection.runId;
+    if (sameRun &&
+        state.selection.projectId === selection.projectId &&
+        state.selection.runId === selection.runId)
+        return state;
+    if (sameRun)
+        return { ...state, selection };
+    return {
+        ...state,
+        selection,
+        displayedRunId: selection.runId,
+        sessionId: undefined,
+        stepSequence: undefined,
+        offset: 0,
+        modal: state.modal?.type === "confirmation" ? undefined : state.modal,
+    };
+}
+function dashboardInput(state, input, key, context) {
+    if (key.tab)
+        return {
+            state: {
+                ...state,
+                focus: focuses[(focuses.indexOf(state.focus) + (key.shift ? 2 : 1)) % 3],
+                offset: 0,
+            },
+        };
+    if (input === "a")
+        return { state: { ...state, focus: "sessions" } };
+    if (key.leftArrow || key.rightArrow) {
+        const next = adjacent(context.projects, context.projects.findIndex((item) => item.id === context.project?.id), key.leftArrow ? -1 : 1);
+        return {
+            state: {
+                ...state,
+                selection: { projectId: next?.id },
+                focus: "runs",
+                offset: 0,
+            },
+        };
+    }
+    if (key.return && context.run)
+        return { state: { ...state, screen: "details", offset: 0 } };
+    if (input === "[" || input === "]") {
+        const next = adjacent(context.events, context.events.findIndex((item) => item.sequence === context.event?.sequence), input === "]" ? 1 : -1);
+        return { state: { ...state, stepSequence: next?.sequence } };
+    }
+    if (key.end)
+        return { state: { ...state, stepSequence: undefined } };
+    if (input === "p" && context.project && !context.pending)
+        return {
+            state,
+            effect: {
+                type: "command",
+                kind: context.project.paused ? "resume" : "pause",
+                target: context.project.id,
+            },
+        };
+    return { state };
+}
+function moveVertically(state, key, context) {
+    const delta = key.upArrow || key.pageUp ? -1 : 1;
+    if (state.screen === "details" || state.focus === "summary") {
+        const current = state.screen === "details"
+            ? Math.min(state.offset, context.scrollMaximum)
+            : state.offset;
+        const distance = key.pageUp || key.pageDown ? context.pageSize : 1;
+        return {
+            ...state,
+            offset: Math.max(0, Math.min(context.scrollMaximum, current + delta * distance)),
+        };
+    }
+    if (state.focus === "sessions") {
+        const next = adjacent(context.sessions, context.sessions.findIndex((item) => item.id === context.session?.id), delta);
+        return { ...state, sessionId: next?.id };
+    }
+    const next = adjacent(context.runs, context.runs.findIndex((item) => item.id === context.run?.id), delta);
+    return {
+        ...state,
+        selection: { projectId: context.project?.id, runId: next?.id },
+    };
+}
+function openAgentLog(state, context) {
+    const currentExecutionId = context.run?.executions?.at(-1)?.id ?? context.run?.id;
+    const stageSources = (context.run?.stageLogs ?? [])
+        .filter((item) => item.executionId === currentExecutionId)
+        .map((item) => ({
+        path: item.path,
+        label: `${item.step} · stage diagnostic`,
+    }));
+    const sources = [
+        ...stageSources,
+        ...context.logSessions.map((session) => ({
+            path: session.log,
+            label: `${session.step} · invocation ${session.attempt}`,
+        })),
+    ];
+    if (!sources.length)
+        return state;
+    return {
+        ...state,
+        modal: {
+            type: "logs",
+            sources,
+            initial: context.logSession
+                ? Math.max(0, stageSources.length +
+                    context.logSessions.findIndex((session) => session.id === context.logSession?.id))
+                : 0,
+        },
+    };
+}
+function adjacent(items, index, delta) {
+    return items[Math.max(0, Math.min(items.length - 1, index + delta))];
+}

package/dist/src/tui/monitor.js

@@ -1,233 +1,114 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useApp, useInput, useWindowSize } from "ink";
 import { useEffect, useState } from "react";
-import { actionAvailability } from "./actions.js";
 import { minimumTerminalSize } from "./constants.js";
 import { useMonitorData } from "./data.js";
 import { ConfirmDialog, HelpDialog } from "./dialogs.js";
 import { cells, colorFor, wrapLines } from "./format.js";
 import { monitorLayout } from "./layout.js";
 import { LogViewer } from "./log.js";
+import { initialNavigation, transitionNavigation, } from "./monitor-navigation.js";
+import { projectRunProjection } from "./projection.js";
 import { detailLines, Lines, RunList, summaryLines, wrapDetailLines, } from "./views.js";
 const notificationNoticeDurationMs = 2000;
-const focuses = ["runs", "summary", "sessions"];
 const statusRefreshIntervalMs = 1_000;
 const actionDescriptions = {
     stop: "Cancel this run and wait for its active local work to stop.",
     retry: "Create a new run and branch; execute the workflow again.",
+    "retry-refresh": "Create a new run using the current hosted issue and validation selection.",
     recover: "Continue the failed publication step using completed work.",
 };
-function currentExecutionSessions(run, sessions, events) {
-    const current = run?.executions?.at(-1);
-    if (!current || (run?.executions?.length ?? 0) <= 1)
-        return sessions;
-    const currentStepIds = new Set(events.flatMap((event) => {
-        const payload = event.payload;
-        return payload.executionId === current.id &&
-            typeof payload.stepId === "number"
-            ? [payload.stepId]
-            : [];
-    }));
-    if (currentStepIds.size)
-        return sessions.filter((item) => currentStepIds.has(item.stepId));
-    const executionCreatedAt = Date.parse(current.createdAt);
-    if (!Number.isFinite(executionCreatedAt))
-        return [];
-    return sessions.filter((item) => Date.parse(item.startedAt) >= executionCreatedAt);
-}
-function latestSession(sessions) {
-    const byRecency = [...sessions].sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
-    return (byRecency.filter((item) => item.outcome === "running").at(-1) ??
-        byRecency.at(-1));
-}
 export function Monitor({ source, size, notificationWriter, }) {
     const window = useWindowSize();
     const { columns, rows } = size ?? window;
     const { exit } = useApp();
-    const [selection, setSelection] = useState({});
+    const [navigation, setNavigation] = useState(initialNavigation);
+    const { selection, focus, screen, sessionId, stepSequence, offset, modal } = navigation;
+    const confirmation = modal?.type === "confirmation" ? modal : undefined;
+    const logs = modal?.type === "logs" ? modal : undefined;
     const data = useMonitorData(source, selection, notificationWriter);
     const { projects, project, projectRuns, run, sessions, events } = data;
-    const [focus, setFocus] = useState("runs");
-    const [screen, setScreen] = useState("dashboard");
-    const [sessionId, setSessionId] = useState();
-    const [stepSequence, setStepSequence] = useState();
-    const [offset, setOffset] = useState(0);
-    const [helpOpen, setHelpOpen] = useState(false);
-    const [confirmation, setConfirmation] = useState();
-    const [logs, setLogs] = useState();
+    const dismissModal = () => setNavigation((current) => transitionNavigation(current, { type: "dismiss" }).state);
     const [now, setNow] = useState(Date.now());
     const [notificationNoticeUntil] = useState(() => Date.now() + notificationNoticeDurationMs);
     const showNotificationNotice = Boolean(notificationWriter) && now < notificationNoticeUntil;
     const layout = monitorLayout(columns, rows - (showNotificationNotice ? 1 : 0), screen === "details");
     const { wide, height, paneWidth, summaryWidth } = layout;
     const session = sessions.find((item) => item.id === sessionId) ?? sessions[0];
-    const executionSessions = currentExecutionSessions(run, sessions, events);
-    const detailLogSession = latestSession(executionSessions);
+    const { executionSessions, detailLogSession, recoveryReason, available } = projectRunProjection({
+        run,
+        project,
+        projectRuns,
+        sessions,
+        events,
+        pending: Boolean(data.pending),
+    });
     const event = events.find((item) => item.sequence === stepSequence) ?? events.at(-1);
     useEffect(() => {
         const timer = setInterval(() => setNow(Date.now()), statusRefreshIntervalMs);
         return () => clearInterval(timer);
     }, []);
     useEffect(() => {
-        // Pin default selections by identity before incoming rows can reorder them.
-        setSelection((current) => current.projectId === project?.id && current.runId === run?.id
-            ? current
-            : { projectId: project?.id, runId: run?.id });
+        // Pin default selections and reset run-specific navigation in one transition.
+        setNavigation((current) => transitionNavigation(current, {
+            type: "selection",
+            selection: { projectId: project?.id, runId: run?.id },
+        }).state);
     }, [project?.id, run?.id]);
-    // biome-ignore lint/correctness/useExhaustiveDependencies: reset navigation when the selected run identity changes.
-    useEffect(() => {
-        setSessionId(undefined);
-        setStepSequence(undefined);
-        setOffset(0);
-        setConfirmation(undefined);
-    }, [run?.id]);
-    const selectProject = (delta) => {
-        const index = projects.findIndex((item) => item.id === project?.id);
-        const next = projects[Math.max(0, Math.min(projects.length - 1, index + delta))];
-        setSelection({ projectId: next?.id });
-        setFocus("runs");
-        setOffset(0);
-    };
-    const openAgentLog = (candidates = sessions, initialSession = session) => {
-        if (!candidates.length)
-            return;
-        setLogs({
-            sources: candidates.map((item) => ({
-                path: item.log,
-                label: `${item.step} · invocation ${item.attempt}`,
-            })),
-            initial: Math.max(0, candidates.findIndex((item) => item.id === initialSession?.id)),
-        });
-    };
-    const { recoveryReason, available } = actionAvailability({
-        run,
-        project,
-        projectRuns,
-        pending: Boolean(data.pending),
-    });
     const detailDocument = run
         ? detailLines(run, sessions, now, recoveryReason, layout.details.width, available)
         : ["Run no longer available"];
     const wrappedDetailLines = wrapDetailLines(detailDocument, layout.details.width);
     const detailOffset = Math.min(offset, Math.max(0, wrappedDetailLines.length - layout.details.height));
+    const terminalIsLargeEnough = columns >= minimumTerminalSize.columns && rows >= minimumTerminalSize.rows;
     useInput((input, key) => {
-        if (key.ctrl || key.meta || key.eventType === "release")
-            return;
-        const terminalIsLargeEnough = columns >= minimumTerminalSize.columns &&
-            rows >= minimumTerminalSize.rows;
-        if (logs && terminalIsLargeEnough)
-            return;
-        if (terminalIsLargeEnough && (confirmation || helpOpen))
-            return;
-        if (input === "q") {
+        const viewport = screen === "details" ? layout.details : layout.summary;
+        const scrollLines = run
+            ? screen === "details"
+                ? wrappedDetailLines
+                : wrapLines(summaryLines(run, now, event), viewport.width)
+            : [];
+        const navigationEvent = {
+            type: "key",
+            input,
+            key,
+            context: {
+                terminalIsLargeEnough,
+                projects,
+                project,
+                runs: projectRuns,
+                run,
+                sessions,
+                session,
+                events,
+                event,
+                logSessions: screen === "details" ? executionSessions : sessions,
+                logSession: screen === "details" ? detailLogSession : session,
+                available,
+                pending: Boolean(data.pending),
+                scrollMaximum: Math.max(0, scrollLines.length - viewport.height),
+                pageSize: layout.details.height,
+            },
+        };
+        const { effect } = transitionNavigation(navigation, navigationEvent);
+        setNavigation((current) => transitionNavigation(current, navigationEvent).state);
+        if (effect?.type === "exit")
             exit();
-            return;
-        }
-        if (!terminalIsLargeEnough)
-            return;
-        if (key.escape) {
-            setScreen("dashboard");
-            setFocus("runs");
-            setOffset(0);
-            return;
-        }
-        if (input === "?") {
-            setHelpOpen(true);
-            return;
-        }
-        if (key.tab && screen === "dashboard") {
-            setFocus(focuses[(focuses.indexOf(focus) + (key.shift ? 2 : 1)) % 3]);
-            setOffset(0);
-        }
-        if (input === "a" && screen === "dashboard") {
-            setScreen("dashboard");
-            setFocus("sessions");
-        }
-        if (key.leftArrow && screen === "dashboard")
-            selectProject(-1);
-        if (key.rightArrow && screen === "dashboard")
-            selectProject(1);
-        if (key.return && run && screen === "dashboard") {
-            setScreen("details");
-            setOffset(0);
-        }
-        if (input === "l")
-            screen === "details"
-                ? openAgentLog(executionSessions, detailLogSession)
-                : openAgentLog();
-        if (input === "v" && run?.validation?.length)
-            setLogs({
-                sources: run.validation.map((item) => ({
-                    path: item.log,
-                    label: `${item.command} · exit ${item.exitCode}`,
-                })),
-                initial: 0,
-            });
-        if (screen === "dashboard" && (input === "[" || input === "]")) {
-            const index = events.findIndex((item) => item.sequence === event?.sequence);
-            setStepSequence(events[Math.max(0, Math.min(events.length - 1, index + (input === "]" ? 1 : -1)))]?.sequence);
-        }
-        if (key.end && screen === "dashboard")
-            setStepSequence(undefined);
-        if (key.upArrow || key.downArrow || key.pageUp || key.pageDown) {
-            const delta = key.upArrow || key.pageUp ? -1 : 1;
-            if (screen === "details" || focus === "summary") {
-                const lines = run
-                    ? screen === "details"
-                        ? detailDocument
-                        : summaryLines(run, now, event)
-                    : [];
-                const viewport = screen === "details" ? layout.details : layout.summary;
-                setOffset((value) => {
-                    const maximum = Math.max(0, (screen === "details"
-                        ? wrapDetailLines(lines, viewport.width)
-                        : wrapLines(lines, viewport.width)).length - viewport.height);
-                    const current = screen === "details" ? Math.min(value, maximum) : value;
-                    return Math.max(0, Math.min(maximum, current +
-                        delta *
-                            (key.pageUp || key.pageDown ? layout.details.height : 1)));
-                });
-            }
-            else if (focus === "sessions") {
-                const index = sessions.findIndex((item) => item.id === session?.id);
-                setSessionId(sessions[Math.max(0, Math.min(sessions.length - 1, index + delta))]
-                    ?.id);
-            }
-            else {
-                const index = projectRuns.findIndex((item) => item.id === run?.id);
-                setSelection({
-                    projectId: project?.id,
-                    runId: projectRuns[Math.max(0, Math.min(projectRuns.length - 1, index + delta))]?.id,
-                });
-            }
-        }
-        if (input === "p" && screen === "dashboard" && project && !data.pending)
-            void data.action(project.paused ? "resume" : "pause", project.id);
-        const kind = input === "s"
-            ? "stop"
-            : input === "r"
-                ? "retry"
-                : input === "c"
-                    ? "recover"
-                    : undefined;
-        if (kind && run && available[kind])
-            setConfirmation({
-                kind,
-                runId: run.id,
-                title: `#${run.issue.number} ${run.issue.title}`,
-            });
+        if (effect?.type === "command")
+            void data.action(effect.kind, effect.target);
     });
-    if (columns < minimumTerminalSize.columns || rows < minimumTerminalSize.rows)
+    if (!terminalIsLargeEnough)
         return (_jsx(Box, { width: columns, height: rows, flexDirection: "column", children: _jsx(Text, { children: cells(`Resize terminal to at least ${minimumTerminalSize.columns}×${minimumTerminalSize.rows}. q closes monitor.`, columns) }) }));
-    if (helpOpen)
-        return (_jsx(HelpDialog, { columns: columns, rows: rows, onClose: () => setHelpOpen(false) }));
+    if (modal?.type === "help")
+        return _jsx(HelpDialog, { columns: columns, rows: rows, onClose: dismissModal });
     if (confirmation)
-        return (_jsx(ConfirmDialog, { columns: columns, rows: rows, title: `Confirm ${confirmation.kind}`, subject: confirmation.title, description: actionDescriptions[confirmation.kind], available: run?.id === confirmation.runId && available[confirmation.kind], onCancel: () => setConfirmation(undefined), onConfirm: () => {
+        return (_jsx(ConfirmDialog, { columns: columns, rows: rows, title: `Confirm ${confirmation.kind}`, subject: confirmation.title, description: actionDescriptions[confirmation.kind], available: run?.id === confirmation.runId &&
+                available[confirmation.kind === "retry-refresh" ? "retry" : confirmation.kind], onCancel: dismissModal, onConfirm: () => {
                 void data.action(confirmation.kind, confirmation.runId);
-                setConfirmation(undefined);
+                dismissModal();
             } }));
     if (logs)
-        return (_jsx(LogViewer, { ...logs, columns: columns, rows: rows, onBack: () => setLogs(undefined) }));
+        return (_jsx(LogViewer, { ...logs, columns: columns, rows: rows, onBack: dismissModal }));
     const freshness = data.lastUpdated
         ? `refreshed ${Math.max(0, Math.floor((now - data.lastUpdated) / statusRefreshIntervalMs))}s ago`
         : "freshness unavailable";
@@ -242,9 +123,15 @@ export function Monitor({ source, size, notificationWriter, }) {
         ? columns < 120
             ? "l current log"
             : `l log: ${detailLogSession.step} invocation ${detailLogSession.attempt} (${detailLogSession.outcome})`
-        : "";
+        : run?.stageLogs?.some((item) => item.executionId === (run.executions?.at(-1)?.id ?? run.id))
+            ? "l stage diagnostic"
+            : "";
     const controls = [
-        screen === "details" ? detailsLogControl : sessions.length ? "l log" : "",
+        screen === "details"
+            ? detailsLogControl
+            : sessions.length || run?.stageLogs?.length
+                ? "l log"
+                : "",
         run?.validation?.length
             ? columns < 120
                 ? "v checks"

package/dist/src/tui/projection.d.ts

@@ -0,0 +1,22 @@
+import type { RunRecord } from "../domain.js";
+import type { EventRecord, InvocationRecord, ProjectState } from "../store.js";
+interface RunProjectionInput {
+    run?: RunRecord;
+    project?: ProjectState;
+    projectRuns: RunRecord[];
+    sessions?: InvocationRecord[];
+    events?: EventRecord[];
+    pending: boolean;
+}
+/** Operator facts derived from one selected Run; admission remains authoritative. */
+export declare function projectRunProjection({ run, project, projectRuns, sessions, events, pending, }: RunProjectionInput): {
+    recoveryReason: string | undefined;
+    available: {
+        stop: boolean;
+        retry: boolean;
+        recover: boolean;
+    };
+    executionSessions: InvocationRecord[];
+    detailLogSession: InvocationRecord | undefined;
+};
+export {};

package/dist/src/tui/projection.js

@@ -0,0 +1,49 @@
+import { recoveryUnavailable } from "../recovery.js";
+/** Operator facts derived from one selected Run; admission remains authoritative. */
+export function projectRunProjection({ run, project, projectRuns, sessions = [], events = [], pending, }) {
+    const recoveryReason = run
+        ? (recoveryUnavailable(run) ??
+            project?.blocked ??
+            (projectRuns.some((item) => item.taskKey === run.taskKey && item.attempt > run.attempt)
+                ? "A newer attempt has superseded this run"
+                : undefined))
+        : undefined;
+    const executionSessions = currentExecutionSessions(run, sessions, events);
+    return {
+        recoveryReason,
+        available: {
+            stop: Boolean(run && !pending && ["queued", "running"].includes(run.outcome)),
+            retry: Boolean(run &&
+                !pending &&
+                ["failed", "blocked", "cancelled"].includes(run.outcome) &&
+                !projectRuns.some((item) => item.taskKey === run.taskKey &&
+                    ["queued", "running"].includes(item.outcome))),
+            recover: Boolean(run && !pending && !recoveryReason),
+        },
+        executionSessions,
+        detailLogSession: latestSession(executionSessions),
+    };
+}
+function currentExecutionSessions(run, sessions, events) {
+    const current = run?.executions?.at(-1);
+    if (!current || (run?.executions?.length ?? 0) <= 1)
+        return sessions;
+    const currentStepIds = new Set(events.flatMap((event) => {
+        const payload = event.payload;
+        return payload.executionId === current.id &&
+            typeof payload.stepId === "number"
+            ? [payload.stepId]
+            : [];
+    }));
+    if (currentStepIds.size)
+        return sessions.filter((item) => currentStepIds.has(item.stepId));
+    const executionCreatedAt = Date.parse(current.createdAt);
+    if (!Number.isFinite(executionCreatedAt))
+        return [];
+    return sessions.filter((item) => Date.parse(item.startedAt) >= executionCreatedAt);
+}
+function latestSession(sessions) {
+    const byRecency = [...sessions].sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
+    return (byRecency.filter((item) => item.outcome === "running").at(-1) ??
+        byRecency.at(-1));
+}

package/dist/src/validation-selection.d.ts

@@ -0,0 +1,6 @@
+import type { Project } from "./config.js";
+/** Resolve the one ticket-selected set against project-owned commands. */
+export declare function selectValidation(body: string, project: Project): {
+    profile?: string;
+    commands: Project["validation"];
+};