@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/bootstrap/analytics-projection.js

@@ -0,0 +1,26 @@
+import { ExecutionEventType } from '../execution/index.js';
+import { WorkEventType } from '../work/index.js';
+export const analyticsProjection = {
+    name: 'operator-analytics',
+    select: () => ({ key: 'global' }),
+    initial: () => ({ events: 0, workItems: 0, runs: 0, days: {} }),
+    project(previous, event) {
+        const day = event.occurredAt.slice(0, 10);
+        const bucket = previous.days[day] ?? { events: 0, workItems: 0, runs: 0 };
+        const workItems = event.eventType === WorkEventType.ItemCreated ? 1 : 0;
+        const runs = event.eventType === ExecutionEventType.RunStarted ? 1 : 0;
+        return {
+            events: previous.events + 1,
+            workItems: previous.workItems + workItems,
+            runs: previous.runs + runs,
+            days: {
+                ...previous.days,
+                [day]: {
+                    events: bucket.events + 1,
+                    workItems: bucket.workItems + workItems,
+                    runs: bucket.runs + runs,
+                },
+            },
+        };
+    },
+};

package/dist/src/bootstrap/board-projection.js

@@ -0,0 +1,337 @@
+import { ActivityOutcomeKind } from '../activities/index.js';
+import { agentTokenUsage, ExecutionEventType, RunStatus, selectRunExecutionEvent, } from '../execution/index.js';
+import { isApprovalAwaitingSignalKind, OrchestrationEventType, orchestrationStatusTransitions, selectWorkflowOrchestrationEvent, WorkflowStatus, } from '../orchestration/index.js';
+import { toWorkItemKey } from '../surfaces/index.js';
+import { selectWorkEvent, WorkEventType } from '../work/index.js';
+const conditionShape = {
+    ready: true,
+    active: true,
+    'needs-input': true,
+    error: true,
+    finished: true,
+};
+const conditions = Object.keys(conditionShape);
+const BoardCondition = {
+    Ready: conditions[0],
+    Active: conditions[1],
+    NeedsInput: conditions[2],
+    Error: conditions[3],
+    Finished: conditions[4],
+};
+export const boardProjection = {
+    name: 'operator-board',
+    select: () => ({ key: 'global' }),
+    initial: () => ({ cards: {}, workflows: {}, runs: {}, children: {}, childRuns: {} }),
+    project(previous, envelope) {
+        const work = selectWorkEvent(envelope);
+        if (work !== null)
+            return projectWork(previous, work, envelope.occurredAt);
+        const workflow = selectWorkflowOrchestrationEvent(envelope);
+        if (workflow !== null)
+            return projectWorkflow(previous, workflow, envelope.occurredAt);
+        const run = selectRunExecutionEvent(envelope);
+        return run === null ? previous : projectRun(previous, run, envelope.occurredAt);
+    },
+};
+export function boardConditionCounts(view) {
+    return Object.values(view.cards).reduce((counts, card) => {
+        counts[card.condition] = (counts[card.condition] ?? 0) + 1;
+        return counts;
+    }, {});
+}
+function projectWork(view, event, occurredAt) {
+    const id = event.stream.id;
+    if (event.eventType === WorkEventType.ItemCreated) {
+        const card = {
+            workItemKey: toWorkItemKey(id),
+            workItemId: id,
+            objective: event.payload.objective,
+            condition: BoardCondition.Ready,
+            dwellSince: occurredAt,
+            runCount: 0,
+            totalTokens: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            totalCostUsd: 0,
+            totalDurationMs: 0,
+        };
+        return { ...view, cards: { ...view.cards, [id]: card } };
+    }
+    const current = view.cards[id];
+    if (current === undefined)
+        return view;
+    if (event.eventType === WorkEventType.ObjectiveRevised)
+        return {
+            ...view,
+            cards: { ...view.cards, [id]: { ...current, objective: event.payload.objective } },
+        };
+    if (event.eventType === WorkEventType.ItemFrozen)
+        return { ...view, cards: { ...view.cards, [id]: { ...current, frozen: true } } };
+    if (event.eventType === WorkEventType.ItemUnfrozen) {
+        const { frozen: _frozen, ...unfrozen } = current;
+        return { ...view, cards: { ...view.cards, [id]: unfrozen } };
+    }
+    if (event.eventType === WorkEventType.ItemClosed ||
+        event.eventType === WorkEventType.ItemCancelled) {
+        return {
+            ...view,
+            cards: { ...view.cards, [id]: { ...current, condition: BoardCondition.Finished } },
+        };
+    }
+    // Deletion is a purge, not a lifecycle outcome — the card must disappear
+    // from the board entirely rather than settle into any condition column.
+    if (event.eventType === WorkEventType.ItemDeleted) {
+        const { [id]: _removed, ...cards } = view.cards;
+        return { ...view, cards };
+    }
+    return view;
+}
+function projectWorkflow(view, event, occurredAt) {
+    if (event.eventType === OrchestrationEventType.InstanceStarted) {
+        const workId = event.payload.workItemId;
+        const card = view.cards[workId];
+        if (card === undefined)
+            return view;
+        const workflows = { ...view.workflows, [event.stream.id]: workId };
+        if ('parentWorkflowInstanceId' in event.payload)
+            return {
+                ...view,
+                workflows,
+                children: { ...view.children, [event.stream.id]: event.payload.entry },
+            };
+        return {
+            ...view,
+            cards: {
+                ...view.cards,
+                [workId]: {
+                    ...card,
+                    workflowName: event.payload.workflowName,
+                    stage: event.payload.entry,
+                    dwellSince: occurredAt,
+                    condition: BoardCondition.Ready,
+                },
+            },
+            workflows,
+        };
+    }
+    if (view.children?.[event.stream.id] !== undefined)
+        return view;
+    const located = lookupWorkflowCard(view, event.stream.id);
+    if (located === undefined)
+        return view;
+    const { workId, card } = located;
+    // Closed/cancelled is terminal for a WorkItem — there is no reopen path
+    // (see work-item.spec.md) — so a workflow status event that arrives after
+    // closure (e.g. InstanceBlocked from the now-orphaned instance halting)
+    // must not resurrect the card out of Finished.
+    if (card.condition === BoardCondition.Finished)
+        return view;
+    // A new stage is always Ready regardless of the condition it inherits —
+    // Error from the prior stage's failed run, or whatever it held before the
+    // SignalAccepted that unblocked it — until a Run actually starts (Active)
+    // or a fresh SignalWaitStarted arrives (Needs Input).
+    if (event.eventType === OrchestrationEventType.StageEntered)
+        return {
+            ...view,
+            cards: {
+                ...view.cards,
+                [workId]: {
+                    ...card,
+                    stage: event.payload.stage,
+                    dwellSince: occurredAt,
+                    condition: BoardCondition.Ready,
+                },
+            },
+        };
+    // Every event that changes a workflow instance's status is looked up from
+    // orchestrationStatusTransitions rather than hand-matched here, so a new
+    // status-changing event type added to the engine automatically reaches
+    // the board instead of silently sitting at whatever condition it had
+    // before — this is exactly the class of gap that let the card sit in
+    // Ready while GitHub's own label already said working.
+    const status = orchestrationStatusTransitions[event.eventType];
+    if (status === undefined)
+        return view;
+    const withCondition = { ...card, condition: boardConditionForStatus(status) };
+    if (event.eventType === OrchestrationEventType.SignalWaitStarted)
+        return {
+            ...view,
+            cards: {
+                ...view.cards,
+                [workId]: { ...withCondition, ...awaitingApprovalField(event.payload.signalKind) },
+            },
+        };
+    if (event.eventType === OrchestrationEventType.SignalAccepted)
+        return { ...view, cards: { ...view.cards, [workId]: withoutAwaitingApproval(withCondition) } };
+    return { ...view, cards: { ...view.cards, [workId]: withCondition } };
+}
+function boardConditionForStatus(status) {
+    switch (status) {
+        // Orchestration "active" means outstanding work, not a run in flight —
+        // the board's Active condition is reserved for RunStarted (below).
+        case WorkflowStatus.Active:
+            return BoardCondition.Ready;
+        case WorkflowStatus.Waiting:
+        case WorkflowStatus.Blocked:
+            return BoardCondition.NeedsInput;
+        case WorkflowStatus.Completed:
+            return BoardCondition.Finished;
+        case WorkflowStatus.Superseded:
+            return BoardCondition.Error;
+    }
+}
+function lookupWorkflowCard(view, streamId) {
+    const workId = view.workflows[streamId];
+    if (workId === undefined)
+        return undefined;
+    const card = view.cards[workId];
+    return card === undefined ? undefined : { workId, card };
+}
+function awaitingApprovalField(signalKind) {
+    return isApprovalAwaitingSignalKind(signalKind) ? { awaitingApproval: true } : {};
+}
+const runTerminalEventTypes = new Set([
+    ExecutionEventType.RunSucceeded,
+    ExecutionEventType.RunFailed,
+    ExecutionEventType.RunCancelled,
+    ExecutionEventType.RunAmbiguous,
+]);
+function terminalFinishedAt(event) {
+    if (event.eventType === ExecutionEventType.RunSucceeded ||
+        event.eventType === ExecutionEventType.RunFailed ||
+        event.eventType === ExecutionEventType.RunCancelled ||
+        event.eventType === ExecutionEventType.RunAmbiguous)
+        return event.payload.finishedAt;
+    return undefined;
+}
+// RunSucceeded is a transport-level fact only: the agent can still report
+// a failed/blocked sentinel inside its outcome, so the board's condition
+// must follow outcome.kind, not just the event type, or a failed/blocked
+// run leaves the card silently stuck on the prior "active" condition.
+function terminalRunFields(event) {
+    if (event.eventType === ExecutionEventType.RunSucceeded) {
+        const kind = event.payload.outcome.kind;
+        // A successful outcome means the runner has stopped, but does not decide
+        // the workflow's next state. Keep the workflow-owned condition until its
+        // next lifecycle event (ActivityRequested, SignalWaitStarted, or
+        // InstanceCompleted) changes it.
+        if (kind === ActivityOutcomeKind.Failed)
+            return { lastRunOutcome: kind, condition: BoardCondition.Error };
+        if (kind === ActivityOutcomeKind.Blocked)
+            return { lastRunOutcome: kind, condition: BoardCondition.NeedsInput };
+        return { lastRunOutcome: kind };
+    }
+    if (event.eventType === ExecutionEventType.RunFailed)
+        return { lastRunOutcome: RunStatus.Failed, condition: BoardCondition.Error };
+    if (event.eventType === ExecutionEventType.RunCancelled)
+        return { lastRunOutcome: RunStatus.Cancelled, condition: BoardCondition.Error };
+    if (event.eventType === ExecutionEventType.RunAmbiguous)
+        return { lastRunOutcome: RunStatus.Ambiguous, condition: BoardCondition.Error };
+    return undefined;
+}
+function projectRun(view, event, _occurredAt) {
+    if (event.eventType === ExecutionEventType.RunStarted)
+        return projectRunStarted(view, event);
+    const workId = view.runs[event.stream.id];
+    const card = workId === undefined ? undefined : view.cards[workId];
+    if (card === undefined || workId === undefined)
+        return view;
+    if (runTerminalEventTypes.has(event.eventType))
+        return projectRunTerminal(view, event, workId, card);
+    if (event.eventType === ExecutionEventType.RunRunnerResultReported)
+        return projectRunnerResult(view, workId, card, event.payload.agent?.metadata);
+    return view;
+}
+function projectRunTerminal(view, event, workId, card) {
+    const finishedAt = terminalFinishedAt(event);
+    const runDurationMs = card.activeRun === undefined || finishedAt === undefined
+        ? 0
+        : Date.parse(finishedAt) - Date.parse(card.activeRun.startedAt);
+    const terminal = terminalRunFields(event);
+    // Same legacy-checkpoint tolerance as the `children` guard above: a
+    // checkpoint persisted before `childRuns` was added round-trips without
+    // it, and this is the first read of the field after a Run starts.
+    const isChildRun = view.childRuns?.[event.stream.id] === true;
+    return {
+        ...view,
+        cards: {
+            ...view.cards,
+            [workId]: {
+                ...withoutActiveRun(card),
+                ...(terminal === undefined ? {} : { lastRunOutcome: terminal.lastRunOutcome }),
+                ...(terminal === undefined || isChildRun || terminal.condition === undefined
+                    ? {}
+                    : { condition: terminal.condition }),
+                totalDurationMs: card.totalDurationMs + runDurationMs,
+            },
+        },
+    };
+}
+function projectRunStarted(view, event) {
+    const workId = view.workflows[event.payload.workflowInstanceId];
+    const card = workId === undefined ? undefined : view.cards[workId];
+    if (card === undefined || workId === undefined)
+        return view;
+    // Same legacy-checkpoint tolerance as the `children` guard in
+    // projectWorkflow: a RunStarted event reaches this field independently of
+    // that guard, so a checkpoint predating `children` must not crash here either.
+    const childAction = view.children?.[event.payload.workflowInstanceId];
+    const isChildRun = childAction !== undefined;
+    return {
+        ...view,
+        runs: { ...view.runs, [event.stream.id]: workId },
+        ...(isChildRun ? { childRuns: { ...view.childRuns, [event.stream.id]: true } } : {}),
+        cards: {
+            ...view.cards,
+            [workId]: {
+                ...(isChildRun ? card : withoutLastRunOutcome(withoutAwaitingApproval(card))),
+                runCount: card.runCount + 1,
+                ...(isChildRun ? {} : { condition: BoardCondition.Active }),
+                lastRunAt: event.payload.startedAt,
+                activeRun: {
+                    action: childAction ?? card.stage ?? event.payload.activity,
+                    startedAt: event.payload.startedAt,
+                    ...(event.payload.runner?.name === undefined
+                        ? {}
+                        : { runnerName: event.payload.runner.name }),
+                },
+            },
+        },
+    };
+}
+function projectRunnerResult(view, workId, card, metadata) {
+    const usage = agentTokenUsage(metadata);
+    return {
+        ...view,
+        cards: {
+            ...view.cards,
+            [workId]: {
+                ...card,
+                totalTokens: card.totalTokens + usage.tokens,
+                inputTokens: (card.inputTokens ?? 0) + numeric(metadata, 'inputTokens'),
+                outputTokens: (card.outputTokens ?? 0) + numeric(metadata, 'outputTokens'),
+                cacheReadTokens: (card.cacheReadTokens ?? 0) + numeric(metadata, 'cacheReadTokens'),
+                cacheWriteTokens: (card.cacheWriteTokens ?? 0) + numeric(metadata, 'cacheWriteTokens'),
+                totalCostUsd: card.totalCostUsd + usage.costUsd,
+            },
+        },
+    };
+}
+function numeric(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === 'number' ? value : 0;
+}
+function withoutAwaitingApproval(card) {
+    const { awaitingApproval: _awaitingApproval, ...withoutApproval } = card;
+    return withoutApproval;
+}
+function withoutActiveRun(card) {
+    const { activeRun: _activeRun, ...withoutRun } = card;
+    return withoutRun;
+}
+function withoutLastRunOutcome(card) {
+    const { lastRunOutcome: _lastRunOutcome, ...withoutOutcome } = card;
+    return withoutOutcome;
+}