lorenz 0.1.0

package/packages/dispatch-coordinator/dist/index.js

@@ -0,0 +1,16 @@
+// @lorenz/dispatch-coordinator
+//
+// Runtime-facing coordinator that wraps the proven @lorenz/worker-pool
+// machine pool and an injected McpEndpointManager to mint per-run RunSlots.
+// Distinct from the pure-policy @lorenz/dispatch package.
+//
+// STEP 1 surface: the DispatchCoordinator is a 1:1 passthrough over WorkerPool
+// (default slotsPerMachine=1 + the null McpEndpointManager make every RunSlot
+// carry mcpEndpoint=null), so the runtime boundary is byte-identical to calling
+// the WorkerPool directly. Later steps add per-run MCP endpoints, co-residence, and
+// a provider hot-swap behind this same surface.
+export { createDispatchCoordinator, EndpointOpenError, RunSlotCollisionError, } from "./coordinator.js";
+export { nullEndpointManager, createNullEndpointManager } from "./nullEndpointManager.js";
+export { createPerRunEndpointManager, } from "./mcpEndpointManager.js";
+export { checkSlotsPerMachineGate } from "./gate.js";
+//# sourceMappingURL=index.js.map

package/packages/dispatch-coordinator/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,uEAAuE;AACvE,4EAA4E;AAC5E,0DAA0D;AAC1D,EAAE;AACF,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,oFAAoF;AACpF,gDAAgD;AAEhD,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,GAQtB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAE1F,OAAO,EACL,2BAA2B,GAG5B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAwC,MAAM,WAAW,CAAC"}

package/packages/dispatch-coordinator/dist/mcpEndpointManager.d.ts

@@ -0,0 +1,28 @@
+import type { Settings } from "@lorenz/domain";
+import type { AgentMcpEndpointLease } from "@lorenz/mcp";
+import type { McpEndpointManager } from "./types.js";
+/**
+ * The injected per-run endpoint acquirer. Structurally matches
+ * `acquireAgentMcpEndpointForRun(settings, workerHost, runKey)` from
+ * `@lorenz/mcp`, which issues the token, refcounts the local server, and opens
+ * the per-run tunnel via `workerHostPool.openForRun(...)`, returning ONE lease
+ * whose `release()` revokes the token, drops the local-server ref, and calls
+ * `closeForRun(...)` (all three sub-resources owned together).
+ */
+export type AcquireAgentMcpEndpointForRun = (settings: Settings, workerHost: string, runKey: string) => Promise<AgentMcpEndpointLease>;
+/** Constructor deps for {@link createPerRunEndpointManager}. */
+export interface CreatePerRunEndpointManagerDeps {
+    /** The injected `acquireAgentMcpEndpointForRun`-shaped function (from `@lorenz/mcp`). */
+    acquireForRun: AcquireAgentMcpEndpointForRun;
+}
+/**
+ * Constructs the CONCRETE per-run {@link McpEndpointManager} (`perRunEndpoint =
+ * true`, the capability the STEP 3 startup gate consumes). For an ssh-addressable
+ * `workerHost` it opens the WHOLE per-run endpoint lease via the injected
+ * `acquireForRun`; for a local (empty) host it returns `null` (acp keeps its
+ * own endpoint, the byte-identical local path). `release(lease)` closes the lease
+ * (revoking the token, dropping the local-server ref, and closing the per-run
+ * tunnel together) and is a safe no-op for the `null` local lease.
+ */
+export declare function createPerRunEndpointManager(deps: CreatePerRunEndpointManagerDeps): McpEndpointManager;
+//# sourceMappingURL=mcpEndpointManager.d.ts.map

package/packages/dispatch-coordinator/dist/mcpEndpointManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpEndpointManager.d.ts","sourceRoot":"","sources":["../src/mcpEndpointManager.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAC1C,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAEpC,gEAAgE;AAChE,MAAM,WAAW,+BAA+B;IAC9C,yFAAyF;IACzF,aAAa,EAAE,6BAA6B,CAAC;CAC9C;AAaD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,+BAA+B,GACpC,kBAAkB,CAuBpB"}

package/packages/dispatch-coordinator/dist/mcpEndpointManager.js

@@ -0,0 +1,54 @@
+// The CONCRETE per-run McpEndpointManager (STEP 2 / T2c).
+//
+// Where the NULL passthrough mints nothing (acp keeps owning its own endpoint),
+// this manager OWNS the WHOLE per-run MCP endpoint lease (auth token + refcounted
+// local mcp server + reverse tunnel, bundled behind one `AgentMcpEndpointLease`)
+// so two co-resident runs on one machine never share a single host-keyed endpoint.
+//
+// Dependency direction (invariant #8): this package must stay free of any
+// `@lorenz/mcp` / tunnel RUNTIME dependency, so the concrete acquire function
+// (`acquireAgentMcpEndpointForRun`) is INJECTED, not imported. The daemon wiring
+// (apps/cli/daemon.ts), which already depends on `@lorenz/mcp`, threads the real
+// function in. The `AgentMcpEndpointLease` type is pulled in TYPE-ONLY (fully
+// erased by tsc), so no runtime edge to `@lorenz/mcp` is formed here.
+/**
+ * A `workerHost` is LOCAL (no per-run endpoint needed; acp keeps acquiring AND
+ * releasing its own endpoint exactly as today) when it is empty. Every other
+ * value is a real ssh-addressable host the per-run endpoint is opened against.
+ * This mirrors acp's truthy-host => remote rule, so the single-slot / local path
+ * stays byte-identical.
+ */
+function isLocalWorkerHost(workerHost) {
+    return workerHost.length === 0;
+}
+/**
+ * Constructs the CONCRETE per-run {@link McpEndpointManager} (`perRunEndpoint =
+ * true`, the capability the STEP 3 startup gate consumes). For an ssh-addressable
+ * `workerHost` it opens the WHOLE per-run endpoint lease via the injected
+ * `acquireForRun`; for a local (empty) host it returns `null` (acp keeps its
+ * own endpoint, the byte-identical local path). `release(lease)` closes the lease
+ * (revoking the token, dropping the local-server ref, and closing the per-run
+ * tunnel together) and is a safe no-op for the `null` local lease.
+ */
+export function createPerRunEndpointManager(deps) {
+    const { acquireForRun } = deps;
+    return {
+        perRunEndpoint: true,
+        async open(req) {
+            if (isLocalWorkerHost(req.workerHost)) {
+                // Local host: mint nothing so acp keeps acquiring AND releasing its own
+                // endpoint (the single-slot / local path is untouched).
+                return null;
+            }
+            return acquireForRun(req.settings, req.workerHost, req.runKey);
+        },
+        async release(lease) {
+            // The local path minted no lease; releasing null is a safe no-op so the
+            // RunSlot settle path is uniform whether or not an endpoint was opened.
+            if (lease === null)
+                return;
+            await lease.release();
+        },
+    };
+}
+//# sourceMappingURL=mcpEndpointManager.js.map

package/packages/dispatch-coordinator/dist/mcpEndpointManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpEndpointManager.js","sourceRoot":"","sources":["../src/mcpEndpointManager.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,EAAE;AACF,gFAAgF;AAChF,kFAAkF;AAClF,iFAAiF;AACjF,mFAAmF;AACnF,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,iFAAiF;AACjF,iFAAiF;AACjF,8EAA8E;AAC9E,sEAAsE;AA2BtE;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,UAAkB;IAC3C,OAAO,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC;AACjC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAAqC;IAErC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;IAC/B,OAAO;QACL,cAAc,EAAE,IAAI;QACpB,KAAK,CAAC,IAAI,CAAC,GAIV;YACC,IAAI,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACtC,wEAAwE;gBACxE,wDAAwD;gBACxD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACjE,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,KAAmC;YAC/C,wEAAwE;YACxE,wEAAwE;YACxE,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO;YAC3B,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/packages/dispatch-coordinator/dist/nullEndpointManager.d.ts

@@ -0,0 +1,18 @@
+import type { McpEndpointManager } from "./types.js";
+/**
+ * The no-op {@link McpEndpointManager} used by the STEP 1 passthrough
+ * coordinator. `perRunEndpoint` is `false` (the capability the STEP 3 gate
+ * reads), `open()` resolves to `null` (no per-run endpoint is minted, so acp
+ * owns its own endpoint as today), and `release(null)` is a no-op. Stateless and
+ * therefore safe to share as a singleton.
+ */
+export declare const nullEndpointManager: McpEndpointManager;
+/**
+ * Constructs a fresh NULL passthrough {@link McpEndpointManager}. The shared
+ * {@link nullEndpointManager} singleton is sufficient (the manager is
+ * stateless), but a factory keeps the construction site symmetric with the
+ * concrete remote manager landing in STEP 2 and lets a caller hold a distinct
+ * instance if it wants reference identity.
+ */
+export declare function createNullEndpointManager(): McpEndpointManager;
+//# sourceMappingURL=nullEndpointManager.d.ts.map

package/packages/dispatch-coordinator/dist/nullEndpointManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullEndpointManager.d.ts","sourceRoot":"","sources":["../src/nullEndpointManager.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAahC,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,kBAAkB,CAE9D"}

package/packages/dispatch-coordinator/dist/nullEndpointManager.js

@@ -0,0 +1,40 @@
+// The NULL passthrough McpEndpointManager.
+//
+// STEP 1 wiring: when no concrete per-run endpoint manager is injected, the
+// coordinator uses this null manager so it stays a 1:1 passthrough over the
+// existing WorkerPool. `perRunEndpoint` is `false`, so acp keeps acquiring AND
+// releasing its OWN endpoint exactly as today (byte-identical runtime
+// behaviour); `open` mints nothing (returns null) and `release` is a no-op. It
+// holds no state, so a single frozen singleton is safe to share.
+/**
+ * The no-op {@link McpEndpointManager} used by the STEP 1 passthrough
+ * coordinator. `perRunEndpoint` is `false` (the capability the STEP 3 gate
+ * reads), `open()` resolves to `null` (no per-run endpoint is minted, so acp
+ * owns its own endpoint as today), and `release(null)` is a no-op. Stateless and
+ * therefore safe to share as a singleton.
+ */
+export const nullEndpointManager = Object.freeze({
+    perRunEndpoint: false,
+    async open() {
+        // Mints nothing: acp keeps owning its own endpoint (the STEP 1 byte-identical
+        // path). The trivial await keeps the method genuinely async (the port's
+        // contract is `Promise`-returning) without an unused-await lint conflict.
+        await Promise.resolve();
+        return null;
+    },
+    async release() {
+        // noop: the null manager never holds a lease.
+        await Promise.resolve();
+    },
+});
+/**
+ * Constructs a fresh NULL passthrough {@link McpEndpointManager}. The shared
+ * {@link nullEndpointManager} singleton is sufficient (the manager is
+ * stateless), but a factory keeps the construction site symmetric with the
+ * concrete remote manager landing in STEP 2 and lets a caller hold a distinct
+ * instance if it wants reference identity.
+ */
+export function createNullEndpointManager() {
+    return nullEndpointManager;
+}
+//# sourceMappingURL=nullEndpointManager.js.map

package/packages/dispatch-coordinator/dist/nullEndpointManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullEndpointManager.js","sourceRoot":"","sources":["../src/nullEndpointManager.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,+EAA+E;AAC/E,sEAAsE;AACtE,+EAA+E;AAC/E,iEAAiE;AAIjE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAuB,MAAM,CAAC,MAAM,CAAC;IACnE,cAAc,EAAE,KAAK;IACrB,KAAK,CAAC,IAAI;QACR,8EAA8E;QAC9E,wEAAwE;QACxE,0EAA0E;QAC1E,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,KAAK,CAAC,OAAO;QACX,8CAA8C;QAC9C,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1B,CAAC;CACF,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,mBAAmB,CAAC;AAC7B,CAAC"}

package/packages/dispatch-coordinator/dist/types.d.ts

@@ -0,0 +1,119 @@
+import type { Settings } from "@lorenz/domain";
+import type { AgentMcpEndpointLease } from "@lorenz/mcp";
+import type { WorkerOutcome } from "@lorenz/worker-pool";
+/**
+ * One run's slot over a leased machine. A `RunSlot` fuses the machine-side
+ * {@link WorkerLease} sub-handle (settle/heartbeat) with this run's optional
+ * per-run MCP endpoint lease, plus the registry identity the coordinator keys
+ * fairness/recycle accounting on.
+ *
+ * `release(outcome)` / `fail(reason)` are idempotent and exactly-once across
+ * BOTH the normal settle path and a machine-recycle-initiated fail: they close
+ * THIS slot's endpoint (a no-op when `mcpEndpoint` is null, as in STEP 1) THEN
+ * delegate to the wrapped `WorkerLease` (itself leaseId+settled+DESTROYED guarded)
+ * THEN deregister from the coordinator's registry.
+ *
+ * In STEP 1 the coordinator is a 1:1 passthrough: `mcpEndpoint` is always null,
+ * so `release`/`fail` are byte-identical to the underlying `WorkerLease` settle.
+ */
+export interface RunSlot {
+    /** Stable per-slot identity used as the registry key (issueId/slotIndex/leaseId derived). */
+    readonly slotId: string;
+    /** Identity of the underlying leased machine (the `WorkerLease.workerId`). */
+    readonly machineLeaseId: string;
+    /** The issue this slot serves (drives per-issue fairness accounting). */
+    readonly issueId: string;
+    /** The ensemble slot index this run occupies on its machine. */
+    readonly slotIndex: number;
+    /** The wrapped `WorkerLease` generation id; rotates on retry, settle-guarded. */
+    readonly leaseId: string;
+    /** SSH-addressable worker host this slot runs against. */
+    readonly workerHost: string;
+    /** Issue-scoped per-run key (`${issueId}#${slotIndex}`) feeding the per-run endpoint/tunnel. */
+    readonly runKey: string;
+    /** The WHOLE per-run endpoint lease, or null in STEP 1 / on the local path. */
+    readonly mcpEndpoint: AgentMcpEndpointLease | null;
+    /** Mirrors `WorkerLease.acquiredAtMs` (the lease-bind timestamp). */
+    readonly acquiredAtMs: number;
+    /** Forwards to `WorkerLease.heartbeat()` (orphan-detection keepalive). */
+    heartbeat(): void;
+    /**
+     * Settle this slot exactly once: close the endpoint (noop for null) THEN
+     * settle the wrapped lease with `outcome` (`healthy` keeps the worker, `poison`
+     * recycles it) THEN deregister. A second call is a no-op.
+     */
+    release(outcome: WorkerOutcome): Promise<void>;
+    /**
+     * Settle this slot exactly once as a failure (equivalent to
+     * `release('poison')` with a recorded `reason`). A second call is a no-op.
+     */
+    fail(reason: string): Promise<void>;
+}
+/**
+ * Request to acquire a {@link RunSlot}. Mirrors the worker-pool `AcquireRequest`
+ * shape so the STEP 1 coordinator can pass it straight through to `pool.acquire`
+ * (1:1 passthrough). `affinityKey` is the prior `workerHost` for sticky retry,
+ * NOT the pending sentinel.
+ */
+export interface AcquireRunSlotRequest {
+    issueId: string;
+    slotIndex: number;
+    labels: ReadonlyArray<string>;
+    affinityKey?: string | null;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    /**
+     * The FULL workflow {@link Settings}, threaded straight to
+     * `McpEndpointManager.open`. The concrete per-run manager reads
+     * `settings.server.port` (via `acquireAgentMcpEndpointForRun`) to build the
+     * remote endpoint, so the coordinator must forward the workflow Settings here -
+     * NOT its own `WorkerPoolSettings`, which has no `server.port` and would make an
+     * enabled per-run-endpoint pool fail at acquire and never dispatch. The null
+     * passthrough ignores it.
+     *
+     * Optional only so a legacy passthrough caller that pre-dates this field (and
+     * already injects a full Settings as the coordinator's constructor `settings`)
+     * keeps compiling; the production runtime ALWAYS supplies it.
+     */
+    settings?: Settings;
+    /**
+     * Whether THIS run actually consumes a per-run MCP endpoint over the reverse
+     * tunnel. Only the ACP/Claude executor reads the threaded `mcpEndpoint` (its
+     * `/mcp` server is reached through the reverse tunnel); the Codex/appserver
+     * executor runs its dynamic tools IN-PROCESS and IGNORES the endpoint entirely.
+     *
+     * When `false`, the coordinator SKIPS `mcpEndpointManager.open` AND the
+     * tunnel-ceiling reservation/accounting for this acquire (the bound slot's
+     * `mcpEndpoint` stays null), so a Codex worker-pool run is never SKIPPED by
+     * mcp_endpoint_open_failed, remote port-forward restrictions, or
+     * maxConcurrentTunnels for an endpoint it would never use.
+     *
+     * Defaults to `true` (the existing ACP behaviour) when omitted, so a legacy
+     * caller that pre-dates this field keeps opening the per-run endpoint exactly as
+     * before. The production runtime computes it from the resolved executor kind
+     * (`acp` -> true; `appserver`/codex -> false).
+     */
+    needsMcpEndpoint?: boolean;
+}
+/**
+ * The injected port the coordinator uses to own each run's WHOLE MCP endpoint
+ * (token + refcounted local server + reverse tunnel) behind ONE lease object.
+ * `perRunEndpoint` is the capability the STEP 3 startup gate consumes: the NULL
+ * passthrough reports `false` (acp keeps acquiring/releasing its own endpoint,
+ * the STEP 1 byte-identical behaviour); a concrete remote manager reports `true`.
+ *
+ * `open` returns null when this manager does not mint a per-run endpoint (the
+ * NULL passthrough always, or the concrete manager on a local/non-ssh host).
+ * `release` accepts that null and is a no-op for it, so the RunSlot settle path
+ * is uniform whether or not an endpoint was minted.
+ */
+export interface McpEndpointManager {
+    readonly perRunEndpoint: boolean;
+    open(req: {
+        settings: Settings;
+        workerHost: string;
+        runKey: string;
+    }): Promise<AgentMcpEndpointLease | null>;
+    release(lease: AgentMcpEndpointLease | null): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/dispatch-coordinator/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO;IACtB,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACnD,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,SAAS,IAAI,IAAI,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,IAAI,CAAC,GAAG,EAAE;QACR,QAAQ,EAAE,QAAQ,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC;IAC1C,OAAO,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D"}

package/packages/dispatch-coordinator/dist/types.js

@@ -0,0 +1,17 @@
+// Shared types for @lorenz/dispatch-coordinator.
+//
+// Leaf types module: every implementation file (runSlot, mcpEndpointManager, the
+// coordinator) imports from here so concrete files never form import cycles. The
+// only cross-package value dependencies are the canonical worker-pool/domain nouns.
+//
+// `AgentMcpEndpointLease` (from `@lorenz/mcp`) is the WHOLE per-run endpoint
+// lease (auth token + refcounted local mcp server + reverse tunnel) the
+// coordinator owns end-to-end in later steps. It is pulled in with a TYPE-ONLY
+// import so it is fully erased by tsc and forms NO runtime edge to
+// `@lorenz/mcp` (which pulls in the observability server, the tunnel pool,
+// hono, etc.) - keeping this package (and `worker-pool`) free of any
+// mcp/tunnel RUNTIME dependency (invariant #8 in the dispatch-coordinator plan).
+// In STEP 1 every RunSlot carries `mcpEndpoint = null`, so nothing here reads the
+// lease at runtime yet; the type lives here only to nail the contract shape.
+export {};
+//# sourceMappingURL=types.js.map

package/packages/dispatch-coordinator/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,EAAE;AACF,iFAAiF;AACjF,iFAAiF;AACjF,oFAAoF;AACpF,EAAE;AACF,6EAA6E;AAC7E,wEAAwE;AACxE,+EAA+E;AAC/E,mEAAmE;AACnE,2EAA2E;AAC3E,qEAAqE;AACrE,iFAAiF;AACjF,kFAAkF;AAClF,6EAA6E"}

package/packages/dispatch-coordinator/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@lorenz/dispatch-coordinator",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@lorenz/domain": "file:../domain",
+    "@lorenz/mcp": "file:../mcp",
+    "@lorenz/worker-pool": "file:../worker-pool"
+  }
+}