@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/execution/contracts/events.js

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import { activationId, activityName, activityOrchestrationGroupId, activityWorkflowInstanceId, ExternalExecutionKind, } from '../../activities/index.js';
+import { brandedStringSchema, eventEnvelopeSchema, offsetIsoTimestampSchema, } from '../../kernel/index.js';
+import { runId } from './identifiers.js';
+import { ExecutionStreamKind } from './streams.js';
+import { ExecutionCancellationReason, ExecutionFailureCode, RunStatus, WorkspaceMode, } from './vocabulary.js';
+export const runStartedPayloadSchema = z
+    .object({
+    activationId: brandedStringSchema(activationId),
+    activity: brandedStringSchema(activityName),
+    stage: z.string().min(1).optional(),
+    workflowInstanceId: brandedStringSchema(activityWorkflowInstanceId),
+    orchestrationGroupId: brandedStringSchema(activityOrchestrationGroupId),
+    attempt: z.number().int().positive(),
+    startedAt: offsetIsoTimestampSchema,
+    runner: z
+        .object({
+        name: z.string().min(1),
+        model: z.string().min(1).optional(),
+        effort: z.string().min(1).optional(),
+        pool: z.string().min(1).optional(),
+        cli: z.string().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    workspace: z
+        .object({
+        mode: z.enum([WorkspaceMode.ReadOnly, WorkspaceMode.Branch]),
+        path: z.string().min(1),
+        branch: z.string().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const leasePayloadSchema = z
+    .object({
+    owner: z.string().min(1),
+    acquiredAt: offsetIsoTimestampSchema,
+    expiresAt: offsetIsoTimestampSchema,
+})
+    .strict();
+export const runnerResultPayloadSchema = z
+    .object({
+    transport: z.enum([
+        RunStatus.Succeeded,
+        RunStatus.Failed,
+        RunStatus.Cancelled,
+        RunStatus.Ambiguous,
+    ]),
+    // Legacy persisted events may still carry these fields; new writers never emit them.
+    output: z.string().optional(),
+    runner: z.string().min(1).optional(),
+    agent: z
+        .object({
+        outcome: z.enum(['DONE', 'REJECTED', 'BLOCKED', 'FAILED']),
+        displayBody: z.string(),
+        artifacts: z
+            .array(z
+            .object({
+            kind: z.string().min(1),
+            externalKey: z
+                .object({ adapter: z.string().min(1), key: z.string().min(1) })
+                .strict(),
+        })
+            .strict())
+            .optional(),
+        metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const ExecutionEventType = {
+    RunStarted: 'execution.run-started',
+    RunSucceeded: 'execution.run-succeeded',
+    RunFailed: 'execution.run-failed',
+    RunLeaseClaimed: 'execution.run-lease-claimed',
+    RunLeaseRenewed: 'execution.run-lease-renewed',
+    RunExternalExecutionReported: 'execution.run-external-execution-reported',
+    RunRunnerResultReported: 'execution.run-runner-result-reported',
+    RunWorkspaceCleanupFailed: 'execution.workspace-cleanup-failed',
+    RunCancellationRequested: 'execution.run-cancellation-requested',
+    RunCancellationConfirmed: 'execution.run-cancellation-confirmed',
+    RunCancelled: 'execution.run-cancelled',
+    RunRecovered: 'execution.run-recovered',
+    RunAmbiguityObserved: 'execution.run-ambiguity-observed',
+    RunAmbiguous: 'execution.run-ambiguous',
+    ActivationClaimed: 'execution.activation-claimed',
+    ActivationReleased: 'execution.activation-released',
+};
+export const ExecutionEventNamespace = 'execution.';
+const runStreamSchema = z
+    .object({
+    kind: z.literal(ExecutionStreamKind.Run),
+    id: brandedStringSchema(runId),
+})
+    .strict();
+const activationStreamSchema = z
+    .object({
+    kind: z.literal(ExecutionStreamKind.Activation),
+    id: brandedStringSchema(activationId),
+})
+    .strict();
+const runEventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunStarted),
+        stream: runStreamSchema,
+        payload: runStartedPayloadSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunRunnerResultReported),
+        stream: runStreamSchema,
+        payload: runnerResultPayloadSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunWorkspaceCleanupFailed),
+        stream: runStreamSchema,
+        payload: z.object({ message: z.string().min(1) }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunCancelled),
+        stream: runStreamSchema,
+        payload: z.object({ finishedAt: offsetIsoTimestampSchema }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunSucceeded),
+        stream: runStreamSchema,
+        payload: z
+            .object({
+            outcome: z.object({ kind: z.string().min(1), data: z.unknown().optional() }).strict(),
+            finishedAt: offsetIsoTimestampSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunFailed),
+        stream: runStreamSchema,
+        payload: z
+            .object({
+            failure: z
+                .object({
+                kind: z.enum([ExecutionFailureCode.Unexpected]),
+                message: z.string(),
+                details: z
+                    .object({
+                    sourceKind: z.string().min(1),
+                    sourceDetails: z.unknown().optional(),
+                })
+                    .strict()
+                    .optional(),
+            })
+                .strict(),
+            finishedAt: offsetIsoTimestampSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunLeaseClaimed),
+        stream: runStreamSchema,
+        payload: leasePayloadSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunLeaseRenewed),
+        stream: runStreamSchema,
+        payload: leasePayloadSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunExternalExecutionReported),
+        stream: runStreamSchema,
+        payload: z
+            .object({
+            kind: z.enum([ExternalExecutionKind.Process, ExternalExecutionKind.RemoteSession]),
+            id: z.string().min(1),
+            startedAt: offsetIsoTimestampSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunCancellationRequested),
+        stream: runStreamSchema,
+        payload: z
+            .object({
+            requestedAt: offsetIsoTimestampSchema,
+            reason: z.enum(Object.values(ExecutionCancellationReason)),
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunCancellationConfirmed),
+        stream: runStreamSchema,
+        payload: z.object({ confirmedAt: offsetIsoTimestampSchema }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunRecovered),
+        stream: runStreamSchema,
+        payload: z
+            .object({
+            result: runnerResultPayloadSchema,
+            outcome: z.object({ kind: z.string().min(1), data: z.unknown().optional() }).strict(),
+            finishedAt: offsetIsoTimestampSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunAmbiguityObserved),
+        stream: runStreamSchema,
+        payload: z.object({ reason: z.string().min(1), attempt: z.number().int().positive() }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.RunAmbiguous),
+        stream: runStreamSchema,
+        payload: z.object({ reason: z.string().min(1), finishedAt: offsetIsoTimestampSchema }).strict(),
+    }),
+]);
+const activationEventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.ActivationClaimed),
+        stream: activationStreamSchema,
+        payload: z
+            .object({
+            runId: brandedStringSchema(runId),
+            owner: z.string().min(1),
+            expiresAt: offsetIsoTimestampSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ExecutionEventType.ActivationReleased),
+        stream: activationStreamSchema,
+        payload: z.object({ runId: brandedStringSchema(runId) }).strict(),
+    }),
+]);
+const eventSchema = z.union([runEventSchema, activationEventSchema]);
+export function decodeExecutionEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidExecutionEvent(event, result.error);
+    return result.data;
+}
+export function decodeRunExecutionEvent(event) {
+    const result = runEventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidExecutionEvent(event, result.error);
+    return result.data;
+}
+export function decodeActivationExecutionEvent(event) {
+    const result = activationEventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidExecutionEvent(event, result.error);
+    return result.data;
+}
+export function selectExecutionEvent(event) {
+    return event.eventType.startsWith(ExecutionEventNamespace) ? decodeExecutionEvent(event) : null;
+}
+export function selectRunExecutionEvent(event) {
+    if (!event.eventType.startsWith(ExecutionEventNamespace))
+        return null;
+    if (event.stream.kind === ExecutionStreamKind.Run)
+        return decodeRunExecutionEvent(event);
+    decodeExecutionEvent(event);
+    return null;
+}
+export function selectActivationExecutionEvent(event) {
+    if (!event.eventType.startsWith(ExecutionEventNamespace))
+        return null;
+    if (event.stream.kind === ExecutionStreamKind.Activation)
+        return decodeActivationExecutionEvent(event);
+    decodeExecutionEvent(event);
+    return null;
+}
+function invalidExecutionEvent(event, cause) {
+    return new Error(`Invalid Execution event ${event.eventId} at global position ${event.globalPosition} (${event.eventType}): ${cause.message}`, { cause });
+}

package/dist/src/execution/contracts/identifiers.js

@@ -0,0 +1,5 @@
+export const runId = (value) => {
+    if (value.trim().length === 0)
+        throw new Error('RunId must not be empty');
+    return value;
+};

package/dist/src/execution/contracts/liveness.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/contracts/results.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/contracts/runner.js

@@ -0,0 +1,15 @@
+// inputTokens/outputTokens/cacheReadTokens/cacheWriteTokens/costUsd are the known
+// numeric keys agent-runner-adapter.ts writes into AgentRunResponse.metadata.
+export function agentTokenUsage(metadata) {
+    const numeric = (key) => {
+        const value = metadata?.[key];
+        return typeof value === 'number' ? value : 0;
+    };
+    return {
+        tokens: numeric('inputTokens') +
+            numeric('outputTokens') +
+            numeric('cacheReadTokens') +
+            numeric('cacheWriteTokens'),
+        costUsd: numeric('costUsd'),
+    };
+}

package/dist/src/execution/contracts/streams.js

@@ -0,0 +1,10 @@
+export const ExecutionStreamKind = { Run: 'run', Activation: 'execution-activation' };
+export const runStream = (id) => ({
+    kind: ExecutionStreamKind.Run,
+    id,
+});
+export const isRunStream = (stream) => stream.kind === ExecutionStreamKind.Run;
+export const activationStream = (id) => ({
+    kind: ExecutionStreamKind.Activation,
+    id,
+});

package/dist/src/execution/contracts/views.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/contracts/vocabulary.js

@@ -0,0 +1,43 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const RunStatus = defineClosedVocabulary({
+    Started: 'started',
+    Succeeded: 'succeeded',
+    Failed: 'failed',
+    Cancelled: 'cancelled',
+    Ambiguous: 'ambiguous',
+});
+export const ExecutionFailureCode = defineClosedVocabulary({
+    Unexpected: 'unexpected-execution-failure',
+});
+export const ExecutionCancellationReason = defineClosedVocabulary({
+    Operator: 'operator',
+    WorkCancelled: 'work-cancelled',
+    WorkClosed: 'work-closed',
+    WorkflowSuperseded: 'workflow-superseded',
+    Timeout: 'timeout',
+    Shutdown: 'shutdown',
+    Maintenance: 'maintenance',
+});
+export const ExternalExecutionState = defineClosedVocabulary({
+    Running: 'running',
+    Completed: 'completed',
+    Absent: 'absent',
+    Unknown: 'unknown',
+});
+export const WorkspaceMode = defineClosedVocabulary({
+    None: 'none',
+    ReadOnly: 'read-only',
+    Branch: 'branch',
+});
+const transcriptChannelShape = { input: true, agent: true };
+const transcriptChannels = Object.keys(transcriptChannelShape);
+export const TranscriptChannel = {
+    Input: transcriptChannels[0],
+    Agent: transcriptChannels[1],
+};
+const transcriptGroupKindShape = { session: true, run: true };
+const transcriptGroupKinds = Object.keys(transcriptGroupKindShape);
+export const TranscriptGroupKind = {
+    Session: transcriptGroupKinds[0],
+    Run: transcriptGroupKinds[1],
+};

package/dist/src/execution/contracts/workspace.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/domain/run-result.js

@@ -0,0 +1,34 @@
+import { ExecutionFailureCode } from '../contracts/vocabulary.js';
+export function failureFrom(error) {
+    const source = sourceFailure(error);
+    return {
+        kind: ExecutionFailureCode.Unexpected,
+        message: source.message,
+        details: {
+            sourceKind: source.kind,
+            ...(source.details === undefined ? {} : { sourceDetails: source.details }),
+        },
+    };
+}
+function sourceFailure(error) {
+    if (error instanceof Error)
+        return {
+            kind: error.name,
+            message: error.message,
+            ...('details' in error ? { details: error.details } : {}),
+        };
+    if (typeof error === 'object' && error !== null) {
+        const kind = Reflect.get(error, 'kind');
+        const message = Reflect.get(error, 'message');
+        const details = Reflect.get(error, 'details');
+        return {
+            kind: typeof kind === 'string' && kind.length > 0 ? kind : 'non-error-object',
+            message: typeof message === 'string' ? message : failureValue(error),
+            ...(details === undefined ? {} : { details }),
+        };
+    }
+    return { kind: typeof error, message: failureValue(error) };
+}
+function failureValue(error) {
+    return typeof error === 'symbol' ? error.toString() : `${error}`;
+}

package/dist/src/execution/domain/run.js

@@ -0,0 +1,142 @@
+import { EventActorKind } from '../../kernel/index.js';
+import { ExecutionEventType } from '../contracts/events.js';
+import { ExecutionFailureCode, RunStatus } from '../contracts/vocabulary.js';
+export function foldRun(events) {
+    const started = events.find((event) => event.eventType === ExecutionEventType.RunStarted);
+    if (started === undefined)
+        return null;
+    const state = {
+        runId: started.stream.id,
+        activationId: started.payload.activationId,
+        activity: started.payload.activity,
+        ...(started.payload.stage === undefined ? {} : { stage: started.payload.stage }),
+        workflowInstanceId: started.payload.workflowInstanceId,
+        orchestrationGroupId: started.payload.orchestrationGroupId,
+        attempt: started.payload.attempt,
+        status: RunStatus.Started,
+        ambiguityAttempts: 0,
+        escalated: false,
+        startedAt: started.payload.startedAt,
+        ...(started.payload.runner === undefined ? {} : { runner: started.payload.runner }),
+        ...(started.payload.workspace === undefined ? {} : { workspace: started.payload.workspace }),
+    };
+    for (const event of events)
+        applyRunEvent(state, event);
+    return state;
+}
+function applyRunEvent(state, event) {
+    if (state.status !== RunStatus.Started) {
+        if (state.status === RunStatus.Ambiguous &&
+            event.actor.kind === EventActorKind.Operator &&
+            (event.eventType === ExecutionEventType.RunSucceeded ||
+                event.eventType === ExecutionEventType.RunFailed))
+            return applyTerminalEvent(state, event);
+        return;
+    }
+    switch (event.eventType) {
+        case ExecutionEventType.RunStarted:
+            return;
+        case ExecutionEventType.RunSucceeded:
+        case ExecutionEventType.RunFailed:
+        case ExecutionEventType.RunCancelled:
+            return applyTerminalEvent(state, event);
+        default:
+            return applyLivenessEvent(state, event);
+    }
+}
+function applyTerminalEvent(state, event) {
+    if (event.eventType === ExecutionEventType.RunSucceeded) {
+        Object.assign(state, {
+            status: RunStatus.Succeeded,
+            finishedAt: event.payload.finishedAt,
+            outcome: event.payload.outcome,
+            escalated: false,
+        });
+        return;
+    }
+    if (event.eventType === ExecutionEventType.RunCancelled) {
+        Object.assign(state, { status: RunStatus.Cancelled, finishedAt: event.payload.finishedAt });
+        return;
+    }
+    Object.assign(state, {
+        status: RunStatus.Failed,
+        finishedAt: event.payload.finishedAt,
+        failure: event.payload.failure,
+        escalated: false,
+    });
+}
+// eslint-disable-next-line complexity
+function applyLivenessEvent(state, event) {
+    switch (event.eventType) {
+        case ExecutionEventType.RunLeaseClaimed:
+        case ExecutionEventType.RunLeaseRenewed:
+            Object.assign(state, { lease: event.payload });
+            return;
+        case ExecutionEventType.RunExternalExecutionReported:
+            Object.assign(state, { externalExecution: event.payload });
+            return;
+        case ExecutionEventType.RunWorkspaceCleanupFailed:
+            return;
+        case ExecutionEventType.RunRunnerResultReported:
+            Object.assign(state, event.payload.agent === undefined ? {} : { agent: event.payload.agent });
+            return;
+        case ExecutionEventType.RunCancellationRequested:
+            Object.assign(state, { cancellation: event.payload });
+            return;
+        case ExecutionEventType.RunCancellationConfirmed:
+            if (state.cancellation !== undefined)
+                Object.assign(state, {
+                    cancellation: { ...state.cancellation, confirmedAt: event.payload.confirmedAt },
+                });
+            return;
+        case ExecutionEventType.RunRecovered:
+            Object.assign(state, recoveredState(event.payload.result, event.payload.finishedAt, event.payload.outcome));
+            return;
+        case ExecutionEventType.RunAmbiguityObserved:
+            Object.assign(state, {
+                ambiguityAttempts: event.payload.attempt,
+                failure: { kind: ExecutionFailureCode.Unexpected, message: event.payload.reason },
+            });
+            return;
+        case ExecutionEventType.RunAmbiguous:
+            Object.assign(state, {
+                status: RunStatus.Ambiguous,
+                finishedAt: event.payload.finishedAt,
+                failure: { kind: ExecutionFailureCode.Unexpected, message: event.payload.reason },
+                escalated: true,
+            });
+            return;
+        default:
+            assertNever(event);
+    }
+}
+function recoveredState(result, finishedAt, outcome) {
+    if (result.transport === RunStatus.Succeeded)
+        return {
+            status: RunStatus.Succeeded,
+            finishedAt,
+            ...(outcome === undefined ? {} : { outcome }),
+        };
+    if (result.transport === RunStatus.Cancelled)
+        return { status: RunStatus.Cancelled, finishedAt };
+    if (result.transport === RunStatus.Ambiguous)
+        return {
+            status: RunStatus.Ambiguous,
+            finishedAt,
+            failure: {
+                kind: ExecutionFailureCode.Unexpected,
+                message: result.failure?.message ?? 'Recovered execution is ambiguous',
+            },
+        };
+    return {
+        status: RunStatus.Failed,
+        finishedAt,
+        failure: {
+            kind: ExecutionFailureCode.Unexpected,
+            message: result.failure?.message ?? 'Recovered execution failed',
+        },
+    };
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Execution event: ${JSON.stringify(value)}`);
+}

package/dist/src/execution/index.js

@@ -0,0 +1,31 @@
+export * from './application/execution-projection.js';
+export * from './application/execution-service.js';
+export * from './application/recovery-service.js';
+export * from './application/run-repository.js';
+export * from './contracts/commands.js';
+export * from './contracts/config.js';
+export * from './contracts/control-plane.js';
+export * from './contracts/event-factory.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/liveness.js';
+export * from './contracts/runner.js';
+export * from './contracts/results.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './contracts/vocabulary.js';
+export * from './contracts/workspace.js';
+export * from './domain/run-result.js';
+export * from './domain/run.js';
+export * from './infrastructure/prompt-templates.js';
+export * from './infrastructure/runners/claude.js';
+export * from './infrastructure/runners/codex.js';
+export * from './infrastructure/runners/command.js';
+export * from './infrastructure/runners/cursor.js';
+export * from './infrastructure/runners/fake.js';
+export * from './infrastructure/runners/fake-scenarios.js';
+export * from './infrastructure/runners/registry.js';
+export * from './infrastructure/transcripts.js';
+export * from './infrastructure/transcript-store.js';
+export * from './infrastructure/workspace/fake-workspace.js';
+export * from './infrastructure/workspace/git-workspace.js';

package/dist/src/execution/infrastructure/agent-runner-adapter.js

@@ -0,0 +1,114 @@
+import { RunStatus } from '../contracts/vocabulary.js';
+export function parseAgentRunnerResponse(result) {
+    const parsed = parseResult(result.output);
+    return {
+        outcome: result.transport === RunStatus.Succeeded ? parsed.outcome : 'FAILED',
+        displayBody: result.transport === RunStatus.Succeeded
+            ? parsed.displayBody
+            : result.failure?.message || parsed.displayBody || 'Runner failed without a response.',
+        metadata: metadata(result),
+    };
+}
+function parseResult(output) {
+    const direct = parseEnvelope(output);
+    if (direct !== undefined)
+        return {
+            outcome: direct.status,
+            displayBody: direct.displayBody ?? synthesized(direct.status),
+        };
+    const fence = /^```(?:wake-result[^\n]*\n|[ \t]*\n[ \t]*wake-result[ \t]*\n)([\s\S]*?)^```[ \t]*$/gm;
+    let last = null;
+    let match;
+    while ((match = fence.exec(output)) !== null)
+        last = match;
+    if (last !== null) {
+        try {
+            const json = (last[1] ?? '').replace(/\n(?:DONE|REJECTED|BLOCKED|FAILED)[ \t]*\n?$/, '');
+            const value = JSON.parse(json);
+            if (isOutcome(value.status))
+                return {
+                    outcome: value.status,
+                    displayBody: output.slice(0, last.index).trim() || synthesized(value.status),
+                };
+        }
+        catch {
+            // A malformed envelope intentionally falls through to the legacy sentinel rules.
+        }
+    }
+    const lines = output.split('\n');
+    const lastLine = lines
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && line !== '```')
+        .at(-1);
+    const normalized = lastLine?.replace(/^(?:\*\*|__)(.+)(?:\*\*|__)$/, '$1');
+    if (!isOutcome(normalized))
+        return {
+            outcome: output.trim().length === 0 ? 'FAILED' : 'BLOCKED',
+            displayBody: output.trim(),
+        };
+    let removed = false;
+    return {
+        outcome: normalized,
+        displayBody: lines
+            .reverse()
+            .filter((line) => {
+            if (!removed && line.trim() === lastLine) {
+                removed = true;
+                return false;
+            }
+            return true;
+        })
+            .reverse()
+            .join('\n')
+            .trim(),
+    };
+}
+function parseEnvelope(value) {
+    try {
+        const parsed = JSON.parse(value.trim());
+        if (!isOutcome(parsed.status))
+            return undefined;
+        return {
+            status: parsed.status,
+            ...(typeof parsed.displayBody === 'string' && parsed.displayBody.trim().length > 0
+                ? { displayBody: parsed.displayBody }
+                : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isOutcome(value) {
+    return value === 'DONE' || value === 'REJECTED' || value === 'BLOCKED' || value === 'FAILED';
+}
+function synthesized(outcome) {
+    return {
+        DONE: 'Run completed.',
+        REJECTED: 'Run rejected - needs changes.',
+        BLOCKED: 'Run blocked - needs input.',
+        FAILED: 'Run failed.',
+    }[outcome];
+}
+function metadata(result) {
+    return {
+        runner: result.runner,
+        ...(result.model === undefined ? {} : { model: result.model }),
+        ...(result.sessionId === undefined ? {} : { sessionId: result.sessionId }),
+        ...(result.tokenUsage === undefined
+            ? {}
+            : {
+                inputTokens: result.tokenUsage.input,
+                outputTokens: result.tokenUsage.output,
+                ...(result.tokenUsage.cacheRead === undefined
+                    ? {}
+                    : { cacheReadTokens: result.tokenUsage.cacheRead }),
+                ...(result.tokenUsage.cacheWrite === undefined
+                    ? {}
+                    : { cacheWriteTokens: result.tokenUsage.cacheWrite }),
+                ...(result.tokenUsage.costUsd === undefined
+                    ? {}
+                    : { costUsd: result.tokenUsage.costUsd }),
+            }),
+    };
+}