@boxxy/model 0.1.2 → 0.1.3

package/README.md

@@ -31,12 +31,14 @@ The package runs on [Bun](https://bun.sh) 1.3 or newer.
 
 - The branded ids and names, with a zod schema for each in `brandSchemas`.
 - The store rows, the port interfaces, the plug-in interfaces and the loaded rules.
-- The fact catalog, with a zod schema for each fact type's payload in `factSchemas`
-  ([facts and the outbox](../../docs/design/boxxy/slice-1.md#facts-and-the-outbox)).
-- `BuildCloseOut` and its schema, `buildCloseOutSchema`
-  ([the build close-out](../../docs/design/boxxy/slice-1.md#the-build-close-out)).
-- `deriveItemState`, which derives an item's state from its rows
-  ([derived item state](../../docs/design/boxxy/slice-1.md#derived-item-state)).
+- The fact catalog `WorkFacts`, with a zod schema for each fact type's payload in `workFactSchemas`
+  ([v1 facts](../../docs/design/boxxy/v1-facts-and-pepys.md)).
+- The four close-outs of the v1 phases, each with its schema, and `closeOutSchema` for any of them.
+- The output schemas of the two pepys reports, `costToLandSchema` and `stageTimeSchema`.
+- `definePhase`, which registers a phase kind with its close-out type hidden.
+- `buildItemViews`, which derives each item's position and state from its rows and the rules, with
+  `findPosition` and `deriveItemState`.
+- `pickSeatTake` and `collectSeatSync`, which give a store's seat take and seat sync.
 - `liveLevers`, which drops the levers a later undo lever cancels and those past their expiry.
 - `signalKey`, which builds a signal's key from its name and the content hash of its parameters.
 - `defineSignal`, `defineGate` and `defineAdmission`, which register a plug-in with its parameter

package/dist/closeouts/build-close-out-schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const buildCloseOutSchema: z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"built">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"blocked">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"abandoned">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    criteria: z.ZodArray<z.ZodObject<{
+        criterion: z.core.$ZodBranded<z.ZodString, "CriterionId", "out">;
+        evidence: z.core.$ZodBranded<z.ZodString, "FactId", "out">;
+    }, z.core.$strip>>;
+    openItems: z.ZodArray<z.ZodType<import("./types.ts").OpenItem, unknown, z.core.$ZodTypeInternals<import("./types.ts").OpenItem, unknown>>>;
+    friction: z.ZodArray<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;
+    }, z.core.$strip>>;
+    frictionDropped: z.ZodNumber;
+}, z.core.$strict>;

package/dist/closeouts/close-out-answer-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { CloseOutAnswer } from './types.ts';
+export declare const closeOutAnswerSchema: z.ZodType<CloseOutAnswer>;

package/dist/closeouts/close-out-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { CloseOut } from './types.ts';
+export declare const closeOutSchema: z.ZodType<CloseOut>;

package/dist/closeouts/design-close-out-schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const designCloseOutSchema: z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"designed">;
+        design: z.ZodObject<{
+            summary: z.ZodString;
+            location: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"blocked">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"abandoned">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    friction: z.ZodArray<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;
+    }, z.core.$strip>>;
+    frictionDropped: z.ZodNumber;
+}, z.core.$strict>;

package/dist/closeouts/friction-schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const frictionSchema: 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;
+}, z.core.$strip>;

package/dist/closeouts/open-item-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { OpenItem } from './types.ts';
+export declare const openItemSchema: z.ZodType<OpenItem>;

package/dist/closeouts/review-close-out-schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const reviewCloseOutSchema: z.ZodObject<{
+    verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"passed">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"changes-requested">;
+        findings: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            body: z.ZodString;
+            path: z.ZodExactOptional<z.ZodString>;
+            line: z.ZodExactOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">;
+    noslop: z.ZodObject<{
+        version: z.ZodNumber;
+        reviewID: z.ZodString;
+        head: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
+        counts: z.ZodObject<{
+            findings: z.ZodNumber;
+            failedCalls: z.ZodNumber;
+            fixChecks: z.ZodNumber;
+        }, z.core.$strip>;
+        reportBytes: z.ZodNumber;
+        report: z.ZodNullable<z.ZodJSONSchema>;
+    }, z.core.$strip>;
+    friction: z.ZodArray<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;
+    }, z.core.$strip>>;
+    frictionDropped: z.ZodNumber;
+}, z.core.$strict>;

package/dist/closeouts/triage-close-out-schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const triageCloseOutSchema: z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"accepted">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"duplicate">;
+        of: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"declined">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    set: z.ZodExactOptional<z.ZodObject<{
+        kind: z.ZodExactOptional<z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">>;
+        designMode: z.ZodExactOptional<z.ZodEnum<{
+            agent: "agent";
+            attended: "attended";
+        }>>;
+        acceptance: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strict>>;
+    relations: z.ZodArray<z.ZodObject<{
+        type: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
+        target: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+    }, z.core.$strip>>;
+    friction: z.ZodArray<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;
+    }, z.core.$strip>>;
+    frictionDropped: z.ZodNumber;
+}, z.core.$strict>;

package/dist/closeouts/types.d.ts

@@ -0,0 +1,221 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { AttemptId, CommitSha, Criterion, CriterionId, DesignMode, EvidenceRow, FactId, ItemId, ItemKindName, ItemView, RelationTypeName, RepoName } from '../types.ts';
+export type CloseOut = TriageCloseOut | DesignCloseOut | BuildCloseOut | ReviewCloseOut;
+export interface TriageCloseOut {
+    readonly result: {
+        readonly kind: 'accepted';
+    } | {
+        readonly kind: 'duplicate';
+        readonly of: ItemId;
+    } | {
+        readonly kind: 'declined';
+        readonly reason: string;
+    };
+    readonly set?: {
+        readonly kind?: ItemKindName;
+        readonly designMode?: DesignMode;
+        readonly acceptance?: readonly {
+            readonly text: string;
+        }[];
+    };
+    readonly relations: readonly RelationDraft[];
+    readonly friction: readonly Friction[];
+    readonly frictionDropped: number;
+}
+export interface DesignCloseOut {
+    readonly result: {
+        readonly kind: 'designed';
+        readonly design: DesignRef;
+    } | {
+        readonly kind: 'blocked';
+        readonly reason: string;
+    } | {
+        readonly kind: 'abandoned';
+        readonly reason: string;
+    };
+    readonly friction: readonly Friction[];
+    readonly frictionDropped: number;
+}
+export interface DesignRef {
+    readonly summary: string;
+    readonly location: string | null;
+}
+export interface BuildCloseOut {
+    readonly result: {
+        readonly kind: 'built';
+    } | {
+        readonly kind: 'blocked';
+        readonly reason: string;
+    } | {
+        readonly kind: 'abandoned';
+        readonly reason: string;
+    };
+    readonly criteria: readonly {
+        readonly criterion: CriterionId;
+        readonly evidence: FactId;
+    }[];
+    readonly openItems: readonly OpenItem[];
+    readonly friction: readonly Friction[];
+    readonly frictionDropped: number;
+}
+export interface ReviewCloseOut {
+    readonly verdict: {
+        readonly kind: 'passed';
+    } | {
+        readonly kind: 'changes-requested';
+        readonly findings: readonly Finding[];
+    };
+    readonly noslop: NoslopSummary;
+    readonly friction: readonly Friction[];
+    readonly frictionDropped: number;
+}
+export interface NoslopSummary {
+    readonly version: number;
+    readonly reviewID: string;
+    readonly head: CommitSha;
+    readonly counts: {
+        readonly findings: number;
+        readonly failedCalls: number;
+        readonly fixChecks: number;
+    };
+    readonly reportBytes: number;
+    readonly report: JsonValue | null;
+}
+export interface Finding {
+    readonly title: string;
+    readonly body: string;
+    readonly path?: string;
+    readonly line?: number;
+}
+export interface RelationDraft {
+    readonly type: RelationTypeName;
+    readonly target: ItemId;
+}
+export interface OpenItem {
+    readonly kind: 'core.issue';
+    readonly title: string;
+    readonly body: string;
+}
+export type FrictionTargetKind = 'skill' | 'rule' | 'lint' | 'agents-md' | 'tool';
+export interface Friction {
+    readonly target: {
+        readonly kind: FrictionTargetKind;
+        readonly name: string;
+    };
+    readonly change: string;
+}
+export type Effect = {
+    readonly kind: 'file-item';
+    readonly item: OpenItem;
+} | {
+    readonly kind: 'close-item';
+    readonly reason: string;
+    readonly of: ItemId | null;
+} | {
+    readonly kind: 'add-relation';
+    readonly relation: RelationDraft;
+} | {
+    readonly kind: 'set-kind';
+    readonly itemKind: ItemKindName;
+} | {
+    readonly kind: 'set-field';
+    readonly field: 'designMode';
+    readonly value: DesignMode;
+} | {
+    readonly kind: 'set-acceptance';
+    readonly criteria: readonly Criterion[];
+} | {
+    readonly kind: 'record-proposal';
+    readonly friction: Friction;
+};
+export type CloseOutProblem = {
+    readonly kind: 'schema';
+    readonly path: string;
+    readonly message: string;
+} | {
+    readonly kind: 'unknown-criterion';
+    readonly criterion: CriterionId;
+} | {
+    readonly kind: 'foreign-evidence';
+    readonly evidence: FactId;
+} | {
+    readonly kind: 'built-without-evidence';
+    readonly criteria: readonly CriterionId[];
+} | {
+    readonly kind: 'no-acceptance';
+} | {
+    readonly kind: 'unknown-item';
+    readonly item: string;
+} | {
+    readonly kind: 'unknown-kind';
+    readonly itemKind: string;
+} | {
+    readonly kind: 'refused-relation';
+    readonly type: string;
+    readonly target: string;
+    readonly reason: 'unknown-type' | 'self';
+} | {
+    readonly kind: 'phase-rule';
+    readonly message: string;
+} | {
+    readonly kind: 'too-large';
+    readonly bytes: number;
+    readonly max: number;
+};
+export type CloseOutParse<Body> = {
+    readonly kind: 'valid';
+    readonly closeOut: Body;
+} | {
+    readonly kind: 'invalid';
+    readonly problems: readonly CloseOutProblem[];
+};
+export interface CloseOutParser<Body> {
+    parse: (raw: unknown, ctx: CloseOutContext) => CloseOutParse<Body>;
+    readonly jsonSchema: JsonValue;
+}
+export interface CloseOutContext {
+    readonly item: ItemView;
+    readonly attempt: AttemptId;
+    readonly evidence: readonly EvidenceRow[];
+    readonly world: CloseOutWorld;
+}
+export interface CloseOutWorld {
+    readonly items: ReadonlySet<ItemId>;
+    readonly kinds: ReadonlySet<ItemKindName>;
+    readonly relationTypes: ReadonlySet<RelationTypeName>;
+}
+export interface CriterionText {
+    readonly id: CriterionId;
+    readonly text: string;
+}
+export interface AcceptanceInput {
+    readonly acceptance: readonly CriterionText[];
+}
+export interface BuildInput {
+    readonly acceptance: readonly CriterionText[];
+    readonly design: DesignRef | null;
+    readonly findings: readonly Finding[];
+    readonly pullRequest: PullRequestLink | null;
+}
+export interface ReviewInput {
+    readonly acceptance: readonly CriterionText[];
+    readonly design: DesignRef | null;
+    readonly pullRequest: PullRequestLink | null;
+}
+export interface PullRequestLink {
+    readonly repo: RepoName;
+    readonly number: number;
+    readonly url: string;
+}
+export type CloseOutAnswer = {
+    readonly kind: 'recorded';
+    readonly attempt: AttemptId;
+    readonly factId: FactId;
+    readonly repeat: boolean;
+} | {
+    readonly kind: 'rejected';
+    readonly problems: readonly CloseOutProblem[];
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'no-attempt' | 'already-closed-out' | 'not-current';
+};

package/dist/dispatch/build-applied-change.d.ts

@@ -0,0 +1,6 @@
+import type { StoreChange } from '../ports/types.ts';
+export interface ChangeAssignments {
+    readonly lastLeverSeq: number;
+    readonly lastNoticeId: number;
+}
+export declare function buildAppliedChange(change: StoreChange, assignments: ChangeAssignments): Pick<StoreChange, 'writes' | 'facts'>;

package/dist/dispatch/collect-seat-sync.d.ts

@@ -0,0 +1,14 @@
+import type { Limit } from '../planning/types.ts';
+import type { AttemptRow, Instant, LimitSeatRow } from '../types.ts';
+export interface SeatSync {
+    readonly release: readonly LimitSeatRow[];
+    readonly take: readonly LimitSeatRow[];
+}
+interface SeatSyncInput {
+    readonly limits: readonly Limit[];
+    readonly held: readonly LimitSeatRow[];
+    readonly attempts: readonly AttemptRow[];
+    readonly at: Instant;
+}
+export declare function collectSeatSync(input: SeatSyncInput): SeatSync;
+export {};

package/dist/dispatch/pick-seat-take.d.ts

@@ -0,0 +1,10 @@
+import type { LimitFill, SeatTake } from '../planning/types.ts';
+import type { Instant, LimitName, LimitSeatRow } from '../types.ts';
+export type SeatTakeAnswer = {
+    readonly kind: 'take';
+    readonly seats: readonly LimitSeatRow[];
+} | {
+    readonly kind: 'limit-full' | 'unknown-limit';
+    readonly limit: LimitName;
+};
+export declare function pickSeatTake(take: SeatTake, limits: readonly LimitFill[], at: Instant): SeatTakeAnswer;

package/dist/dispatch/types.d.ts

@@ -0,0 +1,11 @@
+import type { SpawnRequest } from '../ports/types.ts';
+import type { AttemptRow, KeptSession } from '../types.ts';
+export type Claim = {
+    readonly kind: 'start';
+    readonly attempt: AttemptRow;
+    readonly spawn: SpawnRequest;
+    readonly kept: KeptSession | null;
+} | {
+    readonly kind: 'wake';
+    readonly attempt: AttemptRow;
+};

package/dist/{outbox-fact-schema.d.ts → facts/outbox-fact-schema.d.ts}

@@ -1,3 +1,3 @@
 import { z } from 'zod';
-import type { OutboxFact } from './types/facts.ts';
+import type { OutboxFact } from './types.ts';
 export declare const outboxFactSchema: z.ZodType<OutboxFact>;

package/dist/facts/parse-new-fact.d.ts

@@ -0,0 +1,2 @@
+import type { AnyNewFact } from './types.ts';
+export declare function parseNewFact(fact: AnyNewFact): AnyNewFact;

package/dist/facts/types.d.ts

@@ -0,0 +1,191 @@
+import type { ContentHash, JsonValue } from '@boxxy/content-hash';
+import type { CloseOut, Effect, Friction } from '../closeouts/types.ts';
+import type { SeatRef } from '../planning/types.ts';
+import type { WakeSource } from '../ports/types.ts';
+import type { ActorRef, AgentSessionId, AtcSessionId, AttemptId, CallerIdentity, ClosingCause, CommitSha, Criterion, CriterionId, DecisionRow, DesignMode, EvidenceKind, FactId, FieldValues, Instant, ItemId, ItemKindName, ItemRow, LeverRow, Minutes, PhaseName, PoolName, Product, RecipeHash, RelationTypeName, RepoName, RulesVersion, SessionMode } from '../types.ts';
+export type EntityRef = `boxxy:item:${string}`;
+export interface FactEnvelope<M extends object, T extends keyof M & string = keyof M & string> {
+    readonly id: FactId;
+    readonly type: T;
+    readonly v: 1;
+    readonly api: 'boxxy/1';
+    readonly entity: EntityRef;
+    readonly actor: ActorRef;
+    readonly at: Instant;
+    readonly payload: M[T] & {
+        readonly storeVersion: number;
+    };
+}
+export interface NewFact<T extends FactType> {
+    readonly id: FactId;
+    readonly type: T;
+    readonly entity: EntityRef;
+    readonly actor: ActorRef;
+    readonly payload: WorkFacts[T];
+}
+export type AnyNewFact = {
+    [T in FactType]: NewFact<T>;
+}[FactType];
+export interface OutboxFact {
+    readonly seq: number;
+    readonly factId: FactId;
+    readonly type: FactType;
+    readonly entity: EntityRef;
+    readonly actor: ActorRef;
+    readonly at: Instant;
+    readonly payload: JsonValue;
+    readonly sentAt: Instant | null;
+    readonly parkedAt: Instant | null;
+    readonly parkedReason: string | null;
+}
+export type FactType = keyof WorkFacts;
+export interface RelationPayload {
+    readonly source: ItemId;
+    readonly target: ItemId;
+    readonly type: RelationTypeName;
+}
+interface OfAttempt {
+    readonly attempt: AttemptId;
+}
+export interface WorkFacts {
+    'boxxy.item.filed': Omit<ItemRow, 'keptSession'>;
+    'boxxy.item.noted': {
+        readonly seq: number;
+        readonly text: string;
+    };
+    'boxxy.item.edited': {
+        readonly title?: string;
+        readonly outcome?: string;
+        readonly acceptance?: readonly Criterion[];
+        readonly kind?: ItemKindName;
+        readonly fields?: {
+            readonly designMode?: DesignMode;
+        };
+        readonly labels?: readonly string[];
+        readonly byAttempt: AttemptId | null;
+    };
+    'boxxy.item.closed': {
+        readonly reason: string;
+        readonly byAttempt: AttemptId | null;
+        readonly ended: readonly {
+            readonly attempt: AttemptId;
+            readonly how: 'settled' | 'closing';
+        }[];
+    };
+    'boxxy.relation.added': RelationPayload;
+    'boxxy.relation.removed': RelationPayload;
+    'boxxy.lever.recorded': LeverRow;
+    'boxxy.attempt.claimed': OfAttempt & {
+        readonly phase: PhaseName;
+        readonly number: number;
+        readonly round: number;
+        readonly mode: SessionMode;
+        readonly pool: PoolName;
+        readonly fields: FieldValues;
+        readonly seats: readonly SeatRef[];
+        readonly recipeHash: RecipeHash;
+        readonly skillsRef: CommitSha | null;
+        readonly rulesVersion: RulesVersion;
+    };
+    'boxxy.decision.recorded': DecisionRow;
+    'boxxy.attempt.started': OfAttempt & {
+        readonly atcSession: AtcSessionId;
+        readonly resumeFallback: boolean;
+        readonly caller: CallerIdentity | null;
+    };
+    'boxxy.attempt.spawn_unanswered': OfAttempt & {
+        readonly reason: string;
+    };
+    'boxxy.attempt.reconciled': OfAttempt & {
+        readonly atcSession: AtcSessionId;
+        readonly caller: CallerIdentity | null;
+    };
+    'boxxy.attempt.session_bound': OfAttempt & {
+        readonly atcSession: AtcSessionId;
+        readonly agentSession: AgentSessionId;
+        readonly product: Product;
+        readonly source: 'worker' | 'hook';
+        readonly seenAt: Instant;
+    };
+    'boxxy.attempt.slept': OfAttempt & {
+        readonly idleSince: Instant;
+        readonly asked: boolean;
+    };
+    'boxxy.attempt.wake_requested': OfAttempt & {
+        readonly by: WakeSource;
+    };
+    'boxxy.attempt.woken': OfAttempt & {
+        readonly holdGen: number;
+        readonly seats: readonly SeatRef[];
+        readonly overCap: boolean;
+    };
+    'boxxy.attempt.resumed': OfAttempt & {
+        readonly atcSession: AtcSessionId;
+        readonly caller: CallerIdentity | null;
+    };
+    'boxxy.attempt.closed_out': OfAttempt & {
+        readonly phase: PhaseName;
+        readonly closeOut: CloseOut;
+        readonly hash: ContentHash;
+    };
+    'boxxy.attempt.timed_out': OfAttempt & {
+        readonly phase: PhaseName;
+        readonly afterMinutes: Minutes;
+    };
+    'boxxy.attempt.turn_ended': OfAttempt & {
+        readonly phase: PhaseName;
+    };
+    'boxxy.attempt.settled': OfAttempt & {
+        readonly phase: PhaseName;
+        readonly round: number;
+        readonly state: 'succeeded' | 'failed';
+        readonly failure: string | null;
+        readonly outcome: string;
+        readonly returnedOutcome: string | null;
+        readonly closing: ClosingCause | null;
+        readonly asleep: boolean;
+        readonly sessionStopped: boolean;
+        readonly endedAt: Instant;
+        readonly criteria: readonly {
+            readonly criterion: CriterionId;
+            readonly evidence: readonly FactId[];
+        }[];
+        readonly matched: readonly ItemId[];
+        readonly frictionDropped: number;
+        readonly skippedEffects: readonly {
+            readonly effect: Effect['kind'];
+            readonly reason: string;
+        }[];
+    };
+    'boxxy.proposal.recorded': OfAttempt & Friction;
+    'boxxy.evidence.recorded': OfAttempt & {
+        readonly kind: EvidenceKind;
+        readonly ref: string;
+        readonly observed: string | null;
+    };
+    'boxxy.pull_request.linked': OfAttempt & {
+        readonly repo: RepoName;
+        readonly number: number;
+        readonly url: string;
+        readonly pullRequestId: string;
+        readonly source: 'hook' | 'watch';
+    };
+    'boxxy.commit.linked': OfAttempt & {
+        readonly repo: RepoName;
+        readonly sha: CommitSha;
+        readonly pullRequestNumber: number;
+    };
+    'boxxy.pull_request.merged': OfAttempt & {
+        readonly repo: RepoName;
+        readonly number: number;
+        readonly pullRequestId: string;
+        readonly mergedAt: Instant;
+        readonly mergeCommit: CommitSha;
+    };
+    'boxxy.pull_request.closed': OfAttempt & {
+        readonly repo: RepoName;
+        readonly number: number;
+        readonly pullRequestId: string;
+    };
+}
+export {};