@farmslot/protocol 0.21.0 → 0.25.0

package/dist/contracts/gate-park.js

@@ -0,0 +1,415 @@
+/**
+ * Gate-park state for clients (ADR-054 `free-slot` at an operator wait).
+ *
+ * A run parked with `free-slot` keeps its gate answerable while its slot goes
+ * back to dispatch. Three facts then live in three different places — the park
+ * record's slot disposition, the restore stages the record owes, and the
+ * Gateway's verdict on whether the original slot can take the run back — and a
+ * surface that reads any one of them alone gets the run's state wrong:
+ *
+ *   - occupancy alone reports a restore that re-bound the slot and then failed
+ *     as "back", so the gate looks answerable against a worker nothing proved;
+ *   - the phase alone reports a `partial` that never reached the slot the same
+ *     way as one that freed it;
+ *   - a client that decides slot availability itself picks a slot the Gateway
+ *     did not, which is the one thing ADR-054 forbids.
+ *
+ * So this module owns the single reading, and Command Center, Companion, and
+ * the CLI all render it. Availability is never derived here: it is carried in
+ * from a Gateway verdict, or reported as not known.
+ *
+ * The predicates below moved out of the Gateway so clients share the exact
+ * definitions the Gateway acts on rather than approximations of them.
+ */
+import { MACHINE_PARK_RESTORE_STAGES, } from './runs.js';
+/**
+ * Whether this run's machine-park record released its slot (ADR-054
+ * `free-slot` at an operator wait, amending ADR-038's gate-held slot hold).
+ *
+ * `slotFreedAt` records the fact, not the intent: it is written only after the
+ * park stopped the runner and every manifest resource AND the ownership
+ * release landed, so a partial park never reads as freed. While it is set, the
+ * park record — not the slot row — is the authority for the run's slot
+ * binding: the run keeps `slotId` (the recovery handle and the workspace
+ * branch key off it) but stops counting as an occupant of that slot.
+ *
+ * This is the OCCUPANCY predicate. It must never claim a slot is free before
+ * the release actually landed, so dispatch cannot hand out a slot whose worker
+ * is still running. Use `isGateParkInFlightOrFreed` for the safety fences,
+ * which have the opposite bias.
+ */
+export function isSlotFreedByPark(run) {
+    const park = run.park;
+    if (!park?.slotFreedAt)
+        return false;
+    // `slotReboundAt` is the counterpart fact, and it is what ends the release.
+    // `slotFreedAt` deliberately survives the whole restore — it is what tells a
+    // retry which stages it still owes — so reading it alone would report a slot
+    // the run is sitting in as free for dispatch.
+    return !park.slotReboundAt;
+}
+/**
+ * Whether a gate park still owes a restore before its gate may be answered.
+ *
+ * The question consumption asks, and it is NOT "does the run occupy its slot".
+ * A restore that re-bound the slot, booted its resources, and then failed to
+ * get a structured acknowledgement out of the worker leaves an occupied slot
+ * and a running process — and answering the gate there drives the engine
+ * against a worker that never confirmed it came back. So this keys on the
+ * restore's own stage record, which is the only thing that says what landed.
+ */
+export function needsGateParkRestore(run) {
+    const park = run.park;
+    if (!park)
+        return false;
+    // `restored` is the ONLY thing that ends the obligation. Not the stage list:
+    // every stage can be complete and the record still be `partial`, because the
+    // orchestration resume after them failed — and reading the stages as done
+    // there left the run unable to answer its gate and unable to be restored
+    // through it. Not the residuals either: a reload that started the worker and
+    // lost its acknowledgement leaves an occupied slot and a running process.
+    if (park.phase === 'restored' || park.phase === 'cancelled')
+        return false;
+    if (park.mode !== 'release' || park.slotDisposition !== 'freed')
+        return false;
+    // The park itself is still landing. There is nothing coherent to restore
+    // into yet, and the in-flight fence covers that case instead.
+    //
+    // Everything else got PAST the park: it freed the slot, or a restore already
+    // re-bound it. A record written before stages were tracked lands here through
+    // `slotReboundAt` — it cleared its freed marker at the rebind, so that is the
+    // only fact left saying a restore touched it.
+    //
+    // A park that settled without reaching the slot at all is deliberately NOT
+    // here. It owes no freed-slot stages, and the outstanding-effect fence below
+    // is the right guard for it: it can still leave a run answerable where it
+    // stands when the park stopped nothing.
+    return Boolean(park.slotFreedAt) || Boolean(park.slotReboundAt);
+}
+/**
+ * Whether a slot-freeing park is either done or still in flight for this run.
+ *
+ * The opposite bias to `isSlotFreedByPark`: it goes true the moment the
+ * write-ahead record declares a freeing park and stays true through the window
+ * where the runner and resources are being stopped but `slotFreedAt` has not
+ * been written yet.
+ *
+ * Every guard that must not act on a run whose slot is disappearing uses this:
+ * resolving a gate, applying a posture, driving a resolved gate onward, or
+ * tearing the slot down after a failure. Answering a gate mid-park would
+ * publish against a worker that is being stopped underneath it.
+ *
+ * It is keyed on intent-or-fact HONESTLY, which matters as much as the fence
+ * itself. A fence that never lifts is not a fence, it is a strand: the run can
+ * neither answer its gate nor be restored, and cancelling it is the only exit.
+ * So:
+ *
+ *   - the record owes a restore — it freed the slot, or a restore re-bound it
+ *     and has not settled `restored`. Fenced, until that restore or a cancel.
+ *   - a park that never reached the slot and settled `partial` — it will not
+ *     finish. It is still fenced
+ *     while ANY of its effects is outstanding: a detach not yet rolled back, or
+ *     a runner that is not PROVABLY still running. A stopped worker cannot act
+ *     on a gate answer, and letting the operator answer anyway would be the
+ *     silent version of the strand. `machine.pause.restore` is the exit: it
+ *     reloads the worker and settles the record, which lifts the fence. Only a
+ *     park that detached nothing and left an observably live worker leaves the
+ *     run answerable where it stands.
+ *   - otherwise, while the intent is live — fenced.
+ */
+export function isGateParkInFlightOrFreed(run) {
+    const park = run.park;
+    if (!park)
+        return false;
+    // A record the operator already settled fences nothing, even though it still
+    // carries the historical `slotFreedAt` of the release it undid.
+    if (park.phase === 'restored' || park.phase === 'cancelled')
+        return false;
+    // Everything that still owes a restore is fenced, by construction rather than
+    // by two lists of conditions that have to be kept in step. A gate that can be
+    // answered while a restore is outstanding is the whole failure this guards,
+    // and `needsGateParkRestore` already covers every freed or re-bound record —
+    // so what remains below is only the park that never reached the slot.
+    if (needsGateParkRestore(run))
+        return true;
+    if (park.mode !== 'release' || park.slotDisposition !== 'freed')
+        return false;
+    if (park.phase === 'partial') {
+        if (park.preservedWorkspace?.detachedAt)
+            return true;
+        // The park stops the runner before it ever touches the slot, so a partial
+        // that got past that point has a dead worker even though the run still owns
+        // its slot. Restore is what brings it back.
+        //
+        // `unknown` fences too, and that direction matters: it means the probe
+        // could not see the worker, which for a failure before the re-host is the
+        // NORMAL answer — the recorded handle still names the pane a successor
+        // destroyed. Reading "could not observe" as "still running" lifts the fence
+        // on a dead worker, and the next gate answer runs FINALIZE against it. Only
+        // an observed live worker leaves the run answerable.
+        return park.residuals?.runner !== 'running';
+    }
+    return true;
+}
+/**
+ * Whether machine parking still holds this run.
+ *
+ * The park RECORD is the authority for "is this run parked", not the run's
+ * persisted posture. A restore or a cancel settles the record while the posture
+ * it was applied under stays on the run, so a reader that trusts the posture
+ * decides an already-restored run is still parked — and then refuses to park it
+ * again, forever, as a no-op.
+ */
+export function hasLiveParkRecord(run) {
+    const park = run.park;
+    if (!park)
+        return false;
+    return park.phase !== 'restored' && park.phase !== 'cancelled';
+}
+function slotStateOf(park) {
+    if (park.phase === 'restored' || park.phase === 'cancelled')
+        return 'settled';
+    if (park.mode !== 'release' || park.slotDisposition !== 'freed')
+        return 'retained';
+    if (park.slotFreedAt && !park.slotReboundAt)
+        return 'freed';
+    // The re-home note is written write-ahead, before the claim, so it can be
+    // present while the slot is still freed — which is why occupancy is read
+    // FIRST above. Here the slot is bound, and `rehome` says which one.
+    if (park.slotReboundAt)
+        return park.rehome ? 'rehoming' : 'restoring';
+    // A `partial` never reached the slot AND has stopped trying, so it is not
+    // "still landing". Whether its gate is answerable is not a second opinion
+    // formed here — it is `isGateParkInFlightOrFreed`, the same predicate
+    // `assertNotGateParked` fences the resolution on. Deriving it any other way
+    // is how the surfaces came to tell an operator to wait for a park that had
+    // already given up, on a run whose worker was alive and whose gate the
+    // Gateway would have accepted.
+    if (park.phase === 'partial') {
+        return isGateParkInFlightOrFreed({ park }) ? 'partial-needs-restore' : 'partial-answerable';
+    }
+    // The write-ahead record declares the intent before any release effect lands.
+    return 'freeing';
+}
+function restoreStageView(park) {
+    const progress = park.restoreProgress;
+    if (!progress) {
+        return {
+            state: 'not-started',
+            attempting: null,
+            completed: [],
+            remaining: MACHINE_PARK_RESTORE_STAGES,
+        };
+    }
+    const completed = MACHINE_PARK_RESTORE_STAGES.filter((stage) => progress.completed.includes(stage));
+    const remaining = MACHINE_PARK_RESTORE_STAGES.filter((stage) => !progress.completed.includes(stage));
+    // An attempted stage is in flight, not complete: the marker is written BEFORE
+    // the stage runs, so a crash inside one is visible as unfinished rather than
+    // as an absence. `complete` therefore requires every stage landed AND nothing
+    // being attempted, which is `machineParkRestoreComplete`.
+    const state = remaining.length === 0 && !progress.attempting
+        ? 'complete'
+        : completed.length === 0 && !progress.attempting
+            ? 'not-started'
+            : 'in-progress';
+    return {
+        state,
+        attempting: progress.attempting ?? null,
+        completed,
+        remaining,
+    };
+}
+/**
+ * The one reading of a run's gate park, or `null` when the run has no park
+ * record at all.
+ *
+ * `verdict` carries a Gateway-resolved restore target when the caller has read
+ * one (`machine.pause.restore`). Without it the target's `available` stays
+ * `null`: the record says which slot a restore would use, never whether that
+ * slot is free right now.
+ */
+export function gateParkView(run, verdict) {
+    const park = run.park;
+    if (!park)
+        return null;
+    const disposition = park.slotDisposition ?? 'retained';
+    const slotState = slotStateOf(park);
+    const proof = park.recoveryProof;
+    return {
+        runId: run.id,
+        machine: park.machine,
+        slotId: park.slotId,
+        phase: park.phase,
+        slotState,
+        slotDisposition: disposition,
+        freedSlotId: isSlotFreedByPark({ park }) ? park.slotId : null,
+        ...(park.slotFreedAt ? { slotFreedAt: park.slotFreedAt } : {}),
+        ...(park.slotReboundAt ? { slotReboundAt: park.slotReboundAt } : {}),
+        ...(park.preservedWorkspace ? { preservedWorkspace: park.preservedWorkspace } : {}),
+        restoreBeforeGateAnswer: needsGateParkRestore({ park }),
+        restoreStage: restoreStageView(park),
+        restoreTarget: {
+            slotId: verdict?.target.slotId ?? park.rehome?.toSlotId ?? park.slotId,
+            // The park's ORIGINAL slot, which the record no longer names once a
+            // re-home has moved `slotId`. `rehome.fromSlotId` is the only surviving
+            // record of it, so it wins over the record's current binding.
+            originalSlotId: verdict?.target.originalSlotId ?? park.rehome?.fromSlotId ?? park.slotId,
+            disposition: verdict?.target.disposition ?? disposition,
+            available: verdict ? verdict.target.available : null,
+            ...(verdict?.eligibility ? { code: verdict.eligibility.code } : {}),
+            ...(verdict?.eligibility ? { reason: verdict.eligibility.reason } : {}),
+        },
+        ...(park.restoreRefusal ? { refusal: park.restoreRefusal } : {}),
+        ...(proof
+            ? {
+                workerProof: {
+                    kind: proof.acknowledgement.kind,
+                    reason: proof.acknowledgement.reason,
+                    acceptedAt: proof.acceptedAt,
+                },
+            }
+            : {}),
+    };
+}
+/**
+ * The gate park a client should render beside a run's gate, or `null` when
+ * there is nothing outstanding to say.
+ *
+ * A settled record is deliberately excluded: it describes a park the operator
+ * already resolved, and showing it beside a live gate reads as "this run is
+ * parked" when it is not.
+ */
+export function liveGateParkView(run, verdict) {
+    const view = gateParkView(run, verdict);
+    if (!view || view.slotState === 'settled')
+        return null;
+    return view;
+}
+/**
+ * Operator wording for the run's slot under its park.
+ *
+ * The sentences live here rather than in each client because the same claim has
+ * to read the same way in Command Center, Companion, and the CLI. A per-client
+ * copy is how "parked" came to mean the slot was gone on one surface and still
+ * held on another.
+ */
+export function gateParkStateLabel(view) {
+    if (view.slotState === 'retained')
+        return 'Parked, slot retained';
+    if (view.slotState === 'freeing')
+        return 'Parking, slot not freed yet';
+    // Neither partial says "parking": the park stopped, and the difference
+    // between the two is the only thing that tells the operator what to do next.
+    if (view.slotState === 'partial-answerable') {
+        return 'Park failed before the slot; worker still running';
+    }
+    if (view.slotState === 'partial-needs-restore')
+        return 'Park failed partway; needs a restore';
+    if (view.slotState === 'freed')
+        return 'Parked, slot freed for dispatch';
+    if (view.slotState === 'restoring')
+        return 'Restoring into its slot';
+    if (view.slotState === 'rehoming') {
+        return `Restoring into ${view.restoreTarget.slotId} (was ${view.restoreTarget.originalSlotId})`;
+    }
+    return 'Park settled';
+}
+/** One compact line: what the park did with the slot, the branch it preserved, what it still owes. */
+export function gateParkSummaryLine(view) {
+    const target = view.restoreTarget;
+    const rehomed = target.slotId !== target.originalSlotId;
+    const parts = [
+        gateParkStateLabel(view),
+        // The slot the run is going to, and where it came from. A single `slot X`
+        // after a re-home named the NEW slot with no hint it had moved, which reads
+        // as if the park had always been there.
+        rehomed ? `slot ${target.slotId} (was ${target.originalSlotId})` : `slot ${view.slotId}`,
+    ];
+    if (view.preservedWorkspace) {
+        const workspace = view.preservedWorkspace;
+        parts.push(`branch ${workspace.branch} at ${workspace.headSha}${workspace.detachedAt ? ' (detached)' : ''}`);
+    }
+    if (view.restoreStage.remaining.length && view.restoreStage.state !== 'not-started') {
+        parts.push(`restore owes ${view.restoreStage.remaining.join(', ')}`);
+    }
+    if (view.restoreStage.attempting)
+        parts.push(`attempting ${view.restoreStage.attempting}`);
+    if (view.workerProof)
+        parts.push(`worker ${view.workerProof.kind}`);
+    return parts.join(' · ');
+}
+export function gateParkGateNotice(view) {
+    if (!view)
+        return null;
+    if (view.slotState === 'freeing') {
+        return {
+            kind: 'park-in-flight',
+            blocking: true,
+            message: 'A free-slot park is still landing for this run, so its gate cannot be answered yet.',
+        };
+    }
+    if (view.slotState === 'partial-needs-restore') {
+        return {
+            kind: 'park-needs-restore',
+            blocking: true,
+            // Deliberately says what to DO. This park has stopped, so "wait" is the
+            // one instruction that cannot work, and it is what the old copy gave.
+            message: `A free-slot park failed partway and left an effect outstanding, so this gate cannot be answered until a restore settles it. Waiting will not clear it — restore the run into ${view.slotId}, or cancel it.`,
+            ...(view.refusal ? { refusal: view.refusal } : {}),
+        };
+    }
+    if (view.slotState === 'partial-answerable') {
+        return {
+            kind: 'park-answerable',
+            blocking: false,
+            message: `A free-slot park failed before it reached ${view.slotId} and left the worker running, so this gate can be answered where it stands.`,
+            ...(view.refusal ? { refusal: view.refusal } : {}),
+        };
+    }
+    if (!view.restoreBeforeGateAnswer)
+        return null;
+    const target = view.restoreTarget;
+    // `available === null` is "not known", never "unavailable": only a Gateway
+    // verdict answers it, and treating an unread answer as a block would stand in
+    // the operator's way for a restore that would have succeeded.
+    //
+    // A recorded refusal is likewise not a current verdict. It says the LAST
+    // attempt refused, which is the best thing known only while nothing newer has
+    // looked; an `available: true` verdict is newer by construction, and letting
+    // a stale refusal outrank it blocks a restore the Gateway just approved.
+    if (target.available === false) {
+        return {
+            kind: 'restore-blocked',
+            blocking: true,
+            message: `Answering this gate restores the run into ${target.slotId} first, and the Gateway reports that slot cannot take it back.${target.reason ? ` ${target.reason}` : ''}`,
+            ...(view.refusal ? { refusal: view.refusal } : {}),
+        };
+    }
+    if (target.available === null && view.refusal) {
+        return {
+            kind: 'restore-blocked',
+            blocking: true,
+            message: `Answering this gate restores the run into ${target.slotId} first, and the last restore attempt refused. Nothing has re-checked that slot since.`,
+            refusal: view.refusal,
+        };
+    }
+    if (target.slotId !== target.originalSlotId) {
+        return {
+            kind: 'restore-first',
+            blocking: false,
+            // Says the slot MOVED, because the operator's attach target moves with
+            // it. A message naming only the new slot reads as if the park had been
+            // there all along, and one naming only the old sends them to a pane a
+            // successor owns.
+            message: `Answering this gate restores the run into ${target.slotId} first — ${target.originalSlotId} was taken — then resolves the decision.`,
+            ...(view.refusal ? { refusal: view.refusal, refusalSuperseded: true } : {}),
+        };
+    }
+    return {
+        kind: 'restore-first',
+        blocking: false,
+        message: `Answering this gate restores the run into ${target.slotId} first, then resolves the decision.`,
+        ...(view.refusal ? { refusal: view.refusal, refusalSuperseded: true } : {}),
+    };
+}
+//# sourceMappingURL=gate-park.js.map

package/dist/contracts/gate-park.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-park.js","sourceRoot":"","sources":["../../src/contracts/gate-park.ts"],"names":[],"mappings":"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"}

package/dist/contracts/index.d.ts

@@ -6,14 +6,18 @@ export * from './bug-score.js';
 export * from './chat.js';
 export * from './common.js';
 export * from './config.js';
+export * from './device-inventory.js';
 export * from './dispatch.js';
 export * from './evals.js';
 export * from './execution-templates.js';
 export * from './family.js';
+export * from './gate-park.js';
 export * from './interactive-operator-packets.js';
 export * from './pr-recommendation.js';
+export * from './pressure-admission.js';
 export * from './provider-accounts.js';
 export * from './recipes.js';
+export * from './resource-posture.js';
 export * from './resources.js';
 export * from './reviews.js';
 export * from './roadmap.js';

package/dist/contracts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/dist/contracts/index.js

@@ -6,14 +6,18 @@ export * from './bug-score.js';
 export * from './chat.js';
 export * from './common.js';
 export * from './config.js';
+export * from './device-inventory.js';
 export * from './dispatch.js';
 export * from './evals.js';
 export * from './execution-templates.js';
 export * from './family.js';
+export * from './gate-park.js';
 export * from './interactive-operator-packets.js';
 export * from './pr-recommendation.js';
+export * from './pressure-admission.js';
 export * from './provider-accounts.js';
 export * from './recipes.js';
+export * from './resource-posture.js';
 export * from './resources.js';
 export * from './reviews.js';
 export * from './roadmap.js';

package/dist/contracts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/dist/contracts/pressure-admission.d.ts

@@ -0,0 +1,175 @@
+import type { ProcessAttributionConfidence, ProcessOwnershipClass } from '../rpc/resources.js';
+import type { HostPressureAdmissionMode } from './runtime-capabilities.js';
+/**
+ * Dispatch admission has no queue: a machine under sustained pressure either
+ * accepts new dispatches or refuses them. Same vocabulary as the capability
+ * side so one word means one thing across both gates.
+ */
+export type DispatchPressureAdmissionMode = Exclude<HostPressureAdmissionMode, 'queue'>;
+export declare const DISPATCH_PRESSURE_ADMISSION_MODES: readonly DispatchPressureAdmissionMode[];
+/** Machine-level admission state derived from the bounded pressure sample
+ * ring. `disabled` means the gateway-owned switch is off — the DEFAULT: the
+ * dispatch is admitted whatever the evidence says, while the evidence itself
+ * is still evaluated and carried as an advisory, and sampling/history/charts
+ * continue. */
+export type PressureAdmissionState = 'green' | 'transient' | 'sustained-critical' | 'unavailable' | 'stale' | 'override' | 'disabled';
+/** Stable machine-readable rejection codes. Never rename — clients and
+ * operators key automation off these. */
+export declare const PRESSURE_ADMISSION_REJECTION_CODES: readonly ["PRESSURE_SUSTAINED_CRITICAL", "PRESSURE_EVIDENCE_UNAVAILABLE", "PRESSURE_EVIDENCE_STALE", "PRESSURE_PREVIEW_STALE", "PRESSURE_OVERRIDE_STALE", "PRESSURE_OVERRIDE_MISMATCH", "PRESSURE_OVERRIDE_REASON_REQUIRED", "PRESSURE_OVERRIDE_CONSUMED"];
+export type PressureAdmissionRejectionCode = (typeof PRESSURE_ADMISSION_REJECTION_CODES)[number];
+/** One normalized sample from the bounded machine pressure ring. Ratios are
+ * 0..1 (load1 is load average over cores, so it can exceed 1). */
+export interface PressureAdmissionSample {
+    collectedAt: string;
+    /** Process-inventory generation the sample was collected under, when known. */
+    generation?: string;
+    sampleId?: number;
+    cpu: number;
+    memory: number;
+    disk: number;
+    load1?: number;
+    /** True when this sample crossed the policy's critical thresholds. */
+    critical: boolean;
+}
+/** Attributed cause behind the pressure, from Goal 1 process attribution.
+ * Unknown/manual ownership can explain pressure but is never a cleanup target. */
+export interface PressureAdmissionCause {
+    process: string;
+    processCount: number;
+    cpuPercent: number;
+    rssBytes: number;
+    classification: ProcessOwnershipClass;
+    confidence: ProcessAttributionConfidence;
+    slotId?: string;
+    runId?: string;
+    /** False for unknown/manual ownership — those rows must never be rendered as
+     * cleanup targets, only as explanation. */
+    cleanupEligible: boolean;
+}
+/** Evidence backing an admission decision. `generation` is the preview
+ * identity: execution rejects decisions bound to a generation that no longer
+ * matches the current ring. */
+export interface PressureAdmissionEvidence {
+    machine: string;
+    /** Opaque identity of the latest sample (generation/sampleId/collectedAt
+     * digest). Null when no sample exists — nothing to bind an override to. */
+    generation: string | null;
+    evaluatedAt: string;
+    /** Tail of the bounded ring the policy evaluated, oldest first. */
+    samples: PressureAdmissionSample[];
+    consecutiveCriticalSamples: number;
+    requiredConsecutiveCriticalSamples: number;
+    /** Milliseconds after which the newest sample counts as stale. */
+    staleAfterMs: number;
+    latestSampleAt: string | null;
+    /** Present when a validation-only fixture forced this machine's state.
+     * Real fleet evidence never carries this flag. */
+    validationFixture?: true;
+}
+/** Preview identity carried from an admitted preview into execution. FIND_SLOT
+ * validates it against fresh evidence BEFORE claiming a slot and, on success,
+ * consumes it by stamping `consumedAt` — so a long PREPARE cannot turn a
+ * green-to-green generation move into a failure at launch time. Execution
+ * still recomputes fresh evidence and rejects if pressure became unsafe; an
+ * UNconsumed ref reaching execution (a path that skipped FIND_SLOT
+ * validation) is rejected with PRESSURE_PREVIEW_STALE as defense in depth.
+ * `consumedAt` is gateway-stamped only; client-supplied values are stripped. */
+export interface PressureAdmissionReference {
+    machine: string;
+    pressureGeneration: string;
+    consumedAt?: string;
+}
+/** One-dispatch operator override request. Bound to an exact machine and the
+ * pressure generation the operator saw; execution recomputes and rejects the
+ * override when the generation moved. */
+export interface PressureDispatchOverride {
+    machine: string;
+    pressureGeneration: string;
+    reason: string;
+}
+/** Audit record stamped by the gateway when an override is accepted. */
+export interface PressureOverrideAudit extends PressureDispatchOverride {
+    /** Authenticated principal that requested the override ('system' for
+     * in-process maintenance callers, which cannot originate from an ingress). */
+    principalId: string;
+    requestedAt: string;
+    /** An override never outlives the single dispatch it was issued for. */
+    scope: 'single-dispatch';
+    /**
+     * Durable consumption record, persisted at the launch gate BEFORE the
+     * runner starts (intent before effect). Bound to one exact DISPATCH engine
+     * attempt: a same-attempt provider retry sees its own attempt key and stays
+     * idempotent; a replay or new attempt rejects with
+     * PRESSURE_OVERRIDE_CONSUMED and needs a fresh override.
+     */
+    consumed?: {
+        attemptKey: string;
+        consumedAt: string;
+    };
+}
+/**
+ * What the policy WOULD have rejected with, on a dispatch that was admitted
+ * anyway because the gate is switched off. Advisory only: nothing downstream
+ * may turn this into a refusal.
+ */
+export interface PressureAdmissionAdvisory {
+    code: PressureAdmissionRejectionCode;
+    /** Operator-facing reason. Backend-owned; clients render it verbatim. */
+    reason: string;
+    causes: PressureAdmissionCause[];
+}
+export interface PressureAdmissionAdmitted {
+    outcome: 'admitted';
+    machine: string;
+    state: Extract<PressureAdmissionState, 'green' | 'transient' | 'override' | 'disabled'>;
+    evidence: PressureAdmissionEvidence;
+    /** Present only when state='override': the accepted one-shot override. */
+    override?: PressureOverrideAudit;
+    /**
+     * Present ONLY on state='disabled': the gate is switched off, so this
+     * dispatch was admitted without enforcement. Distinguishes "evaluated and
+     * green" from "not enforced at all".
+     */
+    enforced?: false;
+    /** Present when an unenforced decision would otherwise have been rejected. */
+    advisory?: PressureAdmissionAdvisory;
+}
+export interface PressureAdmissionRejected {
+    outcome: 'rejected';
+    machine: string;
+    state: Extract<PressureAdmissionState, 'sustained-critical' | 'unavailable' | 'stale'>;
+    code: PressureAdmissionRejectionCode;
+    /** Operator-facing reason. Backend-owned; clients render it verbatim. */
+    reason: string;
+    causes: PressureAdmissionCause[];
+    evidence: PressureAdmissionEvidence;
+    /** True when a fresh explicit override against `evidence.generation` can
+     * admit one dispatch. False for unavailable/stale evidence — fail closed. */
+    overridable: boolean;
+}
+export type PressureAdmissionDecision = PressureAdmissionAdmitted | PressureAdmissionRejected;
+/** Gateway-owned durable switch for pressure-based dispatch prevention.
+ * Default DISABLED — sustained-pressure dispatch prevention is opt-in. Enabling
+ * turns on pressure rejection/override prompts; sampling, history, and charts
+ * run either way. Never affects slot ownership, capability, runner, branch, or
+ * other safety checks. */
+export interface PressureAdmissionControlState {
+    enabled: boolean;
+    /** ISO timestamp of the last change; null when still at the default. */
+    updatedAt: string | null;
+    /** Authenticated principal that made the last change; null at the default. */
+    updatedBy: string | null;
+    /**
+     * Set when FARMSLOT_DISPATCH_PRESSURE_ADMISSION is exported on the gateway
+     * process. The env value WINS over the durable state above, which is still
+     * reported verbatim so an operator can see both.
+     */
+    envOverride?: DispatchPressureAdmissionMode;
+}
+export interface PressureAdmissionSetEnabledParams {
+    enabled: boolean;
+}
+export type PressureAdmissionGetResult = PressureAdmissionControlState;
+export type PressureAdmissionSetEnabledResult = PressureAdmissionControlState;
+export declare function isPressureAdmissionRejected(decision: PressureAdmissionDecision | undefined): decision is PressureAdmissionRejected;
+//# sourceMappingURL=pressure-admission.d.ts.map