@boxxy/model 0.1.1 → 0.1.3

package/dist/types/registries.d.ts

@@ -1,150 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type { z } from 'zod';
-import type { ConceptPin, ItemKindName, LeverKind, LoadedRecipe, MaxAttemptsByKind, PhaseName, PipelineName, RecipeName, RulesVersion } from './core.ts';
-import type { Admission, FrameItem, Gate, Pool, PropagationLine, Signal, SignalKey, SignalName, View, Waiver } from './planning.ts';
-export type Schema<T> = z.ZodType<T>;
-export interface ParamKinds<P> {
-    signal: Signal<P>;
-    gate: Gate<P>;
-    admission: Admission<P>;
-}
-export type ParamKindName = keyof ParamKinds<unknown>;
-export interface Registered<K extends ParamKindName> {
-    readonly kind: K;
-    readonly name: string;
-    open: <R>(use: <P>(plugin: ParamKinds<P>[K]) => R) => R;
-}
-export interface Resolved<K extends ParamKindName> {
-    readonly kind: K;
-    readonly name: string;
-    readonly key: string;
-    open: <R>(use: <P>(plugin: ParamKinds<P>[K], params: P) => R) => R;
-}
-export type ConceptName = string;
-export interface Concept {
-    name: ConceptName;
-    version: number;
-    signals?: Registered<'signal'>[];
-    gates?: Registered<'gate'>[];
-    waivers?: Waiver[];
-    levers?: LeverKind[];
-    filterFields?: FilterField[];
-}
-export interface FilterField {
-    name: string;
-    value: (item: FrameItem) => string | readonly string[] | null;
-}
-export interface PlainKinds {
-    waiver: Waiver;
-    'filter-field': FilterField;
-    lever: {
-        readonly kind: LeverKind;
-    };
-    view: View;
-}
-export type PluginKindName = ParamKindName | keyof PlainKinds;
-export type Registry = {
-    readonly [K in ParamKindName]: ReadonlyMap<string, Registered<K>>;
-} & {
-    readonly [K in keyof PlainKinds]: ReadonlyMap<string, PlainKinds[K]>;
-} & {
-    readonly pins: readonly ConceptPin[];
-};
-export interface KindRules {
-    readonly pipeline: Pipeline;
-    readonly recipes: Readonly<Record<PhaseName, RecipeName>>;
-}
-export interface Pipeline {
-    readonly name: PipelineName;
-    readonly steps: readonly PipelineStep[];
-}
-export interface PipelineStep {
-    readonly phase: PhaseName;
-    readonly maxAttempts: number;
-}
-export type ConceptEntry = `${string}@${number}`;
-export type PluginRef = string | Readonly<Record<string, JsonValue>>;
-export type SignalRef = SignalName | Readonly<Record<string, JsonValue>>;
-export interface RulesFile {
-    readonly version: 1;
-    readonly concepts: readonly ConceptEntry[];
-    readonly kinds: Readonly<Record<string, {
-        readonly pipeline: readonly string[] | PipelineName;
-        readonly maxAttempts: Readonly<Record<string, number>>;
-        readonly recipes: Readonly<Record<string, string>>;
-    }>>;
-    readonly pools: readonly {
-        readonly name: string;
-        readonly slots: number;
-        readonly takes: Readonly<Record<string, JsonValue>>;
-        readonly order: readonly SignalRef[];
-    }[];
-    readonly lead: readonly SignalRef[];
-    readonly propagation: readonly {
-        readonly value: string;
-        readonly over: string;
-        readonly toward: 'source' | 'target';
-    }[];
-    readonly recipes: Readonly<Record<string, {
-        readonly agent: string;
-        readonly model: string;
-        readonly effort: string;
-        readonly prompt: string;
-        readonly source: string;
-    }>>;
-}
-export interface LoadedRules {
-    readonly version: RulesVersion;
-    readonly commit: string;
-    readonly registry: Registry;
-    readonly signals: ReadonlyMap<SignalKey, Resolved<'signal'>>;
-    readonly gates: readonly Resolved<'gate'>[];
-    readonly kinds: ReadonlyMap<ItemKindName, KindRules>;
-    readonly maxAttemptsByKind: MaxAttemptsByKind;
-    readonly pools: readonly Pool[];
-    readonly propagation: readonly PropagationLine[];
-    readonly recipes: ReadonlyMap<RecipeName, LoadedRecipe>;
-}
-export interface LoadRejection {
-    readonly file: string;
-    readonly path: string;
-    readonly reason: LoadRejectionReason;
-}
-export type LoadRejectionReason = {
-    readonly kind: 'invalid';
-    readonly message: string;
-} | {
-    readonly kind: 'unknown-concept';
-    readonly ref: string;
-} | {
-    readonly kind: 'unknown-signal';
-    readonly signal: string;
-} | {
-    readonly kind: 'bad-plugin-params';
-    readonly pluginKind: ParamKindName;
-    readonly name: string;
-    readonly message: string;
-} | {
-    readonly kind: 'unknown-link-type';
-    readonly link: string;
-} | {
-    readonly kind: 'signal-without-combine';
-    readonly signal: string;
-} | {
-    readonly kind: 'missing-recipe';
-    readonly itemKind: string;
-    readonly phase: string;
-} | {
-    readonly kind: 'missing-prompt';
-    readonly path: string;
-} | {
-    readonly kind: 'uncommitted-changes';
-};
-export type LoadResult = {
-    readonly kind: 'loaded';
-    readonly rules: LoadedRules;
-    readonly warnings: readonly string[];
-} | {
-    readonly kind: 'rejected';
-    readonly rejections: readonly LoadRejection[];
-};

package/src/derive-item-state.ts

@@ -1,76 +0,0 @@
-import type { AttemptRow, DerivedState, ItemRow, ItemRows } from './types/core.ts';
-
-interface StateInput {
-  readonly item: ItemRow;
-  readonly rows: ItemRows;
-
-  // the succeeded and failed attempts that ended after the item's latest `item.retry` lever
-  readonly counted: readonly AttemptRow[];
-}
-
-interface StateRule {
-  readonly derived: DerivedState;
-  readonly holds: (input: StateInput) => boolean;
-}
-
-const stateRules: readonly StateRule[] = [
-  { derived: { state: 'archived' }, holds: (input) => input.item.closedAt !== null },
-  { derived: { state: 'done' }, holds: (input) => hasMergedPullRequest(input.rows) },
-  { derived: { state: 'running' }, holds: (input) => input.rows.liveLease !== null },
-  { derived: { state: 'waiting', reason: 'PR open' }, holds: hasOpenPullRequest },
-  { derived: { state: 'waiting', reason: 'no PR linked' }, holds: hasSucceededWithoutPullRequest },
-  { derived: { state: 'waiting', reason: 'attempts used up' }, holds: hasUsedUpAttempts },
-  { derived: { state: 'idea' }, holds: (input) => input.item.acceptance.length === 0 },
-  { derived: { state: 'blocked' }, holds: (input) => hasOpenBlocker(input.rows) },
-];
-
-export function deriveItemState(item: ItemRow, rows: ItemRows): DerivedState {
-  const input = { item, rows, counted: collectCountedAttempts(rows) };
-
-  return stateRules.find((rule) => rule.holds(input))?.derived ?? { state: 'ready' };
-}
-
-function collectCountedAttempts(rows: ItemRows): AttemptRow[] {
-  const retryAt = Math.max(
-    Number.NEGATIVE_INFINITY,
-    ...rows.levers.filter((lever) => lever.kind === 'item.retry').map((lever) => lever.at),
-  );
-
-  return rows.attempts.filter((attempt) => attempt.endedAt !== null && attempt.endedAt > retryAt);
-}
-
-function hasMergedPullRequest(rows: ItemRows): boolean {
-  const succeeded = new Set(collectSucceeded(rows.attempts).map((attempt) => attempt.id));
-
-  return rows.pullRequests.some((pr) => pr.state === 'merged' && succeeded.has(pr.attempt));
-}
-
-function collectSucceeded(attempts: readonly AttemptRow[]): AttemptRow[] {
-  return attempts.filter((attempt) => attempt.state === 'succeeded');
-}
-
-function hasOpenPullRequest(input: StateInput): boolean {
-  const succeeded = new Set(collectSucceeded(input.counted).map((attempt) => attempt.id));
-
-  return input.rows.pullRequests.some((pr) => pr.state === 'open' && succeeded.has(pr.attempt));
-}
-
-function hasSucceededWithoutPullRequest(input: StateInput): boolean {
-  const linked = new Set(input.rows.pullRequests.map((pr) => pr.attempt));
-
-  return collectSucceeded(input.counted).some((attempt) => !linked.has(attempt.id));
-}
-
-function hasUsedUpAttempts(input: StateInput): boolean {
-  const failed = input.counted.filter((attempt) => attempt.state === 'failed');
-
-  return failed.length >= input.rows.maxAttempts;
-}
-
-function hasOpenBlocker(rows: ItemRows): boolean {
-  return rows.links.some((link) => {
-    const blockerState = rows.blockerStates.get(link.source);
-
-    return link.type === 'blocks' && blockerState !== 'done' && blockerState !== 'archived';
-  });
-}

package/src/fact-schemas.ts

@@ -1,138 +0,0 @@
-import { z } from 'zod';
-import { brandSchemas } from './brand-schemas.ts';
-import { buildCloseOutSchema } from './build-close-out-schema.ts';
-import { frictionSchema } from './friction-schema.ts';
-import type { FactType, SliceOneFacts } from './types/facts.ts';
-
-const actorRefSchema = z.union([
-  z.literal('boxxy:owner:local'),
-  z.templateLiteral(['boxxy:runner:', brandSchemas.runnerId]),
-  z.templateLiteral(['boxxy:attempt:', brandSchemas.attemptId]),
-  z.templateLiteral(['boxxy:hook:', brandSchemas.attemptId]),
-]);
-
-const criterionSchema = z.object({
-  id: brandSchemas.criterionId,
-  text: z.string().min(1),
-  evidence: z.array(brandSchemas.factId),
-});
-
-const linkPayloadSchema = z.object({
-  source: brandSchemas.itemId,
-  target: brandSchemas.itemId,
-  type: brandSchemas.linkTypeName,
-});
-
-const faultSchema = z.object({
-  plugin: z.string().min(1),
-  kind: z.enum(['signal', 'gate', 'waiver', 'admission', 'propagation']),
-  item: brandSchemas.itemId.nullable(),
-  error: z.string(),
-});
-
-const copiedEvidenceSchema = z.object({
-  criterion: brandSchemas.criterionId,
-  evidence: z.array(brandSchemas.factId),
-});
-
-const pullRequestNumberSchema = z.number().int().positive();
-
-export const factSchemas: { readonly [T in FactType]: z.ZodType<SliceOneFacts[T]> } = {
-  'boxxy.item.filed': z.object({
-    id: brandSchemas.itemId,
-    kind: brandSchemas.itemKindName,
-    repo: brandSchemas.repoName,
-    title: z.string().min(1),
-    outcome: z.string().min(1),
-    acceptance: z.array(criterionSchema),
-    foundInAttempt: brandSchemas.attemptId.nullable(),
-    filedBy: actorRefSchema,
-    filedAt: brandSchemas.instant,
-    closedAt: brandSchemas.instant.nullable(),
-    closeReason: z.string().nullable(),
-  }),
-  'boxxy.item.edited': z
-    .object({
-      title: z.string().min(1).exactOptional(),
-      outcome: z.string().min(1).exactOptional(),
-      acceptance: z.array(criterionSchema).exactOptional(),
-    })
-    .refine((fields) => Object.keys(fields).length > 0, 'an edit changes at least one field'),
-  'boxxy.item.closed': z.object({ reason: z.string().min(1) }),
-  'boxxy.link.added': linkPayloadSchema,
-  'boxxy.link.removed': linkPayloadSchema,
-  'boxxy.lever.recorded': z.object({
-    seq: z.number().int().nonnegative(),
-    kind: z.templateLiteral([z.string().min(1), '.', z.string().min(1)]),
-    item: brandSchemas.itemId,
-    until: brandSchemas.instant.nullable(),
-    expiresAt: brandSchemas.instant.nullable(),
-    reason: z.string().nullable(),
-    actor: actorRefSchema,
-    at: brandSchemas.instant,
-  }),
-  'boxxy.attempt.claimed': z.object({
-    item: brandSchemas.itemId,
-    phase: brandSchemas.phaseName,
-    number: z.number().int().positive(),
-    pool: brandSchemas.poolName,
-    slot: z.number().int().nonnegative(),
-    gen: z.number().int().nonnegative(),
-    recipeHash: brandSchemas.recipeHash,
-    rulesVersion: brandSchemas.rulesVersion,
-  }),
-  'boxxy.decision.recorded': z.object({
-    id: brandSchemas.decisionId,
-    attempt: brandSchemas.attemptId,
-    item: brandSchemas.itemId,
-    pool: brandSchemas.poolName,
-    rulesVersion: brandSchemas.rulesVersion,
-    snapshotHash: brandSchemas.snapshotHash,
-    storeVersion: z.number().int().nonnegative(),
-    pepysOffsets: z.record(brandSchemas.streamName, z.number().int().nonnegative()),
-    faults: z.array(faultSchema),
-    at: brandSchemas.instant,
-  }),
-  'boxxy.attempt.started': z.object({ atcSession: brandSchemas.atcSessionId }),
-  'boxxy.attempt.reconciling': z.object({ reason: z.string().min(1) }),
-  'boxxy.attempt.reconciled': z.object({ atcSession: brandSchemas.atcSessionId }),
-  'boxxy.attempt.session_bound': z.object({
-    atcSession: brandSchemas.atcSessionId,
-    agentSession: brandSchemas.agentSessionId,
-    seenAt: brandSchemas.instant,
-  }),
-  'boxxy.attempt.closed_out': z.object({ closeOut: buildCloseOutSchema }),
-  'boxxy.attempt.settled': z.object({
-    state: z.enum(['succeeded', 'failed']),
-    failure: z.string().min(1).nullable(),
-    endedAt: brandSchemas.instant,
-    criteria: z.array(copiedEvidenceSchema),
-    matched: z.array(brandSchemas.itemId),
-    frictionDropped: z.number().int().nonnegative(),
-  }),
-  'boxxy.evidence.recorded': z.object({
-    kind: z.enum(['pr', 'commit', 'test', 'ci-run', 'live-check']),
-    ref: z.string().min(1),
-    observed: z.string().nullable(),
-  }),
-  'boxxy.evidence.pr_linked': z.object({
-    repo: brandSchemas.repoName,
-    number: pullRequestNumberSchema,
-    url: z.url(),
-  }),
-  'boxxy.evidence.commit_linked': z.object({
-    repo: brandSchemas.repoName,
-    sha: brandSchemas.commitSha,
-    pr: pullRequestNumberSchema,
-  }),
-  'boxxy.pr.merged': z.object({
-    repo: brandSchemas.repoName,
-    number: pullRequestNumberSchema,
-    mergedAt: brandSchemas.instant,
-    mergeCommit: brandSchemas.commitSha,
-  }),
-  'boxxy.pr.closed': z.object({ repo: brandSchemas.repoName, number: pullRequestNumberSchema }),
-  'boxxy.proposal.recorded': frictionSchema,
-  'boxxy.runner.paused': z.object({ runner: brandSchemas.runnerId }),
-  'boxxy.runner.resumed': z.object({ runner: brandSchemas.runnerId }),
-};

package/src/friction-schema.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import type { Friction } from './types/facts.ts';
-
-export const frictionSchema: z.ZodType<Friction> = z.object({
-  target: z.object({
-    kind: z.enum(['skill', 'rule', 'lint', 'agents-md', 'tool']),
-    name: z.string().min(1),
-  }),
-  change: z.string().min(1),
-});

package/src/test-utils/build-mock-item-rows.ts

@@ -1,14 +0,0 @@
-import type { ItemRows } from '../types/core.ts';
-
-export function buildMockItemRows(overrides: Partial<ItemRows> = {}): ItemRows {
-  return {
-    links: [],
-    blockerStates: new Map(),
-    levers: [],
-    attempts: [],
-    liveLease: null,
-    pullRequests: [],
-    maxAttempts: 2,
-    ...overrides,
-  };
-}

package/src/test-utils/build-mock-pull-request-row.ts

@@ -1,16 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { brandSchemas } from '../brand-schemas.ts';
-import type { PullRequestRow } from '../types/core.ts';
-
-export function buildMockPullRequestRow(overrides: Partial<PullRequestRow> = {}): PullRequestRow {
-  return {
-    repo: brandSchemas.repoName.parse(`${faker.string.alpha(8)}/${faker.string.alpha(8)}`),
-    number: faker.number.int({ min: 1, max: 10_000 }),
-    attempt: brandSchemas.attemptId.parse(faker.string.uuid({ version: 7 })),
-    state: 'open',
-    mergedAt: null,
-    mergeCommit: null,
-    checkedAt: brandSchemas.instant.parse(faker.number.int({ max: 1_800_000_000_000 })),
-    ...overrides,
-  };
-}

package/src/types/dispatch.ts

@@ -1,95 +0,0 @@
-import type { ContentHash } from '@boxxy/content-hash';
-import type {
-  AttemptId,
-  AttemptRow,
-  CriterionId,
-  EvidenceRow,
-  FactId,
-  ForcedFailure,
-  Instant,
-  ItemView,
-  KnownFailure,
-  LiveAttemptState,
-  Minutes,
-  RecipeName,
-  RepoName,
-} from './core.ts';
-import type { Friction, OpenItem } from './facts.ts';
-import type { SessionReading, SpawnRequest } from './ports.ts';
-
-export interface SpawnContext {
-  readonly repoPaths: ReadonlyMap<RepoName, string>;
-  readonly pluginFolder: { readonly path: string; readonly hash: ContentHash };
-  readonly promptTemplates: ReadonlyMap<RecipeName, string>;
-}
-
-export interface Claim {
-  readonly attempt: AttemptRow;
-  readonly spawn: SpawnRequest;
-}
-
-export type ReconcileAction =
-  | {
-      readonly kind: 'move-to-running';
-      readonly fact: 'boxxy.attempt.started' | 'boxxy.attempt.reconciled';
-    }
-  | { readonly kind: 'bind-session' }
-  | { readonly kind: 'settle' }
-  | { readonly kind: 'fail'; readonly failure: Extract<KnownFailure, 'session-lost'> }
-  | {
-      readonly kind: 'respawn';
-      readonly giveUpAfter: Minutes;
-      readonly then: Extract<KnownFailure, 'spawn-lost'>;
-    };
-
-export type ReconcileTable = Readonly<
-  Record<SessionReading['kind'], Readonly<Record<LiveAttemptState, ReconcileAction>>>
->;
-
-export interface Settlement {
-  readonly state: 'succeeded' | 'failed';
-  readonly failure: string | null;
-  readonly openItems: readonly OpenItem[];
-  readonly criteria: readonly {
-    readonly criterion: CriterionId;
-    readonly evidence: readonly FactId[];
-  }[];
-  readonly friction: readonly Friction[];
-  readonly frictionDropped: number;
-}
-
-export interface SettleRule<Out = unknown> {
-  settle: (input: SettleInput<Out>) => Settlement;
-}
-
-export interface SettleInput<Out> {
-  readonly attempt: AttemptRow;
-  readonly item: ItemView;
-  readonly closeOut: CloseOutParse<Out> | null;
-
-  // a `forced` reason wins over the close-out's state
-  readonly forced: ForcedFailure | null;
-  readonly now: Instant;
-}
-
-export interface CloseOutContext {
-  readonly item: ItemView;
-  readonly attempt: AttemptId;
-
-  // the attempt's own evidence rows
-  readonly evidence: readonly EvidenceRow[];
-}
-
-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[] };
-
-export type CloseOutParse<Out> =
-  | { readonly kind: 'valid'; readonly closeOut: Out }
-  | { readonly kind: 'invalid'; readonly problems: readonly CloseOutProblem[] };
-
-export interface CloseOutParser<Out> {
-  parse: (raw: unknown, ctx: CloseOutContext) => CloseOutParse<Out>;
-}

package/src/types/facts.ts

@@ -1,166 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type {
-  ActorRef,
-  AgentSessionId,
-  AtcSessionId,
-  CommitSha,
-  Criterion,
-  CriterionId,
-  DecisionRow,
-  EvidenceKind,
-  FactId,
-  Instant,
-  ItemId,
-  ItemRow,
-  LeverRow,
-  LinkTypeName,
-  PhaseName,
-  PoolName,
-  RecipeHash,
-  RepoName,
-  RulesVersion,
-  RunnerId,
-} from './core.ts';
-
-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 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 EntityRef =
-  | `boxxy:item:${string}`
-  | `boxxy:link:${string}:${string}:${string}`
-  | `boxxy:attempt:${string}`
-  | `boxxy:decision:${string}`
-  | `boxxy:runner:${string}`;
-
-export interface FactEnvelope<
-  M extends object = SliceOneFacts,
-  T extends keyof M & string = keyof M & string,
-> {
-  readonly id: FactId;
-  readonly type: T;
-
-  // oxlint-disable-next-line id-length -- pepys's fact envelope names this field
-  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 keyof M & string, M extends object = SliceOneFacts> {
-  readonly id: FactId;
-  readonly type: T;
-  readonly entity: EntityRef;
-  readonly actor: ActorRef;
-  readonly payload: M[T];
-}
-
-export interface OutboxFact {
-  readonly seq: number;
-  readonly factId: FactId;
-  readonly type: string;
-  readonly entity: EntityRef;
-  readonly actor: ActorRef;
-  readonly at: Instant;
-  readonly payload: JsonValue;
-  readonly sentAt: Instant | null;
-}
-
-export type FactType = keyof SliceOneFacts;
-
-export interface LinkPayload {
-  readonly source: ItemId;
-  readonly target: ItemId;
-  readonly type: LinkTypeName;
-}
-
-export interface SliceOneFacts {
-  'boxxy.item.filed': ItemRow;
-  'boxxy.item.edited': {
-    readonly title?: string;
-    readonly outcome?: string;
-    readonly acceptance?: readonly Criterion[];
-  };
-  'boxxy.item.closed': { readonly reason: string };
-  'boxxy.link.added': LinkPayload;
-  'boxxy.link.removed': LinkPayload;
-  'boxxy.lever.recorded': LeverRow;
-  'boxxy.attempt.claimed': {
-    readonly item: ItemId;
-    readonly phase: PhaseName;
-    readonly number: number;
-    readonly pool: PoolName;
-    readonly slot: number;
-    readonly gen: number;
-    readonly recipeHash: RecipeHash;
-    readonly rulesVersion: RulesVersion;
-  };
-  'boxxy.decision.recorded': DecisionRow;
-  'boxxy.attempt.started': { readonly atcSession: AtcSessionId };
-  'boxxy.attempt.reconciling': { readonly reason: string };
-  'boxxy.attempt.reconciled': { readonly atcSession: AtcSessionId };
-  'boxxy.attempt.session_bound': {
-    readonly atcSession: AtcSessionId;
-    readonly agentSession: AgentSessionId;
-    readonly seenAt: Instant;
-  };
-  'boxxy.attempt.closed_out': { readonly closeOut: BuildCloseOut };
-  'boxxy.attempt.settled': {
-    readonly state: 'succeeded' | 'failed';
-    readonly failure: string | null;
-    readonly endedAt: Instant;
-    readonly criteria: readonly {
-      readonly criterion: CriterionId;
-      readonly evidence: readonly FactId[];
-    }[];
-    readonly matched: readonly ItemId[];
-    readonly frictionDropped: number;
-  };
-  'boxxy.evidence.recorded': {
-    readonly kind: EvidenceKind;
-    readonly ref: string;
-    readonly observed: string | null;
-  };
-  'boxxy.evidence.pr_linked': {
-    readonly repo: RepoName;
-    readonly number: number;
-    readonly url: string;
-  };
-  'boxxy.evidence.commit_linked': {
-    readonly repo: RepoName;
-    readonly sha: CommitSha;
-    readonly pr: number;
-  };
-  'boxxy.pr.merged': {
-    readonly repo: RepoName;
-    readonly number: number;
-    readonly mergedAt: Instant;
-    readonly mergeCommit: CommitSha;
-  };
-  'boxxy.pr.closed': { readonly repo: RepoName; readonly number: number };
-  'boxxy.proposal.recorded': Friction;
-  'boxxy.runner.paused': { readonly runner: RunnerId };
-  'boxxy.runner.resumed': { readonly runner: RunnerId };
-}