@boxxy/model 0.0.0 → 0.1.1

package/dist/types/planning.d.ts

@@ -0,0 +1,94 @@
+import type { FaultRecord, Instant, ItemId, ItemView, LeverRow, LinkRow, LinkTypeName, PhaseName, PoolName } from './core.ts';
+import type { Schema } from './registries.ts';
+export type SignalName = string;
+export type GateName = string;
+export type WaiverName = string;
+export type AdmissionName = string;
+export type ViewName = string;
+export type SignalKey = `${SignalName}#${string}`;
+export interface Snapshot {
+    storeVersion: number;
+    items: ItemView[];
+    links: LinkRow[];
+    levers: LeverRow[];
+    freeSlots: Record<PoolName, number>;
+}
+export interface FrameItem extends ItemView {
+    readonly phase: PhaseName;
+}
+export interface Frame {
+    candidates: FrameItem[];
+    fields: Map<ItemId, Readonly<Record<string, readonly string[]>>>;
+    values: Map<SignalKey, Map<ItemId, number>>;
+    holds: Map<ItemId, Hold[]>;
+    lifted: Map<ItemId, Lift[]>;
+    faults: Fault[];
+}
+export type FrameValues = ReadonlyMap<SignalKey, ReadonlyMap<ItemId, number>>;
+export interface Hold {
+    readonly gate: GateName;
+    readonly reason: string;
+    readonly until?: Instant;
+}
+export interface Lift {
+    readonly waiver: WaiverName;
+    readonly gate: GateName;
+    readonly reason: string;
+}
+export type Fault = FaultRecord;
+export interface Decision {
+    picks: Pick[];
+}
+export interface Pick {
+    item: ItemId;
+    phase: PhaseName;
+    pool: PoolName;
+}
+export interface Pool {
+    readonly name: PoolName;
+    readonly slots: number;
+    readonly takes: Readonly<Record<string, readonly string[]>>;
+    readonly order: readonly SignalKey[];
+}
+export interface PlanContext {
+    now: Instant;
+    levers: LeverRow[];
+    links: LinkRow[];
+    values: FrameValues;
+}
+export interface Signal<P> {
+    name: SignalName;
+    params: Schema<P>;
+    value: (item: FrameItem, ctx: PlanContext, params: P) => number | null;
+    combine?: (left: number, right: number) => number;
+}
+export interface Gate<P> {
+    name: GateName;
+    liftable: boolean;
+    params: Schema<P>;
+    hold: (item: FrameItem, ctx: PlanContext, params: P) => Hold | null;
+}
+export interface Waiver {
+    name: WaiverName;
+    lifts: GateName;
+    lift: (item: FrameItem, hold: Hold, ctx: PlanContext) => Lift | null;
+}
+export interface Admission<P> {
+    name: AdmissionName;
+    params: Schema<P>;
+    admit: (item: FrameItem, ctx: PlanContext, params: P) => AdmissionGrant | null;
+}
+export interface AdmissionGrant {
+    readonly admission: AdmissionName;
+    readonly pools: readonly PoolName[] | 'any';
+    readonly reason: string;
+}
+export interface View<I = unknown, O = unknown> {
+    name: ViewName;
+    render: (frame: Frame, input: I) => O;
+}
+export interface PropagationLine {
+    readonly value: SignalName;
+    readonly over: LinkTypeName;
+    readonly toward: 'source' | 'target';
+}

package/dist/types/ports.d.ts

@@ -0,0 +1,218 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, CommitSha, DecisionRow, Effort, EvidenceRow, FactId, Instant, ItemId, ItemRow, ItemState, ItemView, ItemWithLevers, LeaseRow, LeverRow, LinkRow, MaxAttemptsByKind, PhaseName, PoolName, PoolSlotRow, PullRequestRef, PullRequestRow, RepoName, RunnerId, RunnerRow } from './core.ts';
+import type { FactType, NewFact, OutboxFact } from './facts.ts';
+import type { Snapshot } from './planning.ts';
+export interface ClaimStore {
+    exclusive: <T>(work: (tx: StoreTx) => Promise<T>) => Promise<T>;
+    read: <T>(work: (tx: StoreReader) => Promise<T>) => Promise<T>;
+}
+export interface StoreReader {
+    readSnapshot: (now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<Snapshot>;
+    readItem: (id: ItemId, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemView | null>;
+    readItemDetail: (id: ItemId, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemDetailRows | null>;
+    listItems: (filter: ItemFilter, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemWithLevers[]>;
+    listOpenIssues: (repo: RepoName, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemView[]>;
+    readLastLeaseGen: (item: ItemId, phase: PhaseName) => Promise<number>;
+    readAttempt: (id: AttemptId) => Promise<AttemptRow | null>;
+    listEvidence: (attempt: AttemptId) => Promise<EvidenceRow[]>;
+    listLiveAttempts: () => Promise<AttemptRow[]>;
+    listSucceededAttemptsWithoutPr: () => Promise<AttemptRow[]>;
+    findAttemptBySession: (session: AtcSessionId) => Promise<AttemptRow | null>;
+    findAttemptByAgentSession: (session: AgentSessionId) => Promise<AttemptId | null>;
+    listWatchedPullRequests: () => Promise<PullRequestRow[]>;
+    listPoolSlots: () => Promise<PoolSlotRow[]>;
+    readUnsentFacts: (limit: number) => Promise<OutboxFact[]>;
+    readOutboxLag: () => Promise<{
+        readonly unsent: number;
+        readonly oldestUnsentAt: Instant | null;
+    }>;
+    readRunner: (id: RunnerId) => Promise<RunnerRow | null>;
+}
+export interface ItemDetailRows {
+    readonly item: ItemWithLevers;
+    readonly attempts: readonly AttemptRow[];
+    readonly links: readonly LinkRow[];
+    readonly evidence: readonly EvidenceRow[];
+    readonly pullRequests: readonly PullRequestRow[];
+}
+export interface StoreTx extends StoreReader {
+    applyChange: (change: StoreChange) => Promise<ApplyResult>;
+    markFactsSent: (ids: FactId[], at: Instant) => Promise<void>;
+    writeHeartbeat: (runner: RunnerId, at: Instant) => Promise<void>;
+    syncPoolSlots: (pools: readonly {
+        readonly name: PoolName;
+        readonly slots: number;
+    }[]) => Promise<void>;
+    markPullRequestChecked: (ref: PullRequestRef, at: Instant) => Promise<void>;
+}
+export interface StoreChange {
+    at: Instant;
+    under?: {
+        item: ItemId;
+        phase: PhaseName;
+        gen: number;
+        slot?: {
+            pool: PoolName;
+            slot: number;
+            gen: number;
+        };
+    };
+    writes: RowWrite[];
+    facts: AnyNewFact[];
+}
+export type ApplyResult = {
+    kind: 'applied';
+    slot: {
+        pool: PoolName;
+        slot: number;
+        gen: number;
+    } | null;
+} | {
+    kind: 'stale-generation';
+} | {
+    kind: 'lease-held';
+} | {
+    kind: 'no-free-slot';
+} | {
+    kind: 'guard-mismatch';
+    table: TableName;
+    key: JsonValue;
+};
+export interface ItemFilter {
+    readonly state?: ItemState;
+    readonly repo?: RepoName;
+}
+export interface Tables {
+    items: ItemRow;
+    links: LinkRow;
+    levers: LeverRow;
+    attempts: AttemptRow;
+    attempt_sessions: AttemptSessionRow;
+    leases: LeaseRow;
+    pool_slots: PoolSlotRow;
+    decisions: DecisionRow;
+    evidence: EvidenceRow;
+    pull_requests: PullRequestRow;
+    runners: RunnerRow;
+}
+export type TableName = keyof Tables;
+export type RowWrite = {
+    [T in TableName]: {
+        readonly op: 'insert';
+        readonly table: T;
+        readonly row: Tables[T];
+    };
+}[TableName] | {
+    [T in TableName]: {
+        readonly op: 'update';
+        readonly table: T;
+        readonly key: Partial<Tables[T]>;
+        readonly expect: Partial<Tables[T]>;
+        readonly set: Partial<Tables[T]>;
+    };
+}[TableName] | {
+    readonly op: 'take-slot';
+    readonly pool: PoolName;
+    readonly holder: AttemptId;
+} | {
+    readonly op: 'release-slot';
+    readonly pool: PoolName;
+    readonly slot: number;
+    readonly holder: AttemptId;
+};
+export type AnyNewFact = {
+    [T in FactType]: NewFact<T>;
+}[FactType];
+export interface WorkerKind {
+    start: (request: SpawnRequest) => Promise<StartOutcome>;
+    reconcile: (attempt: AttemptRow) => Promise<SessionReading>;
+}
+export type StartOutcome = {
+    kind: 'started';
+    atcSession: AtcSessionId;
+    agentSession: AgentSessionId | null;
+} | {
+    kind: 'refused';
+    reason: string;
+} | {
+    kind: 'unknown';
+    reason: string;
+};
+export type SessionReading = {
+    kind: 'running';
+    atcSession: AtcSessionId;
+    agentSession: AgentSessionId | null;
+} | {
+    kind: 'ended';
+    atcSession: AtcSessionId;
+    agentSession: AgentSessionId | null;
+} | {
+    kind: 'absent';
+};
+export interface SpawnRequest {
+    readonly cwd: string;
+    readonly prompt: string;
+    readonly agent: string;
+    readonly model: string;
+    readonly effort: Effort;
+    readonly pluginDirs: readonly string[];
+    readonly name: `boxxy/${string}`;
+    readonly idempotencyKey: AttemptId;
+}
+export interface SessionFault {
+    readonly kind: 'fault';
+    readonly fault: 'agent-session-owned';
+    readonly agentSession: AgentSessionId;
+    readonly attempt: AttemptId;
+    readonly holder: AttemptId;
+}
+export interface FactSink {
+    append: (facts: OutboxFact[]) => Promise<'accepted' | {
+        kind: 'unknown';
+        reason: string;
+    } | {
+        kind: 'rejected';
+        error: string;
+    }>;
+}
+export interface CostToLandRow {
+    readonly item: ItemId;
+    readonly title: string;
+    readonly repo: RepoName;
+    readonly landedAt: Instant;
+    readonly model: string;
+    readonly attempts: number;
+    readonly requests: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheCreationTokens: number;
+    readonly totalInputTokens: number;
+    readonly costUsd: number;
+}
+export interface CostToLandInput {
+    readonly repo?: string;
+    readonly landedFrom?: string;
+    readonly landedTo?: string;
+}
+export interface CostReader {
+    costToLand: (input: CostToLandInput) => Promise<CostToLandRow[]>;
+}
+export interface Forge {
+    readPullRequest: (ref: PullRequestRef) => Promise<PullRequestReading | 'not-found'>;
+    listOpenPullRequests: (repo: RepoName) => Promise<PullRequestRef[]>;
+}
+export interface PullRequestReading {
+    url: string;
+    state: 'open' | 'closed' | 'merged';
+    mergedAt: Instant | null;
+    mergeCommit: CommitSha | null;
+    commits: {
+        sha: CommitSha;
+        message: string;
+    }[];
+}
+export interface Clock {
+    now: () => Instant;
+}
+export type NewId = () => string;

package/dist/types/registries.d.ts

@@ -0,0 +1,150 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/model",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "description": "The types that boxxy's packages share",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/libs/model#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
@@ -20,7 +20,8 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./src/index.ts"
-    }
+    },
+    "./test-utils/*": "./src/test-utils/*.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -29,6 +30,11 @@
     "build": "rm -rf dist && tsrs -p tsconfig.build.json",
     "typecheck": "tsrs --noEmit"
   },
+  "dependencies": {
+    "@boxxy/content-hash": "0.1.0",
+    "@faker-js/faker": "10.6.0",
+    "zod": "4.6.7"
+  },
   "engines": {
     "bun": ">=1.3",
     "node": ">=24"

package/src/brand-schemas.ts

@@ -0,0 +1,46 @@
+import { contentHashSchema } from '@boxxy/content-hash';
+import { z } from 'zod';
+
+const uuidV7Schema = z
+  .string()
+  .regex(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u);
+
+const nameSchema = z.string().min(1);
+
+export const brandSchemas = {
+  instant: z.number().int().nonnegative().brand<'Instant'>(),
+  itemId: uuidV7Schema.brand<'ItemId'>(),
+  attemptId: uuidV7Schema.brand<'AttemptId'>(),
+  decisionId: uuidV7Schema.brand<'DecisionId'>(),
+  factId: z.templateLiteral(['manual:', uuidV7Schema]).brand<'FactId'>(),
+  runnerId: z
+    .string()
+    .regex(/^[a-z0-9-]+$/u)
+    .brand<'RunnerId'>(),
+  atcSessionId: nameSchema.brand<'AtcSessionId'>(),
+  agentSessionId: nameSchema.brand<'AgentSessionId'>(),
+  commitSha: z
+    .string()
+    .regex(/^[0-9a-f]{40}$/u)
+    .brand<'CommitSha'>(),
+  repoName: z
+    .string()
+    .regex(/^[\w.-]+\/[\w.-]+$/u)
+    .brand<'RepoName'>(),
+  criterionId: z
+    .string()
+    .regex(/^a[1-9]\d*$/u)
+    .brand<'CriterionId'>(),
+  itemKindName: nameSchema.brand<'ItemKindName'>(),
+  linkTypeName: nameSchema.brand<'LinkTypeName'>(),
+  phaseName: nameSchema.brand<'PhaseName'>(),
+  pipelineName: nameSchema.brand<'PipelineName'>(),
+  poolName: nameSchema.brand<'PoolName'>(),
+  recipeName: nameSchema.brand<'RecipeName'>(),
+  workerKindName: nameSchema.brand<'WorkerKindName'>(),
+  sourceName: nameSchema.brand<'SourceName'>(),
+  streamName: nameSchema.brand<'StreamName'>(),
+  recipeHash: contentHashSchema.brand<'RecipeHash'>(),
+  snapshotHash: contentHashSchema.brand<'SnapshotHash'>(),
+  rulesVersion: contentHashSchema.brand<'RulesVersion'>(),
+};

package/src/build-close-out-schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { brandSchemas } from './brand-schemas.ts';
+import { frictionSchema } from './friction-schema.ts';
+import type { BuildCloseOut } from './types/facts.ts';
+
+const reasonSchema = z.string().min(1);
+const builtSchema = z.object({ kind: z.literal('built') });
+const blockedSchema = z.object({ kind: z.literal('blocked'), reason: reasonSchema });
+const abandonedSchema = z.object({ kind: z.literal('abandoned'), reason: reasonSchema });
+
+const citedEvidenceSchema = z.object({
+  criterion: brandSchemas.criterionId,
+  evidence: brandSchemas.factId,
+});
+
+const openItemSchema = z.object({
+  kind: z.literal('core.issue'),
+  title: z.string().min(1),
+  body: z.string(),
+});
+
+export const buildCloseOutSchema: z.ZodType<BuildCloseOut> = z.object({
+  result: z.discriminatedUnion('kind', [builtSchema, blockedSchema, abandonedSchema]),
+  criteria: z.array(citedEvidenceSchema),
+  openItems: z.array(openItemSchema),
+  friction: z.array(frictionSchema),
+  frictionDropped: z.number().int().nonnegative(),
+});

package/src/define-admission.ts

@@ -0,0 +1,6 @@
+import type { Admission } from './types/planning.ts';
+import type { Registered } from './types/registries.ts';
+
+export function defineAdmission<P>(admission: Admission<P>): Registered<'admission'> {
+  return { kind: 'admission', name: admission.name, open: (use) => use(admission) };
+}

package/src/define-gate.ts

@@ -0,0 +1,6 @@
+import type { Gate } from './types/planning.ts';
+import type { Registered } from './types/registries.ts';
+
+export function defineGate<P>(gate: Gate<P>): Registered<'gate'> {
+  return { kind: 'gate', name: gate.name, open: (use) => use(gate) };
+}

package/src/define-signal.ts

@@ -0,0 +1,6 @@
+import type { Signal } from './types/planning.ts';
+import type { Registered } from './types/registries.ts';
+
+export function defineSignal<P>(signal: Signal<P>): Registered<'signal'> {
+  return { kind: 'signal', name: signal.name, open: (use) => use(signal) };
+}

package/src/derive-item-state.ts

@@ -0,0 +1,76 @@
+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';
+  });
+}