@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/core/workspace-cleanup.js

@@ -1,117 +0,0 @@
-import { readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, relative } from 'node:path';
-import { WORKSPACE_CLEANED_EVENT, WORKSPACE_CLEANUP_FAILED_EVENT } from '../domain/event-types.js';
-import { createEventEnvelope } from '../lib/event-log.js';
-const TRANSCRIPT_CLEANED_AT_MARKER = '.cleaned-at';
-// Cleans up per-issue workspaces and applies transcript retention once the
-// originating issue is closed. A cleanup failure is recorded as an event and
-// skipped rather than aborting the sweep.
-export function createWorkspaceCleanup(deps) {
-    function eventStampNow() {
-        return deps.clock.now().toISOString();
-    }
-    function isPerIssueWorkspacePath(workspacePath) {
-        const workspacesRoot = join(deps.config.paths.wakeRoot, 'workspaces');
-        const rel = relative(workspacesRoot, workspacePath);
-        return !rel.startsWith('..') && !isAbsolute(rel) && rel.length > 0;
-    }
-    async function markTranscriptDirectoryCleaned(workItemKey, cleanedAt) {
-        const transcriptDir = deps.stateStore.paths.transcriptWorkDir(workItemKey);
-        const transcriptDirStat = await stat(transcriptDir).catch(() => undefined);
-        if (transcriptDirStat === undefined || !transcriptDirStat.isDirectory()) {
-            return;
-        }
-        await writeFile(join(transcriptDir, TRANSCRIPT_CLEANED_AT_MARKER), `${cleanedAt}\n`, 'utf8');
-    }
-    async function applyTranscriptCleanupRetention(workItemKey, cleanedAt) {
-        if (deps.config.transcripts.retentionMs === 0) {
-            await rm(deps.stateStore.paths.transcriptWorkDir(workItemKey), {
-                recursive: true,
-                force: true,
-            });
-            return;
-        }
-        await markTranscriptDirectoryCleaned(workItemKey, cleanedAt);
-    }
-    async function sweepExpiredTranscriptDirs() {
-        const retentionMs = deps.config.transcripts.retentionMs;
-        const transcriptDirs = await readdir(deps.stateStore.paths.transcriptsRoot, {
-            withFileTypes: true,
-        }).catch(() => []);
-        const nowMs = deps.clock.now().getTime();
-        for (const entry of transcriptDirs) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            const transcriptDir = join(deps.stateStore.paths.transcriptsRoot, entry.name);
-            const markerPath = join(transcriptDir, TRANSCRIPT_CLEANED_AT_MARKER);
-            const marker = await readFile(markerPath, 'utf8').catch(() => undefined);
-            if (marker === undefined) {
-                continue;
-            }
-            const cleanedAtMs = Date.parse(marker.trim());
-            if (!Number.isFinite(cleanedAtMs)) {
-                continue;
-            }
-            if (nowMs - cleanedAtMs >= retentionMs) {
-                await rm(transcriptDir, { recursive: true, force: true });
-            }
-        }
-    }
-    async function cleanupClosedIssueWorkspaces(projections) {
-        for (const projection of projections) {
-            const { workspacePath } = projection.wake;
-            if (projection.issue.state === 'closed' &&
-                workspacePath !== undefined &&
-                isPerIssueWorkspacePath(workspacePath)) {
-                try {
-                    await deps.workspaceManager.cleanupWorkspace({ workspacePath });
-                    await applyTranscriptCleanupRetention(projection.workItemKey, eventStampNow());
-                }
-                catch (error) {
-                    const failedAt = eventStampNow();
-                    await deps.stateStore.appendEventEnvelope(createEventEnvelope({
-                        eventId: `workspace-cleanup-failed-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}`,
-                        workItemKey: projection.workItemKey,
-                        streamScope: 'work-item',
-                        direction: 'internal',
-                        sourceSystem: 'wake',
-                        sourceEventType: WORKSPACE_CLEANUP_FAILED_EVENT,
-                        sourceRefs: {
-                            repo: projection.issue.repo,
-                            issueNumber: projection.issue.number,
-                        },
-                        occurredAt: failedAt,
-                        ingestedAt: failedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            workspacePath,
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                    }));
-                    continue;
-                }
-                const cleanedAt = eventStampNow();
-                const cleanupEvent = createEventEnvelope({
-                    eventId: `workspace-cleaned-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}-${deps.clock.now().getTime()}`,
-                    workItemKey: projection.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'internal',
-                    sourceSystem: 'wake',
-                    sourceEventType: WORKSPACE_CLEANED_EVENT,
-                    sourceRefs: {
-                        repo: projection.issue.repo,
-                        issueNumber: projection.issue.number,
-                    },
-                    occurredAt: cleanedAt,
-                    ingestedAt: cleanedAt,
-                    trigger: 'immediate',
-                    payload: { workspacePath },
-                });
-                await deps.stateStore.appendEventEnvelope(cleanupEvent);
-                await deps.projectionUpdater.rebuildFromEvents([cleanupEvent]);
-            }
-        }
-    }
-    return { cleanupClosedIssueWorkspaces, sweepExpiredTranscriptDirs };
-}

package/dist/src/domain/branch-naming.js

@@ -1,14 +0,0 @@
-/**
- * Wake's branch-naming convention for a work item's implementation branch,
- * keyed on the originating ticket's issue number (spec D2 — human-readable,
- * not the opaque work id).
- *
- * Lives in domain/ (not the git adapter) because it is pure vocabulary with
- * no IO: `core/` needs it to compute the branch a run should have pushed to
- * when verifying agent-reported artifacts, and `core/` may import domain/
- * but never a concrete adapter directly. `adapters/git/git-workspace-manager.ts`
- * re-exports this for its own callers so existing imports keep working.
- */
-export function branchNameForIssue(issueNumber) {
-    return `wake/issue-${issueNumber}`;
-}

package/dist/src/domain/custom-commands.js

@@ -1,58 +0,0 @@
-export const reservedCommandNames = ['approved', 'changes', 'interrupt'];
-function latestUnhandledHumanComment(issue) {
-    const context = issue.context;
-    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-    const lastBotIndex = issue.comments.reduce((acc, c, i) => (c.isBotAuthored ? i : acc), -1);
-    const humanCommentsAfterBot = issue.comments
-        .slice(lastBotIndex + 1)
-        .filter((c) => !c.isBotAuthored);
-    const latestHumanComment = humanCommentsAfterBot.at(-1);
-    if (latestHumanComment === undefined || latestHumanComment.id === handledCommentId) {
-        return undefined;
-    }
-    return latestHumanComment;
-}
-function commandNameFromBody(body) {
-    for (const line of body.split(/\r?\n/)) {
-        const match = /^\/([A-Za-z0-9_.-]+)\b/.exec(line.trim());
-        if (match?.[1] !== undefined) {
-            return match[1].toLowerCase();
-        }
-    }
-    return null;
-}
-export function customCommandAction(command, config) {
-    const entry = Object.entries(config.commands).find(([name]) => name.toLowerCase() === command.toLowerCase());
-    if (entry === undefined) {
-        return undefined;
-    }
-    const [name, definition] = entry;
-    return definition.action ?? name;
-}
-export function isCustomCommandAction(action, config) {
-    return Object.entries(config.commands).some(([name, definition]) => (definition.action ?? name) === action);
-}
-export function customCommandWorkspace(action, config) {
-    return Object.entries(config.commands).find(([name, definition]) => (definition.action ?? name) === action)?.[1].workspace;
-}
-export function resolveCustomCommand(issue, config) {
-    const latestHumanComment = latestUnhandledHumanComment(issue);
-    if (latestHumanComment === undefined) {
-        return null;
-    }
-    const command = commandNameFromBody(latestHumanComment.body);
-    if (command === null) {
-        return null;
-    }
-    const definitionEntry = Object.entries(config.commands).find(([name]) => name.toLowerCase() === command);
-    if (definitionEntry === undefined) {
-        return null;
-    }
-    const [configuredName, definition] = definitionEntry;
-    return {
-        action: definition.action ?? configuredName,
-        command: configuredName,
-        comment: latestHumanComment,
-        workspace: definition.workspace,
-    };
-}

package/dist/src/domain/event-types.js

@@ -1,158 +0,0 @@
-export const AUTONOMOUS_DECISION_AUDIT_EVENT = 'wake.audit.autonomous-decision';
-export const CORRELATION_PRIMARY_CONFLICT_EVENT = 'wake.correlation.primary-conflict';
-export const CORRELATION_REGISTERED_EVENT = 'wake.correlation.registered';
-export const CORRELATION_RETRACTED_EVENT = 'wake.correlation.retracted';
-export const LABELS_REQUESTED_EVENT = 'wake.labels.requested';
-export const PR_AUTO_MERGE_ENABLED_EVENT = 'wake.pr-auto-merge.enabled';
-export const PR_REVIEW_APPROVED_EVENT = 'wake.pr-review.approved';
-export const PUBLISH_CONFIRMED_EVENT = 'wake.publish.confirmed';
-export const PUBLISH_FAILED_EVENT = 'wake.publish.failed';
-export const PUBLISH_INTENT_REQUESTED_EVENT = 'wake.publish.intent.requested';
-export const PUBLISH_SENT_UNCONFIRMED_EVENT = 'wake.publish.sent-unconfirmed';
-export const RETRY_REQUESTED_EVENT = 'wake.retry.requested';
-export const RUN_REQUESTED_EVENT = 'wake.run.requested';
-export const RUN_CLAIMED_EVENT = 'wake.run.claimed';
-export const RUN_COMPLETED_EVENT = 'wake.run.completed';
-export const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
-export const WORK_ITEM_CREATED_EVENT = 'wake.workitem.created';
-export const WORK_ITEM_DELETED_EVENT = 'wake.workitem.deleted';
-export const WORK_ITEM_FROZEN_EVENT = 'wake.workitem.frozen';
-export const WORK_ITEM_UNFROZEN_EVENT = 'wake.workitem.unfrozen';
-export const WORKSPACE_CLEANED_EVENT = 'wake.workspace.cleaned';
-export const WORKSPACE_CLEANUP_FAILED_EVENT = 'wake.workspace.cleanup-failed';
-export const wakeEventTypeValues = [
-    AUTONOMOUS_DECISION_AUDIT_EVENT,
-    CORRELATION_PRIMARY_CONFLICT_EVENT,
-    CORRELATION_REGISTERED_EVENT,
-    CORRELATION_RETRACTED_EVENT,
-    LABELS_REQUESTED_EVENT,
-    PR_AUTO_MERGE_ENABLED_EVENT,
-    PR_REVIEW_APPROVED_EVENT,
-    PUBLISH_CONFIRMED_EVENT,
-    PUBLISH_FAILED_EVENT,
-    PUBLISH_INTENT_REQUESTED_EVENT,
-    PUBLISH_SENT_UNCONFIRMED_EVENT,
-    RETRY_REQUESTED_EVENT,
-    RUN_REQUESTED_EVENT,
-    RUN_CLAIMED_EVENT,
-    RUN_COMPLETED_EVENT,
-    WORKFLOW_SELECTED_EVENT,
-    WORK_ITEM_CREATED_EVENT,
-    WORK_ITEM_DELETED_EVENT,
-    WORK_ITEM_FROZEN_EVENT,
-    WORK_ITEM_UNFROZEN_EVENT,
-    WORKSPACE_CLEANED_EVENT,
-    WORKSPACE_CLEANUP_FAILED_EVENT,
-];
-export const wakeEventTypeDefinitions = [
-    {
-        type: AUTONOMOUS_DECISION_AUDIT_EVENT,
-        description: 'Records an autonomous workflow decision and the inputs used to make it.',
-        payloadShape: '{ decisionType, workItemId, runId, workflowRevision, inputsConsidered, outcome, timestamp }',
-    },
-    {
-        type: CORRELATION_PRIMARY_CONFLICT_EVENT,
-        description: 'Warns that a requested primary resource correlation was downgraded because another work item already owns the resource.',
-        payloadShape: '{ resourceUri, incumbentWorkItemKey }',
-    },
-    {
-        type: CORRELATION_REGISTERED_EVENT,
-        description: 'Registers a resource URI as correlated to a work item.',
-        payloadShape: '{ resourceUri, role, relation, provenance, registeredBy? }',
-    },
-    {
-        type: CORRELATION_RETRACTED_EVENT,
-        description: 'Removes a resource URI correlation from a work item.',
-        payloadShape: '{ resourceUri }',
-    },
-    {
-        type: LABELS_REQUESTED_EVENT,
-        description: 'Requests outbound synchronization of Wake status, stage, and workflow labels.',
-        payloadShape: "{ statusLabel, stageLabel, workflowLabel, origin, idempotencyKey, deliveryState: 'PENDING' }",
-    },
-    {
-        type: PR_AUTO_MERGE_ENABLED_EVENT,
-        description: 'Records that Wake enabled auto-merge for an approved pull request.',
-        payloadShape: '{ idempotencyKey }',
-    },
-    {
-        type: PR_REVIEW_APPROVED_EVENT,
-        description: 'Records that Wake approved a pull request review after approval policy passed.',
-        payloadShape: '{ idempotencyKey }',
-    },
-    {
-        type: PUBLISH_CONFIRMED_EVENT,
-        description: 'Confirms that an outbound publish intent was delivered or intentionally suppressed.',
-        payloadShape: "{ intentEventId, idempotencyKey, deliveryState: 'CONFIRMED', ...sinkDetails }",
-    },
-    {
-        type: PUBLISH_FAILED_EVENT,
-        description: 'Records a failed outbound publish attempt for bounded retry.',
-        payloadShape: "{ intentEventId, intentEventType, idempotencyKey, deliveryState: 'PENDING', error }",
-    },
-    {
-        type: PUBLISH_INTENT_REQUESTED_EVENT,
-        description: 'Requests an outbound comment, reply, status update, question, or approval card.',
-        payloadShape: "{ kind, origin, body, action, sentinel, runId, idempotencyKey, deliveryState: 'PENDING', sessionId?, model?, cli?, duration?, tokens?, cost?, workspacePath?, failureRepeated?, previousFailureClass? }",
-    },
-    {
-        type: PUBLISH_SENT_UNCONFIRMED_EVENT,
-        description: 'Marks an outbound publish intent as sent before Wake has observed confirmation.',
-        payloadShape: "{ intentEventId, intentEventType, idempotencyKey, deliveryState: 'SENT_UNCONFIRMED' }",
-    },
-    {
-        type: RETRY_REQUESTED_EVENT,
-        description: 'Requests that a failed work item be retried.',
-        payloadShape: '{ requestedBy }',
-    },
-    {
-        type: RUN_REQUESTED_EVENT,
-        description: 'Requests that a scheduled work item be run immediately.',
-        payloadShape: '{ requestedBy }',
-    },
-    {
-        type: RUN_CLAIMED_EVENT,
-        description: 'Records that Wake claimed a work item for an agent run.',
-        payloadShape: '{ action, priorStage, claimedStage?, sourceRevision, watcherRun?, watcherTrigger? }',
-    },
-    {
-        type: RUN_COMPLETED_EVENT,
-        description: 'Records the terminal result of an agent run or internal lifecycle transition.',
-        payloadShape: '{ action?, sentinel, nextStage?, runId, sessionId?, sessionCli?, workspacePath?, reason?, handledCommentId?, failureClass?, blockReason?, executionOutcome?, workflowOutcome?, watcherRun?, allowAutoApproval?, body? }',
-    },
-    {
-        type: WORKFLOW_SELECTED_EVENT,
-        description: 'Pins the workflow selected for a newly minted work item.',
-        payloadShape: '{ workflow, selectedFromEventId }',
-    },
-    {
-        type: WORK_ITEM_CREATED_EVENT,
-        description: 'Mints a Wake work item identity before resource correlation is registered.',
-        payloadShape: '{}',
-    },
-    {
-        type: WORK_ITEM_DELETED_EVENT,
-        description: 'Soft-deletes a work item and excludes it from board display and execution.',
-        payloadShape: '{ requestedBy }',
-    },
-    {
-        type: WORK_ITEM_FROZEN_EVENT,
-        description: 'Marks a work item as frozen so runner ticks will not execute it.',
-        payloadShape: '{ requestedBy }',
-    },
-    {
-        type: WORK_ITEM_UNFROZEN_EVENT,
-        description: 'Clears a work item freeze so runner ticks may execute it again.',
-        payloadShape: '{ requestedBy }',
-    },
-    {
-        type: WORKSPACE_CLEANED_EVENT,
-        description: 'Records successful cleanup of a closed issue workspace.',
-        payloadShape: '{ workspacePath }',
-    },
-    {
-        type: WORKSPACE_CLEANUP_FAILED_EVENT,
-        description: 'Records a workspace cleanup failure without aborting the cleanup sweep.',
-        payloadShape: '{ workspacePath, error }',
-    },
-];

package/dist/src/domain/manual-labels.js

@@ -1 +0,0 @@
-export const alwaysManualIgnoredLabels = ['security', 'wake:manual', 'wake:always-manual'];

package/dist/src/domain/resource-uri.js

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-/**
- * Resource URI grammar: `<provider>:<kind>:<locator>`.
- *
- * `provider` matches the adapter's registered source/sink name; `kind` uses
- * the provider's native vocabulary (`github:pr:…` but `gitlab:mr:…`). The
- * locator grammar is provider-specific and opaque to core — everything after
- * the second colon is matched as a single blob and never inspected here.
- * Core compares URIs for equality only (ADR 0001 §1).
- */
-const RESOURCE_URI_PATTERN = /^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*:.+$/;
-export const resourceUriSchema = z
-    .string()
-    .regex(RESOURCE_URI_PATTERN, 'must match <provider>:<kind>:<locator>');
-export function buildResourceUri(provider, kind, locator) {
-    return resourceUriSchema.parse(`${provider}:${kind}:${locator}`);
-}
-/**
- * Wake-owned relationship vocabulary — the graph edge type, deliberately
- * independent of the URI's provider-native `kind`. A new provider adds URI
- * kinds, never new roles; a new role is a Wake modelling decision.
- */
-export const correlationRoleSchema = z.enum([
-    'representation',
-    'implementation',
-    'discussion',
-    'review',
-    'documentation',
-    'decision',
-]);
-/** Exactly one work item may hold `primary` per resource URI (ADR 0001 §2). */
-export const correlationRelationSchema = z.enum(['primary', 'secondary']);
-export const correlationProvenanceSchema = z.enum([
-    'wake-created',
-    'agent-reported',
-    'detected',
-    'operator-declared',
-]);

package/dist/src/domain/runner-routing.js

@@ -1,127 +0,0 @@
-import { defaultWorkflowName } from './workflows.js';
-export function maxConfiguredRunnerTimeoutMs(config) {
-    const activeRunnerNames = new Set(Object.values(config.tiers).flatMap((candidates) => candidates));
-    for (const workflow of Object.values(config.workflows)) {
-        for (const stageRoute of Object.values(workflow.stages)) {
-            if (stageRoute.runner !== undefined) {
-                activeRunnerNames.add(stageRoute.runner);
-            }
-        }
-    }
-    for (const commandRoute of Object.values(config.commands)) {
-        if (commandRoute.runner !== undefined) {
-            activeRunnerNames.add(commandRoute.runner);
-        }
-    }
-    const registryTimeouts = [...activeRunnerNames]
-        .map((name) => config.runners[name])
-        .map((entry) => (entry === undefined || entry.kind === 'fake' ? undefined : entry.timeoutMs))
-        .filter((timeout) => timeout !== undefined);
-    return registryTimeouts.length > 0 ? Math.max(...registryTimeouts) : Infinity;
-}
-// How often an 'estimated' pause (exponential-backoff guess, not a reset time
-// the CLI actually reported) gets a recovery probe: a real attempt let through
-// early in case the guess overshot and quota actually reset sooner. 'reported'
-// pauses (an actual reset time) are trusted for their full duration - no
-// probing needed since we already know when they clear.
-const recoveryProbeIntervalMs = 15 * 60_000;
-function isRunnerPaused(input) {
-    const health = input.ledger?.runners?.[input.runnerName];
-    const pausedUntil = health?.pausedUntil;
-    if (pausedUntil === undefined || Date.parse(pausedUntil) <= input.now.getTime()) {
-        return { paused: false, isProbe: false };
-    }
-    if (health?.pausedUntilSource === 'estimated' && health.lastFailureAt !== undefined) {
-        const sinceLastFailureMs = input.now.getTime() - Date.parse(health.lastFailureAt);
-        if (sinceLastFailureMs >= recoveryProbeIntervalMs) {
-            return { paused: false, isProbe: true };
-        }
-    }
-    return { paused: true, isProbe: false };
-}
-/**
- * Resolves which named runner should execute a stage/action.
- *
- * A stage pinned directly to a runner (`stages[stage].runner`) has no
- * fallback list, so it always returns that runner regardless of health.
- * A stage routed through a `tier` walks the tier's ordered candidates and
- * skips any currently quota-paused per the ledger (#67 sideways fallback),
- * returning `null` only when every candidate in the tier is paused - callers
- * should treat that as "nothing to do this tick", not a config error. Once a
- * higher-priority candidate's pause expires, it is preferred again on the
- * next call, which is the "rotation" back to the primary runner.
- */
-export function resolveRunnerRouting(input) {
-    const workflowName = input.workflowName ?? defaultWorkflowName(input.config);
-    const workflow = input.config.workflows[workflowName];
-    if (workflow === undefined) {
-        throw new Error(`Unknown workflow "${workflowName}".`);
-    }
-    const commandRouteEntry = input.command === undefined
-        ? Object.entries(input.config.commands).find(([name, route]) => (route.action ?? name) === input.action)
-        : Object.entries(input.config.commands).find(([name]) => name.toLowerCase() === input.command?.toLowerCase());
-    const commandRoute = commandRouteEntry?.[1];
-    if (commandRoute?.runner !== undefined) {
-        const runnerName = commandRoute.runner;
-        const entry = input.config.runners[runnerName];
-        if (entry === undefined) {
-            throw new Error(`Command ${input.action} pins unknown runner "${runnerName}".`);
-        }
-        return {
-            runnerName,
-            runnerKind: entry.kind,
-            ...(commandRoute.tier === undefined ? {} : { tier: commandRoute.tier }),
-            reason: `command ${input.action} pins runner ${runnerName}`,
-        };
-    }
-    const stageRoute = workflow.stages[input.stage];
-    if (stageRoute?.runner !== undefined) {
-        const entry = input.config.runners[stageRoute.runner];
-        if (entry === undefined) {
-            throw new Error(`Stage ${input.stage} pins unknown runner "${stageRoute.runner}".`);
-        }
-        return {
-            runnerName: stageRoute.runner,
-            runnerKind: entry.kind,
-            ...(stageRoute.tier === undefined ? {} : { tier: stageRoute.tier }),
-            reason: `stage ${input.stage} pins runner ${stageRoute.runner}`,
-        };
-    }
-    const tier = commandRoute?.tier ?? stageRoute?.tier ?? input.config.defaultTier;
-    const candidates = input.config.tiers[tier];
-    if (candidates === undefined || candidates.length === 0) {
-        throw new Error(`Stage ${input.stage} routes to unknown or empty tier "${tier}".`);
-    }
-    const now = input.now ?? new Date();
-    let selected;
-    for (const candidate of candidates) {
-        const status = isRunnerPaused({ runnerName: candidate, ledger: input.ledger, now });
-        if (!status.paused) {
-            selected = { runnerName: candidate, isProbe: status.isProbe };
-            break;
-        }
-    }
-    if (selected === undefined) {
-        return null;
-    }
-    const { runnerName, isProbe } = selected;
-    const entry = input.config.runners[runnerName];
-    if (entry === undefined) {
-        throw new Error(`Tier ${tier} references unknown runner "${runnerName}".`);
-    }
-    const isFallback = runnerName !== candidates[0];
-    return {
-        runnerName,
-        runnerKind: entry.kind,
-        tier,
-        reason: isProbe
-            ? `tier ${tier} recovery probe on ${runnerName} (estimated pause not yet elapsed)`
-            : isFallback
-                ? `tier ${tier} fell back to ${runnerName} (higher-priority candidates paused)`
-                : commandRoute?.tier !== undefined
-                    ? `command ${input.action} tier ${tier} selected runner ${runnerName}`
-                    : stageRoute?.tier === undefined
-                        ? `defaultTier ${tier} selected runner ${runnerName}`
-                        : `stage ${input.stage} tier ${tier} selected runner ${runnerName}`,
-    };
-}

package/dist/src/domain/runtime-events.js

@@ -1,36 +0,0 @@
-export const runtimeEventTypeValues = [
-    'run.claimed',
-    'run.started',
-    'workspace.preparing',
-    'workspace.ready',
-    'agent.process.started',
-    'agent.session.started',
-    'agent.progress',
-    'agent.tool.requested',
-    'agent.approval.requested',
-    'agent.input.required',
-    'agent.usage.updated',
-    'agent.turn.completed',
-    'agent.process.exited',
-    'run.completed',
-    'run.failed',
-    'run.stalled',
-    'run.canceled',
-];
-export function isMeaningfulRuntimeEvent(event) {
-    return (event.type === 'agent.progress' ||
-        event.type === 'agent.tool.requested' ||
-        event.type === 'agent.approval.requested' ||
-        event.type === 'agent.input.required' ||
-        event.type === 'agent.usage.updated' ||
-        event.type === 'agent.turn.completed');
-}
-export function runtimeEventPayload(input) {
-    return {
-        ...(input.message === undefined ? {} : { message: input.message }),
-        ...(input.raw === undefined ? {} : { raw: input.raw }),
-        ...(input.exitCode === undefined ? {} : { exitCode: input.exitCode }),
-        ...(input.timedOut === undefined ? {} : { timedOut: input.timedOut }),
-        ...(input.tokenUsage === undefined ? {} : { tokenUsage: input.tokenUsage }),
-    };
-}