@boxxy/pepys 0.0.1 → 0.1.4

package/dist/wire-fact-schemas.d.ts

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+export declare const wireFactSchemas: {
+    'boxxy.item.filed': z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        kind: z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">;
+        repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        title: z.ZodString;
+        outcome: z.ZodString;
+        acceptance: z.ZodArray<z.ZodType<import("@boxxy/model").Criterion, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").Criterion, unknown>>>;
+        fields: z.ZodObject<{
+            designMode: z.ZodExactOptional<z.ZodEnum<{
+                agent: "agent";
+                attended: "attended";
+            }>>;
+        }, z.core.$strip>;
+        labels: z.ZodArray<z.ZodString>;
+        foundInAttempt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        filedBy: z.ZodUnion<readonly [z.ZodLiteral<"boxxy:owner:local">, z.ZodTemplateLiteral<`boxxy:runner:${string}`>, z.ZodTemplateLiteral<`boxxy:attempt:${string}`>, z.ZodTemplateLiteral<`boxxy:hook:${string}`>]>;
+        filedAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        closedAt: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+        closeReason: z.ZodNullable<z.ZodString>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.item.noted': z.ZodObject<{
+        seq: z.ZodNumber;
+        text: z.ZodString;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.item.edited': z.ZodObject<{
+        title: z.ZodExactOptional<z.ZodString>;
+        outcome: z.ZodExactOptional<z.ZodString>;
+        acceptance: z.ZodExactOptional<z.ZodArray<z.ZodType<import("@boxxy/model").Criterion, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").Criterion, unknown>>>>;
+        kind: z.ZodExactOptional<z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">>;
+        fields: z.ZodExactOptional<z.ZodObject<{
+            designMode: z.ZodExactOptional<z.ZodEnum<{
+                agent: "agent";
+                attended: "attended";
+            }>>;
+        }, z.core.$strip>>;
+        labels: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+        byAttempt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.item.closed': z.ZodObject<{
+        reason: z.ZodString;
+        byAttempt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        ended: z.ZodArray<z.ZodObject<{
+            attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            how: z.ZodEnum<{
+                closing: "closing";
+                settled: "settled";
+            }>;
+        }, z.core.$strip>>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.relation.added': z.ZodObject<{
+        source: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        target: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        type: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.relation.removed': z.ZodObject<{
+        source: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        target: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        type: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.lever.recorded': z.ZodObject<{
+        seq: z.ZodNumber;
+        kind: z.ZodTemplateLiteral<`${string}.${string}`>;
+        item: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        until: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+        expiresAt: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+        reason: z.ZodNullable<z.ZodString>;
+        phase: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "PhaseName", "out">>;
+        actor: z.ZodUnion<readonly [z.ZodLiteral<"boxxy:owner:local">, z.ZodTemplateLiteral<`boxxy:runner:${string}`>, z.ZodTemplateLiteral<`boxxy:attempt:${string}`>, z.ZodTemplateLiteral<`boxxy:hook:${string}`>]>;
+        at: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.claimed': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        number: z.ZodNumber;
+        round: z.ZodNumber;
+        mode: z.ZodEnum<{
+            agent: "agent";
+            attended: "attended";
+        }>;
+        pool: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+        fields: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        seats: z.ZodArray<z.ZodObject<{
+            limit: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+        }, z.core.$strip>>;
+        recipeHash: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "RecipeHash", "out">;
+        skillsRef: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CommitSha", "out">>;
+        rulesVersion: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "RulesVersion", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.decision.recorded': z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "DecisionId", "out">;
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        item: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+        kind: z.ZodEnum<{
+            start: "start";
+            wake: "wake";
+        }>;
+        pool: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+        rulesVersion: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "RulesVersion", "out">;
+        snapshotHash: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "SnapshotHash", "out">;
+        pepysOffsets: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "StreamName", "out">, z.ZodNumber>;
+        faults: z.ZodArray<z.ZodObject<{
+            plugin: z.ZodString;
+            kind: z.ZodEnum<{
+                admission: "admission";
+                "filter-field": "filter-field";
+                gate: "gate";
+                propagation: "propagation";
+                signal: "signal";
+                waiver: "waiver";
+            }>;
+            item: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ItemId", "out">>;
+            error: z.ZodString;
+        }, z.core.$strip>>;
+        limits: z.ZodArray<z.ZodObject<{
+            limit: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+            held: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strip>>;
+        at: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.started': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        atcSession: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
+        resumeFallback: z.ZodBoolean;
+        caller: z.ZodNullable<z.ZodType<import("@boxxy/model").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").CallerIdentity, unknown>>>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.spawn_unanswered': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        reason: z.ZodString;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.reconciled': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        atcSession: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
+        caller: z.ZodNullable<z.ZodType<import("@boxxy/model").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").CallerIdentity, unknown>>>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.session_bound': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        atcSession: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
+        agentSession: z.core.$ZodBranded<z.ZodString, "AgentSessionId", "out">;
+        product: z.ZodEnum<{
+            claude_code: "claude_code";
+            codex: "codex";
+        }>;
+        source: z.ZodEnum<{
+            hook: "hook";
+            worker: "worker";
+        }>;
+        seenAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.slept': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        idleSince: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        asked: z.ZodBoolean;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.wake_requested': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        by: z.ZodEnum<{
+            command: "command";
+            "host-slept-unasked": "host-slept-unasked";
+            "session-ran": "session-ran";
+        }>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.woken': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        holdGen: z.ZodNumber;
+        seats: z.ZodArray<z.ZodObject<{
+            limit: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+        }, z.core.$strip>>;
+        overCap: z.ZodBoolean;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.resumed': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        atcSession: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
+        caller: z.ZodNullable<z.ZodType<import("@boxxy/model").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").CallerIdentity, unknown>>>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.closed_out': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        closeOut: z.ZodType<import("@boxxy/model").CloseOut, unknown, z.core.$ZodTypeInternals<import("@boxxy/model").CloseOut, unknown>>;
+        hash: z.core.$ZodBranded<z.ZodString, "ContentHash", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.timed_out': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        afterMinutes: z.ZodNumber;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.turn_ended': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.attempt.settled': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        round: z.ZodNumber;
+        state: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        failure: z.ZodNullable<z.ZodString>;
+        outcome: z.ZodString;
+        returnedOutcome: z.ZodNullable<z.ZodString>;
+        closing: z.ZodNullable<z.ZodEnum<{
+            "closed-out": "closed-out";
+            "item-closed": "item-closed";
+            "skill-missing": "skill-missing";
+            stalled: "stalled";
+            "timed-out": "timed-out";
+            "turn-ended": "turn-ended";
+            "usage-limit": "usage-limit";
+        }>>;
+        asleep: z.ZodBoolean;
+        sessionStopped: z.ZodBoolean;
+        endedAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        criteria: z.ZodArray<z.ZodObject<{
+            criterion: z.core.$ZodBranded<z.ZodString, "CriterionId", "out">;
+            evidence: z.ZodArray<z.core.$ZodBranded<z.ZodString, "FactId", "out">>;
+        }, z.core.$strip>>;
+        matched: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ItemId", "out">>;
+        frictionDropped: z.ZodNumber;
+        skippedEffects: z.ZodArray<z.ZodObject<{
+            effect: z.ZodEnum<{
+                "add-relation": "add-relation";
+                "close-item": "close-item";
+                "file-item": "file-item";
+                "record-proposal": "record-proposal";
+                "set-acceptance": "set-acceptance";
+                "set-field": "set-field";
+                "set-kind": "set-kind";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.proposal.recorded': z.ZodObject<{
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "agents-md": "agents-md";
+                lint: "lint";
+                rule: "rule";
+                skill: "skill";
+                tool: "tool";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        change: z.ZodString;
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.evidence.recorded': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        kind: z.ZodEnum<{
+            "ci-run": "ci-run";
+            commit: "commit";
+            "live-check": "live-check";
+            pull_request: "pull_request";
+            test: "test";
+        }>;
+        ref: z.ZodString;
+        observed: z.ZodNullable<z.ZodString>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.pull_request.linked': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        number: z.ZodNumber;
+        url: z.ZodURL;
+        pullRequestId: z.ZodString;
+        source: z.ZodEnum<{
+            hook: "hook";
+            watch: "watch";
+        }>;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.commit.linked': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        sha: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
+        pullRequestNumber: z.ZodNumber;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.pull_request.merged': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        number: z.ZodNumber;
+        pullRequestId: z.ZodString;
+        mergedAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        mergeCommit: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    'boxxy.pull_request.closed': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        number: z.ZodNumber;
+        pullRequestId: z.ZodString;
+        storeVersion: z.ZodNumber;
+    }, z.core.$strip>;
+};

package/dist/work/boxxy-work-consumer.d.ts

@@ -0,0 +1,125 @@
+export declare const boxxyWorkConsumer: import("@pepys/kit").ConsumerDeclaration<"boxxy_work", {
+    readonly boxxy_item: import("@pepys/kit").TableDeclaration<{
+        readonly id: {
+            readonly kind: "entityID";
+        };
+        readonly kind: {
+            readonly kind: "text";
+        };
+        readonly repo: {
+            readonly kind: "text";
+        };
+        readonly title: {
+            readonly kind: "text";
+        };
+        readonly design_mode: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly filed_at: {
+            readonly kind: "timestamp";
+        };
+        readonly closed_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly close_reason: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly updated_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+    readonly boxxy_attempt: import("@pepys/kit").TableDeclaration<{
+        readonly id: {
+            readonly kind: "entityID";
+        };
+        readonly item_id: {
+            readonly kind: "entityID";
+        };
+        readonly phase: {
+            readonly kind: "text";
+        };
+        readonly number: {
+            readonly kind: "integer";
+        };
+        readonly round: {
+            readonly kind: "integer";
+        };
+        readonly mode: {
+            readonly kind: "text";
+        };
+        readonly pool: {
+            readonly kind: "text";
+        };
+        readonly recipe_hash: {
+            readonly kind: "text";
+        };
+        readonly rules_version: {
+            readonly kind: "text";
+        };
+        readonly atc_session: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly state: {
+            readonly kind: "text";
+        };
+        readonly outcome: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly failure: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly claimed_at: {
+            readonly kind: "timestamp";
+        };
+        readonly started_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly closed_out_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly ended_at: {
+            readonly kind: "timestamp";
+            readonly nullable: true;
+        };
+        readonly sleeps: {
+            readonly kind: "json";
+        };
+        readonly updated_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+    readonly boxxy_attempt_session: import("@pepys/kit").TableDeclaration<{
+        readonly attempt_id: {
+            readonly kind: "entityID";
+        };
+        readonly session_id: {
+            readonly kind: "entityID";
+        };
+        readonly key: {
+            readonly kind: "text";
+        };
+        readonly product: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly caller_issuer: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly caller_subject: {
+            readonly kind: "text";
+            readonly nullable: true;
+        };
+        readonly bound_at: {
+            readonly kind: "timestamp";
+        };
+    }>;
+}, import("@pepys/kit").LinkTypeDeclaration<"attempt_of", "boxxy:attempt", "boxxy:item"> | import("@pepys/kit").LinkTypeDeclaration<"produced", "boxxy:attempt", "github:pull_request"> | import("@pepys/kit").LinkTypeDeclaration<"ran_in", "boxxy:attempt", "telemetry:session">>;

package/dist/work/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ranIn: import("@pepys/kit").LinkTypeDeclaration<"ran_in", "boxxy:attempt", "telemetry:session">;
+export declare const produced: import("@pepys/kit").LinkTypeDeclaration<"produced", "boxxy:attempt", "github:pull_request">;
+export declare const attemptOf: import("@pepys/kit").LinkTypeDeclaration<"attempt_of", "boxxy:attempt", "boxxy:item">;

package/dist/work/fold-work-facts.d.ts

@@ -0,0 +1,2 @@
+import type { WorkFact, WorkFold } from './types.ts';
+export declare function foldWorkFacts(facts: readonly WorkFact[]): WorkFold;

package/dist/work/types.d.ts

@@ -0,0 +1,147 @@
+interface CallerFields {
+    issuer: string;
+    subject: string;
+}
+interface FactBase {
+    id: string;
+    entity: string;
+    at: string;
+}
+export interface ItemFiledFact extends FactBase {
+    type: 'boxxy.item.filed';
+    payload: {
+        kind: string;
+        repo: string;
+        title: string;
+        fields: {
+            designMode?: unknown;
+        };
+    };
+}
+export interface ItemEditedFact extends FactBase {
+    type: 'boxxy.item.edited';
+    payload: {
+        title?: unknown;
+        kind?: unknown;
+        fields?: unknown;
+    };
+}
+export interface ItemClosedFact extends FactBase {
+    type: 'boxxy.item.closed';
+    payload: {
+        reason: string;
+    };
+}
+export interface AttemptClaimedFact extends FactBase {
+    type: 'boxxy.attempt.claimed';
+    payload: {
+        attempt: string;
+        phase: string;
+        number: number;
+        round: number;
+        mode: string;
+        pool: string;
+        recipeHash: string;
+        rulesVersion: string;
+    };
+}
+export interface AttemptSessionFact extends FactBase {
+    type: 'boxxy.attempt.started' | 'boxxy.attempt.reconciled' | 'boxxy.attempt.resumed';
+    payload: {
+        attempt: string;
+        atcSession: string;
+        caller: CallerFields | null;
+    };
+}
+interface SessionBoundFact extends FactBase {
+    type: 'boxxy.attempt.session_bound';
+    payload: {
+        attempt: string;
+        atcSession: string;
+        agentSession: string;
+        product: string;
+    };
+}
+export interface AttemptMarkFact extends FactBase {
+    type: 'boxxy.attempt.slept' | 'boxxy.attempt.woken' | 'boxxy.attempt.closed_out';
+    payload: {
+        attempt: string;
+    };
+}
+export interface AttemptSettledFact extends FactBase {
+    type: 'boxxy.attempt.settled';
+    payload: {
+        attempt: string;
+        state: string;
+        outcome: string;
+        failure: string | null;
+        asleep: boolean;
+    };
+}
+interface PullRequestLinkedFact extends FactBase {
+    type: 'boxxy.pull_request.linked';
+    payload: {
+        attempt: string;
+        pullRequestId: string;
+    };
+}
+interface PassedOverFact extends FactBase {
+    type: 'boxxy.item.noted' | 'boxxy.relation.added' | 'boxxy.relation.removed' | 'boxxy.lever.recorded' | 'boxxy.decision.recorded' | 'boxxy.attempt.spawn_unanswered' | 'boxxy.attempt.wake_requested' | 'boxxy.attempt.timed_out' | 'boxxy.attempt.turn_ended' | 'boxxy.proposal.recorded' | 'boxxy.evidence.recorded' | 'boxxy.commit.linked' | 'boxxy.pull_request.merged' | 'boxxy.pull_request.closed';
+    payload?: unknown;
+}
+export type WorkFact = ItemFiledFact | ItemEditedFact | ItemClosedFact | AttemptClaimedFact | AttemptSessionFact | SessionBoundFact | AttemptMarkFact | AttemptSettledFact | PullRequestLinkedFact | PassedOverFact;
+export interface ItemFold {
+    kind: string;
+    repo: string;
+    title: string;
+    design_mode: string | null;
+    filed_at: string;
+    closed_at: string | null;
+    close_reason: string | null;
+    updated_at: string;
+}
+export interface SleepStretch {
+    from: string;
+    to: string | null;
+}
+export interface AttemptFold {
+    id: string;
+    phase: string;
+    number: number;
+    round: number;
+    mode: string;
+    pool: string;
+    recipe_hash: string;
+    rules_version: string;
+    atc_session: string | null;
+    state: string;
+    outcome: string | null;
+    failure: string | null;
+    claimed_at: string;
+    started_at: string | null;
+    closed_out_at: string | null;
+    ended_at: string | null;
+    sleeps: SleepStretch[];
+    updated_at: string;
+    claimedFact: string;
+    sessions: SessionFold[];
+    pullRequests: PullRequestFold[];
+}
+export interface SessionFold {
+    session: string;
+    key: 'atc' | 'agent';
+    product: string | null;
+    caller_issuer: string | null;
+    caller_subject: string | null;
+    bound_at: string;
+    evidence: string;
+}
+export interface PullRequestFold {
+    id: string;
+    evidence: string;
+}
+export interface WorkFold {
+    item: ItemFold | null;
+    attempts: AttemptFold[];
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boxxy/pepys",
-  "version": "0.0.1",
-  "description": "Placeholder that reserves the name; the first real version comes from the boxxy release",
+  "version": "0.1.4",
+  "description": "The pepys plug-in of boxxy, its fact sink and its report reader",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/packages/pepys#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
   "license": "MIT",
@@ -11,10 +11,57 @@
     "directory": "packages/pepys"
   },
   "files": [
-    "README.md",
-    "LICENSE"
+    "src",
+    "!src/**/*.test.ts",
+    "dist"
   ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./sink": {
+      "types": "./dist/create-pepys-fact-sink.d.ts",
+      "default": "./src/create-pepys-fact-sink.ts"
+    },
+    "./reader": {
+      "types": "./dist/create-pepys-reader.d.ts",
+      "default": "./src/create-pepys-reader.ts"
+    },
+    "./test-utils/*": "./src/test-utils/*.ts"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsrs -p tsconfig.build.json",
+    "glue": "pepys build src/boxxy-work-plugin.ts",
+    "typecheck": "tsrs --noEmit"
+  },
+  "dependencies": {
+    "@boxxy/model": "0.1.4"
+  },
+  "devDependencies": {
+    "@pepys/cli": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-cli-0.0.1.tgz",
+    "@pepys/kit": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-kit-0.0.1.tgz",
+    "@pepys/kysely-turso": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-kysely-turso-0.0.1.tgz",
+    "@pepys/schema": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-schema-0.0.1.tgz",
+    "@pepys/testing": "https://github.com/zgeoff/pepys/releases/download/preview-kit-0.0.1/pepys-testing-0.0.1.tgz",
+    "zod": "4.6.7"
+  },
+  "peerDependencies": {
+    "@pepys/kit": "0.0.1",
+    "@pepys/testing": "0.0.1",
+    "zod": "4.6.7"
+  },
+  "peerDependenciesMeta": {
+    "@pepys/testing": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "bun": ">=1.3",
+    "node": ">=24"
   }
 }