@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/domain/schema.js

@@ -1,1233 +0,0 @@
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { z } from 'zod';
-import { reservedCommandNames } from './custom-commands.js';
-import { runnerSentinelValues } from './stages.js';
-import { correlationProvenanceSchema, correlationRelationSchema, correlationRoleSchema, resourceUriSchema, } from './resource-uri.js';
-import { runtimeEventTypeValues } from './runtime-events.js';
-import { alwaysManualIgnoredLabels } from './manual-labels.js';
-import { workItemStatusSchema } from './work-item-status.js';
-export { AUTONOMOUS_DECISION_AUDIT_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, WORK_ITEM_CREATED_EVENT, } from './event-types.js';
-const isoTimestampSchema = z.string().datetime({ offset: true });
-const identifierSchema = z.string().min(1);
-export const reportedArtifactSchema = z.object({
-    kind: z.literal('pr'),
-    url: z.string().url(),
-});
-export const wakeArtifactsEnvelopeSchema = z.object({
-    artifacts: z.array(reportedArtifactSchema).default([]),
-});
-export const runnerSentinelSchema = z.enum(runnerSentinelValues);
-// A projection persisted before ADR 0002 can still have context.lastRunSentinel
-// = "AWAITING_APPROVAL" on disk. That field is read (not just replayed) on
-// every ordinary parseIssueStateRecord call, not only during an explicit
-// event-log rebuild, so the strict current-vocabulary schema above would
-// reject an untouched legacy projection outright. This schema stays
-// permissive to that one retired value so existing on-disk state keeps
-// loading until it's naturally refreshed by a new run.
-const legacyTolerantRunnerSentinelSchema = z.enum([...runnerSentinelValues, 'AWAITING_APPROVAL']);
-export const executionOutcomeValues = [
-    'COMPLETED',
-    'STARTUP_FAILED',
-    'PROCESS_FAILED',
-    'TIMED_OUT',
-    'STALLED',
-    'CANCELED_BY_RECONCILIATION',
-    'CANCELED_BY_SOURCE_CLOSED',
-    'CANCELED_BY_UNASSIGNMENT',
-    'CANCELED_BY_SUPERSEDING_EVENT',
-    'CANCELED_BY_WORKFLOW_CHANGE',
-    'CANCELED_BY_OPERATOR',
-    'QUOTA_EXHAUSTED',
-    'MALFORMED_OUTPUT',
-    'SUPERSEDED',
-];
-export const workflowOutcomeValues = [
-    'DONE',
-    'BLOCKED',
-    'AWAITING_APPROVAL',
-    'AWAITING_INPUT',
-    'CHANGES_REQUESTED',
-];
-export const executionAttemptLifecycleValues = [
-    'CREATED',
-    'CLAIMED',
-    'PREPARING',
-    'PROCESS_STARTING',
-    'RUNNING',
-    'FINALISING',
-    'TERMINAL',
-];
-export const executionOutcomeSchema = z.enum(executionOutcomeValues);
-export const workflowOutcomeSchema = z.enum(workflowOutcomeValues);
-export const executionAttemptLifecycleSchema = z.enum(executionAttemptLifecycleValues);
-export const runtimeEventSchema = z.object({
-    type: z.enum(runtimeEventTypeValues),
-    runId: z.string(),
-    workItemId: z.string(),
-    runner: z.object({
-        name: z.string(),
-        kind: z.enum(['fake', 'claude', 'codex', 'cursor']),
-        cli: z.string(),
-        model: z.string().optional(),
-    }),
-    sessionId: z.string().optional(),
-    timestamp: isoTimestampSchema,
-    sequence: z.number().int().nonnegative(),
-    payload: z.record(z.string(), z.unknown()).default({}),
-});
-export const defaultAgentIdentity = 'Wake';
-export const defaultSmokePrompt = `This is ${defaultAgentIdentity}, reply with "hi ${defaultAgentIdentity} only"`;
-const claudeEffortSchema = z.enum(['low', 'medium', 'high', 'xhigh', 'max']);
-const codexReasoningEffortSchema = z.enum(['low', 'medium', 'high']);
-const cursorModeSchema = z.enum(['ask', 'agent']);
-const claudeRunnerSettingsSchema = z.object({
-    command: z.string().default('claude'),
-    model: z.string().default('haiku'),
-    smokeModel: z.string().default('haiku'),
-    sessionName: z.string().default(defaultAgentIdentity),
-    remoteControlName: z.string().default(defaultAgentIdentity),
-    smokePrompt: z.string().default(defaultSmokePrompt),
-    timeoutMs: z
-        .number()
-        .int()
-        .positive()
-        .default(30 * 60 * 1000),
-    remoteControl: z
-        .object({
-        enabled: z.boolean().default(false),
-    })
-        .default({ enabled: false }),
-    effort: claudeEffortSchema.optional(),
-});
-const codexRunnerSettingsSchema = z.object({
-    command: z.string().default('codex'),
-    model: z.string().default('gpt-5.5'),
-    smokeModel: z.string().default('gpt-5.4-mini'),
-    smokePrompt: z.string().default(defaultSmokePrompt),
-    timeoutMs: z
-        .number()
-        .int()
-        .positive()
-        .default(30 * 60 * 1000),
-    reasoningEffort: codexReasoningEffortSchema.optional(),
-});
-const fakeRunnerEntrySchema = z.object({
-    kind: z.literal('fake'),
-    cli: z.string().default('Fake'),
-});
-const claudeRunnerEntrySchema = claudeRunnerSettingsSchema.extend({
-    kind: z.literal('claude'),
-});
-const codexRunnerEntrySchema = codexRunnerSettingsSchema.extend({
-    kind: z.literal('codex'),
-});
-const cursorRunnerSettingsSchema = z.object({
-    command: z.string().default('cursor'),
-    model: z.string().default('composer-2.5'),
-    smokeModel: z.string().default('auto'),
-    smokePrompt: z.string().default(defaultSmokePrompt),
-    timeoutMs: z
-        .number()
-        .int()
-        .positive()
-        .default(30 * 60 * 1000),
-    defaultMode: cursorModeSchema.optional(),
-});
-const cursorRunnerEntrySchema = cursorRunnerSettingsSchema.extend({
-    kind: z.literal('cursor'),
-});
-const runnerEntrySchema = z.discriminatedUnion('kind', [
-    fakeRunnerEntrySchema,
-    claudeRunnerEntrySchema,
-    codexRunnerEntrySchema,
-    cursorRunnerEntrySchema,
-]);
-const stageRouteSchema = z.object({
-    action: identifierSchema.optional(),
-    tier: z.string().optional(),
-    runner: z.string().optional(),
-    promptContext: z.record(z.string(), z.unknown()).optional(),
-});
-const runnerRoutingSchema = z.object({
-    runnerName: z.string(),
-    runnerKind: z.enum(['fake', 'claude', 'codex', 'cursor']),
-    tier: z.string().optional(),
-    reason: z.string(),
-});
-const sinkEntrySchema = z
-    .object({
-    kind: z.string().min(1),
-    subscribe: z.array(z.string().min(1)).default([]),
-})
-    .passthrough();
-export const wakeResultEnvelopeSchema = z.object({
-    status: runnerSentinelSchema,
-});
-const stageHistoryEntrySchema = z.object({
-    stage: identifierSchema,
-    changedAt: isoTimestampSchema,
-    reason: z.string(),
-});
-const reviewThreadAnchorSchema = z.object({
-    path: z.string(),
-    line: z.number().int().positive().optional(),
-});
-const commentSnapshotSchema = z.object({
-    id: z.string(),
-    body: z.string(),
-    author: z.object({
-        login: z.string(),
-    }),
-    createdAt: isoTimestampSchema,
-    updatedAt: isoTimestampSchema,
-    isBotAuthored: z.boolean().default(false),
-    // Which correlated surface this comment came from; absent = the originating
-    // issue thread, keeping every pre-existing comment valid under this schema.
-    resourceUri: resourceUriSchema.optional(),
-    reviewThread: reviewThreadAnchorSchema.optional(),
-});
-const issueSnapshotSchema = z.object({
-    repo: z.string(),
-    number: z.number().int().positive(),
-    title: z.string(),
-    body: z.string(),
-    labels: z.array(z.string()),
-    assignees: z.array(z.string()),
-    isPullRequest: z.boolean().default(false),
-    state: z.enum(['open', 'closed']),
-    url: z.string().url(),
-    createdAt: isoTimestampSchema,
-    updatedAt: isoTimestampSchema,
-});
-export const sourceStateRecordSchema = z.object({
-    schemaVersion: z.literal(1),
-    source: z.string(),
-    key: z.string(),
-    lastSuccessfulPollAt: isoTimestampSchema,
-});
-export const eventEnvelopeSourceRefsSchema = z.object({
-    repo: z.string().optional(),
-    issueNumber: z.number().int().positive().optional(),
-    commentId: z.string().optional(),
-    reviewId: z.string().optional(),
-    runId: z.string().optional(),
-    sink: z.string().optional(),
-    sourceUrl: z.string().optional(),
-    // Per-event provenance: which external resource this one event came from.
-    // Item-level ownership lives only in the correlation registry, never here.
-    resourceUri: resourceUriSchema.optional(),
-    // An adapter-supplied hint: the resourceUri of the resource this one
-    // "belongs to" for correlation purposes (e.g. a PR review-thread comment's
-    // parent PR). Opaque to core — never parsed, only used as a fallback key
-    // for resourceIndex.resolve() when resourceUri itself misses the index.
-    // The adapter that emits an event is the only party allowed to know its
-    // own locator grammar; this keeps that knowledge out of core/.
-    parentResourceUri: resourceUriSchema.optional(),
-});
-/**
- * Shared key for events whose resource failed mint qualification (spec D1').
- * Never a real work item: `readIssueState(UNRESOLVED_WORK_ITEM_KEY)` always
- * returns null, so these events are durable and inspectable via the event
- * log but must never materialize a projection or an index entry. Exported
- * from here (rather than only living in tick-runner.ts, which mints these
- * events) so projection-updater.ts's fold can also recognize and skip it —
- * an unqualified event's sourceEventType is still `ticket.upsert` /
- * `fake.issue.upsert` / etc., which the fold would otherwise happily turn
- * into a projection the first time it sees this key with no current record.
- */
-export const UNRESOLVED_WORK_ITEM_KEY = 'unresolved';
-// The envelope's `workItemKey` already carries the identity; this payload is
-// deliberately empty.
-export const workItemCreatedPayloadSchema = z.object({});
-export const correlationRegisteredPayloadSchema = z.object({
-    resourceUri: resourceUriSchema,
-    role: correlationRoleSchema,
-    relation: correlationRelationSchema,
-    provenance: correlationProvenanceSchema,
-    registeredBy: z.string().optional(),
-});
-export const correlationRetractedPayloadSchema = z.object({
-    resourceUri: resourceUriSchema,
-});
-// Warning event emitted when a second `primary` registration lands on an
-// already-claimed URI (ADR 0001 §6). Fold behavior lives in the projection.
-export const correlationPrimaryConflictPayloadSchema = z.object({
-    resourceUri: resourceUriSchema,
-    incumbentWorkItemKey: z.string(),
-});
-// Folded shape of a `wake.correlation.registered`/`wake.correlation.retracted`
-// event, one entry per resourceUri currently held by this work item
-// (ADR 0001 §5). `registeredAt` comes from the folding event's `occurredAt`.
-export const correlatedResourceSchema = z.object({
-    resourceUri: resourceUriSchema,
-    role: correlationRoleSchema,
-    relation: correlationRelationSchema,
-    provenance: correlationProvenanceSchema,
-    registeredBy: z.string().optional(),
-    registeredAt: isoTimestampSchema,
-});
-export const eventEnvelopeSchema = z.object({
-    schemaVersion: z.literal(1),
-    eventId: z.string(),
-    workItemKey: z.string(),
-    streamScope: z.enum(['global-intake', 'work-item']),
-    direction: z.enum(['inbound', 'outbound', 'internal']),
-    sourceSystem: z.string(),
-    sourceEventType: z.string(),
-    sourceRefs: eventEnvelopeSourceRefsSchema,
-    occurredAt: isoTimestampSchema,
-    ingestedAt: isoTimestampSchema,
-    trigger: z.enum(['immediate', 'context-only']),
-    payload: z.record(z.string(), z.unknown()),
-    raw: z.record(z.string(), z.unknown()).optional(),
-    derivedHints: z.record(z.string(), z.unknown()).optional(),
-});
-export const failurePhaseSchema = z.enum([
-    'workspace-validation',
-    'workspace-prep',
-    'process-starting',
-    'running',
-    'result-parsing',
-    'publishing',
-    'unknown',
-]);
-export const externalSideEffectsSchema = z.enum(['none', 'confirmed', 'unknown']);
-export const retrySafetySchema = z.enum([
-    'SAFE_TO_RETRY',
-    'SAFE_TO_RESUME',
-    'REQUIRES_RECONCILIATION',
-    'MANUAL_REVIEW_REQUIRED',
-    'NOT_RETRYABLE',
-]);
-// Typed `context` — every field is optional so an on-disk projection missing
-// some/all of them (pre-dating this schema, or simply untouched since) still
-// parses. See docs/superpowers/specs/2026-07-28-canonical-work-item-status-design.md §4/§8.
-export const issueContextSchema = z.object({
-    // Retry/failure bookkeeping, folded from RUN_COMPLETED (projection-updater.ts).
-    failureCount: z.number().int().nonnegative().optional(),
-    lastRunAction: z.string().optional(),
-    lastCompletedAction: z.string().optional(),
-    lastExecutionOutcome: executionOutcomeSchema.optional(),
-    lastWorkflowOutcome: workflowOutcomeSchema.optional(),
-    lastFailurePhase: failurePhaseSchema.optional(),
-    lastProcessStarted: z.boolean().optional(),
-    lastWorkspaceChanged: z.boolean().optional(),
-    lastExternalSideEffects: externalSideEffectsSchema.optional(),
-    lastRetrySafety: retrySafetySchema.optional(),
-    blockedFromStage: z.string().optional(),
-    lastFailureClass: z.enum(['task', 'quota', 'infra']).optional(),
-    lastHandledCommentId: z.string().optional(),
-    lastRunSentinel: legacyTolerantRunnerSentinelSchema.optional(),
-    // Set while approval-gated (context.status === 'awaiting-approval') so the
-    // approval path knows which action to resume (or skip) once a human responds.
-    pendingApprovalAction: z.string().optional(),
-    pendingApprovalAllowAutoApproval: z.boolean().optional(),
-    // Workflow pinned at mint time (WORKFLOW_SELECTED_EVENT); re-read at every
-    // label write instead of trusting a threaded local (workflow-name-drift, §6).
-    workflow: z.string().optional(),
-    // Canonical status — see work-item-status.ts. Additive alongside
-    // lastRunSentinel, not a replacement for it (§3).
-    status: workItemStatusSchema.optional(),
-    changesRequestedCount: z.number().int().nonnegative().optional(),
-    // Feedback body threaded into the next auto-revise prompt as
-    // promptContextOverrides.parentPendingReviewBody (§5).
-    changesRequestedFeedback: z.string().optional(),
-    // Orthogonal facts — not folded into `status` (§2).
-    frozen: z.object({ at: isoTimestampSchema, by: z.string() }).optional(),
-    deleted: z.object({ at: isoTimestampSchema, by: z.string() }).optional(),
-    scheduled: z.boolean().optional(),
-});
-export const issueStateRecordSchema = z.object({
-    schemaVersion: z.literal(1),
-    workItemKey: z.string(),
-    origin: z.string().optional(),
-    issue: issueSnapshotSchema,
-    comments: z.array(commentSnapshotSchema).default([]),
-    latestComment: commentSnapshotSchema.optional(),
-    wake: z.object({
-        stage: identifierSchema,
-        lastRunId: z.string().optional(),
-        sessionId: z.string().optional(),
-        sessionCli: z.string().optional(),
-        workspacePath: z.string().optional(),
-        blockReason: z.string().optional(),
-        syncedAt: isoTimestampSchema,
-        stageHistory: z.array(stageHistoryEntrySchema),
-        recentEventIds: z.array(z.string()).default([]),
-        expectedEcho: z
-            .object({
-            commentIds: z.array(z.string()).default([]),
-            labels: z.array(z.string()).default([]),
-        })
-            .default({ commentIds: [], labels: [] }),
-    }),
-    context: issueContextSchema.default({}),
-    correlatedResources: z.array(correlatedResourceSchema).default([]),
-});
-export const runInputSnapshotSchema = z.object({
-    schemaVersion: z.literal(1),
-    snapshotId: z.string(),
-    runId: z.string(),
-    createdAt: isoTimestampSchema,
-    action: identifierSchema,
-    workflowName: identifierSchema,
-    claimedStage: identifierSchema,
-    projectionVersion: z.string(),
-    sourceUpdatedAt: isoTimestampSchema,
-    sourceRevision: z.string(),
-    triggerEventId: z.string().optional(),
-    handledThroughEventId: z.string().optional(),
-    workflowHash: z.string(),
-    promptHash: z.string(),
-    repositoryHead: z.string().optional(),
-    workspaceHead: z.string().optional(),
-    runnerConfigurationHash: z.string(),
-    projection: issueStateRecordSchema,
-    recentEvents: z.array(eventEnvelopeSchema),
-});
-const runTokenUsageSchema = z.object({
-    inputTokens: z.number().nonnegative(),
-    outputTokens: z.number().nonnegative(),
-    cacheCreationInputTokens: z.number().nonnegative().optional(),
-    cacheReadInputTokens: z.number().nonnegative().optional(),
-    costUsd: z.number().nonnegative().optional(),
-    turns: z.number().nonnegative().optional(),
-});
-const runLeaseSchema = z.object({
-    leaseId: z.string(),
-    ownerInstanceId: z.string(),
-    acquiredAt: isoTimestampSchema,
-    lastRenewedAt: isoTimestampSchema,
-    expiresAt: isoTimestampSchema,
-});
-function legacyRunLifecycle(input) {
-    if (input.lifecycle !== undefined) {
-        return input;
-    }
-    return {
-        ...input,
-        lifecycle: input.status === 'running' ? 'RUNNING' : 'TERMINAL',
-    };
-}
-export const runRecordSchema = z.preprocess((input) => {
-    return input !== null && typeof input === 'object'
-        ? legacyRunLifecycle(input)
-        : input;
-}, z.object({
-    schemaVersion: z.literal(1),
-    runId: z.string(),
-    // The work item this run belongs to. Required: run records are Wake-owned
-    // state that Wake itself writes, so the work id is always in hand at the
-    // write site, and an optional key would lie about runtime while re-admitting
-    // the ticket-shaped ambiguity minted identity exists to remove.
-    workItemKey: z.string(),
-    // Human-readable representation content only — the ticket this run was
-    // launched against (same reasoning as the projection's retained `issue`
-    // snapshot, spec §9). Never used to find the work item: a transferred issue
-    // gets a new repo/number while the work item and its runs persist (spec D3).
-    repo: z.string(),
-    issueNumber: z.number().int().positive(),
-    action: identifierSchema,
-    lifecycle: executionAttemptLifecycleSchema,
-    status: z.enum([
-        'running',
-        'completed',
-        'awaiting-approval',
-        'rejected',
-        'blocked',
-        'failed',
-        'superseded',
-    ]),
-    startedAt: isoTimestampSchema,
-    finishedAt: isoTimestampSchema.optional(),
-    sessionId: z.string().optional(),
-    sentinel: legacyTolerantRunnerSentinelSchema.optional(),
-    executionOutcome: executionOutcomeSchema.optional(),
-    workflowOutcome: workflowOutcomeSchema.optional(),
-    failurePhase: failurePhaseSchema.optional(),
-    processStarted: z.boolean().optional(),
-    workspaceChanged: z.boolean().optional(),
-    externalSideEffects: externalSideEffectsSchema.optional(),
-    retrySafety: retrySafetySchema.optional(),
-    summary: z.string().optional(),
-    inputSnapshotId: z.string().optional(),
-    routing: runnerRoutingSchema.optional(),
-    lease: runLeaseSchema.optional(),
-    workerPid: z.number().int().positive().optional(),
-    workerProcessStartedAt: z.string().optional(),
-    agentPid: z.number().int().positive().optional(),
-    agentProcessStartedAt: z.string().optional(),
-    lastMeaningfulActivityAt: isoTimestampSchema.optional(),
-    runtimeEvents: z.array(runtimeEventSchema).optional(),
-    tokenUsage: runTokenUsageSchema.optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-}));
-const runnerHealthEntrySchema = z.object({
-    pausedUntil: isoTimestampSchema.optional(),
-    // 'reported' = CLI told us the real reset time; 'estimated' = exponential
-    // backoff guess. Only 'estimated' pauses are eligible for an early recovery
-    // probe (domain/runner-routing.ts) - a reported time is already trustworthy.
-    pausedUntilSource: z.enum(['reported', 'estimated']).optional(),
-    failureCount: z.number().int().nonnegative().default(0),
-    lastFailureAt: isoTimestampSchema.optional(),
-});
-const workflowWorkspaceSchema = z.enum(['none', 'read-only', 'branch']);
-const workflowTriggerScheduleSchema = z.object({
-    cron: z.string().min(1),
-});
-// Matches GitHub's PullRequestMergeMethod GraphQL enum. GitHub's
-// enablePullRequestAutoMerge mutation defaults to MERGE when unspecified,
-// which fails outright on a repo that only allows squash/rebase merges — so
-// this must be explicit rather than inferred.
-export const mergeMethodSchema = z.enum(['MERGE', 'SQUASH', 'REBASE']);
-const approvedMergePolicySchema = z
-    .object({
-    approve: z.boolean().default(false),
-    autoMerge: z.boolean().default(false),
-    mergeMethod: mergeMethodSchema.default('MERGE'),
-    maxFilesChanged: z.number().int().positive().optional(),
-    blockedPaths: z.array(z.string().min(1)).default([]),
-    blockedLabels: z.array(z.string().min(1)).default([]),
-})
-    .default({
-    approve: false,
-    autoMerge: false,
-    mergeMethod: 'MERGE',
-    blockedPaths: [],
-    blockedLabels: [],
-});
-const watchSuccessPolicySchema = z.object({
-    // Resolve the watched parent stage's pending approval gate when the child
-    // workflow run completes DONE — the child's sentinel is its verdict.
-    approve: z.boolean().default(false),
-    merge: approvedMergePolicySchema.optional(),
-});
-const workflowStageSchema = stageRouteSchema.extend({
-    workspace: workflowWorkspaceSchema,
-    onDone: identifierSchema,
-    watch: z
-        .array(z.object({
-        while: z.object({
-            status: z.array(z.string().min(1)).min(1),
-        }),
-        on: z
-            .object({
-            event: z.array(z.string().min(1)).min(1),
-        })
-            .optional(),
-        schedule: workflowTriggerScheduleSchema.optional(),
-        workflow: identifierSchema,
-        onSuccess: watchSuccessPolicySchema.optional(),
-    }))
-        .optional(),
-});
-const workflowTriggerSchema = z.object({
-    schedule: workflowTriggerScheduleSchema.optional(),
-});
-const customCommandSchema = stageRouteSchema.extend({
-    workspace: workflowWorkspaceSchema.default('read-only'),
-});
-const workflowDefinitionSchema = z.object({
-    entryStage: identifierSchema.optional(),
-    trigger: workflowTriggerSchema.optional(),
-    stages: z.record(identifierSchema, workflowStageSchema),
-});
-const workflowSelectorMatchSchema = z
-    .object({
-    kind: z.string().min(1).optional(),
-    sourceEventType: z.string().min(1).optional(),
-    repo: z.string().min(1).optional(),
-    requiredLabels: z.array(z.string()).default([]),
-    ignoredLabels: z.array(z.string()).default([]),
-    requiredAssignees: z.array(z.string()).default([]),
-    requiredAuthors: z.array(z.string()).default([]),
-})
-    .default({
-    requiredLabels: [],
-    ignoredLabels: [],
-    requiredAssignees: [],
-    requiredAuthors: [],
-});
-const workflowSelectorSchema = z.object({
-    workflow: identifierSchema,
-    match: workflowSelectorMatchSchema,
-});
-function defaultPromptsRoot() {
-    const sourceDir = dirname(fileURLToPath(import.meta.url));
-    for (const candidate of [
-        join(process.cwd(), 'prompts'),
-        join(sourceDir, '..', '..', 'prompts'),
-        join(sourceDir, '..', '..', '..', 'prompts'),
-    ]) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    let dir = sourceDir;
-    for (let depth = 0; depth < 8; depth += 1) {
-        if (existsSync(join(dir, 'package.json'))) {
-            return join(dir, 'prompts');
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            break;
-        }
-        dir = parent;
-    }
-    return join(process.cwd(), 'prompts');
-}
-function promptExists(promptsRoot, stageOrAction) {
-    return (existsSync(join(promptsRoot, `${stageOrAction}.md`)) ||
-        existsSync(join(promptsRoot, `${stageOrAction}.start.md`)) ||
-        existsSync(join(promptsRoot, `${stageOrAction}.resume.md`)));
-}
-function canReachDone(start, stages) {
-    const seen = new Set();
-    let current = start;
-    while (current !== 'done') {
-        if (seen.has(current)) {
-            return false;
-        }
-        seen.add(current);
-        const next = stages[current]?.onDone;
-        if (next === undefined) {
-            return false;
-        }
-        current = next;
-    }
-    return true;
-}
-export const ledgerSchema = z.object({
-    schemaVersion: z.literal(1),
-    // Legacy single-runner pause fields, superseded by `runners` (per-runner
-    // health, #67). Kept read-only so ledgers written before the fallback/rotation
-    // change still parse; nothing writes them anymore.
-    pausedUntil: isoTimestampSchema.optional(),
-    quotaFailureCount: z.number().int().nonnegative().optional(),
-    lastQuotaFailureAt: isoTimestampSchema.optional(),
-    runners: z.record(z.string(), runnerHealthEntrySchema).default({}),
-});
-const wakeConfigBaseSchema = z.object({
-    schemaVersion: z.literal(1).default(1),
-    paths: z.object({
-        wakeRoot: z.string(),
-        promptsRoot: z.string().optional(),
-    }),
-    sandbox: z
-        .object({
-        image: z.string().min(1).default('wake-sandbox'),
-        // Base image name (no tag) that `wake sandbox self-update` appends a
-        // release tag to, e.g. "wake-sandbox:v0.0.80". `image` above stays the
-        // resolved ref that `build`/`up`/`update` actually run.
-        imageRepository: z.string().min(1).default('wake-sandbox'),
-        containerName: z.string().min(1).default('wake-sandbox'),
-        containerMountPath: z.string().min(1).default('/wake'),
-        containerHomeMountPath: z.string().min(1).default('/home/wake'),
-        start: z
-            .object({
-            enabled: z.boolean().default(true),
-        })
-            .default({ enabled: true }),
-        extraMounts: z
-            .array(z.object({
-            source: z.string().min(1),
-            target: z.string().min(1),
-            readOnly: z.boolean().optional(),
-        }))
-            .default([]),
-    })
-        .default({
-        image: 'wake-sandbox',
-        imageRepository: 'wake-sandbox',
-        containerName: 'wake-sandbox',
-        containerMountPath: '/wake',
-        containerHomeMountPath: '/home/wake',
-        start: { enabled: true },
-        extraMounts: [],
-    }),
-    dev: z
-        .object({
-        repoRoot: z.string().optional(),
-        mode: z.enum(['source', 'packaged']).optional(),
-    })
-        .default({}),
-    scheduler: z
-        .object({
-        intervalMs: z
-            .number()
-            .int()
-            .positive()
-            .default(60 * 1000),
-        // Cap for the idle-cadence backoff (#81): consecutive idle ticks double the
-        // sleep, up to this ceiling, so a quiet repo doesn't poll every intervalMs.
-        maxIntervalMs: z
-            .number()
-            .int()
-            .positive()
-            .default(5 * 60 * 1000),
-        // Deterministic circuit breaker independent of any specific dispatch-eligibility
-        // bug: caps total runner invocations (main path + watchers) in a trailing
-        // window, counted from durable run records, not in-memory state. A storm
-        // (stuck watcher, misconfigured cron, dedupe bug) hits this ceiling and idles
-        // instead of compounding cost indefinitely.
-        dispatchRateLimit: z
-            .object({
-            windowMs: z
-                .number()
-                .int()
-                .positive()
-                .default(60 * 60 * 1000),
-            maxDispatches: z.number().int().positive().default(20),
-        })
-            .default({ windowMs: 60 * 60 * 1000, maxDispatches: 20 }),
-    })
-        .default({
-        intervalMs: 60 * 1000,
-        maxIntervalMs: 5 * 60 * 1000,
-        dispatchRateLimit: { windowMs: 60 * 60 * 1000, maxDispatches: 20 },
-    }),
-    transcripts: z
-        .object({
-        enabled: z.boolean().default(false),
-        retentionMs: z
-            .number()
-            .int()
-            .nonnegative()
-            .default(3 * 24 * 60 * 60 * 1000),
-    })
-        .default({ enabled: false, retentionMs: 3 * 24 * 60 * 60 * 1000 }),
-    retry: z
-        .object({
-        maxFailureRetries: z.number().int().positive().default(5),
-        maxChangesRequestedRetries: z.number().int().positive().default(3),
-    })
-        .default({ maxFailureRetries: 5, maxChangesRequestedRetries: 3 }),
-    runners: z.record(z.string(), runnerEntrySchema).default({
-        fake: { kind: 'fake', cli: 'Fake' },
-        'claude-haiku': {
-            kind: 'claude',
-            command: 'claude',
-            model: 'haiku',
-            smokeModel: 'haiku',
-            sessionName: defaultAgentIdentity,
-            remoteControlName: defaultAgentIdentity,
-            smokePrompt: defaultSmokePrompt,
-            timeoutMs: 30 * 60 * 1000,
-            remoteControl: { enabled: false },
-        },
-        'claude-opus': {
-            kind: 'claude',
-            command: 'claude',
-            model: 'claude-opus-4-8',
-            smokeModel: 'haiku',
-            sessionName: defaultAgentIdentity,
-            remoteControlName: defaultAgentIdentity,
-            smokePrompt: defaultSmokePrompt,
-            timeoutMs: 30 * 60 * 1000,
-            remoteControl: { enabled: false },
-        },
-        'codex-mini': {
-            kind: 'codex',
-            command: 'codex',
-            model: 'gpt-5.4-mini',
-            smokeModel: 'gpt-5.4-mini',
-            smokePrompt: defaultSmokePrompt,
-            timeoutMs: 30 * 60 * 1000,
-        },
-        'codex-flagship': {
-            kind: 'codex',
-            command: 'codex',
-            model: 'gpt-5.5',
-            smokeModel: 'gpt-5.4-mini',
-            smokePrompt: defaultSmokePrompt,
-            timeoutMs: 30 * 60 * 1000,
-        },
-        'cursor-composer': {
-            kind: 'cursor',
-            command: 'cursor',
-            model: 'composer-2.5',
-            smokeModel: 'auto',
-            smokePrompt: defaultSmokePrompt,
-            timeoutMs: 30 * 60 * 1000,
-        },
-    }),
-    tiers: z.record(z.string(), z.array(z.string().min(1)).min(1)).default({
-        light: ['fake'],
-        standard: ['fake'],
-        deep: ['fake'],
-    }),
-    defaultTier: z.string().default('standard'),
-    workflows: z.record(identifierSchema, workflowDefinitionSchema).default({
-        default: {
-            stages: {
-                refine: {
-                    action: 'refine',
-                    workspace: 'read-only',
-                    tier: 'light',
-                    onDone: 'implement',
-                },
-                implement: {
-                    action: 'implement',
-                    workspace: 'branch',
-                    tier: 'standard',
-                    onDone: 'done',
-                },
-            },
-        },
-        triage: {
-            trigger: {
-                schedule: {
-                    cron: '*/10 * * * *',
-                },
-            },
-            stages: {
-                assign: {
-                    action: 'triage-assign',
-                    workspace: 'none',
-                    tier: 'light',
-                    onDone: 'done',
-                    promptContext: {
-                        triageCapacityAvailable: true,
-                        triageWipCapDescription: 'Wake has no active running work item at triage start; do not assign more than one issue.',
-                    },
-                },
-            },
-        },
-    }),
-    workflowSelectors: z.array(workflowSelectorSchema).default([]),
-    commands: z.record(identifierSchema, customCommandSchema).default({
-        ask: {
-            action: 'ask',
-            workspace: 'read-only',
-            tier: 'light',
-        },
-        codereview: {
-            action: 'codereview',
-            workspace: 'read-only',
-            tier: 'standard',
-        },
-    }),
-    ui: z
-        .object({
-        enabled: z.boolean().default(false),
-        port: z.number().int().positive().default(4317),
-        token: z.string().optional(),
-        tunnel: z
-            .object({
-            enabled: z.boolean().default(false),
-            authToken: z.string().optional(),
-        })
-            .default({ enabled: false }),
-        archiveFreshnessDays: z.number().int().nonnegative().default(5),
-    })
-        .default({ enabled: false, port: 4317, tunnel: { enabled: false }, archiveFreshnessDays: 5 }),
-    sources: z
-        .object({
-        github: z
-            .object({
-            enabled: z.boolean().default(false),
-            repos: z.array(z.string().min(1)).default([]),
-            polling: z
-                .object({
-                maxIssuesPerRepo: z.number().int().positive().default(25),
-                commentPageSize: z.number().int().positive().default(25),
-                lookbackMs: z.number().int().nonnegative().default(60_000),
-            })
-                .default({ maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }),
-            policy: z
-                .object({
-                requiredLabels: z.array(z.string()).default([]),
-                ignoredLabels: z.array(z.string()).default([]),
-                requiredAssignees: z.array(z.string()).default([]),
-            })
-                .default({ requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }),
-            publication: z
-                .object({
-                postStatusComments: z.boolean().default(true),
-                activeLabel: z.string().optional(),
-            })
-                .default({ postStatusComments: true }),
-            pullRequests: z
-                .object({
-                enabled: z.boolean().default(false),
-                maxPullRequestsPerRepo: z.number().int().positive().default(25),
-                commentPageSize: z.number().int().positive().default(25),
-                checks: z
-                    .object({
-                    enabled: z.boolean().default(true),
-                })
-                    .default({ enabled: true }),
-                policy: z
-                    .object({
-                    requiredAuthors: z.array(z.string()).default([]),
-                })
-                    .default({ requiredAuthors: [] }),
-            })
-                .default({
-                enabled: false,
-                maxPullRequestsPerRepo: 25,
-                commentPageSize: 25,
-                checks: { enabled: true },
-                policy: { requiredAuthors: [] },
-            }),
-        })
-            .default({
-            enabled: false,
-            repos: [],
-            polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 },
-            policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] },
-            publication: { postStatusComments: true },
-            pullRequests: {
-                enabled: false,
-                maxPullRequestsPerRepo: 25,
-                commentPageSize: 25,
-                checks: { enabled: true },
-                policy: { requiredAuthors: [] },
-            },
-        }),
-    })
-        .default({
-        github: {
-            enabled: false,
-            repos: [],
-            polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 },
-            policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] },
-            publication: { postStatusComments: true },
-            pullRequests: {
-                enabled: false,
-                maxPullRequestsPerRepo: 25,
-                commentPageSize: 25,
-                checks: { enabled: true },
-                policy: { requiredAuthors: [] },
-            },
-        },
-    }),
-    sinks: z.record(z.string(), sinkEntrySchema).default({}),
-});
-export const wakeInfraConfigSchema = wakeConfigBaseSchema.pick({
-    schemaVersion: true,
-    paths: true,
-    sandbox: true,
-    dev: true,
-    scheduler: true,
-    transcripts: true,
-    retry: true,
-    ui: true,
-    sources: true,
-    sinks: true,
-});
-export const wakeWorkflowConfigSchema = wakeConfigBaseSchema.pick({
-    runners: true,
-    tiers: true,
-    defaultTier: true,
-    workflows: true,
-    workflowSelectors: true,
-    commands: true,
-});
-export const wakeConfigSchema = wakeConfigBaseSchema.superRefine((config, ctx) => {
-    const promptsRoot = config.paths.promptsRoot ?? defaultPromptsRoot();
-    const workflowEntries = Object.entries(config.workflows);
-    const commandEntries = Object.entries(config.commands);
-    if (workflowEntries.length === 0) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['workflows'],
-            message: 'At least one workflow must be configured.',
-        });
-    }
-    for (const [workflowName, workflow] of workflowEntries) {
-        const stageNames = Object.keys(workflow.stages);
-        const stageSet = new Set(stageNames);
-        if (stageNames.length === 0) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['workflows', workflowName, 'stages'],
-                message: 'Workflow must define at least one runnable stage.',
-            });
-            continue;
-        }
-        for (const reserved of ['queue', 'done']) {
-            if (stageSet.has(reserved)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ['workflows', workflowName, 'stages', reserved],
-                    message: `Workflow must not define implicit ${reserved} stage.`,
-                });
-            }
-        }
-        const actualEntryStage = workflow.entryStage ?? stageNames[0];
-        if (workflow.entryStage === 'queue') {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['workflows', workflowName, 'entryStage'],
-                message: 'Workflow entryStage must not be queue.',
-            });
-        }
-        if (actualEntryStage !== undefined && !stageSet.has(actualEntryStage)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['workflows', workflowName, 'entryStage'],
-                message: `Workflow entryStage "${actualEntryStage}" is not a configured stage.`,
-            });
-        }
-        for (const [stageName, stage] of Object.entries(workflow.stages)) {
-            if (stage.onDone === 'queue') {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ['workflows', workflowName, 'stages', stageName, 'onDone'],
-                    message: 'Workflow transitions must not target queue.',
-                });
-            }
-            if (stage.onDone !== 'done' && !stageSet.has(stage.onDone)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ['workflows', workflowName, 'stages', stageName, 'onDone'],
-                    message: `Workflow transition targets unknown stage "${stage.onDone}".`,
-                });
-            }
-            if (stage.action === undefined && !promptExists(promptsRoot, stageName)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: ['workflows', workflowName, 'stages', stageName, 'action'],
-                    message: `Workflow stage "${stageName}" omits action but no prompts/${stageName}.md template exists.`,
-                });
-            }
-            for (const [index, watcher] of (stage.watch ?? []).entries()) {
-                if (watcher.on === undefined && watcher.schedule === undefined) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ['workflows', workflowName, 'stages', stageName, 'watch', index],
-                        message: 'Watcher must declare at least one of on or schedule.',
-                    });
-                }
-                if (config.workflows[watcher.workflow] === undefined) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ['workflows', workflowName, 'stages', stageName, 'watch', index, 'workflow'],
-                        message: `Watcher targets unknown workflow "${watcher.workflow}".`,
-                    });
-                }
-            }
-        }
-        if (actualEntryStage !== undefined &&
-            stageSet.has(actualEntryStage) &&
-            !canReachDone(actualEntryStage, workflow.stages)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['workflows', workflowName],
-                message: 'Workflow cannot reach done from its entry stage.',
-            });
-        }
-    }
-    for (const [index, selector] of config.workflowSelectors.entries()) {
-        if (config.workflows[selector.workflow] === undefined) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['workflowSelectors', index, 'workflow'],
-                message: `Workflow selector targets unknown workflow "${selector.workflow}".`,
-            });
-        }
-    }
-    for (const [commandName, command] of commandEntries) {
-        if (reservedCommandNames.includes(commandName.toLowerCase())) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['commands', commandName],
-                message: `Command "/${commandName}" is reserved for Wake's own control flow.`,
-            });
-        }
-        if (command.action === undefined && !promptExists(promptsRoot, commandName)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: ['commands', commandName, 'action'],
-                message: `Command "/${commandName}" omits action but no prompts/${commandName}.md template exists.`,
-            });
-        }
-    }
-});
-export const claudePrintResultSchema = z
-    .object({
-    type: z.string().optional(),
-    subtype: z.string().optional(),
-    result: z.string(),
-    session_id: z.string().optional(),
-    total_cost_usd: z.number().optional(),
-    num_turns: z.number().optional(),
-    usage: z.record(z.string(), z.unknown()).optional(),
-})
-    .passthrough();
-export function parseIssueStateRecord(input) {
-    return issueStateRecordSchema.parse(input);
-}
-export function parseRunRecord(input) {
-    return runRecordSchema.parse(input);
-}
-export function parseRunInputSnapshot(input) {
-    return runInputSnapshotSchema.parse(input);
-}
-export function parseEventEnvelope(input) {
-    return eventEnvelopeSchema.parse(input);
-}
-export function parseLedger(input) {
-    return ledgerSchema.parse(input);
-}
-function githubTriagePromptContext(config) {
-    const triageIgnoredLabels = [
-        ...new Set([...alwaysManualIgnoredLabels, ...config.sources.github.policy.ignoredLabels]),
-    ];
-    return {
-        triageIgnoredLabels,
-        triageIgnoredLabelsJson: JSON.stringify(triageIgnoredLabels),
-        triageReposJson: JSON.stringify(config.sources.github.repos),
-    };
-}
-function attachDerivedPromptContext(config) {
-    const triageAssignStage = config.workflows.triage?.stages.assign;
-    if (triageAssignStage?.promptContext !== undefined) {
-        triageAssignStage.promptContext = {
-            ...triageAssignStage.promptContext,
-            ...githubTriagePromptContext(config),
-        };
-    }
-    return config;
-}
-export function parseWakeConfig(input) {
-    if (isRecord(input) &&
-        isRecord(input.transcripts) &&
-        'retainAfterWorkspaceCleanup' in input.transcripts) {
-        throw new Error('transcripts.retainAfterWorkspaceCleanup is no longer supported; use transcripts.retentionMs instead. Set transcripts.retentionMs to 0 to delete transcripts immediately on workspace cleanup.');
-    }
-    return structuredClone(attachDerivedPromptContext(wakeConfigSchema.parse(input)));
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function parseSourceStateRecord(input) {
-    return sourceStateRecordSchema.parse(input);
-}
-export function parseClaudePrintResult(input) {
-    return claudePrintResultSchema.parse(input);
-}
-function synthesizeBodyFromEnvelope(envelope) {
-    const labels = {
-        DONE: 'Run completed.',
-        REJECTED: 'Run rejected — needs changes.',
-        BLOCKED: 'Run blocked — needs input.',
-        FAILED: 'Run failed.',
-    };
-    return labels[envelope.status] ?? 'Run finished.';
-}
-export function parseRunnerResult(result) {
-    const wakeResultFencePattern = /^```(?:wake-result[^\n]*\n|[ \t]*\n[ \t]*wake-result[ \t]*\n)([\s\S]*?)^```[ \t]*$/gm;
-    let lastMatch = null;
-    let match;
-    while ((match = wakeResultFencePattern.exec(result)) !== null) {
-        lastMatch = match;
-    }
-    if (lastMatch !== null) {
-        try {
-            const rawContent = lastMatch[1] ?? 'null';
-            // Claude sometimes places the sentinel keyword inside the fence rather than after
-            // the closing fence. Strip a trailing sentinel line so JSON.parse sees only the JSON.
-            // The capture group includes the newline before the closing fence, so allow \n? after.
-            const jsonContent = rawContent.replace(/\n(?:DONE|REJECTED|BLOCKED|FAILED)[ \t]*\n?$/, '') || rawContent;
-            const parsed = wakeResultEnvelopeSchema.safeParse(JSON.parse(jsonContent));
-            if (parsed.success) {
-                const proseBody = result.slice(0, lastMatch.index).trim();
-                return {
-                    status: parsed.data.status,
-                    body: proseBody || synthesizeBodyFromEnvelope(parsed.data),
-                    envelope: 'structured',
-                    result: parsed.data,
-                };
-            }
-        }
-        catch {
-            // Invalid structured trailers intentionally degrade to last-line parsing.
-        }
-    }
-    const offFenceEnvelopePattern = /^```wake-result[^\n]*\n```[ \t]*\n(\{[^\n]+\})[ \t]*$/gm;
-    let offFenceMatch = null;
-    while ((match = offFenceEnvelopePattern.exec(result)) !== null) {
-        offFenceMatch = match;
-    }
-    if (offFenceMatch !== null) {
-        try {
-            const parsed = wakeResultEnvelopeSchema.safeParse(JSON.parse(offFenceMatch[1] ?? 'null'));
-            if (parsed.success) {
-                return {
-                    status: parsed.data.status,
-                    body: result.slice(0, offFenceMatch.index).trim() || synthesizeBodyFromEnvelope(parsed.data),
-                    envelope: 'structured',
-                    result: parsed.data,
-                };
-            }
-        }
-        catch {
-            // Invalid off-fence trailers intentionally degrade to sentinel parsing.
-        }
-    }
-    const lines = result.split('\n');
-    const lastLine = lines
-        .map((line) => line.trim())
-        // Skip closing code fence lines — they appear as the last non-empty line when the
-        // sentinel is embedded inside the fenced block or when a plain ``` fence is used.
-        .filter((line) => line.length > 0 && line !== '```')
-        .at(-1);
-    const normalizedLastLine = lastLine?.replace(/^(?:\*\*|__)(.+)(?:\*\*|__)$/, '$1');
-    const parsed = runnerSentinelSchema.safeParse(normalizedLastLine);
-    if (!parsed.success) {
-        const body = result.trim();
-        return {
-            status: body.length === 0 ? 'FAILED' : 'BLOCKED',
-            body,
-            // No structured envelope AND no recognizable bare sentinel at all —
-            // distinct from 'degraded' (a deliberate bare-sentinel reply) so
-            // callers can retry a runner that simply forgot the trailer instead
-            // of trusting a fabricated BLOCKED/FAILED default.
-            envelope: 'missing',
-        };
-    }
-    let removed = false;
-    const body = lines
-        .slice()
-        .reverse()
-        .filter((line) => {
-        if (!removed && line.trim() === lastLine) {
-            removed = true;
-            return false;
-        }
-        return true;
-    })
-        .reverse()
-        .join('\n')
-        .trim();
-    return {
-        status: parsed.data,
-        body,
-        envelope: 'degraded',
-    };
-}
-export function parseRunnerArtifacts(result) {
-    const fencePattern = /^```wake-artifacts[^\n]*\n([\s\S]*?)^```[ \t]*$/gm;
-    let lastMatch = null;
-    let match;
-    while ((match = fencePattern.exec(result)) !== null) {
-        lastMatch = match;
-    }
-    if (lastMatch === null) {
-        return { artifacts: [] };
-    }
-    try {
-        const parsed = wakeArtifactsEnvelopeSchema.safeParse(JSON.parse(lastMatch[1] ?? '{}'));
-        return parsed.success ? parsed.data : { artifacts: [] };
-    }
-    catch {
-        return { artifacts: [] };
-    }
-}
-export function parseRunnerResultSentinel(result) {
-    return parseRunnerResult(result).status;
-}