@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/protocol/completion.js

@@ -1,4 +1,4 @@
-import { currentVerifiedAttestation, verifyDelivery } from "./intent.js";
+import { currentVerifiedAttestation, verifyDelivery, } from "./intent.js";
 import { admitPlacement } from "./placement.js";
 import { reintegrateOperation } from "./reintegrate.js";
 import { mergeAdmissions, placementStop, timestamp, unpackVerificationOutcome } from "./operations.js";
@@ -112,7 +112,6 @@ async function admitCurrentPlacement(input) {
             ...(input.actor === undefined ? {} : { actor: input.actor }),
             at: timestamp(),
         },
-        ...(input.hereWorkspacePath === undefined ? {} : { hereWorkspacePath: input.hereWorkspacePath }),
     });
 }
 export async function completeCandidate(input) {
@@ -144,7 +143,6 @@ export async function completeCandidate(input) {
             contractId: input.contractId,
             target: input.target,
             ...(input.actor === undefined ? {} : { actor: input.actor }),
-            ...(input.hereWorkspacePath === undefined ? {} : { hereWorkspacePath: input.hereWorkspacePath }),
         });
         if (reintegrated.kind !== "accepted") {
             return { admission, evidence: mergeEvidence(evidence, { placement: reintegrationStop(reintegrated) }) };

package/build/src/protocol/deliver.d.ts

@@ -7,7 +7,7 @@ type DeliveryIdentity = DeliverData;
 export type VerificationReuse = CurrentVerifiedAttestation;
 export type DeliverValue = DeliveryIdentity & CompletionEvidence;
 export type AppointedWorkspace = Readonly<{
-    kind: "here" | "worktree";
+    kind: "worktree";
     path: string;
 }>;
 export type IntegrationConflictMaterialized = Readonly<{
@@ -30,7 +30,6 @@ export declare function prepareDelivery(repository: import("../git/process.js").
     appointment?: Extract<ManagedWorktreeAppointment, {
         kind: "appointed";
     }>;
-    workspacePath?: string;
 }>, input: Readonly<{
     title: string;
     document: string;
@@ -51,7 +50,6 @@ export declare function continueDeliveryOperation(input: Readonly<{
     state: ContractState;
     journal: readonly JournalEntry[];
     deriveDocument: (state: ContractState) => DocumentDerivation;
-    resolveHereWorkspace?: MutationOperationInput["resolveHereWorkspace"];
     actor?: ActorId;
     signal?: AbortSignal;
 }>): Promise<CompletionResult>;

package/build/src/protocol/deliver.js

@@ -1,7 +1,7 @@
 import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, workspaceMergeStatePresent, worktreeChangeId, } from "../git/integration.js";
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { worktreePath } from "../git/workspace.js";
-import { currentBranch, observeContractsForAdmissionAt } from "../git/observe.js";
+import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
@@ -15,15 +15,6 @@ const DELIVER_CONFLICT_RECOVERY = Object.freeze({
 });
 export async function prepareDelivery(repository, stage, input) {
     const { contractId, coordinates } = stage;
-    if (coordinates.workspace === "here" && coordinates.target !== undefined) {
-        const branch = await currentBranch(repository, stage.workspacePath);
-        if (branch !== coordinates.target) {
-            return {
-                kind: "refused",
-                refusal: { kind: "workspace-not-on-target", contractId, target: coordinates.target, branch },
-            };
-        }
-    }
     const appointed = coordinates.workspace === "worktree"
         ? stage.appointment === undefined
             ? appointmentFor(await readPlaceRegister(repository), contractId)
@@ -33,13 +24,13 @@ export async function prepareDelivery(repository, stage, input) {
         contractId,
         coordinates,
         ...(appointed === undefined ? {} : { place: appointed.place }),
-        ...(stage.workspacePath === undefined ? {} : { workspacePath: stage.workspacePath }),
         captureMergeState: true,
         rejectUnmerged: true,
     });
     if (tender.kind === "refused")
         return tender;
-    if (((tender.data.dirty || tender.data.mergeHead !== undefined) && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
+    if (((tender.data.dirty || tender.data.mergeHead !== undefined) && input.includeDirty !== true) ||
+        tender.data.changes.submodules.length > 0) {
         return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
     }
     const commit = await prepareDeliveryCommitMetadata(repository, {
@@ -77,7 +68,6 @@ async function deliverAttempt(input, attempt) {
     const state = contractState(decisionObservation.decision, input.contractId);
     const derivation = state === null ? undefined : input.deriveDocument(state);
     let preparation;
-    let workspacePath;
     if (state === null || derivation === undefined) {
         preparation = { kind: "unavailable" };
     }
@@ -85,9 +75,6 @@ async function deliverAttempt(input, attempt) {
         preparation = { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal };
     }
     else {
-        workspacePath = state.terminal === null && state.coordinates.workspace === "here"
-            ? await input.resolveHereWorkspace?.(state.id)
-            : undefined;
         const materialization = input.materializeConflict === true && state.terminal === null
             ? await materializationMergeStateRefusal(input)
             : undefined;
@@ -95,7 +82,6 @@ async function deliverAttempt(input, attempt) {
             ? await prepareDelivery(input.scope, {
                 contractId: state.id,
                 coordinates: state.coordinates,
-                ...(workspacePath === undefined ? {} : { workspacePath }),
             }, {
                 title: derivation.title,
                 document: derivation.bytes,
@@ -105,14 +91,14 @@ async function deliverAttempt(input, attempt) {
                 includeDirty: input.includeDirty,
             })
             : { kind: "refused", refusal: materialization };
-        preparation = prepared.kind === "refused"
-            ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
-            : {
-                kind: "prepared",
-                document: derivation.document,
-                data: prepared.data,
-                ...(workspacePath === undefined ? {} : { workspacePath }),
-            };
+        preparation =
+            prepared.kind === "refused"
+                ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
+                : {
+                    kind: "prepared",
+                    document: derivation.document,
+                    data: prepared.data,
+                };
     }
     const decision = decideDeliver({
         input: {
@@ -144,7 +130,6 @@ async function deliverAttempt(input, attempt) {
             value: {
                 delivery: preparation.data,
                 derivation,
-                ...(workspacePath === undefined ? {} : { workspacePath }),
             },
         };
     }
@@ -161,7 +146,6 @@ async function completeDelivery(input, first) {
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(first.value.workspacePath === undefined ? {} : { hereWorkspacePath: first.value.workspacePath }),
         ...(first.state.coordinates.target === undefined ? {} : { target: first.state.coordinates.target }),
         verification: derivation.verification,
         initial: first,
@@ -174,9 +158,6 @@ async function completeDelivery(input, first) {
 }
 export async function continueDeliveryOperation(input) {
     const contractId = input.state.id;
-    const hereWorkspacePath = input.state.coordinates.workspace === "here"
-        ? await input.resolveHereWorkspace?.(contractId)
-        : undefined;
     return await completeCandidate({
         channel: input.channel,
         repository: input.scope,
@@ -187,7 +168,6 @@ export async function continueDeliveryOperation(input) {
         verification: input.deriveDocument(input.state).verification,
         initial: { kind: "accepted", state: input.state, journal: input.journal, facts: [] },
         verifyInitial: true,
-        ...(hereWorkspacePath === undefined ? {} : { hereWorkspacePath }),
     });
 }
 function isIntegrationConflict(refusal) {
@@ -210,13 +190,6 @@ async function appointedDeliverWorkspace(input) {
     const state = contractState(observation.decision, input.contractId);
     if (state === null)
         return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
-    if (state.coordinates.workspace === "here") {
-        const path = await input.resolveHereWorkspace?.(state.id);
-        if (path === undefined) {
-            return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
-        }
-        return { workspace: { kind: "here", path }, coordinates: state.coordinates };
-    }
     const appointment = appointmentFor(await readPlaceRegister(input.scope), input.contractId);
     if (appointment === undefined) {
         return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
@@ -244,13 +217,16 @@ async function materializeDeliverConflict(input, refusal) {
     if ("kind" in appointed)
         return appointed;
     const { workspace, coordinates } = appointed;
+    const appointment = appointmentFor(await readPlaceRegister(input.scope), input.contractId);
+    if (appointment === undefined)
+        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
     const mergeState = await mergeStatePresentRefusal(input, workspace);
     if (mergeState !== undefined)
         return { kind: "refused", refusal: mergeState };
     const tender = await captureTender(input.scope, {
         contractId: input.contractId,
         coordinates,
-        workspacePath: workspace.path,
+        place: appointment.place,
     });
     if (tender.kind === "refused")
         return tender;

package/build/src/protocol/intent.d.ts

@@ -13,6 +13,7 @@ type IntentAdmissionOptions<Input, Refusal, Seed> = Readonly<{
     observedContracts?: readonly ContractId[];
     observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
     decorateOffer?: CompanionDecorator;
+    validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
     prepareInput?: (observation: GitDecisionObservation, input: Seed) => Readonly<{
         kind: "prepared";

package/build/src/protocol/intent.js

@@ -3,7 +3,7 @@ import { projectSettings } from "../settings.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { latestCurrentAttestations } from "../core/facts/gate.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
-import { executeVerification } from "../verification/execution.js";
+import { executeVerification, } from "../verification/execution.js";
 import { VERIFIED } from "../verification/declaration.js";
 import { runProtocol } from "./run.js";
 import { mintAttempts } from "./attempt.js";
@@ -19,6 +19,7 @@ export function admitIntent(channel, repository, input, decide, options = {}) {
         decide,
         ...(options.observe === undefined ? {} : { observe: options.observe }),
         ...(options.decorateOffer === undefined ? {} : { decorateOffer: options.decorateOffer }),
+        ...(options.validateAdmission === undefined ? {} : { validateAdmission: options.validateAdmission }),
         ...(options.observationSelection === undefined ? {} : { observationSelection: options.observationSelection }),
         ...(options.prepareInput === undefined ? {} : { prepareInput: options.prepareInput }),
     });
@@ -81,13 +82,14 @@ export async function verifyDelivery(input) {
         step = { failure: "candidate-unavailable", diagnostic: execution.outcome.diagnostic };
     }
     else if (execution.outcome.kind === "environment-failure") {
-        step = "diagnostic" in execution.outcome
-            ? { failure: "environment-failure", diagnostic: execution.outcome.diagnostic }
-            : { failure: "environment-failure", command: execution.outcome.command, detail: execution.outcome.detail };
+        step =
+            "diagnostic" in execution.outcome
+                ? { failure: "environment-failure", diagnostic: execution.outcome.diagnostic }
+                : { failure: "environment-failure", command: execution.outcome.command, detail: execution.outcome.detail };
     }
-    else if (execution.outcome.kind === "unknown-exit"
-        || execution.outcome.kind === "cancelled"
-        || execution.outcome.kind === "spawn-error") {
+    else if (execution.outcome.kind === "unknown-exit" ||
+        execution.outcome.kind === "cancelled" ||
+        execution.outcome.kind === "spawn-error") {
         step = runtimeStop(execution.outcome);
     }
     else {

package/build/src/protocol/operations.d.ts

@@ -9,7 +9,7 @@ import type { DeliverRefusal } from "../core/verbs/deliver.js";
 import type { PlacementRefusal } from "../core/verbs/placement.js";
 import type { AttestationRefusal } from "../core/verbs/attestation.js";
 import type { ContractId, ContractState, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
-import type { BindRefusal, TargetInputRefusal } from "./bind.js";
+import type { BindRefusal, ForkSourceMovedRefusal, TargetInputRefusal } from "./bind.js";
 import type { IntegrationPreparationRefusal } from "../git/integration.js";
 import type { TargetPlacementRefusal } from "../git/target-placement.js";
 import type { VerificationCleanupFailure, VerificationRuntimeStop, VerificationResult } from "./intent.js";
@@ -24,7 +24,7 @@ export type MergeStatePresentRefusal = Readonly<{
     kind: "merge-state-present";
     contractId: ContractId;
     workspace: Readonly<{
-        kind: "here" | "worktree";
+        kind: "worktree" | "worktree";
         path: string;
     }>;
 }>;
@@ -48,7 +48,7 @@ export type DeliveryPreparationRefusal = Readonly<{
     kind: "target-missing" | "worktree-missing";
     contractId: ContractId;
 }> | DirtyWorkspaceRefusal | UnmergedPathsRefusal | IntegrationPreparationRefusal | MergeStatePresentRefusal | TargetPlacementRefusal;
-export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | DeliverConflictRefusal | PlacementRefusal | AttestationRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
+export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | ForkSourceMovedRefusal | DeliverRefusal | DeliveryPreparationRefusal | DeliverConflictRefusal | PlacementRefusal | AttestationRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
 export type IntentRetry = ProtocolTerminal;
 export type IntentOutcome<Value, Refusal = IntentRefusal> = ProtocolIntentOutcome<Value, Refusal>;
 type OperationInput = Readonly<{
@@ -56,10 +56,8 @@ type OperationInput = Readonly<{
     contractId: ContractId;
     actor?: import("../core/facts/types.js").ActorId;
 }>;
-export type HereWorkspaceResolver = (contractId: ContractId) => Promise<string | undefined>;
 export type MutationOperationInput = OperationInput & Readonly<{
     channel: GitDecodeChannel;
-    resolveHereWorkspace?: HereWorkspaceResolver;
 }>;
 export type DocumentDerivation = Readonly<{
     document: DocumentKey;
@@ -129,13 +127,11 @@ export declare function currentBranchOperation(input: Readonly<{
 export declare function contractsOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
-    hereWorkspace?: import("./read/status.js").HereWorkspaceObservationResolver;
 }>): Promise<ContractBoard>;
 export declare function contractObservationOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
     contractId: ContractId;
-    hereWorkspace?: import("./read/status.js").HereWorkspaceObservationResolver;
 }>): Promise<ContractObservation>;
 export declare function documentsOperationAt(scope: RepositoryScope, channel: GitDecodeChannel): Promise<readonly ContractDocumentProjection[]>;
 export declare function stateOperation(input: MutationOperationInput): Promise<ContractState>;

package/build/src/protocol/operations.js

@@ -4,7 +4,9 @@ import { repositoryAt } from "../git/repository.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { readDocuments } from "./read/documents.js";
 import { readContractBoard, readContractObservationAt, } from "./read/status.js";
-export function timestamp() { return new Date().toISOString(); }
+export function timestamp() {
+    return new Date().toISOString();
+}
 export function mergeAdmissions(current, next) {
     const effects = [...(current.physical?.effects ?? []), ...(next.physical?.effects ?? [])];
     const lag = [...(current.physical?.lag ?? []), ...(next.physical?.lag ?? [])];
@@ -49,10 +51,10 @@ export async function currentBranchOperation(input) {
     return await currentBranch(input.scope);
 }
 export async function contractsOperation(input) {
-    return withGitReadObservation(input.scope, input.channel, (observation) => readContractBoard(observation, undefined, input.hereWorkspace));
+    return withGitReadObservation(input.scope, input.channel, (observation) => readContractBoard(observation));
 }
 export async function contractObservationOperation(input) {
-    return await readContractObservationAt(input.scope, input.channel, input.contractId, input.hereWorkspace);
+    return await readContractObservationAt(input.scope, input.channel, input.contractId);
 }
 export async function documentsOperationAt(scope, channel) {
     return withGitReadObservation(scope, channel, readDocuments);

package/build/src/protocol/placement.d.ts

@@ -30,7 +30,6 @@ type PlacementAdmissionInput<ExtraRefusal> = Readonly<{
     repository: GitRepository;
     target: string | undefined;
     placement: PlacementProtocolInput;
-    hereWorkspacePath?: string;
     onDeliveryMissing?: () => Promise<PlacementProtocolResult<ExtraRefusal> | undefined>;
 }>;
 /** Hold the existing target-placement fence for one owner callback. */

package/build/src/protocol/placement.js

@@ -7,7 +7,7 @@ import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
 import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { prepareProtocolAttempt, runProtocol, } from "./run.js";
+import { prepareProtocolAttempt, runProtocol } from "./run.js";
 function placementFailure(error) {
     return { kind: "placement-failed", diagnostic: error instanceof Error ? error.message : String(error) };
 }
@@ -20,7 +20,7 @@ function expectedOperationalDiagnostic(error) {
 function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
-async function runFencedPlacement(repository, input, protocol, hereWorkspacePath) {
+async function runFencedPlacement(repository, input, protocol) {
     for (let index = 0; index < protocol.attempts.length; index += 1) {
         const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
         if (prepared.kind === "refused")
@@ -40,7 +40,7 @@ async function runFencedPlacement(repository, input, protocol, hereWorkspacePath
                 observed,
             };
         }
-        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target, hereWorkspacePath);
+        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
         if (physical.kind === "refused")
             return physical;
         const result = await admitDecidedOffer({
@@ -112,7 +112,7 @@ function isDeliveryMissing(result) {
 }
 /** Run the sole placement adjudicator inside the target's physical fence. */
 export async function admitPlacement(admission) {
-    const { channel, repository, target, placement: input, hereWorkspacePath, onDeliveryMissing } = admission;
+    const { channel, repository, target, placement: input, onDeliveryMissing } = admission;
     const attempts = mintAttempts({ entryCount: 1 });
     const protocol = {
         input,
@@ -126,10 +126,10 @@ export async function admitPlacement(admission) {
     if (target === undefined)
         return await runProtocol(protocol);
     return await runUnderTargetPlacementFence(repository, target, async () => {
-        const result = await runFencedPlacement(repository, input, protocol, hereWorkspacePath);
+        const result = await runFencedPlacement(repository, input, protocol);
         if (onDeliveryMissing === undefined || !isDeliveryMissing(result))
             return result;
-        return await onDeliveryMissing() ?? result;
+        return (await onDeliveryMissing()) ?? result;
     }, (result, error) => result.kind === "accepted"
         ? { ...result, physical: reconcileEffectFailure(error, result.physical) }
         : placementFailure(error));

package/build/src/protocol/read/observation.d.ts

@@ -0,0 +1,11 @@
+import type { GitRepository } from "../../git/process.js";
+import type { ContractRow } from "./status.js";
+export type CurrentPhysicalIssue = Readonly<{
+    kind: "hook-failure";
+    diagnostic: string;
+}> | Readonly<{
+    kind: "target-checkout-retained";
+    target: string;
+}>;
+/** Selected-only pure projection of durable hook failure or retained target checkout. */
+export declare function observeCurrentPhysicalIssue(repository: GitRepository, row: ContractRow): Promise<CurrentPhysicalIssue | undefined>;

package/build/src/protocol/read/observation.js

@@ -0,0 +1,37 @@
+import { observeWorktreeHookMarker } from "../../git/hooks.js";
+import { registeredWorktrees, worktreeGitDirectory } from "../../git/repository.js";
+import { observeTargetCheckoutShape } from "../../git/target-placement.js";
+function appointedWorkspacePath(row) {
+    const observation = row.workspaceObservation;
+    if (observation.kind !== "clean" && observation.kind !== "dirty")
+        return null;
+    return observation.location.kind === "worktree" ? observation.location.path : null;
+}
+/** Selected-only pure projection of durable hook failure or retained target checkout. */
+export async function observeCurrentPhysicalIssue(repository, row) {
+    const workspacePath = appointedWorkspacePath(row);
+    if (workspacePath !== null) {
+        const marker = await observeWorktreeHookMarker(await worktreeGitDirectory(repository, workspacePath));
+        if (marker.kind === "failed")
+            return { kind: "hook-failure", diagnostic: marker.diagnostic };
+    }
+    const target = row.target;
+    const delivery = row.delivery;
+    if (row.phase !== "claimed" || target === null || delivery === null)
+        return undefined;
+    if (row.targetObservation?.head !== delivery.integration.snapshot)
+        return undefined;
+    const worktrees = (await registeredWorktrees(repository))
+        .filter((worktree) => worktree.branch === target)
+        .sort((left, right) => left.path.localeCompare(right.path));
+    for (const worktree of worktrees) {
+        const shape = await observeTargetCheckoutShape(repository, {
+            path: worktree.path,
+            predecessor: delivery.integration.predecessor,
+            candidate: delivery.integration.snapshot,
+        });
+        if (shape === "retained")
+            return { kind: "target-checkout-retained", target };
+    }
+    return undefined;
+}

package/build/src/protocol/read/status.d.ts

@@ -3,7 +3,7 @@ import type { GitRepository } from "../../git/process.js";
 import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
 import type { ContractId, ContractState, DeliverData, JournalEntry, SnapshotId } from "../../core/facts/types.js";
-export type ContractPhase = "waiting" | "bound" | "pending-delivery" | "claimed" | "abandoned";
+export type ContractPhase = "waiting" | "bound" | "tendered" | "claimed" | "abandoned";
 export type ContractDisposition = "active" | "terminal";
 export type ContractGateCurrent = GateCurrent;
 export type ContractGateReport = Readonly<{
@@ -11,16 +11,24 @@ export type ContractGateReport = Readonly<{
     current: ContractGateCurrent;
 }>;
 export type { ContractTargetLag, ContractWorkspaceObservation };
-export type HereWorkspaceObservationResolution = Readonly<{
-    kind: "appointed";
-    path: string;
+export type AfterEndpointObservation = Readonly<{
+    kind: "claimed";
 }> | Readonly<{
-    kind: "unappointed";
+    kind: "active";
+    phase: ContractPhase;
+}> | Readonly<{
+    kind: "abandoned";
 }> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
+    kind: "missing";
+}>;
+export type ContractAfterEdge = Readonly<{
+    contractId: ContractId;
+    endpoint: AfterEndpointObservation;
+}>;
+export type ContractDependent = Readonly<{
+    contractId: ContractId;
+    phase: ContractPhase;
 }>;
-export type HereWorkspaceObservationResolver = (contractId: ContractId) => Promise<HereWorkspaceObservationResolution>;
 export type ContractRow = Readonly<{
     id: ContractId;
     title: string | null;
@@ -28,7 +36,7 @@ export type ContractRow = Readonly<{
     phaseAt: string;
     lastJournalAt: string;
     disposition: ContractDisposition;
-    workspace: "worktree" | "here";
+    workspace: "worktree";
     worktreePath: string | null;
     workspaceObservation: ContractWorkspaceObservation;
     target: string | null;
@@ -42,10 +50,13 @@ export type ContractRow = Readonly<{
         reports: readonly ContractGateReport[];
         satisfied: boolean;
     }>;
+    after: readonly ContractAfterEdge[];
+    dependents: readonly ContractDependent[];
 }>;
 export type ContractBoard = Readonly<{
     root: string;
     state: SnapshotId | null;
+    observedAt: string;
     rows: readonly ContractRow[];
 }>;
 export type ContractObservation = Readonly<{
@@ -58,8 +69,8 @@ export type ContractObservation = Readonly<{
 export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "delivery" | "bound">, bindAt: string): string;
 export declare function lastJournalAtFor(entries: readonly Pick<JournalEntry, "at">[]): string;
 /** Build the Contract board from one immutable git observation. */
-export declare function readContractBoard(observation: GitReadObservation, selected?: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractBoard>;
+export declare function readContractBoard(observation: GitReadObservation, include?: ContractId): Promise<ContractBoard>;
 /** Observe one Contract and its target from one fresh ref epoch. */
-export declare function readContractObservation(observation: GitReadObservation, id: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractObservation>;
+export declare function readContractObservation(observation: GitReadObservation, id: ContractId): Promise<ContractObservation>;
 /** Observe one Contract and its target from one fresh ref epoch. */
-export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractObservation>;
+export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId): Promise<ContractObservation>;