@sentropic/h2a-runtime 0.88.0 → 0.90.0

package/dist/session-lease.d.ts

@@ -0,0 +1,266 @@
+/**
+ * MACHINE-SCOPED session lease store.
+ *
+ * WHY THIS EXISTS. Nine subcontractor sessions, verifiably FINISHED, held 4 325
+ * minutes of concurrency slot for 61.4 minutes of real work (ratio 1:70). The
+ * pool stood at 15 of 12 — over cap, with zero of them working. It was never
+ * scarce; it was hoarded.
+ *
+ * THE DISTINCTION THAT DECIDES THE DESIGN: those sessions were not DEAD, they
+ * were FINISHED — a live process that no longer works (the composer back on its
+ * placeholder, "Worked for X" on screen). Death and inactivity are DISJOINT
+ * modes. A lock released on process death would have freed NONE of them, and
+ * neither does `sweepStaleJobs` (delegate.ts), which skips anything `isJobLive`.
+ * This store covers INACTIVITY: a finished-but-alive session stops beating, so
+ * `now − heartbeatAt > ttlMs` declares it abandoned after 30 minutes instead of
+ * 994.
+ *
+ * THE PATTERN IS `packages/track/src/lease/store.ts`; the LOCATION is not.
+ * Track's store is REPO-scoped (`.track/leases.json`). The concurrency pool is
+ * MACHINE-scoped: sessions from h2a-Impots, h2a-geo, h2a-immo, h2a-kog and
+ * h2a-openerp all consume it, so a lease filed in one repo's `.track/` cannot
+ * arbitrate a resource several repos contend for. It also would make pool
+ * correctness depend on repo identity, which DERIVES. So the file sits beside
+ * `registry.json` in the h2a config dir — the same machine-scoped home the
+ * session registry already uses, under NO `.track/` and under no repo.
+ *
+ * WHAT IS BORROWED FROM TRACK, VERBATIM IN SPIRIT:
+ *  - abandonment is CLOCKLESS, COMPUTED BY THE READER: the caller injects `now`
+ *    and a lease is abandoned iff `now − heartbeatAt > ttlMs`. The store holds
+ *    no clock of its own — `now` is a REQUIRED constructor dependency here
+ *    (stricter than track, which defaults it), so no code path can stamp a
+ *    timestamp from an implicit clock;
+ *  - one ACTIVE lease per subject (here: per session id);
+ *  - each acquisition mints a fresh, unguessable `token`; only the holder
+ *    presenting the matching token may heartbeat, observe or release.
+ *
+ * WHAT THE TOKEN DOES AND DOES NOT GUARANTEE. It is a GENERATION guard, not a
+ * secret: it is persisted in the same file, so any local process that can read
+ * the store can read it. What it structurally prevents is a stale holder — one
+ * that slept through its own abandonment — renewing or releasing the lease that
+ * REPLACED its own. That property is enforced by the code and tested; secrecy
+ * against a local reader is not claimed.
+ */
+/**
+ * Default lease TTL. 30 minutes, the same figure track settled on: long enough
+ * that a session pausing between two tool calls is never mistaken for finished,
+ * short enough that a finished-but-alive session frees its slot within one
+ * working bout instead of the 994 minutes measured on the worst hoarder.
+ */
+export declare const DEFAULT_SESSION_LEASE_TTL_MS: number;
+/**
+ * The CPU rate (ms of CPU per second of wall clock, over a pane's whole process
+ * TREE) at or above which a session counts as WORKING and its lease is beaten.
+ *
+ * MEASURED on this workstation, 2026-07-30: 64 panes across 59 tmux sessions,
+ * one 150 s window, same /proc arithmetic as `proc-cpu.ts`, each pane classified
+ * by what its TUI showed at BOTH ends of the window:
+ *
+ *   idle-but-alive   n=59   median 12 ms/s   p95 23 ms/s   max 53 ms/s
+ *   working          n=2    142 and 146 ms/s
+ *
+ * 75 ms/s sits in the empty band between the two: above EVERY idle sample
+ * observed, well under the working ones. What the measurement does NOT
+ * establish, and this comment will not pretend it does: the working mode rests
+ * on two panes, and a session that works while burning little CPU — one long
+ * network wait, one tool call every ten minutes — reads as finished-but-alive
+ * here. That is survivable only because the decision this constant drives is
+ * whether to BEAT, never whether to kill: a session judged idle is merely
+ * PROPOSED for reclamation to a human or conductor, who can still see it.
+ */
+export declare const DEFAULT_WORKING_CPU_MS_PER_SECOND = 75;
+/** A CPU observation of the session's pane process tree, at a point in time. */
+export interface SessionCpuSample {
+    /** Cumulative CPU (ms) of the pane's whole process tree — `paneTreeCpuMs`. */
+    cpuMs: number;
+    /** ISO-8601 instant the sample was taken (caller-injected clock). */
+    sampledAt: string;
+}
+/**
+ * A lease on one SESSION's concurrency slot. Persisted verbatim in
+ * `session-leases.json`. Abandonment is NOT a stored field: it is computed by
+ * the reader against an injected `now`.
+ */
+export interface SessionLease {
+    leaseId: string;
+    /** Registry entry id of the leased session (a job id / session id). */
+    sessionId: string;
+    /** Who holds the slot — the launching surface or the supervising pass. */
+    holder: string;
+    /** Informational provenance: the repo/cwd the session was launched from. The
+     *  lease is NOT scoped by it — the pool is machine-wide. */
+    workspace?: string;
+    acquiredAt: string;
+    heartbeatAt: string;
+    expiresAt: string;
+    ttlMs: number;
+    /** Per-acquisition generation guard (see the module header). */
+    token: string;
+    /** Last CPU observation — the evidence the beat decision is derived from. */
+    sample?: SessionCpuSample;
+}
+/** Rejected lease operation (wrong token, absent lease, subject already held). */
+export declare class SessionLeaseError extends Error {
+    constructor(message: string);
+}
+/**
+ * Is `lease` abandoned at `now`? PURE and CLOCKLESS: abandoned iff
+ * `now − heartbeatAt > ttlMs`. The single abandonment predicate — reused by the
+ * acquire guard, by the reclaim report, and by callers deciding what to show.
+ */
+export declare function isSessionLeaseAbandoned(lease: SessionLease, now: string): boolean;
+/**
+ * CPU rate (ms of CPU per second of wall clock) between the lease's last
+ * observation and `cpuMsNow` taken at `now`. Undefined when there is no prior
+ * sample, when the elapsed window is not positive, or when the counter went
+ * BACKWARDS (the pane's tree was replaced — a relaunch, or PID reuse): a
+ * negative delta is not a rate, and must never be read as "idle". PURE.
+ */
+export declare function cpuRateMsPerSecond(lease: SessionLease, cpuMsNow: number, now: string): number | undefined;
+/**
+ * What a supervising pass should do with one lease, given a fresh CPU reading.
+ * PURE — the probe is the caller's effect, the decision is testable here.
+ *
+ *  - `beat`     — the tree burned CPU at or above `workingRateMsPerSecond`: the
+ *                 session is WORKING, renew its lease.
+ *  - `observe`  — alive but under the bar (finished-but-alive), or no prior
+ *                 sample to compare against: record the reading WITHOUT renewing,
+ *                 so the TTL keeps running and the next pass has a baseline.
+ *  - `unknown`  — no CPU reading at all (pane gone or unreadable). We do NOT
+ *                 beat: an unreadable pane is not proof of work. We also do not
+ *                 release: this store never decides a session is dead.
+ */
+export type SessionBeatAction = "beat" | "observe" | "unknown";
+export interface SessionBeatDecision {
+    action: SessionBeatAction;
+    /** The computed rate when one could be computed (diagnostics + reporting). */
+    rateMsPerSecond?: number;
+    reason: "working" | "under-threshold" | "no-baseline" | "no-cpu-reading";
+}
+export declare function decideSessionBeat(input: {
+    lease: SessionLease;
+    /** Fresh `paneTreeCpuMs` reading, or undefined when the pane cannot be read. */
+    cpuMsNow: number | undefined;
+    now: string;
+    workingRateMsPerSecond?: number;
+}): SessionBeatDecision;
+/** One abandoned lease, described so a caller can decide whether to reclaim it. */
+export interface SessionReclaimProposal {
+    sessionId: string;
+    holder: string;
+    /** How long the lease has gone unbeaten at `now` (ms). */
+    idleMs: number;
+    ttlMs: number;
+    heartbeatAt: string;
+    /** CPU rate over the whole unbeaten window, when a sample exists (ms/s). */
+    lastRateMsPerSecond?: number;
+}
+/**
+ * The abandoned leases at `now`, as PROPOSALS. This function proposes; it never
+ * executes and never signals a process. A lease still inside its TTL — i.e. one
+ * that still beats — is structurally excluded: the only filter is
+ * `isSessionLeaseAbandoned`, so a beating session can never appear here. PURE.
+ */
+export declare function reclaimProposals(leases: ReadonlyArray<SessionLease>, now: string): SessionReclaimProposal[];
+/**
+ * What a supervising pass must do with each recorded lease, BEFORE any probe.
+ * The registry state decides; the CPU probe only happens for `probe` steps.
+ *
+ *  - `release` — the session reached a terminal state, so its slot is already
+ *    free: the lease must not outlive it.
+ *  - `probe`   — the session is still running: read its pane's CPU and let
+ *    `decideSessionBeat` rule.
+ *  - `leave`   — the lease names a session the registry does not know. We do NOT
+ *    release it: a missing or unreadable registry would otherwise wipe the
+ *    leases of sessions that ARE working. It ages out and gets reported.
+ */
+export type LeaseSupervisionStep = {
+    sessionId: string;
+    action: "release";
+    reason: "terminal";
+} | {
+    sessionId: string;
+    action: "probe";
+    tmuxSession?: string;
+} | {
+    sessionId: string;
+    action: "leave";
+    reason: "unregistered";
+};
+/** The registry facts this planner needs — structural, so no registry import. */
+export interface LeasedSessionState {
+    id: string;
+    jobState?: string;
+    tmuxSession?: string;
+}
+export declare function planLeaseSupervision(leases: ReadonlyArray<SessionLease>, sessions: ReadonlyArray<LeasedSessionState>): LeaseSupervisionStep[];
+/** Machine-scoped path of the session-lease side-store (beside `registry.json`). */
+export declare function resolveSessionLeasePath(): string;
+/**
+ * The session-lease side-store. Every mutation runs under the store's OWN
+ * lockfile (never the registry's) and is written atomically (tmp + rename).
+ *
+ * `now` is a REQUIRED dependency: the store stamps `acquiredAt`/`heartbeatAt`/
+ * `expiresAt` from it, and holds no clock of its own. Abandonment is still the
+ * READER's call — `abandoned(now)` takes the instant explicitly, with no default.
+ */
+export declare class SessionLeaseStore {
+    private readonly leasesPath;
+    private readonly clock;
+    private readonly newId;
+    constructor(leasesPath: string, deps: {
+        now: () => string;
+        newId?: () => string;
+    });
+    /** Every recorded lease (live OR abandoned — liveness is the reader's call). */
+    readAll(): SessionLease[];
+    /** The lease recorded for a session, live or abandoned, if any. */
+    forSession(sessionId: string): SessionLease | undefined;
+    /** The leases abandoned at `now` (explicit instant — the store adds no clock). */
+    abandoned(now: string): SessionLease[];
+    /**
+     * Take the slot for `sessionId`. Rejects when a LIVE lease already covers it
+     * (one active lease per session). An ABANDONED prior lease does not block: the
+     * new acquisition replaces it and mints a FRESH token, so the previous holder
+     * can never beat or release what replaced its lease. An initial `cpuMs`
+     * baseline may be supplied so the first supervising pass can compute a rate.
+     */
+    acquire(input: {
+        sessionId: string;
+        holder: string;
+        workspace?: string;
+        ttlMs?: number;
+        cpuMs?: number;
+    }): SessionLease;
+    /**
+     * Renew a lease — the holder's assertion that the session is WORKING. Only the
+     * matching token is accepted. Resets the reader's abandonment window and, when
+     * `cpuMs` is supplied, records the reading the assertion was based on.
+     */
+    heartbeat(input: {
+        sessionId: string;
+        token: string;
+        cpuMs?: number;
+    }): SessionLease;
+    /**
+     * Record a CPU reading WITHOUT renewing the lease.
+     *
+     * This is what keeps the abandonment clock honest. A session that worked hard
+     * and then finished would, on the next pass, still show a high AVERAGE rate
+     * since its last beat and win itself another renewal it no longer deserves.
+     * Observing separates the two acts: the baseline moves, the TTL does not.
+     */
+    observe(input: {
+        sessionId: string;
+        token: string;
+        cpuMs: number;
+    }): SessionLease;
+    /** Give the slot back. Only the matching token is accepted. */
+    release(input: {
+        sessionId: string;
+        token: string;
+    }): void;
+    /** Shared token-guarded read-modify-write for `heartbeat` and `observe`. */
+    private mutate;
+}
+//# sourceMappingURL=session-lease.d.ts.map

package/dist/session-lease.d.ts.map

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

package/dist/session-lease.js

@@ -0,0 +1,342 @@
+/**
+ * MACHINE-SCOPED session lease store.
+ *
+ * WHY THIS EXISTS. Nine subcontractor sessions, verifiably FINISHED, held 4 325
+ * minutes of concurrency slot for 61.4 minutes of real work (ratio 1:70). The
+ * pool stood at 15 of 12 — over cap, with zero of them working. It was never
+ * scarce; it was hoarded.
+ *
+ * THE DISTINCTION THAT DECIDES THE DESIGN: those sessions were not DEAD, they
+ * were FINISHED — a live process that no longer works (the composer back on its
+ * placeholder, "Worked for X" on screen). Death and inactivity are DISJOINT
+ * modes. A lock released on process death would have freed NONE of them, and
+ * neither does `sweepStaleJobs` (delegate.ts), which skips anything `isJobLive`.
+ * This store covers INACTIVITY: a finished-but-alive session stops beating, so
+ * `now − heartbeatAt > ttlMs` declares it abandoned after 30 minutes instead of
+ * 994.
+ *
+ * THE PATTERN IS `packages/track/src/lease/store.ts`; the LOCATION is not.
+ * Track's store is REPO-scoped (`.track/leases.json`). The concurrency pool is
+ * MACHINE-scoped: sessions from h2a-Impots, h2a-geo, h2a-immo, h2a-kog and
+ * h2a-openerp all consume it, so a lease filed in one repo's `.track/` cannot
+ * arbitrate a resource several repos contend for. It also would make pool
+ * correctness depend on repo identity, which DERIVES. So the file sits beside
+ * `registry.json` in the h2a config dir — the same machine-scoped home the
+ * session registry already uses, under NO `.track/` and under no repo.
+ *
+ * WHAT IS BORROWED FROM TRACK, VERBATIM IN SPIRIT:
+ *  - abandonment is CLOCKLESS, COMPUTED BY THE READER: the caller injects `now`
+ *    and a lease is abandoned iff `now − heartbeatAt > ttlMs`. The store holds
+ *    no clock of its own — `now` is a REQUIRED constructor dependency here
+ *    (stricter than track, which defaults it), so no code path can stamp a
+ *    timestamp from an implicit clock;
+ *  - one ACTIVE lease per subject (here: per session id);
+ *  - each acquisition mints a fresh, unguessable `token`; only the holder
+ *    presenting the matching token may heartbeat, observe or release.
+ *
+ * WHAT THE TOKEN DOES AND DOES NOT GUARANTEE. It is a GENERATION guard, not a
+ * secret: it is persisted in the same file, so any local process that can read
+ * the store can read it. What it structurally prevents is a stale holder — one
+ * that slept through its own abandonment — renewing or releasing the lease that
+ * REPLACED its own. That property is enforced by the code and tested; secrecy
+ * against a local reader is not claimed.
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveConfigDir } from "./config.js";
+import { withFileLock } from "./file-lock.js";
+/**
+ * Default lease TTL. 30 minutes, the same figure track settled on: long enough
+ * that a session pausing between two tool calls is never mistaken for finished,
+ * short enough that a finished-but-alive session frees its slot within one
+ * working bout instead of the 994 minutes measured on the worst hoarder.
+ */
+export const DEFAULT_SESSION_LEASE_TTL_MS = 30 * 60_000;
+/**
+ * The CPU rate (ms of CPU per second of wall clock, over a pane's whole process
+ * TREE) at or above which a session counts as WORKING and its lease is beaten.
+ *
+ * MEASURED on this workstation, 2026-07-30: 64 panes across 59 tmux sessions,
+ * one 150 s window, same /proc arithmetic as `proc-cpu.ts`, each pane classified
+ * by what its TUI showed at BOTH ends of the window:
+ *
+ *   idle-but-alive   n=59   median 12 ms/s   p95 23 ms/s   max 53 ms/s
+ *   working          n=2    142 and 146 ms/s
+ *
+ * 75 ms/s sits in the empty band between the two: above EVERY idle sample
+ * observed, well under the working ones. What the measurement does NOT
+ * establish, and this comment will not pretend it does: the working mode rests
+ * on two panes, and a session that works while burning little CPU — one long
+ * network wait, one tool call every ten minutes — reads as finished-but-alive
+ * here. That is survivable only because the decision this constant drives is
+ * whether to BEAT, never whether to kill: a session judged idle is merely
+ * PROPOSED for reclamation to a human or conductor, who can still see it.
+ */
+export const DEFAULT_WORKING_CPU_MS_PER_SECOND = 75;
+/** Rejected lease operation (wrong token, absent lease, subject already held). */
+export class SessionLeaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SessionLeaseError";
+    }
+}
+/**
+ * Is `lease` abandoned at `now`? PURE and CLOCKLESS: abandoned iff
+ * `now − heartbeatAt > ttlMs`. The single abandonment predicate — reused by the
+ * acquire guard, by the reclaim report, and by callers deciding what to show.
+ */
+export function isSessionLeaseAbandoned(lease, now) {
+    return Date.parse(now) - Date.parse(lease.heartbeatAt) > lease.ttlMs;
+}
+/**
+ * CPU rate (ms of CPU per second of wall clock) between the lease's last
+ * observation and `cpuMsNow` taken at `now`. Undefined when there is no prior
+ * sample, when the elapsed window is not positive, or when the counter went
+ * BACKWARDS (the pane's tree was replaced — a relaunch, or PID reuse): a
+ * negative delta is not a rate, and must never be read as "idle". PURE.
+ */
+export function cpuRateMsPerSecond(lease, cpuMsNow, now) {
+    const previous = lease.sample;
+    if (previous === undefined)
+        return undefined;
+    const elapsedMs = Date.parse(now) - Date.parse(previous.sampledAt);
+    if (!Number.isFinite(elapsedMs) || elapsedMs <= 0)
+        return undefined;
+    const deltaMs = cpuMsNow - previous.cpuMs;
+    if (deltaMs < 0)
+        return undefined;
+    return (deltaMs / elapsedMs) * 1000;
+}
+export function decideSessionBeat(input) {
+    if (input.cpuMsNow === undefined) {
+        return { action: "unknown", reason: "no-cpu-reading" };
+    }
+    const rate = cpuRateMsPerSecond(input.lease, input.cpuMsNow, input.now);
+    if (rate === undefined) {
+        return { action: "observe", reason: "no-baseline" };
+    }
+    const bar = input.workingRateMsPerSecond ?? DEFAULT_WORKING_CPU_MS_PER_SECOND;
+    return rate >= bar
+        ? { action: "beat", rateMsPerSecond: rate, reason: "working" }
+        : { action: "observe", rateMsPerSecond: rate, reason: "under-threshold" };
+}
+/**
+ * The abandoned leases at `now`, as PROPOSALS. This function proposes; it never
+ * executes and never signals a process. A lease still inside its TTL — i.e. one
+ * that still beats — is structurally excluded: the only filter is
+ * `isSessionLeaseAbandoned`, so a beating session can never appear here. PURE.
+ */
+export function reclaimProposals(leases, now) {
+    const nowMs = Date.parse(now);
+    return leases
+        .filter((lease) => isSessionLeaseAbandoned(lease, now))
+        .map((lease) => {
+        const idleMs = nowMs - Date.parse(lease.heartbeatAt);
+        const proposal = {
+            sessionId: lease.sessionId,
+            holder: lease.holder,
+            idleMs,
+            ttlMs: lease.ttlMs,
+            heartbeatAt: lease.heartbeatAt,
+        };
+        return proposal;
+    })
+        .sort((a, b) => b.idleMs - a.idleMs);
+}
+export function planLeaseSupervision(leases, sessions) {
+    const byId = new Map(sessions.map((session) => [session.id, session]));
+    return leases.map((lease) => {
+        const session = byId.get(lease.sessionId);
+        if (session === undefined) {
+            return { sessionId: lease.sessionId, action: "leave", reason: "unregistered" };
+        }
+        if (session.jobState === "done" || session.jobState === "failed") {
+            return { sessionId: lease.sessionId, action: "release", reason: "terminal" };
+        }
+        return {
+            sessionId: lease.sessionId,
+            action: "probe",
+            ...(session.tmuxSession !== undefined ? { tmuxSession: session.tmuxSession } : {}),
+        };
+    });
+}
+/** Machine-scoped path of the session-lease side-store (beside `registry.json`). */
+export function resolveSessionLeasePath() {
+    return join(resolveConfigDir(), "session-leases.json");
+}
+/**
+ * The session-lease side-store. Every mutation runs under the store's OWN
+ * lockfile (never the registry's) and is written atomically (tmp + rename).
+ *
+ * `now` is a REQUIRED dependency: the store stamps `acquiredAt`/`heartbeatAt`/
+ * `expiresAt` from it, and holds no clock of its own. Abandonment is still the
+ * READER's call — `abandoned(now)` takes the instant explicitly, with no default.
+ */
+export class SessionLeaseStore {
+    leasesPath;
+    clock;
+    newId;
+    constructor(leasesPath, deps) {
+        this.leasesPath = leasesPath;
+        this.clock = deps.now;
+        this.newId = deps.newId ?? (() => randomBytes(12).toString("hex"));
+    }
+    /** Every recorded lease (live OR abandoned — liveness is the reader's call). */
+    readAll() {
+        return readLeaseFile(this.leasesPath);
+    }
+    /** The lease recorded for a session, live or abandoned, if any. */
+    forSession(sessionId) {
+        return this.readAll().find((lease) => lease.sessionId === sessionId);
+    }
+    /** The leases abandoned at `now` (explicit instant — the store adds no clock). */
+    abandoned(now) {
+        return this.readAll().filter((lease) => isSessionLeaseAbandoned(lease, now));
+    }
+    /**
+     * Take the slot for `sessionId`. Rejects when a LIVE lease already covers it
+     * (one active lease per session). An ABANDONED prior lease does not block: the
+     * new acquisition replaces it and mints a FRESH token, so the previous holder
+     * can never beat or release what replaced its lease. An initial `cpuMs`
+     * baseline may be supplied so the first supervising pass can compute a rate.
+     */
+    acquire(input) {
+        return withFileLock(this.leasesPath, () => {
+            const all = readLeaseFile(this.leasesPath);
+            const now = this.clock();
+            const existing = all.find((lease) => lease.sessionId === input.sessionId);
+            if (existing !== undefined && !isSessionLeaseAbandoned(existing, now)) {
+                throw new SessionLeaseError(`session-lease: ${input.sessionId} is already held by ${existing.holder} (one active lease per session)`);
+            }
+            const ttlMs = input.ttlMs ?? DEFAULT_SESSION_LEASE_TTL_MS;
+            const lease = {
+                leaseId: this.newId(),
+                sessionId: input.sessionId,
+                holder: input.holder,
+                ...(input.workspace !== undefined ? { workspace: input.workspace } : {}),
+                acquiredAt: now,
+                heartbeatAt: now,
+                expiresAt: new Date(Date.parse(now) + ttlMs).toISOString(),
+                ttlMs,
+                token: this.newId(),
+                ...(input.cpuMs !== undefined
+                    ? { sample: { cpuMs: input.cpuMs, sampledAt: now } }
+                    : {}),
+            };
+            const next = all.filter((l) => l.sessionId !== input.sessionId);
+            next.push(lease);
+            writeLeaseFile(this.leasesPath, next);
+            return lease;
+        });
+    }
+    /**
+     * Renew a lease — the holder's assertion that the session is WORKING. Only the
+     * matching token is accepted. Resets the reader's abandonment window and, when
+     * `cpuMs` is supplied, records the reading the assertion was based on.
+     */
+    heartbeat(input) {
+        return this.mutate(input.sessionId, input.token, "heartbeat", (lease) => {
+            const now = this.clock();
+            return {
+                ...lease,
+                heartbeatAt: now,
+                expiresAt: new Date(Date.parse(now) + lease.ttlMs).toISOString(),
+                ...(input.cpuMs !== undefined
+                    ? { sample: { cpuMs: input.cpuMs, sampledAt: now } }
+                    : {}),
+            };
+        });
+    }
+    /**
+     * Record a CPU reading WITHOUT renewing the lease.
+     *
+     * This is what keeps the abandonment clock honest. A session that worked hard
+     * and then finished would, on the next pass, still show a high AVERAGE rate
+     * since its last beat and win itself another renewal it no longer deserves.
+     * Observing separates the two acts: the baseline moves, the TTL does not.
+     */
+    observe(input) {
+        return this.mutate(input.sessionId, input.token, "observe", (lease) => ({
+            ...lease,
+            sample: { cpuMs: input.cpuMs, sampledAt: this.clock() },
+        }));
+    }
+    /** Give the slot back. Only the matching token is accepted. */
+    release(input) {
+        withFileLock(this.leasesPath, () => {
+            const all = readLeaseFile(this.leasesPath);
+            const idx = all.findIndex((lease) => lease.sessionId === input.sessionId);
+            if (idx === -1) {
+                throw new SessionLeaseError(`session-lease: no lease to release for ${input.sessionId}`);
+            }
+            if (all[idx].token !== input.token) {
+                throw new SessionLeaseError(`session-lease: release token mismatch for ${input.sessionId} — only the holder may release`);
+            }
+            all.splice(idx, 1);
+            writeLeaseFile(this.leasesPath, all);
+        });
+    }
+    /** Shared token-guarded read-modify-write for `heartbeat` and `observe`. */
+    mutate(sessionId, token, verb, apply) {
+        return withFileLock(this.leasesPath, () => {
+            const all = readLeaseFile(this.leasesPath);
+            const idx = all.findIndex((lease) => lease.sessionId === sessionId);
+            if (idx === -1) {
+                throw new SessionLeaseError(`session-lease: no lease to ${verb} for ${sessionId}`);
+            }
+            const lease = all[idx];
+            if (lease.token !== token) {
+                throw new SessionLeaseError(`session-lease: ${verb} token mismatch for ${sessionId} — only the holder may ${verb}`);
+            }
+            const next = apply(lease);
+            all[idx] = next;
+            writeLeaseFile(this.leasesPath, all);
+            return next;
+        });
+    }
+}
+/** Shape guard — a torn or hand-edited row must not poison the whole store. */
+function isSessionLease(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const lease = value;
+    return (typeof lease.leaseId === "string" &&
+        typeof lease.sessionId === "string" &&
+        typeof lease.holder === "string" &&
+        typeof lease.acquiredAt === "string" &&
+        typeof lease.heartbeatAt === "string" &&
+        typeof lease.token === "string" &&
+        typeof lease.ttlMs === "number");
+}
+/**
+ * Read + parse the store. A missing, empty or garbled file degrades to `[]` —
+ * the side-store is advisory, and a read must never throw into a launch path.
+ * The consequence is stated plainly: a corrupt store forgets every lease, which
+ * makes slots look FREE (admits work), never held.
+ */
+function readLeaseFile(leasesPath) {
+    if (!existsSync(leasesPath))
+        return [];
+    try {
+        const raw = readFileSync(leasesPath, "utf8").trim();
+        if (raw === "")
+            return [];
+        const parsed = JSON.parse(raw);
+        const leases = parsed?.leases;
+        if (!Array.isArray(leases))
+            return [];
+        return leases.filter(isSessionLease);
+    }
+    catch {
+        return [];
+    }
+}
+/** Atomic write: tmp file in the same dir, then rename (as the registry does). */
+function writeLeaseFile(leasesPath, leases) {
+    mkdirSync(dirname(leasesPath), { recursive: true });
+    const tmp = `${leasesPath}.tmp.${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify({ version: 1, leases }, null, 2)}\n`, "utf8");
+    renameSync(tmp, leasesPath);
+}
+//# sourceMappingURL=session-lease.js.map

package/dist/session-lease.js.map

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