@kontextmind/kxm 0.7.71 → 0.7.72

package/plugins/kxm/src/hub.ts

@@ -4,6 +4,7 @@ import { createServer, type IncomingMessage, type Server, type ServerResponse }
 import { isIP } from "node:net";
 import { dirname, join, resolve } from "node:path";
 import {
+  DEFAULT_LEASE_TTL_MS,
   DEFAULT_MAX_HOPS,
   DEFAULT_MESSAGE_RETENTION_MS,
   DEFAULT_MESSAGE_TTL_MS,
@@ -13,7 +14,10 @@ import {
   MAX_AGENT_HOST_CHARS,
   MAX_BODY_BYTES,
   MAX_CONTENT_CHARS,
+  MAX_LEASE_RESOURCE_CHARS,
+  MAX_LEASE_TTL_MS,
   MAX_MESSAGE_TTL_MS,
+  MIN_LEASE_TTL_MS,
   MIN_MESSAGE_TTL_MS,
   MIN_MESSAGE_RETENTION_MS,
   ProtocolError,
@@ -27,6 +31,7 @@ import {
   type AgentRecord,
   type DeliveryMode,
   type HubEvent,
+  type LeaseRecord,
   type MessageRecord,
   type WorkflowMessageContext,
 } from "./protocol.ts";
@@ -39,7 +44,7 @@ import { NativeStateProvider } from "./state.ts";
 import { SkillLifecycle } from "./skills.ts";
 import { compileKnowledgeWiki, lintKnowledgeWiki, type WikiSourcePool } from "./wiki.ts";
 import { buildRetrospective, writeRetrospective } from "./retrospective.ts";
-import { MeshStore, type StoredAgent } from "./store.ts";
+import { MeshStore, type LeaseRefusal, type StoredAgent } from "./store.ts";
 import {
   canonicalWorkflowEvidenceKey,
   approveWorkflowDegradation,
@@ -91,6 +96,10 @@ export interface MeshHubOptions {
   skillsDir?: string;
   skillLifecycle?: SkillLifecycle;
   repoRoot?: string;
+  /** The hub clock every lease decision reads. Injectable so a test can move a
+   * lease past its deadline instead of sleeping through a real TTL; production
+   * leaves it at `Date.now`. It is never a client-supplied time. */
+  now?: () => number;
 }
 
 export interface MeshHub {
@@ -132,6 +141,38 @@ function safeTokenEqual(actual: string | undefined, expected: string): boolean {
   return timingSafeStringCompare(actual, expected);
 }
 
+/** The wire answer for a lease the hub will not extend or release. Every one of
+ * these means the caller's token no longer authorizes a shared write: the
+ * holder must stop, not retry. The current lease rides along so the caller can
+ * record who holds the resource now. */
+function leaseRefusal(reason: LeaseRefusal, name: string, lease?: LeaseRecord): ProtocolError {
+  if (reason === "missing") {
+    return new ProtocolError(404, `no lease is held on ${name}`, "lease_not_found");
+  }
+  if (reason === "expired") {
+    return new ProtocolError(
+      409,
+      `lease on ${name} expired at ${lease?.expiresAt ?? "its deadline"}; re-acquire to take it over`,
+      "lease_expired",
+      { lease },
+    );
+  }
+  if (reason === "held") {
+    return new ProtocolError(
+      409,
+      `lease on ${name} is held by ${lease?.holderAgentName ?? "another agent"} until ${lease?.expiresAt ?? "its deadline"}`,
+      "lease_held",
+      { lease },
+    );
+  }
+  return new ProtocolError(
+    409,
+    `fencing token for ${name} was superseded; the hub is now at token ${lease?.fencingToken ?? "a newer value"}`,
+    "lease_superseded",
+    { lease },
+  );
+}
+
 function bearerToken(request: IncomingMessage): string | undefined {
   const header = request.headers.authorization;
   return header?.startsWith("Bearer ") ? header.slice(7) : undefined;
@@ -409,6 +450,7 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
       };
   const webhookWorkflows = new Map((options.webhookWorkflows ?? []).map((workflow) => [workflow.id, workflow]));
   const logger = options.logger ?? (() => undefined);
+  const hubNow = options.now ?? (() => Date.now());
   const assetsDir = options.assetsDir;
   const hubRepoRoot = options.repoRoot ?? (options.dataPath && options.dataPath !== ":memory:" ? resolve(dirname(dirname(options.dataPath))) : process.cwd());
   const store = new MeshStore(options.dataPath);
@@ -461,6 +503,9 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
     contextRequests: 0,
     attemptLatencySecondsTotal: 0,
     meteredCostUsdTotal: 0,
+    leasesGranted: 0,
+    leasesRefused: 0,
+    leasesReleased: 0,
   };
   let cleanupTimer: NodeJS.Timeout | undefined;
   let closed = false;
@@ -1065,6 +1110,16 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
     for (const runId of swept.purgedRuns) {
       logger({ event: "workflow_run_purged", runId });
     }
+    for (const lease of swept.purgedLeases) {
+      logger({
+        event: "lease_purged",
+        resource: lease.resource,
+        project: lease.project,
+        agentId: lease.holderAgentId,
+        fencingToken: lease.fencingToken,
+        expiresAt: lease.expiresAt,
+      });
+    }
   }
 
   function metricsBody(): string {
@@ -1112,6 +1167,12 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
       `kxm_attempt_latency_seconds_total ${counters.attemptLatencySecondsTotal}`,
       "# TYPE kxm_metered_cost_usd_total counter",
       `kxm_metered_cost_usd_total ${counters.meteredCostUsdTotal}`,
+      "# TYPE kxm_leases_granted_total counter",
+      `kxm_leases_granted_total ${counters.leasesGranted}`,
+      "# TYPE kxm_leases_refused_total counter",
+      `kxm_leases_refused_total ${counters.leasesRefused}`,
+      "# TYPE kxm_leases_released_total counter",
+      `kxm_leases_released_total ${counters.leasesReleased}`,
       "",
     ].join("\n");
   }
@@ -2198,6 +2259,81 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
         return;
       }
 
+      // One writer, one clock. Every branch below decides inside a single store
+      // transaction, so two agents racing for the same resource cannot both read it
+      // free. The fencing token increments only on takeover, which is what lets a
+      // holder that slept past its deadline be refused at commit instead of writing
+      // behind whoever replaced it.
+      const leaseMatch = url.pathname.match(/^\/v1\/leases\/([^/]+)\/(acquire|renew|release)$/);
+      if (method === "POST" && leaseMatch) {
+        const holder = requireAgent(request);
+        requireProjectAuth(request, holder.project);
+        const name = requireString(decodeURIComponent(leaseMatch[1]!), "resource", { max: MAX_LEASE_RESOURCE_CHARS });
+        const action = leaseMatch[2]!;
+        const body = await readJson(request);
+        // The caller never names the prefix, so the same branch in two projects is
+        // two leases and neither project can reach the other's.
+        const resource = `${holder.project}/${name}`;
+        const nowMs = hubNow();
+        const leaseLog = { resource, project: holder.project, agentId: holder.id, agentName: holder.name };
+
+        if (action === "acquire") {
+          const ttlMs = parseBoundedInteger(body.ttlMs, "ttlMs", DEFAULT_LEASE_TTL_MS, MIN_LEASE_TTL_MS, MAX_LEASE_TTL_MS);
+          const outcome = store.acquireLease({
+            resource,
+            project: holder.project,
+            name,
+            holderAgentId: holder.id,
+            holderAgentName: holder.name,
+            ttlMs,
+            nowMs,
+          });
+          if (!outcome.ok) {
+            counters.leasesRefused += 1;
+            logger({ event: "lease_denied", ...leaseLog, reason: outcome.reason, heldBy: outcome.lease?.holderAgentId });
+            throw leaseRefusal(outcome.reason, name, outcome.lease);
+          }
+          counters.leasesGranted += 1;
+          logger({
+            event: outcome.renewed ? "lease_renewed" : "lease_acquired",
+            ...leaseLog,
+            fencingToken: outcome.lease.fencingToken,
+            expiresAt: outcome.lease.expiresAt,
+          });
+          json(response, 200, { lease: outcome.lease, renewed: outcome.renewed });
+          return;
+        }
+
+        if (body.fencingToken === undefined) {
+          throw new ProtocolError(400, "fencingToken is required", "lease_token_required");
+        }
+        const fencingToken = parseBoundedInteger(body.fencingToken, "fencingToken", 1, 1, Number.MAX_SAFE_INTEGER);
+        if (action === "renew") {
+          const ttlMs = parseBoundedInteger(body.ttlMs, "ttlMs", DEFAULT_LEASE_TTL_MS, MIN_LEASE_TTL_MS, MAX_LEASE_TTL_MS);
+          const outcome = store.renewLease({ resource, holderAgentId: holder.id, fencingToken, ttlMs, nowMs });
+          if (!outcome.ok) {
+            counters.leasesRefused += 1;
+            logger({ event: "lease_denied", ...leaseLog, reason: outcome.reason, fencingToken });
+            throw leaseRefusal(outcome.reason, name, outcome.lease);
+          }
+          counters.leasesGranted += 1;
+          logger({ event: "lease_renewed", ...leaseLog, fencingToken, expiresAt: outcome.lease.expiresAt });
+          json(response, 200, { lease: outcome.lease, renewed: true });
+          return;
+        }
+
+        const outcome = store.releaseLease({ resource, holderAgentId: holder.id, fencingToken });
+        if (!outcome.ok) {
+          counters.leasesRefused += 1;
+          logger({ event: "lease_denied", ...leaseLog, reason: outcome.reason, fencingToken });
+          throw leaseRefusal(outcome.reason, name, outcome.lease);
+        }
+        counters.leasesReleased += 1;
+        logger({ event: "lease_released", ...leaseLog, fencingToken });
+        json(response, 200, { released: true, lease: outcome.lease });
+        return;
+      }
+
       if (method === "GET" && url.pathname === "/v1/events") {
         const agentId = requireString(url.searchParams.get("agentId"), "agentId", { max: 80 });
         const current = requireAgent(request, agentId);

package/plugins/kxm/src/mcp-server.ts

@@ -8,7 +8,7 @@ import { AGENT_COMMANDS_MAP, enforceToolPolicy, getMcpTools, reconcileInbox } fr
 import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 
-const VERSION = "0.7.71";
+const VERSION = "0.7.72";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;

package/plugins/kxm/src/protocol.ts

@@ -13,6 +13,10 @@ export const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
 export const MAX_BODY_BYTES = 256 * 1024;
 export const MAX_CONTENT_CHARS = 32_000;
 export const MAX_AGENT_HOST_CHARS = 64;
+export const MIN_LEASE_TTL_MS = 5_000;
+export const MAX_LEASE_TTL_MS = 10 * 60_000;
+export const DEFAULT_LEASE_TTL_MS = 5 * 60_000;
+export const MAX_LEASE_RESOURCE_CHARS = 200;
 
 export type DeliveryMode = "steer" | "followUp" | "nextTurn";
 export type MessageStatus = "queued" | "delivered" | "replied" | "cancelled" | "expired" | "error";
@@ -68,6 +72,27 @@ export function toAgentRecord(agent: AgentIdentity, staleAfterMs?: number, now?:
   return { ...agent, ...agentPresenceView(agent, staleAfterMs, now) };
 }
 
+/** One hub-held fenced lease over a project-scoped resource.
+ *
+ * `resource` is what the store keys on: the caller's project prefixed onto the
+ * name it asked for, so two projects naming the same branch never contend.
+ * Expiry is the hub's clock, never the holder's, and `fencingToken` increments
+ * only when a new holder takes over an expired lease — a renewal keeps its
+ * token, so a writer that comes back after a takeover can be told its token
+ * was superseded instead of being allowed to commit. */
+export interface LeaseRecord {
+  /** `${project}/${name}`. */
+  resource: string;
+  project: string;
+  /** The resource as the caller named it, without the project prefix. */
+  name: string;
+  holderAgentId: string;
+  holderAgentName: string;
+  fencingToken: number;
+  acquiredAt: string;
+  expiresAt: string;
+}
+
 export interface MessageReply {
   content: string;
   createdAt: string;

package/plugins/kxm/src/store.ts

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import type { DatabaseSync } from "./sqlite.ts";
-import type { AgentIdentity, MessageRecord } from "./protocol.ts";
+import type { AgentIdentity, LeaseRecord, MessageRecord } from "./protocol.ts";
 import type { ContextItem } from "./context.ts";
 import type { WorkflowJournalEntry, WorkflowRun } from "./workflow.ts";
 import {
@@ -9,7 +9,7 @@ import {
   type DatabaseSchemaSpec,
 } from "./database.ts";
 
-export const HUB_STORE_SCHEMA_VERSION = 3;
+export const HUB_STORE_SCHEMA_VERSION = 4;
 
 export const HUB_STORE_TABLES: Readonly<Record<string, readonly string[]>> = Object.freeze({
   agents: Object.freeze(["id", "record"]),
@@ -19,9 +19,10 @@ export const HUB_STORE_TABLES: Readonly<Record<string, readonly string[]>> = Obj
   workflow_runs: Object.freeze(["id", "definition_id", "delivery_id", "record"]),
   workflow_journal: Object.freeze(["id", "run_id", "category", "area", "record"]),
   context_items: Object.freeze(["id", "project", "kind", "record"]),
+  leases: Object.freeze(["resource", "holder_agent_id", "fencing_token", "expires_at", "record"]),
 });
 
-export const HUB_STORE_SCHEMA_V3 = `
+export const HUB_STORE_SCHEMA_V4 = `
   CREATE TABLE IF NOT EXISTS agents (
     id TEXT PRIMARY KEY,
     record TEXT NOT NULL
@@ -70,10 +71,17 @@ export const HUB_STORE_SCHEMA_V3 = `
     record TEXT NOT NULL
   ) STRICT;
   CREATE INDEX IF NOT EXISTS context_items_project ON context_items(project);
+  CREATE TABLE IF NOT EXISTS leases (
+    resource TEXT PRIMARY KEY,
+    holder_agent_id TEXT NOT NULL,
+    fencing_token INTEGER NOT NULL,
+    expires_at TEXT NOT NULL,
+    record TEXT NOT NULL
+  ) STRICT;
 `;
 
 export const HUB_STORE_SCHEMA_SPEC: DatabaseSchemaSpec = Object.freeze({
-  schema: HUB_STORE_SCHEMA_V3,
+  schema: HUB_STORE_SCHEMA_V4,
   version: HUB_STORE_SCHEMA_VERSION,
   tables: HUB_STORE_TABLES,
 });
@@ -85,6 +93,40 @@ export interface StoredAgent extends AgentIdentity {
   key: string;
 }
 
+/** Why a lease call did not get the resource. `held` is live contention,
+ * `superseded` is a token the hub has already moved past, `expired` is a lease
+ * whose hub-clocked deadline has passed, and `missing` is no lease at all. */
+export type LeaseRefusal = "held" | "superseded" | "expired" | "missing";
+
+export type LeaseOutcome =
+  | { ok: true; lease: LeaseRecord; renewed: boolean }
+  | { ok: false; reason: LeaseRefusal; lease?: LeaseRecord };
+
+export interface LeaseAcquireInput {
+  resource: string;
+  project: string;
+  name: string;
+  holderAgentId: string;
+  holderAgentName: string;
+  ttlMs: number;
+  nowMs: number;
+}
+
+function parseLeaseRecord(record: string): LeaseRecord | undefined {
+  try {
+    return JSON.parse(record) as LeaseRecord;
+  } catch {
+    return undefined;
+  }
+}
+
+/** A deadline the hub cannot read is an expired deadline. The alternative — a
+ * lease nobody can ever take over — is the worse failure. */
+function leaseHasLapsed(lease: LeaseRecord, nowMs: number): boolean {
+  const expiresAtMs = Date.parse(lease.expiresAt);
+  return !Number.isFinite(expiresAtMs) || expiresAtMs <= nowMs;
+}
+
 class MessageMap extends Map<string, MessageRecord> {
   private readonly store: MeshStore;
 
@@ -124,6 +166,7 @@ export class MeshStore {
   readonly workflowRuns = new Map<string, WorkflowRun>();
   readonly journal = new Map<string, WorkflowJournalEntry>();
   readonly contextItems = new Map<string, ContextItem>();
+  readonly leases = new Map<string, LeaseRecord>();
   readonly path?: string;
   private readonly database?: DatabaseSync;
   private readonly agentSequences = new Map<string, number>();
@@ -331,6 +374,140 @@ export class MeshStore {
     return result;
   }
 
+  /** Read the lease over one already project-scoped resource. */
+  getLease(resource: string): LeaseRecord | undefined {
+    if (!this.database) return this.leases.get(resource);
+    const row = this.database.prepare("SELECT record FROM leases WHERE resource = ?").get(resource) as { record: string } | undefined;
+    if (!row) {
+      this.leases.delete(resource);
+      return undefined;
+    }
+    const lease = parseLeaseRecord(row.record);
+    if (lease) this.leases.set(resource, lease);
+    return lease;
+  }
+
+  /**
+   * Take or extend the lease over `resource`, deciding the whole outcome inside
+   * one transaction so two writers cannot both read "free" and both insert.
+   *
+   * The token is the fence: a first acquisition starts at 1, the holder's own
+   * re-acquisition keeps its token, and only a takeover of an expired lease
+   * increments it. That is what lets a holder that wakes up after its deadline
+   * be refused at commit rather than silently writing behind the new holder.
+   */
+  acquireLease(input: LeaseAcquireInput): LeaseOutcome {
+    return this.inLeaseTransaction(() => {
+      const current = this.readLeaseForUpdate(input.resource);
+      const expired = current !== undefined && leaseHasLapsed(current, input.nowMs);
+      if (current && !expired && current.holderAgentId !== input.holderAgentId) {
+        return { ok: false, reason: "held", lease: current };
+      }
+      const fencingToken = current === undefined
+        ? 1
+        : expired
+          ? current.fencingToken + 1
+          : current.fencingToken;
+      const renewed = current !== undefined && !expired;
+      const lease: LeaseRecord = {
+        resource: input.resource,
+        project: input.project,
+        name: input.name,
+        holderAgentId: input.holderAgentId,
+        holderAgentName: input.holderAgentName,
+        fencingToken,
+        acquiredAt: renewed && current ? current.acquiredAt : new Date(input.nowMs).toISOString(),
+        expiresAt: new Date(input.nowMs + input.ttlMs).toISOString(),
+      };
+      this.writeLease(lease);
+      return { ok: true, lease, renewed };
+    });
+  }
+
+  /** Extend a lease the caller still holds under the token it was given. The
+   * token never changes on renewal — a renewal that would need a new token is
+   * a takeover, and takeovers go through `acquireLease`. */
+  renewLease(input: {
+    resource: string;
+    holderAgentId: string;
+    fencingToken: number;
+    ttlMs: number;
+    nowMs: number;
+  }): LeaseOutcome {
+    return this.inLeaseTransaction(() => {
+      const current = this.readLeaseForUpdate(input.resource);
+      if (!current) return { ok: false, reason: "missing" };
+      if (current.holderAgentId !== input.holderAgentId || current.fencingToken !== input.fencingToken) {
+        return { ok: false, reason: "superseded", lease: current };
+      }
+      if (leaseHasLapsed(current, input.nowMs)) {
+        // The deadline passed, so the resource is takeable by anyone. Resurrecting it
+        // under the old token would let a second holder appear behind the first.
+        return { ok: false, reason: "expired", lease: current };
+      }
+      const lease: LeaseRecord = { ...current, expiresAt: new Date(input.nowMs + input.ttlMs).toISOString() };
+      this.writeLease(lease);
+      return { ok: true, lease, renewed: true };
+    });
+  }
+
+  /** Drop a lease the caller holds. A clean release ends the fence: there is no
+   * stale writer left to keep a token for, so the next acquisition starts over. */
+  releaseLease(input: { resource: string; holderAgentId: string; fencingToken: number }): LeaseOutcome {
+    return this.inLeaseTransaction(() => {
+      const current = this.readLeaseForUpdate(input.resource);
+      if (!current) return { ok: false, reason: "missing" };
+      if (current.holderAgentId !== input.holderAgentId || current.fencingToken !== input.fencingToken) {
+        return { ok: false, reason: "superseded", lease: current };
+      }
+      this.deleteLease(input.resource);
+      return { ok: true, lease: current, renewed: false };
+    });
+  }
+
+  /** Every lease of one project, newest deadline last. Reader surface only. */
+  listLeases(project: string): LeaseRecord[] {
+    if (this.database) {
+      const rows = this.database.prepare("SELECT record FROM leases").all() as Array<{ record: string }>;
+      this.leases.clear();
+      for (const row of rows) {
+        const lease = parseLeaseRecord(row.record);
+        if (lease) this.leases.set(lease.resource, lease);
+      }
+    }
+    return [...this.leases.values()]
+      .filter((lease) => lease.project === project)
+      .sort((left, right) => left.resource.localeCompare(right.resource));
+  }
+
+  private inLeaseTransaction(work: () => LeaseOutcome): LeaseOutcome {
+    if (!this.database) return work();
+    return withDatabaseTransaction(this.database, work);
+  }
+
+  private readLeaseForUpdate(resource: string): LeaseRecord | undefined {
+    if (!this.database) return this.leases.get(resource);
+    const row = this.database.prepare("SELECT record FROM leases WHERE resource = ?").get(resource) as { record: string } | undefined;
+    return row ? parseLeaseRecord(row.record) : undefined;
+  }
+
+  private writeLease(lease: LeaseRecord): void {
+    this.leases.set(lease.resource, lease);
+    this.database?.prepare(`
+      INSERT INTO leases (resource, holder_agent_id, fencing_token, expires_at, record) VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(resource) DO UPDATE SET
+        holder_agent_id = excluded.holder_agent_id,
+        fencing_token = excluded.fencing_token,
+        expires_at = excluded.expires_at,
+        record = excluded.record
+    `).run(lease.resource, lease.holderAgentId, lease.fencingToken, lease.expiresAt, JSON.stringify(lease));
+  }
+
+  private deleteLease(resource: string): void {
+    this.leases.delete(resource);
+    this.database?.prepare("DELETE FROM leases WHERE resource = ?").run(resource);
+  }
+
   deleteWorkflowRun(runId: string): void {
     this.workflowRuns.delete(runId);
     this.database?.prepare("DELETE FROM workflow_runs WHERE id = ?").run(runId);
@@ -355,6 +532,7 @@ export class MeshStore {
     purgedRuns: string[];
     purgedJournal: string[];
     purgedContextItems: string[];
+    purgedLeases: LeaseRecord[];
   } {
     const messageCutoffMs = nowMs - messageRetentionMs;
     const messageCutoffIso = new Date(messageCutoffMs).toISOString();
@@ -363,6 +541,7 @@ export class MeshStore {
     const purgedRuns: string[] = [];
     const purgedJournal: string[] = [];
     const purgedContextItems: string[] = [];
+    const purgedLeases: LeaseRecord[] = [];
 
     // 1. Messages
     if (!this.database) {
@@ -441,7 +620,31 @@ export class MeshStore {
       purgedContextItems.push(id);
     }
 
-    return { purgedMessages, purgedRuns, purgedJournal, purgedContextItems };
+    // 5. Leases. An expired lease row is kept on purpose — its token is what a
+    // takeover increments, so reaping it the moment it lapses would let the
+    // fence restart at 1 while a stale holder was still alive. Only rows whose
+    // deadline is older than the retention window, far beyond any live holder's
+    // TTL, are dropped.
+    const leaseCutoffMs = nowMs - runRetentionMs;
+    for (const lease of this.listAllLeases()) {
+      if (leaseHasLapsed(lease, leaseCutoffMs)) {
+        this.deleteLease(lease.resource);
+        purgedLeases.push(lease);
+      }
+    }
+
+    return { purgedMessages, purgedRuns, purgedJournal, purgedContextItems, purgedLeases };
+  }
+
+  private listAllLeases(): LeaseRecord[] {
+    if (!this.database) return [...this.leases.values()];
+    const rows = this.database.prepare("SELECT record FROM leases").all() as Array<{ record: string }>;
+    const result: LeaseRecord[] = [];
+    for (const row of rows) {
+      const lease = parseLeaseRecord(row.record);
+      if (lease) result.push(lease);
+    }
+    return result;
   }
 
   saveWorkflowRun(run: WorkflowRun): void {
@@ -528,6 +731,7 @@ export class MeshStore {
     const workflowRows = this.database.prepare("SELECT record FROM workflow_runs").all() as Array<{ record: string }>;
     const journalRows = this.database.prepare("SELECT record FROM workflow_journal").all() as Array<{ record: string }>;
     const contextRows = this.database.prepare("SELECT record FROM context_items").all() as Array<{ record: string }>;
+    const leaseRows = this.database.prepare("SELECT record FROM leases").all() as Array<{ record: string }>;
     for (const row of agentRows) {
       const agent = JSON.parse(row.record) as StoredAgent;
       this.agents.set(agent.id, agent);
@@ -544,5 +748,9 @@ export class MeshStore {
       const item = JSON.parse(row.record) as ContextItem;
       this.contextItems.set(item.id, item);
     }
+    for (const row of leaseRows) {
+      const lease = parseLeaseRecord(row.record);
+      if (lease) this.leases.set(lease.resource, lease);
+    }
   }
 }