@knpkv/herdr-work 0.11.0 → 0.12.0

package/dist/store.js

@@ -1,9 +1,9 @@
 import { agentConnectTarget, workAbandonActivitySummary, workReassignActivitySummary } from "@knpkv/herdr-fleet";
 import { openPrivateSqlite } from "@knpkv/herdr-fleet/sqlite";
-import { Clock, Crypto, Effect, Equal, Option, Result, Schema } from "effect";
+import { Clock, Crypto, Effect, Equal, Option, Predicate, Result, Schema } from "effect";
 import { Hex } from "effect/encoding";
 import { makeWorkAgentBinding } from "./agent-binding.js";
-import { WorkAdmissionConflictError, WorkAgentBindingAuthorityError, WorkAgentBindingConflictError, WorkCheckpointConflictError, WorkCoordinatorHandoffConflictError, WorkDecisionAuthorityConflictError, WorkDecisionHandoffConflictError, WorkDecisionRevisionConflictError, WorkGoalAbandonmentConflictError, WorkGoalAgentTargetConflictError, WorkGoalBindingRequiresAgentError, WorkGoalLaneActiveError, WorkGoalOwnerMismatchError, WorkGoalReassignmentConflictError, WorkGoalRevisionConflictError, WorkGoalTerminalError, WorkLaneClaimConflictError, WorkLaneGoalConflictError, WorkLaneOperationConflictError, WorkProjectionError, WorkPullRequestLinkError, WorkStoreError, WorkTransactionConflictError } from "./errors.js";
+import { WorkAdmissionConflictError, WorkAgentBindingAuthorityError, WorkAgentBindingConflictError, WorkCheckpointConflictError, WorkCoordinatorHandoffConflictError, WorkDecisionAuthorityConflictError, WorkDecisionHandoffConflictError, WorkDecisionRevisionConflictError, WorkGoalAbandonmentConflictError, WorkGoalAgentTargetConflictError, WorkGoalBindingRequiresAgentError, WorkGoalLaneActiveError, WorkGoalOwnerMismatchError, WorkGoalReassignmentConflictError, WorkGoalRevisionConflictError, WorkGoalTerminalError, WorkLaneClaimConflictError, WorkLaneGoalConflictError, WorkLaneOperationConflictError, WorkProjectionError, WorkPullRequestAttachConflict, WorkPullRequestLinkError, WorkStoreError, WorkTransactionConflictError } from "./errors.js";
 import { validateGoalFamilyHistory } from "./goal-family.js";
 import { agentBindingAdmissionError, workAgentBindingLaneOperationMaxBytes, workAgentBindingLaneOperationMaxRecords } from "./internal/agent-binding-admission.js";
 import { AgentBindingGoalEventRow, AgentBindingLaneOperationRow, agentBindingReadbackError, AgentBindingRow, decodeAgentBindingGoalEvent, decodeAgentBindingRow, laneOperationReadbackError } from "./internal/agent-binding-readback.js";
@@ -13,7 +13,7 @@ import { workHistoryError } from "./internal/history-validation.js";
 import { LaneOperationLedgerRow, LaneOperationTotalsRow, planLegacyLaneOperations, resolveLegacyLaneClaim } from "./internal/legacy-lane-claim.js";
 import { enforcesOneHandoffPerSession, SessionIndexDefinition, sessionIndexDefinitionQuery } from "./internal/session-index.js";
 import { goalActivityLimit, terminalCandidates, terminalCheckpoint, withoutBlockers } from "./internal/terminal-reconcile.js";
-import { admissionEvidence, isTerminalWorkState, WorkAdmissionTarget, WorkAgentBinding, WorkAgentBindingRequest, WorkCoordinatorSessionId, WorkDecisionHandoff, WorkDispatchHandoff, WorkExistingGoalRecovery, WorkGoal, WorkGoalAbandoned, WorkGoalAbandonment, WorkGoalCheckpoint, WorkGoalId, WorkGoalReassigned, WorkGoalReassignment, workHistoryMaxEvents, WorkLaneClaim, WorkLaneClaimed, WorkObservationEnvelope, WorkObservationId, workObservationMaxSkewMillis, WorkObservationSubject, WorkObservedAdmission, WorkObservedFact, workObservedFactMaxBytes, workObservedFactMaxRecords, WorkObservedFailure, WorkProspectiveAdmission, WorkPullRequestLink, WorkReconcileOptions, workReconcilerHeadroom, WorkRecoveryTarget, workSnapshotMaxGoals } from "./model.js";
+import { admissionEvidence, isTerminalWorkState, WorkAdmissionTarget, WorkAgentBinding, WorkAgentBindingRequest, WorkCoordinatorSessionId, WorkDecisionHandoff, WorkDispatchHandoff, WorkExistingGoalRecovery, WorkGoal, WorkGoalAbandoned, WorkGoalAbandonment, WorkGoalCheckpoint, WorkGoalId, WorkGoalReassigned, WorkGoalReassignment, workHistoryMaxEvents, WorkLaneClaim, WorkLaneClaimed, WorkObservationEnvelope, WorkObservationId, workObservationMaxSkewMillis, WorkObservationSubject, WorkObservedAdmission, WorkObservedFact, workObservedFactMaxBytes, workObservedFactMaxRecords, WorkObservedFailure, WorkProspectiveAdmission, WorkPullRequestAttach, WorkPullRequestLink, WorkReconcileOptions, workReconcilerHeadroom, WorkRecoveryTarget, workSnapshotMaxGoals } from "./model.js";
 import { asciiLower, canonicalSubject, observationSubject, reconcilerEventPrefix } from "./observed.js";
 const StoredEventRow = Schema.Struct({ record: Schema.String });
 const StoredEventRows = Schema.Array(StoredEventRow);
@@ -2796,30 +2796,36 @@ export class WorkStore {
         const entries = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ dispatchRequestId: WorkAgentBindingRequest.fields.dispatchRequestId })))(rows).pipe(Effect.mapError(storeError("agent-binding.lane.rows")));
         return entries.map(({ dispatchRequestId }) => dispatchRequestId);
     });
+    /** Builds the checkpoint from the stored head under the append transaction's lock. */
+    attachPullRequest = Effect.fn("WorkStore.attachPullRequest")(function* (input) {
+        const decoded = yield* Schema.decodeUnknownEffect(WorkPullRequestAttach, { onExcessProperty: "error" })(input)
+            .pipe(Effect.mapError(storeError("attachPullRequest.decode")));
+        return yield* this.appendAt(decoded, null).pipe(Effect.catchTag("WorkGoalRevisionConflictError", Effect.die));
+    });
     append = (event) => this.appendAt(event, null).pipe(
-    // Only an expected head can raise it; a plain append never checks one.
-    Effect.catchTag("WorkGoalRevisionConflictError", Effect.die));
-    /**
-     * Appends one checkpoint. With `expectedHead`, the goal's latest checkpoint
-     * must still be that one when the write commits (an exact replay always
-     * succeeds), so a writer that planned from the head cannot bury a newer
-     * owner checkpoint.
-     */
+    // Only guarded writes can raise these; a plain append checks neither.
+    Effect.catchTag(["WorkGoalRevisionConflictError", "WorkPullRequestAttachConflict"], Effect.die));
     /**
-     * Appends one checkpoint. With `mode` `check`, every check runs in the same
-     * transaction and it is rolled back instead of written: the checkpoint is
-     * returned when it would have been appended.
+     * Appends under one transaction. A reconciler guard compares the stored head
+     * and observed fact; an attachment derives its checkpoint from the stored
+     * head after checking the caller's expected event and repository identity.
+     * Same-URL attachments and exact checkpoint replays are no-op successes.
+     * In `check` mode every check runs, then rolls back instead of writing.
      */
     appendAt = Effect.fn("WorkStore.append")(function* (event, guard, mode = "write", 
     // In a check, the checkpoints earlier steps of the same plan would have
     // written: limits are checked as if they were already stored.
     planned = []) {
-        const decoded = yield* Schema.decodeUnknownEffect(WorkGoalCheckpoint)(event).pipe(Effect.mapError(storeError("append.decode")));
+        const decode = "goal" in event
+            ? Schema.decodeUnknownEffect(WorkGoalCheckpoint)(event).pipe(Effect.mapError(storeError("append.decode")))
+            : Schema.decodeUnknownEffect(WorkPullRequestAttach, { onExcessProperty: "error" })(event)
+                .pipe(Effect.mapError(storeError("append.decode")));
+        const input = yield* decode;
         // The reconciler's event and activity ids are its provenance; no other
         // writer may use them.
-        if (guard === null && decoded.eventId.startsWith(reconcilerEventPrefix)) {
+        if (guard === null && input.eventId.startsWith(reconcilerEventPrefix)) {
             return yield* new WorkProjectionError({
-                cause: decoded.eventId,
+                cause: input.eventId,
                 detail: `event ids starting with ${reconcilerEventPrefix} are reserved for the reconciler`,
                 reason: "malformed"
             });
@@ -2837,6 +2843,61 @@ export class WorkStore {
                         transaction = false;
                         return { _tag: "rejected", error };
                     };
+                    const decoded = (() => {
+                        if ("goal" in input)
+                            return input;
+                        const headRow = this.#database.prepare(`SELECT record FROM work_goal_events WHERE goal_id = ?
+               ORDER BY occurred_at DESC, event_id DESC LIMIT 1`).get(input.goalId);
+                        const head = headRow === undefined ? null : Schema.decodeUnknownSync(WorkGoalCheckpoint)(JSON.parse(Schema.decodeUnknownSync(StoredEventRow)(headRow).record));
+                        const conflict = (reason) => new WorkPullRequestAttachConflict({
+                            goalId: input.goalId,
+                            expectedGoalEventId: input.expectedGoalEventId,
+                            actualGoalEventId: head?.eventId ?? null,
+                            reason
+                        });
+                        if (head === null)
+                            return conflict("missing_goal");
+                        if (head.goal.repository.branch !== input.branch ||
+                            head.goal.repository.repository !== input.repository)
+                            return conflict("identity_mismatch");
+                        // A retry returns the stored checkpoint, preserving any later owner updates.
+                        if (head.goal.review?.url === input.reviewUrl) {
+                            return { _tag: "replayed", event: head };
+                        }
+                        if (head.eventId !== input.expectedGoalEventId)
+                            return conflict("stale_event");
+                        if (isTerminalWorkState(head.goal.state) || head.goal.goalFamily?.role === "superseded") {
+                            return conflict("inactive_goal");
+                        }
+                        if (head.goal.review?.url != null)
+                            return conflict("already_attached");
+                        if (input.occurredAt <= head.occurredAt) {
+                            return new WorkProjectionError({
+                                cause: input,
+                                detail: "pull request attachment must advance the goal timestamp",
+                                reason: "inconsistent_history"
+                            });
+                        }
+                        return Schema.decodeUnknownSync(WorkGoalCheckpoint)({
+                            version: "herdr.work.event.v1",
+                            eventId: input.eventId,
+                            occurredAt: input.occurredAt,
+                            goal: {
+                                ...head.goal,
+                                updatedAt: input.occurredAt,
+                                review: { state: "requested", url: input.reviewUrl, summary: null, updatedAt: input.occurredAt }
+                            }
+                        });
+                    })();
+                    if (Predicate.isTagged(decoded, "WorkPullRequestAttachConflict") ||
+                        Predicate.isTagged(decoded, "WorkProjectionError")) {
+                        return reject(decoded);
+                    }
+                    if (Predicate.hasProperty(decoded, "_tag")) {
+                        abort();
+                        transaction = false;
+                        return { _tag: "replayed", event: decoded.event };
+                    }
                     const collisions = Schema.decodeUnknownSync(StoredEventRows)(this.#database
                         .prepare(`SELECT record FROM work_goal_events
                  WHERE event_id = ? OR (goal_id = ? AND occurred_at = ?)`)
@@ -2921,7 +2982,7 @@ export class WorkStore {
                     if (mode === "check") {
                         abort();
                         transaction = false;
-                        return { _tag: "checked" };
+                        return { _tag: "checked", event: decoded };
                     }
                     const result = this.#database.prepare("INSERT INTO work_goal_events (event_id, goal_id, occurred_at, record) VALUES (?, ?, ?, ?)").run(decoded.eventId, decoded.goal.id, decoded.occurredAt, JSON.stringify(decoded));
                     // The reconciler's own record of what it wrote: its authorship and its
@@ -2931,7 +2992,7 @@ export class WorkStore {
                     }
                     this.#database.exec("COMMIT");
                     transaction = false;
-                    return { _tag: "inserted", changes: result.changes };
+                    return { _tag: "inserted", changes: result.changes, event: decoded };
                 }
                 catch (error) {
                     if (transaction)
@@ -2946,11 +3007,11 @@ export class WorkStore {
         if (decision._tag === "replayed")
             return decision.event;
         if (decision._tag === "checked")
-            return decoded;
+            return decision.event;
         if (decision.changes !== 1 && decision.changes !== 1n) {
             return yield* storeError("append.insert.count")(decision.changes);
         }
-        return decoded;
+        return decision.event;
     });
     appendMany = Effect.fn("WorkStore.appendMany")(function* (transactionId, events) {
         if (events.length > workHistoryMaxEvents) {
@@ -4038,7 +4099,7 @@ export class WorkStore {
         // A plan holds no transaction between steps: each check rolls back at once,
         // and later steps are checked against the checkpoints earlier ones planned.
         const planned = [];
-        const appendAt = (checkpoint, guard) => this.appendAt(checkpoint, guard, mode, planned).pipe(Effect.tap(() => Effect.sync(() => {
+        const appendAt = (checkpoint, guard) => this.appendAt(checkpoint, guard, mode, planned).pipe(Effect.catchTag("WorkPullRequestAttachConflict", Effect.die), Effect.tap(() => Effect.sync(() => {
             if (mode === "check")
                 planned.push(checkpoint);
         })));