@boxxy/model 0.1.2 → 0.1.3

package/dist/facts/work-fact-schemas.d.ts

@@ -0,0 +1,293 @@
+import { z } from 'zod';
+export declare const workFactSchemas: {
+    '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("../types.ts").Criterion, unknown, z.core.$ZodTypeInternals<import("../types.ts").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>;
+    }, z.core.$strip>;
+    'boxxy.item.noted': z.ZodObject<{
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, 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("../types.ts").Criterion, unknown, z.core.$ZodTypeInternals<import("../types.ts").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">>;
+    }, 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>>;
+    }, 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">;
+    }, 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">;
+    }, 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">;
+    }, 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">;
+    }, 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">;
+        storeVersion: z.ZodNumber;
+        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">;
+    }, 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("../types.ts").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("../types.ts").CallerIdentity, unknown>>>;
+    }, z.core.$strip>;
+    'boxxy.attempt.spawn_unanswered': z.ZodObject<{
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        reason: z.ZodString;
+    }, 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("../types.ts").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("../types.ts").CallerIdentity, unknown>>>;
+    }, 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">;
+    }, 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;
+    }, 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";
+        }>;
+    }, 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;
+    }, 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("../types.ts").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("../types.ts").CallerIdentity, unknown>>>;
+    }, 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("../index.ts").CloseOut, unknown, z.core.$ZodTypeInternals<import("../index.ts").CloseOut, unknown>>;
+        hash: z.core.$ZodBranded<z.ZodString, "ContentHash", "out">;
+    }, 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;
+    }, 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">;
+    }, 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>>;
+    }, 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">;
+    }, 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>;
+    }, 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";
+        }>;
+    }, 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;
+    }, 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">;
+    }, 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;
+    }, z.core.$strip>;
+};

package/dist/index.d.ts

@@ -1,24 +1,65 @@
 export type { ContentHash, JsonValue } from '@boxxy/content-hash';
-export { brandSchemas } from './brand-schemas.ts';
-export { buildAppliedChange, type ChangeAssignments, type TakenSlot, } from './build-applied-change.ts';
-export { buildCloseOutSchema } from './build-close-out-schema.ts';
-export { buildItemViews } from './build-item-views.ts';
-export { defineAdmission } from './define-admission.ts';
-export { defineGate } from './define-gate.ts';
-export { defineSignal } from './define-signal.ts';
-export { deriveItemState } from './derive-item-state.ts';
-export { factSchemas } from './fact-schemas.ts';
-export { findSlotTake, type SlotTake } from './find-slot-take.ts';
-export { formatKeyPath } from './format-key-path.ts';
-export { frictionSchema } from './friction-schema.ts';
-export { liveLevers } from './live-levers.ts';
-export { outboxFactSchema } from './outbox-fact-schema.ts';
-export { rowSchemas } from './row-schemas.ts';
-export { signalKey } from './signal-key.ts';
-export { toJSONValue } from './to-json-value.ts';
-export type { Actor, ActorRef, AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, AttemptState, CommitSha, ConceptPin, Criterion, CriterionId, DecisionId, DecisionRow, DerivedState, Effort, EvidenceKind, EvidenceRow, EvidenceSource, FactId, FaultRecord, ForcedFailure, Instant, ItemId, ItemKindName, ItemRow, ItemRows, ItemSetRows, ItemState, ItemView, ItemWithLevers, KnownFailure, LeaseRow, LeverKind, LeverRow, LinkRow, LinkTypeName, LiveAttemptState, LoadedRecipe, MaxAttemptsByKind, Minutes, ObservationBoundary, PhaseName, PipelineName, PoolName, PoolSlotRow, PullRequestRef, PullRequestRow, Recipe, RecipeHash, RecipeMaterial, RecipeName, RepoName, ResolvedRecipe, RulesVersion, RunnerId, RunnerRow, SnapshotHash, SourceName, StreamName, WaitingReason, WorkerKindName, } from './types/core.ts';
-export type { Claim, CloseOutContext, CloseOutParse, CloseOutParser, CloseOutProblem, ReconcileAction, ReconcileTable, SettleInput, Settlement, SettleRule, SpawnContext, } from './types/dispatch.ts';
-export type { BuildCloseOut, EntityRef, FactEnvelope, FactType, Friction, FrictionTargetKind, LinkPayload, NewFact, OpenItem, OutboxFact, SliceOneFacts, } from './types/facts.ts';
-export type { Admission, AdmissionGrant, AdmissionName, Decision, Fault, Frame, FrameItem, FrameValues, Gate, GateName, Hold, Lift, Pick, PlanContext, Pool, PropagationLine, Signal, SignalKey, SignalName, Snapshot, View, ViewName, Waiver, WaiverName, } from './types/planning.ts';
-export type { AnyNewFact, ApplyResult, ClaimStore, Clock, CostReader, CostToLandInput, CostToLandRow, FactSink, Forge, ItemDetailRows, ItemFilter, NewId, PullRequestReading, RowWrite, SessionFault, SessionReading, SpawnRequest, StartOutcome, StoreChange, StoreReader, StoreTx, TableName, Tables, WorkerKind, } from './types/ports.ts';
-export type { Concept, ConceptEntry, ConceptName, FilterField, KindRules, LoadedRules, LoadRejection, LoadRejectionReason, LoadResult, ParamKindName, ParamKinds, Pipeline, PipelineStep, PlainKinds, PluginKindName, PluginRef, Registered, Registry, Resolved, RulesFile, Schema, SignalRef, } from './types/registries.ts';
+export { brandSchemas } from './rows/brand-schemas.ts';
+export { buildAppliedChange, type ChangeAssignments } from './dispatch/build-applied-change.ts';
+export { advance } from './pipeline/advance.ts';
+export { attemptRowSchema } from './rows/attempt-row-schema.ts';
+export { attemptSessionRowSchema } from './rows/attempt-session-row-schema.ts';
+export { buildCloseOutSchema } from './closeouts/build-close-out-schema.ts';
+export { buildItemViews } from './items/build-item-views.ts';
+export { collectRetries } from './items/collect-retries.ts';
+export { collectSettled } from './items/collect-settled.ts';
+export { closeOutAnswerSchema } from './closeouts/close-out-answer-schema.ts';
+export { callerIdentitySchema } from './rows/caller-identity-schema.ts';
+export { closeOutSchema } from './closeouts/close-out-schema.ts';
+export { collectSeatSync, type SeatSync } from './dispatch/collect-seat-sync.ts';
+export { costToLandSchema } from './reports/cost-to-land-schema.ts';
+export { criterionSchema } from './rows/criterion-schema.ts';
+export { decisionRowSchema } from './rows/decision-row-schema.ts';
+export { defineAdmission } from './planning/define-admission.ts';
+export { defineGate } from './planning/define-gate.ts';
+export { definePhase } from './rules/define-phase.ts';
+export { defineSignal } from './planning/define-signal.ts';
+export { buildPhase, deriveItemState } from './items/derive-item-state.ts';
+export { designCloseOutSchema } from './closeouts/design-close-out-schema.ts';
+export { evidenceRowSchema } from './rows/evidence-row-schema.ts';
+export { findPosition } from './pipeline/find-position.ts';
+export { formatKeyPath } from './utils/format-key-path.ts';
+export { frictionSchema } from './closeouts/friction-schema.ts';
+export { isFilterMatch } from './planning/is-filter-match.ts';
+export { itemRowSchema } from './rows/item-row-schema.ts';
+export { itemViewSchema } from './rows/item-view-schema.ts';
+export { leverRowSchema } from './rows/lever-row-schema.ts';
+export { limitFillSchema } from './planning/limit-fill-schema.ts';
+export { limitSchema } from './rows/limit-schema.ts';
+export { limitSeatRowSchema } from './rows/limit-seat-row-schema.ts';
+export { loadRejectionSchema } from './rules/load-rejection-schema.ts';
+export { liveLevers } from './items/live-levers.ts';
+export { noteRowSchema } from './rows/note-row-schema.ts';
+export { noticeRowSchema } from './rows/notice-row-schema.ts';
+export { outboxFactSchema } from './facts/outbox-fact-schema.ts';
+export { positionSchema } from './pipeline/position-schema.ts';
+export { parseNewFact } from './facts/parse-new-fact.ts';
+export { pickSeatTake, type SeatTakeAnswer } from './dispatch/pick-seat-take.ts';
+export { pullRequestRowSchema } from './rows/pull-request-row-schema.ts';
+export { relationRowSchema } from './rows/relation-row-schema.ts';
+export { reviewCloseOutSchema } from './closeouts/review-close-out-schema.ts';
+export { rowSchemas } from './rows/row-schemas.ts';
+export { signalKey } from './planning/signal-key.ts';
+export { spawnRequestSchema } from './rows/spawn-request-schema.ts';
+export { stageTimeSchema } from './reports/stage-time-schema.ts';
+export { toJSONValue } from './utils/to-json-value.ts';
+export { triageCloseOutSchema } from './closeouts/triage-close-out-schema.ts';
+export { workFactSchemas } from './facts/work-fact-schemas.ts';
+export { costBases, phaseSteps, stageSteps } from './reports/constants.ts';
+export { engineHoldReasons, engineOutcomes } from './pipeline/constants.ts';
+export type { Actor, ActorRef, AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, AttemptState, CallerIdentity, ClosingCause, CommitSha, ConceptPin, Criterion, CriterionId, DecisionId, DecisionRow, DerivedState, DesignMode, Effort, EngineOutcome, EvidenceKind, EvidenceRow, EvidenceSource, FactId, FaultRecord, FieldValues, ForcedFailure, Instant, ItemFields, ItemId, ItemKindName, ItemRow, ItemState, ItemView, KeptSession, KnownFailure, LeaseRow, LeverKind, LeverRow, LimitCount, LimitName, LimitSeatRow, LiveAttemptState, Minutes, NoteRow, NoticeRow, ObservationBoundary, OutcomeName, PhaseName, PipelineName, PoolName, Product, PullRequestRef, PullRequestRow, Recipe, RecipeHash, RecipeMaterial, RecipeName, RelationRow, RelationTypeName, RepoName, ResolvedRecipe, RulesVersion, RunnerId, RunnerRow, SessionMode, SnapshotHash, SourceName, StreamName, WaitingReason, WorkerKindName, } from './types.ts';
+export type { HoldReason, Position, RetryLever, RulesHoldReason, Settled, } from './pipeline/types.ts';
+export type { AcceptanceInput, BuildCloseOut, BuildInput, CloseOut, CloseOutAnswer, CloseOutContext, CloseOutParse, CloseOutParser, CloseOutProblem, CloseOutWorld, CriterionText, DesignCloseOut, DesignRef, Effect, Finding, Friction, FrictionTargetKind, NoslopSummary, OpenItem, PullRequestLink, RelationDraft, ReviewCloseOut, ReviewInput, TriageCloseOut, } from './closeouts/types.ts';
+export type { Claim } from './dispatch/types.ts';
+export type { AnyNewFact, EntityRef, FactEnvelope, FactType, NewFact, OutboxFact, RelationPayload, WorkFacts, } from './facts/types.ts';
+export type { Admission, AdmissionGrant, AdmissionName, Decision, Fault, Filter, Frame, FrameItem, FrameValues, Gate, GateName, Hold, Lift, Limit, LimitFill, Pick, PlanContext, Pool, PropagationLine, SeatRef, SeatRelease, SeatTake, Signal, SignalKey, SignalName, Snapshot, StartPick, View, ViewName, Wait, WaitReason, Waiver, WaiverName, Wake, WakePick, } from './planning/types.ts';
+export type { ApplyResult, Attention, CallerProof, CapacityBackoff, ClaimStore, Clock, FactSink, ForgetOutcome, Forge, HoldNotice, ItemDetailRows, ItemFilter, NewId, NoticeOutcome, Notifier, OutboxReader, PepysAnswer, PepysReader, SinkAnswer, PullRequestReading, RowWrite, SessionFault, SessionReading, SpawnRequest, StartOutcome, StopOutcome, StoreChange, StoreReader, StoreTx, SuspendOutcome, TableName, Tables, WakeSource, WorkerKind, } from './ports/types.ts';
+export type { CostToLand, StageTime } from './reports/types.ts';
+export type { OutboxStatus } from './reports/outbox-status.ts';
+export type { ItemSetRows, ItemWithLevers } from './items/types.ts';
+export type { Concept, ConceptEntry, ConceptName, Edge, FilterField, ItemRules, KindRules, LoadedRules, LoadRejection, LoadRejectionReason, LoadResult, ParamKindName, ParamKinds, PhaseInputContext, PhaseKind, Pipeline, PipelineStep, PlainKinds, PluginKindName, PluginRef, Registered, Registry, RelationType, Resolved, Schema, SettleInput, Settlement, SignalRef, SkillsPin, SleepRules, } from './rules/types.ts';

package/dist/items/build-item-views.d.ts

@@ -0,0 +1,4 @@
+import type { ItemRules } from '../rules/types.ts';
+import type { Instant } from '../types.ts';
+import type { ItemSetRows, ItemWithLevers } from './types.ts';
+export declare function buildItemViews(rows: ItemSetRows, now: Instant, rules: ItemRules): ItemWithLevers[];

package/dist/items/collect-retries.d.ts

@@ -0,0 +1,3 @@
+import type { RetryLever } from '../pipeline/types.ts';
+import type { LeverRow } from '../types.ts';
+export declare function collectRetries(levers: readonly LeverRow[]): RetryLever[];

package/dist/items/collect-settled.d.ts

@@ -0,0 +1,3 @@
+import type { Settled } from '../pipeline/types.ts';
+import type { AttemptRow } from '../types.ts';
+export declare function collectSettled(attempts: readonly AttemptRow[]): Settled[];

package/dist/items/derive-item-state.d.ts

@@ -0,0 +1,17 @@
+import type { Position } from '../pipeline/types.ts';
+import type { AttemptRow, DerivedState, ItemId, ItemRow, ItemState, LeaseRow, PhaseName, PullRequestRow, RelationRow } from '../types.ts';
+interface DeriveItemStateInput {
+    readonly item: ItemRow;
+    readonly position: Position;
+    readonly liveLease: LeaseRow | null;
+    readonly phases: ReadonlyMap<PhaseName, {
+        readonly needsAcceptance: boolean;
+    }>;
+    readonly attempts: readonly AttemptRow[];
+    readonly pullRequests: readonly PullRequestRow[];
+    readonly relations: readonly RelationRow[];
+    readonly blockerStates: ReadonlyMap<ItemId, ItemState>;
+}
+export declare function deriveItemState(input: DeriveItemStateInput): DerivedState;
+export declare const buildPhase = "build";
+export {};

package/dist/{live-levers.d.ts → items/live-levers.d.ts}

@@ -1,2 +1,2 @@
-import type { Instant, LeverRow } from './types/core.ts';
+import type { Instant, LeverRow } from '../types.ts';
 export declare function liveLevers(levers: readonly LeverRow[], now: Instant): LeverRow[];

package/dist/items/types.d.ts

@@ -0,0 +1,12 @@
+import type { AttemptRow, ItemRow, ItemView, LeaseRow, LeverRow, PullRequestRow, RelationRow } from '../types.ts';
+export interface ItemSetRows {
+    readonly items: readonly ItemRow[];
+    readonly relations: readonly RelationRow[];
+    readonly levers: readonly LeverRow[];
+    readonly attempts: readonly AttemptRow[];
+    readonly liveLeases: readonly LeaseRow[];
+    readonly pullRequests: readonly PullRequestRow[];
+}
+export interface ItemWithLevers extends ItemView {
+    readonly levers: readonly LeverRow[];
+}

package/dist/pipeline/advance.d.ts

@@ -0,0 +1,10 @@
+import type { Pipeline } from '../rules/types.ts';
+import type { Position, Settled } from './types.ts';
+interface AdvanceInput {
+    readonly pipeline: Pipeline;
+    readonly settled: Settled;
+    readonly counted: readonly Settled[];
+    readonly round: number;
+}
+export declare function advance(input: AdvanceInput): Position;
+export {};

package/dist/pipeline/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const engineOutcomes: readonly ["lost", "unsettleable"];
+export declare const engineHoldReasons: readonly ["attempts used up", "rounds used up", "outcome not in rules"];

package/dist/pipeline/count-trailing.d.ts

@@ -0,0 +1 @@
+export declare function countTrailing<T>(list: readonly T[], test: (item: T) => boolean): number;

package/dist/pipeline/find-position.d.ts

@@ -0,0 +1,9 @@
+import type { Pipeline } from '../rules/types.ts';
+import type { Position, RetryLever, Settled } from './types.ts';
+interface FindPositionInput {
+    readonly pipeline: Pipeline | null;
+    readonly attempts: readonly Settled[];
+    readonly retries: readonly RetryLever[];
+}
+export declare function findPosition(input: FindPositionInput): Position;
+export {};

package/dist/pipeline/find-step.d.ts

@@ -0,0 +1,3 @@
+import type { Pipeline, PipelineStep } from '../rules/types.ts';
+import type { PhaseName } from '../types.ts';
+export declare function findStep(pipeline: Pipeline, phase: PhaseName): PipelineStep | undefined;

package/dist/pipeline/merge-by-time.d.ts

@@ -0,0 +1,9 @@
+import type { RetryLever, Settled } from './types.ts';
+export type TimedEvent = {
+    readonly kind: 'settled';
+    readonly settled: Settled;
+} | {
+    readonly kind: 'retry';
+    readonly lever: RetryLever;
+};
+export declare function mergeByTime(attempts: readonly Settled[], retries: readonly RetryLever[]): TimedEvent[];

package/dist/pipeline/position-schema.d.ts

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

package/dist/pipeline/types.d.ts

@@ -0,0 +1,28 @@
+import type { z } from 'zod';
+import type { brandSchemas } from '../rows/brand-schemas.ts';
+import type { Instant, PhaseName } from '../types.ts';
+export type Position = {
+    readonly kind: 'phase';
+    readonly phase: PhaseName;
+    readonly round: number;
+} | {
+    readonly kind: 'end';
+    readonly reason: string;
+} | {
+    readonly kind: 'hold';
+    readonly reason: HoldReason;
+    readonly then: PhaseName;
+    readonly round: number;
+};
+export type HoldReason = 'attempts used up' | 'rounds used up' | 'outcome not in rules' | RulesHoldReason;
+export type RulesHoldReason = z.output<typeof brandSchemas.rulesHoldReason>;
+export interface Settled {
+    readonly phase: PhaseName;
+    readonly outcome: string;
+    readonly endedAt: Instant;
+    readonly failure?: string | null;
+}
+export interface RetryLever {
+    readonly at: Instant;
+    readonly phase: PhaseName | null;
+}

package/dist/planning/define-admission.d.ts

@@ -0,0 +1,3 @@
+import type { Registered } from '../rules/types.ts';
+import type { Admission } from './types.ts';
+export declare function defineAdmission<P>(admission: Admission<P>): Registered<'admission'>;

package/dist/planning/define-gate.d.ts

@@ -0,0 +1,3 @@
+import type { Registered } from '../rules/types.ts';
+import type { Gate } from './types.ts';
+export declare function defineGate<P>(gate: Gate<P>): Registered<'gate'>;

package/dist/planning/define-signal.d.ts

@@ -0,0 +1,3 @@
+import type { Registered } from '../rules/types.ts';
+import type { Signal } from './types.ts';
+export declare function defineSignal<P>(signal: Signal<P>): Registered<'signal'>;

package/dist/planning/is-filter-match.d.ts

@@ -0,0 +1,3 @@
+import type { FieldValues } from '../types.ts';
+import type { Filter } from './types.ts';
+export declare function isFilterMatch(filter: Filter, fields: FieldValues): boolean;

package/dist/planning/limit-fill-schema.d.ts

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

package/dist/{signal-key.d.ts → planning/signal-key.d.ts}

@@ -1,3 +1,3 @@
 import type { JsonValue } from '@boxxy/content-hash';
-import type { SignalKey, SignalName } from './types/planning.ts';
+import type { SignalKey, SignalName } from './types.ts';
 export declare function signalKey(name: SignalName, params: JsonValue): SignalKey;