@knpkv/herdr-work 0.5.3 → 0.7.0

package/dist/model.d.ts

@@ -9,8 +9,10 @@ export declare const WorkLaneOperationId: Schema.String;
 export type WorkLaneOperationId = typeof WorkLaneOperationId.Type;
 export declare const WorkCoordinatorSessionId: Schema.String;
 export type WorkCoordinatorSessionId = typeof WorkCoordinatorSessionId.Type;
-export declare const WorkState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+export declare const WorkState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
 export type WorkState = typeof WorkState.Type;
+/** A goal in one of these states is finished: nothing may bind to it, link it, or move it back. */
+export declare const isTerminalWorkState: (state: WorkState) => boolean;
 export declare const DeliveryStage: Schema.Literals<readonly ["local", "review", "pull_request", "merged", "deployed"]>;
 export type DeliveryStage = typeof DeliveryStage.Type;
 export declare const WorkOwner: Schema.Struct<{
@@ -110,7 +112,7 @@ export declare const WorkGoal: Schema.Struct<{
     readonly title: Schema.String;
     readonly summary: Schema.String;
     readonly detail: Schema.String;
-    readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+    readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
     readonly owner: Schema.Struct<{
         readonly id: Schema.String;
         readonly name: Schema.String;
@@ -193,7 +195,7 @@ export declare const WorkGoalFamilyGroup: Schema.Struct<{
         readonly title: Schema.String;
         readonly summary: Schema.String;
         readonly detail: Schema.String;
-        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
         readonly owner: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
@@ -272,7 +274,7 @@ export declare const WorkGoalFamilyGroup: Schema.Struct<{
         readonly title: Schema.String;
         readonly summary: Schema.String;
         readonly detail: Schema.String;
-        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
         readonly owner: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
@@ -358,7 +360,7 @@ export declare const WorkGoalCheckpoint: Schema.Struct<{
         readonly title: Schema.String;
         readonly summary: Schema.String;
         readonly detail: Schema.String;
-        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
         readonly owner: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
@@ -563,6 +565,19 @@ export declare const WorkAgentBindingRequest: Schema.Struct<{
         readonly approvalJobId: Schema.String;
         readonly approvalActor: Schema.String;
     }>>;
+    /**
+     * Set when the reconciler admitted an observed worker without an approval:
+     * the same evidence as a prospective admission, credited to the observation
+     * that showed it.
+     */
+    readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+        readonly sessionId: Schema.String;
+        readonly workAssignment: Schema.String;
+        readonly baseHead: Schema.String;
+        readonly expectedAbsenceToken: Schema.String;
+        readonly actor: Schema.Literal<"reconciler">;
+        readonly observationId: Schema.String;
+    }>>;
     readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
         readonly sessionId: Schema.String;
         readonly workAssignment: Schema.String;
@@ -588,6 +603,12 @@ export declare const WorkAgentBindingRequest: Schema.Struct<{
 }>;
 export interface WorkAgentBindingRequest extends Schema.Schema.Type<typeof WorkAgentBindingRequest> {
 }
+/**
+ * The admission evidence a binding was created with, whether an approved job
+ * (`prospectiveAdmission`) or the reconciler (`observedAdmission`) admitted it.
+ * Session, assignment and base-head checks read it so both kinds behave alike.
+ */
+export declare const admissionEvidence: (request: WorkAgentBindingRequest) => WorkAgentBindingRequest["prospectiveAdmission"] | WorkAgentBindingRequest["observedAdmission"];
 /** Durable result of atomically binding a started worker to its Work goal. */
 export declare const WorkAgentBinding: Schema.Struct<{
     readonly version: Schema.Literal<"herdr.work.agent-binding.v1">;
@@ -614,6 +635,19 @@ export declare const WorkAgentBinding: Schema.Struct<{
             readonly approvalJobId: Schema.String;
             readonly approvalActor: Schema.String;
         }>>;
+        /**
+         * Set when the reconciler admitted an observed worker without an approval:
+         * the same evidence as a prospective admission, credited to the observation
+         * that showed it.
+         */
+        readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+            readonly sessionId: Schema.String;
+            readonly workAssignment: Schema.String;
+            readonly baseHead: Schema.String;
+            readonly expectedAbsenceToken: Schema.String;
+            readonly actor: Schema.Literal<"reconciler">;
+            readonly observationId: Schema.String;
+        }>>;
         readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
             readonly sessionId: Schema.String;
             readonly workAssignment: Schema.String;
@@ -684,7 +718,7 @@ export declare const WorkAgentBinding: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -784,7 +818,7 @@ export declare const WorkPullRequestLink: Schema.Struct<{
         readonly title: Schema.String;
         readonly summary: Schema.String;
         readonly detail: Schema.String;
-        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
         readonly owner: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
@@ -921,6 +955,19 @@ export declare const WorkPullRequestLink: Schema.Struct<{
                 readonly approvalJobId: Schema.String;
                 readonly approvalActor: Schema.String;
             }>>;
+            /**
+             * Set when the reconciler admitted an observed worker without an approval:
+             * the same evidence as a prospective admission, credited to the observation
+             * that showed it.
+             */
+            readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+                readonly sessionId: Schema.String;
+                readonly workAssignment: Schema.String;
+                readonly baseHead: Schema.String;
+                readonly expectedAbsenceToken: Schema.String;
+                readonly actor: Schema.Literal<"reconciler">;
+                readonly observationId: Schema.String;
+            }>>;
             readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
                 readonly sessionId: Schema.String;
                 readonly workAssignment: Schema.String;
@@ -991,7 +1038,7 @@ export declare const WorkPullRequestLink: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -1204,7 +1251,7 @@ export declare const WorkAdmissionPreflight: Schema.TaggedUnion<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -1341,6 +1388,19 @@ export declare const WorkAdmissionPreflight: Schema.TaggedUnion<{
                         readonly approvalJobId: Schema.String;
                         readonly approvalActor: Schema.String;
                     }>>;
+                    /**
+                     * Set when the reconciler admitted an observed worker without an approval:
+                     * the same evidence as a prospective admission, credited to the observation
+                     * that showed it.
+                     */
+                    readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+                        readonly sessionId: Schema.String;
+                        readonly workAssignment: Schema.String;
+                        readonly baseHead: Schema.String;
+                        readonly expectedAbsenceToken: Schema.String;
+                        readonly actor: Schema.Literal<"reconciler">;
+                        readonly observationId: Schema.String;
+                    }>>;
                     readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
                         readonly sessionId: Schema.String;
                         readonly workAssignment: Schema.String;
@@ -1411,7 +1471,7 @@ export declare const WorkAdmissionPreflight: Schema.TaggedUnion<{
                         readonly title: Schema.String;
                         readonly summary: Schema.String;
                         readonly detail: Schema.String;
-                        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                         readonly owner: Schema.Struct<{
                             readonly id: Schema.String;
                             readonly name: Schema.String;
@@ -1558,6 +1618,48 @@ export declare const WorkProspectiveAdmission: Schema.Struct<{
     readonly approvalActor: Schema.String;
 }>;
 export type WorkProspectiveAdmission = typeof WorkProspectiveAdmission.Type;
+/**
+ * An admission the reconciler makes without an approval, for a worker it
+ * observed: the same fields as an approved admission, with the observation in
+ * place of the job. The caller (hostd) has already checked what the store can't
+ * see: the pane is on this host with lineage, and its worktree is the canonical
+ * toplevel on the PR branch at the PR head with an origin equal to the PR's
+ * repository. The store re-checks the absence evidence in its transaction.
+ */
+export declare const WorkObservedAdmission: Schema.Struct<{
+    readonly repository: Schema.String;
+    readonly pullRequest: Schema.Number;
+    readonly reviewUrl: Schema.String;
+    readonly goalId: Schema.String;
+    readonly laneId: Schema.String;
+    readonly operationId: Schema.String;
+    readonly expectedAbsenceToken: Schema.String;
+    readonly head: Schema.String;
+    readonly baseHead: Schema.String;
+    readonly owner: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+    }>;
+    readonly sessionId: Schema.String;
+    readonly expectedWork: Schema.String;
+    readonly worker: Schema.Struct<{
+        readonly host: Schema.String;
+        readonly agentId: Schema.String;
+        readonly name: Schema.String;
+        readonly paneId: Schema.String;
+        readonly relationship: Schema.optionalKey<Schema.Struct<{
+            readonly parentAgentId: Schema.String;
+            readonly relation: Schema.Literals<readonly ["delegated", "pair", "review"]>;
+        }>>;
+    }>;
+    readonly worktree: Schema.String;
+    readonly branch: Schema.String;
+    readonly title: Schema.String;
+    readonly summary: Schema.String;
+    readonly detail: Schema.String;
+    readonly observationId: Schema.String;
+}>;
+export type WorkObservedAdmission = typeof WorkObservedAdmission.Type;
 /** Read-only evidence for a genuine, existing unlinked canonical goal. */
 export declare const WorkRecoveryTarget: Schema.Struct<{
     readonly repository: Schema.String;
@@ -1673,7 +1775,7 @@ export declare const WorkRecoveryPreflight: Schema.TaggedUnion<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -1810,6 +1912,19 @@ export declare const WorkRecoveryPreflight: Schema.TaggedUnion<{
                         readonly approvalJobId: Schema.String;
                         readonly approvalActor: Schema.String;
                     }>>;
+                    /**
+                     * Set when the reconciler admitted an observed worker without an approval:
+                     * the same evidence as a prospective admission, credited to the observation
+                     * that showed it.
+                     */
+                    readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+                        readonly sessionId: Schema.String;
+                        readonly workAssignment: Schema.String;
+                        readonly baseHead: Schema.String;
+                        readonly expectedAbsenceToken: Schema.String;
+                        readonly actor: Schema.Literal<"reconciler">;
+                        readonly observationId: Schema.String;
+                    }>>;
                     readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
                         readonly sessionId: Schema.String;
                         readonly workAssignment: Schema.String;
@@ -1880,7 +1995,7 @@ export declare const WorkRecoveryPreflight: Schema.TaggedUnion<{
                         readonly title: Schema.String;
                         readonly summary: Schema.String;
                         readonly detail: Schema.String;
-                        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                         readonly owner: Schema.Struct<{
                             readonly id: Schema.String;
                             readonly name: Schema.String;
@@ -2032,6 +2147,129 @@ export declare const WorkExistingGoalRecovery: Schema.Struct<{
 }>;
 export type WorkExistingGoalRecovery = typeof WorkExistingGoalRecovery.Type;
 /** The approved Fleet job supplies actor, job identity, and immutable hash. */
+/** An approved `work.abandon` job, with the approval the Fleet service persisted. */
+export declare const WorkGoalAbandonment: Schema.Struct<{
+    readonly kind: Schema.Literal<"work.abandon">;
+    readonly goalId: Schema.String;
+    readonly owner: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+    }>;
+    readonly reason: Schema.String;
+    readonly expectedGoalEventId: Schema.String;
+    readonly expectedGoalUpdatedAt: Schema.Number;
+    readonly approvalJobId: Schema.String;
+    readonly approvalActor: Schema.String;
+    readonly approvalApprovedBy: Schema.String;
+    readonly approvalApprovedAt: Schema.Number;
+    readonly approvalHash: Schema.String;
+}>;
+export type WorkGoalAbandonment = typeof WorkGoalAbandonment.Type;
+/** Durable result of one abandonment: its checkpoint, identified by the approval job id. */
+export declare const WorkGoalAbandoned: Schema.Struct<{
+    readonly abandonment: Schema.Struct<{
+        readonly kind: Schema.Literal<"work.abandon">;
+        readonly goalId: Schema.String;
+        readonly owner: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+        }>;
+        readonly reason: Schema.String;
+        readonly expectedGoalEventId: Schema.String;
+        readonly expectedGoalUpdatedAt: Schema.Number;
+        readonly approvalJobId: Schema.String;
+        readonly approvalActor: Schema.String;
+        readonly approvalApprovedBy: Schema.String;
+        readonly approvalApprovedAt: Schema.Number;
+        readonly approvalHash: Schema.String;
+    }>;
+    readonly checkpoint: Schema.Struct<{
+        readonly version: Schema.Literal<"herdr.work.event.v1">;
+        readonly eventId: Schema.String;
+        readonly occurredAt: Schema.Number;
+        readonly goal: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly title: Schema.String;
+            readonly summary: Schema.String;
+            readonly detail: Schema.String;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+            readonly owner: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+            }>;
+            readonly repository: Schema.Struct<{
+                readonly repository: Schema.String;
+                readonly branch: Schema.String;
+            }>;
+            readonly spend: Schema.NullOr<Schema.Struct<{
+                readonly currency: Schema.String;
+                readonly minorUnits: Schema.Number;
+            }>>;
+            readonly delivery: Schema.Literals<readonly ["local", "review", "pull_request", "merged", "deployed"]>;
+            readonly blocker: Schema.NullOr<Schema.Struct<{
+                readonly summary: Schema.String;
+                readonly since: Schema.Number;
+            }>>;
+            readonly connectTarget: Schema.NullOr<Schema.Struct<{
+                readonly host: Schema.String;
+                readonly agentId: Schema.String;
+                readonly url: Schema.String;
+            }>>;
+            readonly goalFamily: Schema.optionalKey<Schema.Struct<{
+                readonly canonicalGoalId: Schema.String;
+                readonly role: Schema.Literals<readonly ["canonical", "superseded"]>;
+            }>>;
+            readonly agentHierarchy: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly agent: Schema.Struct<{
+                    readonly host: Schema.String;
+                    readonly agentId: Schema.String;
+                    readonly name: Schema.String;
+                    readonly paneId: Schema.String;
+                    readonly relationship: Schema.optionalKey<Schema.Struct<{
+                        readonly parentAgentId: Schema.String;
+                        readonly relation: Schema.Literals<readonly ["delegated", "pair", "review"]>;
+                    }>>;
+                }>;
+            }>>>;
+            readonly activity: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["note", "status", "blocker", "request", "review", "shipment"]>;
+                readonly summary: Schema.String;
+                readonly occurredAt: Schema.Number;
+            }>>>;
+            readonly blockers: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly summary: Schema.String;
+                readonly since: Schema.Number;
+            }>>>;
+            readonly requests: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly summary: Schema.String;
+                readonly state: Schema.Literals<readonly ["open", "approved", "rejected", "fulfilled"]>;
+                readonly requestedAt: Schema.Number;
+                readonly approvalTarget: Schema.NullOr<Schema.Struct<{
+                    readonly host: Schema.String;
+                    readonly jobId: Schema.String;
+                    readonly url: Schema.String;
+                }>>;
+            }>>>;
+            readonly review: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly updatedAt: Schema.Number;
+                readonly url: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly approvalTarget: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly host: Schema.String;
+                readonly jobId: Schema.String;
+                readonly url: Schema.String;
+            }>>>;
+            readonly createdAt: Schema.Number;
+            readonly updatedAt: Schema.Number;
+        }>;
+    }>;
+}>;
+export interface WorkGoalAbandoned extends Schema.Schema.Type<typeof WorkGoalAbandoned> {
+}
 export declare const WorkGoalReassignment: Schema.Struct<{
     readonly kind: Schema.Literal<"work.reassign">;
     readonly goalId: Schema.String;
@@ -2121,7 +2359,7 @@ export declare const WorkGoalReassigned: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -2259,6 +2497,19 @@ export declare const WorkGoalReassigned: Schema.Struct<{
                 readonly approvalJobId: Schema.String;
                 readonly approvalActor: Schema.String;
             }>>;
+            /**
+             * Set when the reconciler admitted an observed worker without an approval:
+             * the same evidence as a prospective admission, credited to the observation
+             * that showed it.
+             */
+            readonly observedAdmission: Schema.optionalKey<Schema.Struct<{
+                readonly sessionId: Schema.String;
+                readonly workAssignment: Schema.String;
+                readonly baseHead: Schema.String;
+                readonly expectedAbsenceToken: Schema.String;
+                readonly actor: Schema.Literal<"reconciler">;
+                readonly observationId: Schema.String;
+            }>>;
             readonly existingGoalRecovery: Schema.optionalKey<Schema.Struct<{
                 readonly sessionId: Schema.String;
                 readonly workAssignment: Schema.String;
@@ -2329,7 +2580,7 @@ export declare const WorkGoalReassigned: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -2485,6 +2736,335 @@ export declare const WorkDispatchHandoff: Schema.Struct<{
 }>;
 export interface WorkDispatchHandoff extends Schema.Schema.Type<typeof WorkDispatchHandoff> {
 }
+/**
+ * The key one subject's facts and failures are stored under, such as
+ * `github:<owner>/<repo>#<n>` or `herdr:<host>/<agentId>`. Composite, so it is
+ * bounded on its own rather than by `Identifier`.
+ */
+export declare const WorkObservationSubject: Schema.String;
+/** CI status of a pull request's head, rolled up from its check runs and statuses. */
+export declare const WorkObservedChecks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+export type WorkObservedChecks = typeof WorkObservedChecks.Type;
+/** A pull request as GitHub reported it. Facts only; never approval to act on it. */
+export declare const WorkPullRequestObservation: Schema.Struct<{
+    readonly _tag: Schema.tag<"pull_request">;
+    readonly repository: Schema.String;
+    readonly pullRequest: Schema.Number;
+    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+    readonly branch: Schema.String;
+    readonly head: Schema.String;
+    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+}>;
+export interface WorkPullRequestObservation extends Schema.Schema.Type<typeof WorkPullRequestObservation> {
+}
+/** An agent pane as Herdr reported it; `gone` means the pane is no longer in the host's snapshot. */
+export declare const WorkAgentObservation: Schema.TaggedStruct<"agent", {
+    readonly host: Schema.String;
+    readonly agentId: Schema.String;
+    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+}>;
+export interface WorkAgentObservation extends Schema.Schema.Type<typeof WorkAgentObservation> {
+}
+/** A source that could not be read. It is reported, never turned into a fact about a goal. */
+export declare const WorkUnknownObservation: Schema.TaggedStruct<"unknown", {
+    readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+    readonly subject: Schema.String;
+    readonly reason: Schema.String;
+}>;
+export interface WorkUnknownObservation extends Schema.Schema.Type<typeof WorkUnknownObservation> {
+}
+export declare const WorkObservation: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"pull_request">;
+    readonly repository: Schema.String;
+    readonly pullRequest: Schema.Number;
+    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+    readonly branch: Schema.String;
+    readonly head: Schema.String;
+    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+}>, Schema.TaggedStruct<"agent", {
+    readonly host: Schema.String;
+    readonly agentId: Schema.String;
+    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+}>, Schema.TaggedStruct<"unknown", {
+    readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+    readonly subject: Schema.String;
+    readonly reason: Schema.String;
+}>]>;
+export type WorkObservation = typeof WorkObservation.Type;
+/** One observation and when it was made. Observing the same facts again is a no-op. */
+export declare const WorkObservationEnvelope: Schema.Struct<{
+    readonly observation: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"pull_request">;
+        readonly repository: Schema.String;
+        readonly pullRequest: Schema.Number;
+        readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+        readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+        readonly closedAt: Schema.NullOr<Schema.Number>;
+    }>, Schema.TaggedStruct<"agent", {
+        readonly host: Schema.String;
+        readonly agentId: Schema.String;
+        readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+    }>, Schema.TaggedStruct<"unknown", {
+        readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+        readonly subject: Schema.String;
+        readonly reason: Schema.String;
+    }>]>;
+    readonly observedAt: Schema.Number;
+}>;
+export interface WorkObservationEnvelope extends Schema.Schema.Type<typeof WorkObservationEnvelope> {
+}
+/**
+ * A stored observation's id, and what `reconcile` accepts as confirmation of
+ * it: lowercase hex of the SHA-256 of the UTF-8 bytes persisted in
+ * `work_observed_facts.record`. That record is the JSON of the encoded
+ * observation alone (a pull request's or an agent's fields, in schema field
+ * order) with its case-insensitive identity, the repository or host,
+ * ASCII-lowercased. `observedAt` is not an input, so the same facts read again
+ * keep their id.
+ */
+export declare const WorkObservationId: Schema.brand<Schema.String, "WorkObservationId">;
+export type WorkObservationId = typeof WorkObservationId.Type;
+/**
+ * The latest stored fact for one subject. `observedAt` is when these exact
+ * facts were first seen, so for a `gone` agent it is the time it went away;
+ * `confirmedAt` is the last time a read returned them again.
+ */
+export declare const WorkObservedFact: Schema.Struct<{
+    readonly subject: Schema.String;
+    readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+    readonly observedAt: Schema.Number;
+    readonly confirmedAt: Schema.Number;
+    readonly observation: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"pull_request">;
+        readonly repository: Schema.String;
+        readonly pullRequest: Schema.Number;
+        readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+        readonly branch: Schema.String;
+        readonly head: Schema.String;
+        readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+        readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+        readonly closedAt: Schema.NullOr<Schema.Number>;
+    }>, Schema.TaggedStruct<"agent", {
+        readonly host: Schema.String;
+        readonly agentId: Schema.String;
+        readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+    }>]>;
+}>;
+export interface WorkObservedFact extends Schema.Schema.Type<typeof WorkObservedFact> {
+}
+/**
+ * The current run of failed reads for one subject. `since` is the first
+ * failure of the run; a later failure keeps it, a good read newer than every
+ * failure ends the run, and a good read inside it restarts the run at its
+ * latest failure.
+ */
+export declare const WorkObservedFailure: Schema.Struct<{
+    readonly subject: Schema.String;
+    readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+    readonly reason: Schema.String;
+    readonly since: Schema.Number;
+    /** The latest failed read of the run; `source` and `reason` are from it. */
+    readonly lastAt: Schema.Number;
+}>;
+export interface WorkObservedFailure extends Schema.Schema.Type<typeof WorkObservedFailure> {
+}
+/** The overlay keeps one latest fact per subject, within its own bounds; over them, the oldest facts go first. */
+/** How far ahead of the store's clock an observation may be stamped before it is skipped as stale. */
+export declare const workObservationMaxSkewMillis: number;
+export declare const workObservedFactMaxRecords = 4096;
+export declare const workObservedFactMaxBytes: number;
+/**
+ * What `observe` did with one envelope: stored a new fact, found the same
+ * facts already stored, skipped it as older than the stored fact, or reported
+ * a source it could not read.
+ */
+export declare const WorkObserveOutcome: Schema.TaggedUnion<{
+    readonly stale: Schema.TaggedStruct<"stale", {
+        readonly subject: Schema.String;
+    }>;
+    readonly stored: Schema.TaggedStruct<"stored", {
+        readonly subject: Schema.String;
+        readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+    }>;
+    readonly unchanged: Schema.TaggedStruct<"unchanged", {
+        readonly subject: Schema.String;
+        readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+    }>;
+    readonly unknown: Schema.TaggedStruct<"unknown", {
+        readonly subject: Schema.String;
+        readonly reason: Schema.String;
+    }>;
+}>;
+export type WorkObserveOutcome = typeof WorkObserveOutcome.Type;
+export declare const WorkObserveReport: Schema.Struct<{
+    readonly outcomes: Schema.$Array<Schema.TaggedUnion<{
+        readonly stale: Schema.TaggedStruct<"stale", {
+            readonly subject: Schema.String;
+        }>;
+        readonly stored: Schema.TaggedStruct<"stored", {
+            readonly subject: Schema.String;
+            readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+        }>;
+        readonly unchanged: Schema.TaggedStruct<"unchanged", {
+            readonly subject: Schema.String;
+            readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+        }>;
+        readonly unknown: Schema.TaggedStruct<"unknown", {
+            readonly subject: Schema.String;
+            readonly reason: Schema.String;
+        }>;
+    }>>;
+    readonly evicted: Schema.Number;
+}>;
+export interface WorkObserveReport extends Schema.Schema.Type<typeof WorkObserveReport> {
+}
+/** History the reconciler always leaves free for owners and approvals. */
+export declare const workReconcilerHeadroom = 256;
+/**
+ * What `reconcile` did for one goal whose pull request is observed merged or
+ * closed: recorded it as finished, found it already recorded once by the
+ * reconciler (it never stamps a goal twice, even after an owner reopens it),
+ * or found a newer owner checkpoint than the one it planned from (it tries
+ * again on the next run).
+ */
+/**
+ * What `reconcile` may act on: `confirmed` lists the pull request facts the
+ * caller has just read and the store accepted, the `subject` and
+ * `observationId` of each `stored` or `unchanged` outcome from that `observe`.
+ * A read refused as stale, or one that failed, confirms nothing, so a fact
+ * stored earlier (the pull request may since have reopened) is never acted on.
+ */
+export declare const WorkReconcileOptions: Schema.Struct<{
+    readonly confirmed: Schema.$Array<Schema.Struct<{
+        readonly subject: Schema.String;
+        readonly observationId: Schema.brand<Schema.String, "WorkObservationId">;
+    }>>;
+}>;
+export interface WorkReconcileOptions extends Schema.Schema.Type<typeof WorkReconcileOptions> {
+}
+export declare const WorkReconcileOutcome: Schema.TaggedUnion<{
+    readonly applied: Schema.TaggedStruct<"applied", {
+        readonly goalId: Schema.String;
+        readonly eventId: Schema.String;
+        readonly state: Schema.Literals<readonly ["completed", "abandoned"]>;
+    }>;
+    readonly conflict: Schema.TaggedStruct<"conflict", {
+        readonly goalId: Schema.String;
+    }>;
+    readonly recorded: Schema.TaggedStruct<"recorded", {
+        readonly goalId: Schema.String;
+        readonly eventId: Schema.String;
+    }>;
+}>;
+export type WorkReconcileOutcome = typeof WorkReconcileOutcome.Type;
+/** What the Work tab shows for a goal: its recorded state, or a newer observed one. */
+export declare const WorkDisplayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+export type WorkDisplayState = typeof WorkDisplayState.Type;
+/** Observed facts overlaid on one goal at read time. Nothing here is goal history. */
+export declare const WorkGoalObserved: Schema.Struct<{
+    readonly pullRequest: Schema.NullOr<Schema.Struct<{
+        readonly fact: Schema.Struct<{
+            readonly _tag: Schema.tag<"pull_request">;
+            readonly repository: Schema.String;
+            readonly pullRequest: Schema.Number;
+            readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+            readonly branch: Schema.String;
+            readonly head: Schema.String;
+            readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+            readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+            readonly closedAt: Schema.NullOr<Schema.Number>;
+        }>;
+        readonly observedAt: Schema.Number;
+        readonly confirmedAt: Schema.Number;
+    }>>;
+    readonly agent: Schema.NullOr<Schema.Struct<{
+        readonly fact: Schema.TaggedStruct<"agent", {
+            readonly host: Schema.String;
+            readonly agentId: Schema.String;
+            readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+        }>;
+        readonly observedAt: Schema.Number;
+        readonly confirmedAt: Schema.Number;
+    }>>;
+    /**
+     * A source that can't currently be read for this goal; the oldest failing
+     * run when both its pull request and its agent fail. `lastGoodAt` is when
+     * that subject last read successfully, null if it never has. A goal with no
+     * pull request URL or no agent has no subject there, so no failure either.
+     */
+    readonly unknown: Schema.NullOr<Schema.Struct<{
+        readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+        readonly reason: Schema.String;
+        readonly since: Schema.Number;
+        readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+    }>>;
+    readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+    readonly stale: Schema.Boolean;
+}>;
+export interface WorkGoalObserved extends Schema.Schema.Type<typeof WorkGoalObserved> {
+}
+export declare const WorkGoalObservedEntry: Schema.Struct<{
+    readonly pullRequest: Schema.NullOr<Schema.Struct<{
+        readonly fact: Schema.Struct<{
+            readonly _tag: Schema.tag<"pull_request">;
+            readonly repository: Schema.String;
+            readonly pullRequest: Schema.Number;
+            readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+            readonly branch: Schema.String;
+            readonly head: Schema.String;
+            readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+            readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+            readonly closedAt: Schema.NullOr<Schema.Number>;
+        }>;
+        readonly observedAt: Schema.Number;
+        readonly confirmedAt: Schema.Number;
+    }>>;
+    readonly agent: Schema.NullOr<Schema.Struct<{
+        readonly fact: Schema.TaggedStruct<"agent", {
+            readonly host: Schema.String;
+            readonly agentId: Schema.String;
+            readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+        }>;
+        readonly observedAt: Schema.Number;
+        readonly confirmedAt: Schema.Number;
+    }>>;
+    /**
+     * A source that can't currently be read for this goal; the oldest failing
+     * run when both its pull request and its agent fail. `lastGoodAt` is when
+     * that subject last read successfully, null if it never has. A goal with no
+     * pull request URL or no agent has no subject there, so no failure either.
+     */
+    readonly unknown: Schema.NullOr<Schema.Struct<{
+        readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+        readonly reason: Schema.String;
+        readonly since: Schema.Number;
+        readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+    }>>;
+    readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+    readonly stale: Schema.Boolean;
+    readonly goalId: Schema.String;
+}>;
+export interface WorkGoalObservedEntry extends Schema.Schema.Type<typeof WorkGoalObservedEntry> {
+}
+/**
+ * Who wrote one goal activity, when it was not the goal's owner: the
+ * reconciler (from an observed fact) or an approved Fleet job.
+ */
+export declare const WorkActivityProvenance: Schema.Struct<{
+    readonly goalId: Schema.String;
+    readonly activityId: Schema.String;
+    readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+    readonly approvalJobId: Schema.NullOr<Schema.String>;
+}>;
+export interface WorkActivityProvenance extends Schema.Schema.Type<typeof WorkActivityProvenance> {
+}
 export declare const WorkSnapshotWindow: Schema.Literals<readonly ["now", "day", "week", "month"]>;
 export type WorkSnapshotWindow = typeof WorkSnapshotWindow.Type;
 export declare const WorkSnapshot: Schema.Struct<{
@@ -2496,7 +3076,7 @@ export declare const WorkSnapshot: Schema.Struct<{
         readonly title: Schema.String;
         readonly summary: Schema.String;
         readonly detail: Schema.String;
-        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+        readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
         readonly owner: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
@@ -2577,7 +3157,7 @@ export declare const WorkSnapshot: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -2656,7 +3236,7 @@ export declare const WorkSnapshot: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -2731,6 +3311,72 @@ export declare const WorkSnapshot: Schema.Struct<{
             readonly updatedAt: Schema.Number;
         }>>;
     }>>>;
+    /**
+     * Observed facts per goal, merged at read time; only the `now` window
+     * carries them, and only for goals something was observed about.
+     */
+    readonly observed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly pullRequest: Schema.NullOr<Schema.Struct<{
+            readonly fact: Schema.Struct<{
+                readonly _tag: Schema.tag<"pull_request">;
+                readonly repository: Schema.String;
+                readonly pullRequest: Schema.Number;
+                readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+                readonly branch: Schema.String;
+                readonly head: Schema.String;
+                readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+                readonly closedAt: Schema.NullOr<Schema.Number>;
+            }>;
+            readonly observedAt: Schema.Number;
+            readonly confirmedAt: Schema.Number;
+        }>>;
+        readonly agent: Schema.NullOr<Schema.Struct<{
+            readonly fact: Schema.TaggedStruct<"agent", {
+                readonly host: Schema.String;
+                readonly agentId: Schema.String;
+                readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+            }>;
+            readonly observedAt: Schema.Number;
+            readonly confirmedAt: Schema.Number;
+        }>>;
+        /**
+         * A source that can't currently be read for this goal; the oldest failing
+         * run when both its pull request and its agent fail. `lastGoodAt` is when
+         * that subject last read successfully, null if it never has. A goal with no
+         * pull request URL or no agent has no subject there, so no failure either.
+         */
+        readonly unknown: Schema.NullOr<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+            readonly reason: Schema.String;
+            readonly since: Schema.Number;
+            readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+        }>>;
+        readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+        readonly stale: Schema.Boolean;
+        readonly goalId: Schema.String;
+    }>>>;
+    /**
+     * How many goals' observed entries were left out to keep the snapshot within
+     * the response budget; the most recently updated goals keep theirs.
+     */
+    readonly observedOmitted: Schema.optionalKey<Schema.Number>;
+    /** Activities written by the reconciler or an approved job; only on `now`. */
+    readonly activityProvenance: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly goalId: Schema.String;
+        readonly activityId: Schema.String;
+        readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+        readonly approvalJobId: Schema.NullOr<Schema.String>;
+    }>>>;
+    /**
+     * Goals whose non-owner activities are all in `activityProvenance`. In a
+     * covered goal an activity missing from it is the owner's; a goal that isn't
+     * covered has unknown provenance. Trimming to the response budget drops
+     * whole goals, never single activities.
+     */
+    readonly activityProvenanceGoals: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    /** How many goals were left uncovered to keep the snapshot within the response budget. */
+    readonly activityProvenanceOmitted: Schema.optionalKey<Schema.Number>;
 }>;
 export interface WorkSnapshot extends Schema.Schema.Type<typeof WorkSnapshot> {
 }
@@ -2745,7 +3391,7 @@ export declare const WorkSnapshots: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -2826,7 +3472,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -2905,7 +3551,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -2980,6 +3626,72 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly updatedAt: Schema.Number;
             }>>;
         }>>>;
+        /**
+         * Observed facts per goal, merged at read time; only the `now` window
+         * carries them, and only for goals something was observed about.
+         */
+        readonly observed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly pullRequest: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.Struct<{
+                    readonly _tag: Schema.tag<"pull_request">;
+                    readonly repository: Schema.String;
+                    readonly pullRequest: Schema.Number;
+                    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+                    readonly branch: Schema.String;
+                    readonly head: Schema.String;
+                    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+                    readonly closedAt: Schema.NullOr<Schema.Number>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            readonly agent: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.TaggedStruct<"agent", {
+                    readonly host: Schema.String;
+                    readonly agentId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            /**
+             * A source that can't currently be read for this goal; the oldest failing
+             * run when both its pull request and its agent fail. `lastGoodAt` is when
+             * that subject last read successfully, null if it never has. A goal with no
+             * pull request URL or no agent has no subject there, so no failure either.
+             */
+            readonly unknown: Schema.NullOr<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+                readonly reason: Schema.String;
+                readonly since: Schema.Number;
+                readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+            }>>;
+            readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+            readonly stale: Schema.Boolean;
+            readonly goalId: Schema.String;
+        }>>>;
+        /**
+         * How many goals' observed entries were left out to keep the snapshot within
+         * the response budget; the most recently updated goals keep theirs.
+         */
+        readonly observedOmitted: Schema.optionalKey<Schema.Number>;
+        /** Activities written by the reconciler or an approved job; only on `now`. */
+        readonly activityProvenance: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly goalId: Schema.String;
+            readonly activityId: Schema.String;
+            readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+            readonly approvalJobId: Schema.NullOr<Schema.String>;
+        }>>>;
+        /**
+         * Goals whose non-owner activities are all in `activityProvenance`. In a
+         * covered goal an activity missing from it is the owner's; a goal that isn't
+         * covered has unknown provenance. Trimming to the response budget drops
+         * whole goals, never single activities.
+         */
+        readonly activityProvenanceGoals: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** How many goals were left uncovered to keep the snapshot within the response budget. */
+        readonly activityProvenanceOmitted: Schema.optionalKey<Schema.Number>;
     }>;
     readonly day: Schema.Struct<{
         readonly window: Schema.Literals<readonly ["now", "day", "week", "month"]>;
@@ -2990,7 +3702,7 @@ export declare const WorkSnapshots: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -3071,7 +3783,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3150,7 +3862,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3225,6 +3937,72 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly updatedAt: Schema.Number;
             }>>;
         }>>>;
+        /**
+         * Observed facts per goal, merged at read time; only the `now` window
+         * carries them, and only for goals something was observed about.
+         */
+        readonly observed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly pullRequest: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.Struct<{
+                    readonly _tag: Schema.tag<"pull_request">;
+                    readonly repository: Schema.String;
+                    readonly pullRequest: Schema.Number;
+                    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+                    readonly branch: Schema.String;
+                    readonly head: Schema.String;
+                    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+                    readonly closedAt: Schema.NullOr<Schema.Number>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            readonly agent: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.TaggedStruct<"agent", {
+                    readonly host: Schema.String;
+                    readonly agentId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            /**
+             * A source that can't currently be read for this goal; the oldest failing
+             * run when both its pull request and its agent fail. `lastGoodAt` is when
+             * that subject last read successfully, null if it never has. A goal with no
+             * pull request URL or no agent has no subject there, so no failure either.
+             */
+            readonly unknown: Schema.NullOr<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+                readonly reason: Schema.String;
+                readonly since: Schema.Number;
+                readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+            }>>;
+            readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+            readonly stale: Schema.Boolean;
+            readonly goalId: Schema.String;
+        }>>>;
+        /**
+         * How many goals' observed entries were left out to keep the snapshot within
+         * the response budget; the most recently updated goals keep theirs.
+         */
+        readonly observedOmitted: Schema.optionalKey<Schema.Number>;
+        /** Activities written by the reconciler or an approved job; only on `now`. */
+        readonly activityProvenance: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly goalId: Schema.String;
+            readonly activityId: Schema.String;
+            readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+            readonly approvalJobId: Schema.NullOr<Schema.String>;
+        }>>>;
+        /**
+         * Goals whose non-owner activities are all in `activityProvenance`. In a
+         * covered goal an activity missing from it is the owner's; a goal that isn't
+         * covered has unknown provenance. Trimming to the response budget drops
+         * whole goals, never single activities.
+         */
+        readonly activityProvenanceGoals: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** How many goals were left uncovered to keep the snapshot within the response budget. */
+        readonly activityProvenanceOmitted: Schema.optionalKey<Schema.Number>;
     }>;
     readonly week: Schema.Struct<{
         readonly window: Schema.Literals<readonly ["now", "day", "week", "month"]>;
@@ -3235,7 +4013,7 @@ export declare const WorkSnapshots: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -3316,7 +4094,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3395,7 +4173,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3470,6 +4248,72 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly updatedAt: Schema.Number;
             }>>;
         }>>>;
+        /**
+         * Observed facts per goal, merged at read time; only the `now` window
+         * carries them, and only for goals something was observed about.
+         */
+        readonly observed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly pullRequest: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.Struct<{
+                    readonly _tag: Schema.tag<"pull_request">;
+                    readonly repository: Schema.String;
+                    readonly pullRequest: Schema.Number;
+                    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+                    readonly branch: Schema.String;
+                    readonly head: Schema.String;
+                    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+                    readonly closedAt: Schema.NullOr<Schema.Number>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            readonly agent: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.TaggedStruct<"agent", {
+                    readonly host: Schema.String;
+                    readonly agentId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            /**
+             * A source that can't currently be read for this goal; the oldest failing
+             * run when both its pull request and its agent fail. `lastGoodAt` is when
+             * that subject last read successfully, null if it never has. A goal with no
+             * pull request URL or no agent has no subject there, so no failure either.
+             */
+            readonly unknown: Schema.NullOr<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+                readonly reason: Schema.String;
+                readonly since: Schema.Number;
+                readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+            }>>;
+            readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+            readonly stale: Schema.Boolean;
+            readonly goalId: Schema.String;
+        }>>>;
+        /**
+         * How many goals' observed entries were left out to keep the snapshot within
+         * the response budget; the most recently updated goals keep theirs.
+         */
+        readonly observedOmitted: Schema.optionalKey<Schema.Number>;
+        /** Activities written by the reconciler or an approved job; only on `now`. */
+        readonly activityProvenance: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly goalId: Schema.String;
+            readonly activityId: Schema.String;
+            readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+            readonly approvalJobId: Schema.NullOr<Schema.String>;
+        }>>>;
+        /**
+         * Goals whose non-owner activities are all in `activityProvenance`. In a
+         * covered goal an activity missing from it is the owner's; a goal that isn't
+         * covered has unknown provenance. Trimming to the response budget drops
+         * whole goals, never single activities.
+         */
+        readonly activityProvenanceGoals: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** How many goals were left uncovered to keep the snapshot within the response budget. */
+        readonly activityProvenanceOmitted: Schema.optionalKey<Schema.Number>;
     }>;
     readonly month: Schema.Struct<{
         readonly window: Schema.Literals<readonly ["now", "day", "week", "month"]>;
@@ -3480,7 +4324,7 @@ export declare const WorkSnapshots: Schema.Struct<{
             readonly title: Schema.String;
             readonly summary: Schema.String;
             readonly detail: Schema.String;
-            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+            readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
             readonly owner: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly name: Schema.String;
@@ -3561,7 +4405,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3640,7 +4484,7 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly title: Schema.String;
                 readonly summary: Schema.String;
                 readonly detail: Schema.String;
-                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed"]>;
+                readonly state: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
                 readonly owner: Schema.Struct<{
                     readonly id: Schema.String;
                     readonly name: Schema.String;
@@ -3715,6 +4559,72 @@ export declare const WorkSnapshots: Schema.Struct<{
                 readonly updatedAt: Schema.Number;
             }>>;
         }>>>;
+        /**
+         * Observed facts per goal, merged at read time; only the `now` window
+         * carries them, and only for goals something was observed about.
+         */
+        readonly observed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly pullRequest: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.Struct<{
+                    readonly _tag: Schema.tag<"pull_request">;
+                    readonly repository: Schema.String;
+                    readonly pullRequest: Schema.Number;
+                    readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+                    readonly branch: Schema.String;
+                    readonly head: Schema.String;
+                    readonly review: Schema.Literals<readonly ["not_requested", "requested", "changes_requested", "approved"]>;
+                    readonly checks: Schema.Literals<readonly ["none", "pending", "passing", "failing"]>;
+                    readonly closedAt: Schema.NullOr<Schema.Number>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            readonly agent: Schema.NullOr<Schema.Struct<{
+                readonly fact: Schema.TaggedStruct<"agent", {
+                    readonly host: Schema.String;
+                    readonly agentId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["idle", "working", "blocked", "done", "gone"]>;
+                }>;
+                readonly observedAt: Schema.Number;
+                readonly confirmedAt: Schema.Number;
+            }>>;
+            /**
+             * A source that can't currently be read for this goal; the oldest failing
+             * run when both its pull request and its agent fail. `lastGoodAt` is when
+             * that subject last read successfully, null if it never has. A goal with no
+             * pull request URL or no agent has no subject there, so no failure either.
+             */
+            readonly unknown: Schema.NullOr<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["github", "herdr", "git"]>;
+                readonly reason: Schema.String;
+                readonly since: Schema.Number;
+                readonly lastGoodAt: Schema.NullOr<Schema.Number>;
+            }>>;
+            readonly displayState: Schema.Literals<readonly ["planned", "working", "blocked", "review", "deployed", "completed", "abandoned"]>;
+            readonly stale: Schema.Boolean;
+            readonly goalId: Schema.String;
+        }>>>;
+        /**
+         * How many goals' observed entries were left out to keep the snapshot within
+         * the response budget; the most recently updated goals keep theirs.
+         */
+        readonly observedOmitted: Schema.optionalKey<Schema.Number>;
+        /** Activities written by the reconciler or an approved job; only on `now`. */
+        readonly activityProvenance: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly goalId: Schema.String;
+            readonly activityId: Schema.String;
+            readonly provenance: Schema.Literals<readonly ["reconciler", "approval"]>;
+            readonly approvalJobId: Schema.NullOr<Schema.String>;
+        }>>>;
+        /**
+         * Goals whose non-owner activities are all in `activityProvenance`. In a
+         * covered goal an activity missing from it is the owner's; a goal that isn't
+         * covered has unknown provenance. Trimming to the response budget drops
+         * whole goals, never single activities.
+         */
+        readonly activityProvenanceGoals: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** How many goals were left uncovered to keep the snapshot within the response budget. */
+        readonly activityProvenanceOmitted: Schema.optionalKey<Schema.Number>;
     }>;
 }>;
 export interface WorkSnapshots extends Schema.Schema.Type<typeof WorkSnapshots> {