lorenz 0.1.5 → 0.1.7

package/node_modules/@lorenz/tool-sdk/dist/module.js

@@ -0,0 +1,42 @@
+import { makeSdkModuleContract } from "@lorenz/domain";
+/**
+ * The tool SDK version this build of the engine speaks. Out-of-tree tool-pack
+ * modules declare the version they target via {@link ToolProviderModule.sdkVersion};
+ * the loader rejects a mismatch before the module ever reaches the registry.
+ * Major-only: additive, backwards-compatible SDK changes never bump it.
+ */
+export const TOOL_SDK_VERSION = 1;
+const contract = makeSdkModuleContract({
+    errorPrefix: "tool_provider",
+    moduleNoun: "a tool provider module",
+    identityField: "name",
+    defineCall: "defineToolProvider({ name, sdkVersion, toolSpecs, executeTool })",
+    requiredFns: [
+        { field: "toolSpecs", signature: "toolSpecs(settings)", article: "a" },
+        { field: "executeTool", signature: "executeTool(name, input, context)", article: "an" },
+    ],
+    sdkVersion: TOOL_SDK_VERSION,
+});
+/**
+ * Structural check + version handshake for a dynamically loaded tool module.
+ * `source` names where the value came from so every error is actionable.
+ */
+export const assertToolProviderModule = contract.assertModule;
+/**
+ * Authoring sugar for out-of-tree tool modules: shape-asserts the module at
+ * definition time (so a typo fails in the author's tests, not the operator's
+ * daemon) and returns it unchanged. Usage:
+ *
+ * ```ts
+ * export default defineToolProvider({
+ *   name: "acme",
+ *   sdkVersion: 1,
+ *   toolSpecs: (settings) => [...],
+ *   executeTool: (name, input, context) => acmeExecute(name, input, context),
+ * });
+ * ```
+ */
+export function defineToolProvider(module) {
+    return contract.defineModule(module, "defineToolProvider");
+}
+//# sourceMappingURL=module.js.map

package/node_modules/@lorenz/tool-sdk/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAIvD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAYlC,MAAM,QAAQ,GAAG,qBAAqB,CAAqB;IACzD,WAAW,EAAE,eAAe;IAC5B,UAAU,EAAE,wBAAwB;IACpC,aAAa,EAAE,MAAM;IACrB,UAAU,EAAE,kEAAkE;IAC9E,WAAW,EAAE;QACX,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,qBAAqB,EAAE,OAAO,EAAE,GAAG,EAAE;QACtE,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,mCAAmC,EAAE,OAAO,EAAE,IAAI,EAAE;KACxF;IACD,UAAU,EAAE,gBAAgB;CAC7B,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAGM,QAAQ,CAAC,YAAY,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAA0B;IAC3D,OAAO,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAC7D,CAAC"}

package/node_modules/@lorenz/tracker-sdk/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { TrackerContext, TrackerComment, TrackerCreateIssueInput, TrackerOpsContext, TrackerProvider, TrackerQueryResult, TrackerToolOps, } from "./provider.js";
+export type { TrackerContext, TrackerComment, TrackerProvider } from "./provider.js";
 export { TrackerRegistry, defaultTrackerRegistry } from "./registry.js";
 export { rejectUnknownOptions, resolveEnvReference, stringListOption, stringOption, } from "./options.js";
-export { createTrackerToolProvider } from "./toolPack.js";
+export { TRACKER_SDK_VERSION, assertTrackerProviderModule, defineTrackerProvider, type TrackerProviderModule, } from "./module.js";
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@lorenz/tracker-sdk/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC"}

package/node_modules/@lorenz/tracker-sdk/dist/index.js

@@ -1,4 +1,4 @@
 export { TrackerRegistry, defaultTrackerRegistry } from "./registry.js";
 export { rejectUnknownOptions, resolveEnvReference, stringListOption, stringOption, } from "./options.js";
-export { createTrackerToolProvider } from "./toolPack.js";
+export { TRACKER_SDK_VERSION, assertTrackerProviderModule, defineTrackerProvider, } from "./module.js";
 //# sourceMappingURL=index.js.map

package/node_modules/@lorenz/tracker-sdk/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,qBAAqB,GAEtB,MAAM,aAAa,CAAC"}

package/node_modules/@lorenz/tracker-sdk/dist/module.d.ts

@@ -0,0 +1,37 @@
+import type { TrackerProvider } from "./provider.js";
+/**
+ * The tracker SDK version this build of the engine speaks. Out-of-tree tracker
+ * modules declare the version they target via {@link TrackerProviderModule.sdkVersion};
+ * the loader rejects a mismatch before the module ever reaches the registry.
+ * Major-only: additive, backwards-compatible SDK changes never bump it.
+ */
+export declare const TRACKER_SDK_VERSION = 1;
+/**
+ * The unit an OUT-OF-TREE tracker module exports: a {@link TrackerProvider}
+ * carrying the SDK version it targets. A dynamically imported module crosses a
+ * version boundary the daemon cannot type-check, so the explicit `sdkVersion`
+ * handshake stands in for the compiler.
+ */
+export interface TrackerProviderModule extends TrackerProvider {
+    readonly sdkVersion: number;
+}
+/**
+ * Structural check + version handshake for a dynamically loaded tracker module.
+ * `source` names where the value came from so every error is actionable.
+ */
+export declare const assertTrackerProviderModule: (value: unknown, source: string) => asserts value is TrackerProviderModule;
+/**
+ * Authoring sugar for out-of-tree tracker modules: shape-asserts the module at
+ * definition time (so a typo fails in the author's tests, not the operator's
+ * daemon) and returns it unchanged. Usage:
+ *
+ * ```ts
+ * export default defineTrackerProvider({
+ *   kind: "acme",
+ *   sdkVersion: 1,
+ *   createClient: (settings, context) => new AcmeTrackerClient(settings, context),
+ * });
+ * ```
+ */
+export declare function defineTrackerProvider(module: TrackerProviderModule): TrackerProviderModule;
+//# sourceMappingURL=module.d.ts.map

package/node_modules/@lorenz/tracker-sdk/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAWD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,CACxC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,KAAK,IAAI,qBAA6C,CAAC;AAEpE;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,qBAAqB,CAE1F"}

package/node_modules/@lorenz/tracker-sdk/dist/module.js

@@ -0,0 +1,38 @@
+import { makeSdkModuleContract } from "@lorenz/domain";
+/**
+ * The tracker SDK version this build of the engine speaks. Out-of-tree tracker
+ * modules declare the version they target via {@link TrackerProviderModule.sdkVersion};
+ * the loader rejects a mismatch before the module ever reaches the registry.
+ * Major-only: additive, backwards-compatible SDK changes never bump it.
+ */
+export const TRACKER_SDK_VERSION = 1;
+const contract = makeSdkModuleContract({
+    errorPrefix: "tracker_provider",
+    moduleNoun: "a tracker provider module",
+    identityField: "kind",
+    defineCall: "defineTrackerProvider({ kind, sdkVersion, createClient })",
+    requiredFns: [{ field: "createClient", signature: "createClient(settings, context)", article: "a" }],
+    sdkVersion: TRACKER_SDK_VERSION,
+});
+/**
+ * Structural check + version handshake for a dynamically loaded tracker module.
+ * `source` names where the value came from so every error is actionable.
+ */
+export const assertTrackerProviderModule = contract.assertModule;
+/**
+ * Authoring sugar for out-of-tree tracker modules: shape-asserts the module at
+ * definition time (so a typo fails in the author's tests, not the operator's
+ * daemon) and returns it unchanged. Usage:
+ *
+ * ```ts
+ * export default defineTrackerProvider({
+ *   kind: "acme",
+ *   sdkVersion: 1,
+ *   createClient: (settings, context) => new AcmeTrackerClient(settings, context),
+ * });
+ * ```
+ */
+export function defineTrackerProvider(module) {
+    return contract.defineModule(module, "defineTrackerProvider");
+}
+//# sourceMappingURL=module.js.map

package/node_modules/@lorenz/tracker-sdk/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAIvD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAYrC,MAAM,QAAQ,GAAG,qBAAqB,CAAwB;IAC5D,WAAW,EAAE,kBAAkB;IAC/B,UAAU,EAAE,2BAA2B;IACvC,aAAa,EAAE,MAAM;IACrB,UAAU,EAAE,2DAA2D;IACvE,WAAW,EAAE,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,iCAAiC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;IACpG,UAAU,EAAE,mBAAmB;CAChC,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAGM,QAAQ,CAAC,YAAY,CAAC;AAEpE;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAA6B;IACjE,OAAO,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAChE,CAAC"}

package/node_modules/@lorenz/tracker-sdk/dist/provider.d.ts

@@ -1,4 +1,4 @@
-import type { Issue, RuntimeTrackerClient, Settings } from "@lorenz/domain";
+import type { RuntimeTrackerClient, Settings } from "@lorenz/domain";
 /** Ambient dependencies handed to provider hooks that must not touch process globals directly. */
 export interface TrackerContext {
     env: NodeJS.ProcessEnv;
@@ -8,25 +8,7 @@ export interface TrackerContext {
      */
     resolveSecret?: (value: string | undefined, fallbackEnvVar?: string) => string | undefined;
 }
-/** Dependencies for building the normalized tool operations of one tracker. */
-export interface TrackerOpsContext {
-    fetchImpl: typeof fetch;
-}
-/** Input accepted by {@link TrackerToolOps.createIssue}. */
-export interface TrackerCreateIssueInput {
-    title: string;
-    body?: string | undefined;
-    status?: string | undefined;
-    /** Tracker user identity to assign the created issue to when the backend supports assignment. */
-    assignee?: string | undefined;
-}
-/** Natively projected query payload returned by {@link TrackerToolOps.queryRows}. */
-export interface TrackerQueryResult {
-    rows: Array<Record<string, unknown>>;
-    total: number;
-    skipped?: unknown[] | undefined;
-}
-/** Normalized tracker issue comment returned by the provider-neutral comment tools. */
+/** Normalized tracker issue comment returned by tracker clients and their comment tools. */
 export interface TrackerComment {
     id: string;
     body: string;
@@ -35,35 +17,13 @@ export interface TrackerComment {
     updatedAt?: string | null | undefined;
     url?: string | null | undefined;
 }
-/**
- * Normalized issue operations backing the provider-neutral `tracker_*` tool pack. Every
- * member is optional: a missing member makes the corresponding tool report itself as
- * unsupported for this tracker instead of failing mid-call.
- *
- * Backends that filter and project natively (e.g. the local board's query DSL) implement
- * {@link queryRows}; backends that return whole issues implement {@link queryIssues} and let
- * the pack project rows with the shared select/filter helpers.
- */
-export interface TrackerToolOps {
-    readIssue?(issueId: string): Promise<Issue>;
-    /** Issues matching generic query args (`issueIds`, `states`, provider-native queries such as `jql`). */
-    queryIssues?(args: Record<string, unknown>): Promise<Issue[]>;
-    /** Pre-projected rows for backends with a native query surface; takes precedence over {@link queryIssues}. */
-    queryRows?(args: Record<string, unknown>): Promise<TrackerQueryResult>;
-    updateStatus?(issueId: string, status: string): Promise<Issue>;
-    listComments?(issueId: string): Promise<TrackerComment[]>;
-    addComment?(issueId: string, body: string): Promise<TrackerComment | void>;
-    updateComment?(issueId: string, commentId: string, body: string): Promise<TrackerComment>;
-    createIssue?(input: TrackerCreateIssueInput): Promise<Issue>;
-}
 /**
  * Everything Lorenz needs to know about one issue-tracker backend, bundled as a single
- * extension point. A provider owns its slice of the selected tracker bundle, the runtime
- * client that feeds issues into dispatch, and the normalized operations behind the
- * provider-neutral `tracker_*` tools. Agent-facing tool packs are a separate extension
- * point (`ToolProvider` in `@lorenz/tool-sdk`): a tracker package may ship one, declare
- * it as a default pack for this tracker, and a workflow may still mount other registered
- * packs explicitly through its `tools:` map.
+ * extension point. A provider owns its slice of the selected tracker bundle and the runtime
+ * client that feeds issues into dispatch. Agent-facing tool packs are a separate extension
+ * point (`ToolProvider` in `@lorenz/tool-sdk`): a tracker package may ship one and declare
+ * it through {@link defaultToolPacks} so it mounts when this tracker drives dispatch, and a
+ * workflow may still mount other registered packs explicitly through its `tools:` map.
  *
  * The core (config parsing, runtime, MCP server, CLI) is provider-agnostic and talks to
  * providers exclusively through this contract via a {@link TrackerRegistry}. Adding a new
@@ -99,14 +59,10 @@ export interface TrackerProvider {
     /** Build the runtime client that feeds candidate issues into the dispatch loop. */
     createClient(settings: Settings, context: TrackerContext): RuntimeTrackerClient;
     /**
-     * Normalized operations backing the neutral `tracker_*` pack for this backend; return
-     * `undefined` (or omit the member) when the backend exposes no agent-facing operations.
-     */
-    createToolOps?(settings: Settings, context: TrackerOpsContext): TrackerToolOps | undefined;
-    /**
-     * Provider-specific tool packs mounted by default when this tracker drives dispatch.
-     * The core always mounts the neutral `tracker` pack separately; this hook declares any
-     * additional minimum packs owned by the tracker extension.
+     * Tool packs mounted by default when this tracker drives dispatch. This is how a tracker
+     * extension exposes its agent-facing tools (e.g. Jira's `tracker_*` pack, Linear's
+     * `linear_graphql` pack); return the names of the registered {@link ToolProvider} packs the
+     * backend owns. Omit when the backend ships no agent tools.
      */
     defaultToolPacks?(settings: Settings): readonly string[];
     /** Operator-facing URL of the tracked project, shown in dashboards. */

package/node_modules/@lorenz/tracker-sdk/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE5E,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC5F;AAED,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,OAAO,KAAK,CAAC;CACzB;AAED,4DAA4D;AAC5D,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;CACjC;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC5C,wGAAwG;IACxG,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IAC9D,8GAA8G;IAC9G,SAAS,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACvE,YAAY,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/D,YAAY,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC1D,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC3E,aAAa,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1F,WAAW,CAAC,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAC9D;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACtE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACrE,+DAA+D;IAC/D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C;;;;OAIG;IACH,YAAY,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClG;;;OAGG;IACH,gBAAgB,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC5C,mFAAmF;IACnF,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,GAAG,oBAAoB,CAAC;IAChF;;;OAGG;IACH,aAAa,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,cAAc,GAAG,SAAS,CAAC;IAC3F;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,MAAM,EAAE,CAAC;IACzD,uEAAuE;IACvE,UAAU,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;CACrD"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAErE,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC5F;AAED,4FAA4F;AAC5F,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACtE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACrE,+DAA+D;IAC/D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C;;;;OAIG;IACH,YAAY,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClG;;;OAGG;IACH,gBAAgB,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC5C,mFAAmF;IACnF,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,GAAG,oBAAoB,CAAC;IAChF;;;;;OAKG;IACH,gBAAgB,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,MAAM,EAAE,CAAC;IACzD,uEAAuE;IACvE,UAAU,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;CACrD"}

package/node_modules/@lorenz/tracker-sdk/package.json

@@ -9,7 +9,6 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@lorenz/domain": "0.1.1",
-    "@lorenz/tool-sdk": "0.1.1"
+    "@lorenz/domain": "0.1.1"
   }
 }

package/node_modules/@lorenz/worker-host-pool/dist/index.d.ts

@@ -9,16 +9,44 @@ export declare class WorkerHostPool {
     private readonly availableRemoteMcpPorts;
     private readonly remoteMcpTunnelsByEndpoint;
     private readonly remoteMcpTunnelEntriesByLeaseId;
-    private readonly perRunMcpTunnels;
+    /**
+     * Monotonic generation per host:port tunnel slot, surviving entry teardown so
+     * a recreated entry gets a STRICTLY higher generation than the one it
+     * replaces. A `closeForRun` recorded against a prior generation is rejected.
+     */
+    private readonly remoteMcpTunnelGenerations;
+    /**
+     * Per-run holds on the SHARED per-host tunnels, keyed by `${workerHost}#${runKey}`.
+     * Each entry records which leaseId (and which generation) a run holds so
+     * `closeForRun` drops exactly that run's refcount - opening the tunnel on the
+     * first co-resident run and closing it at the last deref.
+     */
+    private readonly perRunTunnelHolds;
     acquireRemoteMcpTunnel(workerHost: string, localHost: string, localPort: number): Promise<RemoteMcpTunnelLease>;
     releaseRemoteMcpTunnel(lease: RemoteMcpTunnelLease): void;
+    /**
+     * Acquire a hold on the per-HOST reverse tunnel for one run. Co-resident runs
+     * on the SAME host share ONE `ssh -R` tunnel (opened on the first run, closed
+     * at the last `closeForRun`); they are kept apart by their per-run Token B
+     * claim, not by a distinct remote port. The generation captured here is what a
+     * later `closeForRun` is CAS-checked against, so a host:port recycle that bumps
+     * the slot's generation strands a stale late-close instead of decrementing the
+     * fresh entry.
+     */
     openForRun(workerHost: string, runKey: string, localHost: string, localPort: number): Promise<RemoteMcpTunnelLease>;
     closeForRun(workerHost: string, runKey: string): void;
-    private allocateRemoteMcpPort;
-    private isRemoteMcpPortLive;
-    private confirmPerRunMcpTunnelReady;
-    private handlePerRunMcpTunnelProcessEnd;
-    private closePerRunMcpTunnel;
+    /**
+     * Drop one run's hold on its shared per-host tunnel. CAS late-close reject: if
+     * the live entry for the hold's endpoint has a STRICTLY higher generation than
+     * the hold recorded, the slot was recycled and a fresh owner holds the live
+     * ref - this stale release must NOT decrement the new entry's refcount. The
+     * hold's own leaseId either still maps to the original (same-generation) entry
+     * or was already cleared on that entry's teardown, so dropping it is otherwise
+     * idempotent.
+     */
+    private releasePerRunHold;
+    private ensureRemoteMcpTunnelEntry;
+    private dropRemoteMcpTunnelLease;
     private closeRemoteMcpTunnel;
     private handleRemoteMcpTunnelProcessEnd;
     private waitForRemoteMcpTunnelReady;

package/node_modules/@lorenz/worker-host-pool/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAcD,qBAAa,cAAc;IACzB,OAAO,CAAC,iBAAiB,CAAU;IACnC,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAgB;IACxD,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA2C;IACtF,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAA2C;IAI3F,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2C;IAEtE,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,oBAAoB,CAAC;IAuChC,sBAAsB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI;IAYnD,UAAU,CACd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,oBAAoB,CAAC;IA4ChC,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAkBrD,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,mBAAmB;YAUb,2BAA2B;IAkBzC,OAAO,CAAC,+BAA+B;IAUvC,OAAO,CAAC,oBAAoB;IAwB5B,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,+BAA+B;YAUzB,2BAA2B;YAW3B,2BAA2B;IAezC,OAAO,CAAC,mCAAmC;IA+B3C,OAAO,CAAC,yBAAyB;IAMjC,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,0BAA0B;IAYlC,OAAO,CAAC,0BAA0B;CAOnC;AAMD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAqCD,qBAAa,cAAc;IACzB,OAAO,CAAC,iBAAiB,CAAU;IACnC,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAgB;IACxD,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA2C;IACtF,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAA2C;IAC3F;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA6B;IACxE;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IAEnE,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,oBAAoB,CAAC;IAMhC,sBAAsB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI;IASzD;;;;;;;;OAQG;IACG,UAAU,CACd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,oBAAoB,CAAC;IAqChC,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIrD;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;YAiBX,0BAA0B;IAkDxC,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,+BAA+B;YAUzB,2BAA2B;YAW3B,2BAA2B;IAezC,OAAO,CAAC,mCAAmC;IA+B3C,OAAO,CAAC,yBAAyB;IAMjC,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,0BAA0B;IAYlC,OAAO,CAAC,0BAA0B;CAOnC;AAMD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/node_modules/@lorenz/worker-host-pool/dist/index.js

@@ -5,49 +5,22 @@ export class WorkerHostPool {
     availableRemoteMcpPorts = [];
     remoteMcpTunnelsByEndpoint = new Map();
     remoteMcpTunnelEntriesByLeaseId = new Map();
-    // Per-run tunnels are keyed by `${workerHost}#${runKey}`, NOT host-coalesced,
-    // so each run owns a distinct entry (and distinct remote port). One run's
-    // localPort change can never replace another run's entry.
-    perRunMcpTunnels = new Map();
+    /**
+     * Monotonic generation per host:port tunnel slot, surviving entry teardown so
+     * a recreated entry gets a STRICTLY higher generation than the one it
+     * replaces. A `closeForRun` recorded against a prior generation is rejected.
+     */
+    remoteMcpTunnelGenerations = new Map();
+    /**
+     * Per-run holds on the SHARED per-host tunnels, keyed by `${workerHost}#${runKey}`.
+     * Each entry records which leaseId (and which generation) a run holds so
+     * `closeForRun` drops exactly that run's refcount - opening the tunnel on the
+     * first co-resident run and closing it at the last deref.
+     */
+    perRunTunnelHolds = new Map();
     async acquireRemoteMcpTunnel(workerHost, localHost, localPort) {
         const endpointKey = this.remoteMcpTunnelEndpointKey(workerHost, localHost, localPort);
-        const current = this.remoteMcpTunnelsByEndpoint.get(endpointKey);
-        if (current && !current.processEnded) {
-            await this.waitForRemoteMcpTunnelReady(current);
-            return this.createRemoteMcpTunnelLease(current);
-        }
-        if (current)
-            this.closeRemoteMcpTunnel(current, true);
-        const recycledPort = this.availableRemoteMcpPorts.shift();
-        const remotePort = recycledPort ?? this.nextRemoteMcpPort;
-        let process;
-        try {
-            process = startReverseTunnel(workerHost, remotePort, localHost, localPort);
-        }
-        catch (error) {
-            if (recycledPort !== undefined)
-                this.recycleRemoteMcpPort(recycledPort);
-            throw error;
-        }
-        if (recycledPort === undefined)
-            this.nextRemoteMcpPort += 1;
-        const entry = {
-            workerHost,
-            localHost,
-            localPort,
-            process,
-            leaseIds: new Set(),
-            readyPromise: Promise.resolve(),
-            remotePort,
-            processEnded: false,
-            recyclePortOnProcessEnd: false,
-        };
-        this.remoteMcpTunnelsByEndpoint.set(endpointKey, entry);
-        process.on("close", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
-        process.on("exit", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
-        process.on("error", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
-        entry.readyPromise = this.confirmRemoteMcpTunnelReady(entry);
-        await this.waitForRemoteMcpTunnelReady(entry);
+        const entry = await this.ensureRemoteMcpTunnelEntry(workerHost, localHost, localPort, endpointKey);
         return this.createRemoteMcpTunnelLease(entry);
     }
     releaseRemoteMcpTunnel(lease) {
@@ -57,26 +30,89 @@ export class WorkerHostPool {
         if (entry.workerHost !== lease.workerHost || entry.remotePort !== lease.remotePort) {
             return;
         }
-        this.remoteMcpTunnelEntriesByLeaseId.delete(lease.leaseId);
-        entry.leaseIds.delete(lease.leaseId);
-        if (entry.leaseIds.size > 0)
-            return;
-        this.closeRemoteMcpTunnel(entry, true);
+        this.dropRemoteMcpTunnelLease(entry, lease.leaseId);
     }
+    /**
+     * Acquire a hold on the per-HOST reverse tunnel for one run. Co-resident runs
+     * on the SAME host share ONE `ssh -R` tunnel (opened on the first run, closed
+     * at the last `closeForRun`); they are kept apart by their per-run Token B
+     * claim, not by a distinct remote port. The generation captured here is what a
+     * later `closeForRun` is CAS-checked against, so a host:port recycle that bumps
+     * the slot's generation strands a stale late-close instead of decrementing the
+     * fresh entry.
+     */
     async openForRun(workerHost, runKey, localHost, localPort) {
-        const key = perRunKey(workerHost, runKey);
-        const current = this.perRunMcpTunnels.get(key);
-        if (current &&
-            !current.processEnded &&
-            current.localHost === localHost &&
-            current.localPort === localPort) {
+        const holdKey = perRunKey(workerHost, runKey);
+        const endpointKey = this.remoteMcpTunnelEndpointKey(workerHost, localHost, localPort);
+        // Re-opening the SAME run (e.g. resume) reuses its existing hold when the
+        // shared host entry is still live - no second refcount/lease for one run.
+        const existingHold = this.perRunTunnelHolds.get(holdKey);
+        if (existingHold) {
+            const heldEntry = this.remoteMcpTunnelEntriesByLeaseId.get(existingHold.leaseId);
+            if (heldEntry &&
+                !heldEntry.processEnded &&
+                heldEntry.localHost === localHost &&
+                heldEntry.localPort === localPort) {
+                await this.waitForRemoteMcpTunnelReady(heldEntry);
+                return {
+                    leaseId: existingHold.leaseId,
+                    workerHost: heldEntry.workerHost,
+                    remotePort: heldEntry.remotePort,
+                };
+            }
+            // The run's prior hold is stale (entry torn down or the local endpoint
+            // moved): drop it and take a fresh hold on the current shared entry.
+            this.releasePerRunHold(holdKey);
+        }
+        const entry = await this.ensureRemoteMcpTunnelEntry(workerHost, localHost, localPort, endpointKey);
+        const lease = this.createRemoteMcpTunnelLease(entry);
+        this.perRunTunnelHolds.set(holdKey, {
+            leaseId: lease.leaseId,
+            endpointKey,
+            generation: entry.generation,
+        });
+        return lease;
+    }
+    closeForRun(workerHost, runKey) {
+        this.releasePerRunHold(perRunKey(workerHost, runKey));
+    }
+    /**
+     * Drop one run's hold on its shared per-host tunnel. CAS late-close reject: if
+     * the live entry for the hold's endpoint has a STRICTLY higher generation than
+     * the hold recorded, the slot was recycled and a fresh owner holds the live
+     * ref - this stale release must NOT decrement the new entry's refcount. The
+     * hold's own leaseId either still maps to the original (same-generation) entry
+     * or was already cleared on that entry's teardown, so dropping it is otherwise
+     * idempotent.
+     */
+    releasePerRunHold(holdKey) {
+        const hold = this.perRunTunnelHolds.get(holdKey);
+        if (!hold)
+            return;
+        this.perRunTunnelHolds.delete(holdKey);
+        const liveGeneration = this.remoteMcpTunnelGenerations.get(hold.endpointKey);
+        if (liveGeneration !== undefined && hold.generation < liveGeneration) {
+            // Stale late-close against a recycled slot: never touch the live entry.
+            return;
+        }
+        const entry = this.remoteMcpTunnelEntriesByLeaseId.get(hold.leaseId);
+        if (!entry)
+            return;
+        this.dropRemoteMcpTunnelLease(entry, hold.leaseId);
+    }
+    // Reuse-or-open a host-keyed reverse tunnel entry. A live entry for this
+    // host:port is shared (refcounted by leases); a torn-down one is replaced by a
+    // fresh entry whose generation is STRICTLY higher than the slot's last value.
+    async ensureRemoteMcpTunnelEntry(workerHost, localHost, localPort, endpointKey) {
+        const current = this.remoteMcpTunnelsByEndpoint.get(endpointKey);
+        if (current && !current.processEnded) {
             await this.waitForRemoteMcpTunnelReady(current);
-            return this.createRemoteMcpTunnelLease(current);
+            return current;
         }
         if (current)
-            this.closePerRunMcpTunnel(key, current, true);
-        const remotePort = this.allocateRemoteMcpPort();
-        const recycledPort = remotePort < this.nextRemoteMcpPort ? remotePort : undefined;
+            this.closeRemoteMcpTunnel(current, true);
+        const recycledPort = this.availableRemoteMcpPorts.shift();
+        const remotePort = recycledPort ?? this.nextRemoteMcpPort;
         let process;
         try {
             process = startReverseTunnel(workerHost, remotePort, localHost, localPort);
@@ -88,6 +124,12 @@ export class WorkerHostPool {
         }
         if (recycledPort === undefined)
             this.nextRemoteMcpPort += 1;
+        // Bump the slot's generation when a brand-new entry replaces a torn-down
+        // one. The first entry for a host:port gets generation 1; each recycle is
+        // strictly higher, so a per-run hold recorded against the prior generation
+        // is fenced out of the new entry's refcount.
+        const generation = (this.remoteMcpTunnelGenerations.get(endpointKey) ?? 0) + 1;
+        this.remoteMcpTunnelGenerations.set(endpointKey, generation);
         const entry = {
             workerHost,
             localHost,
@@ -98,99 +140,24 @@ export class WorkerHostPool {
             remotePort,
             processEnded: false,
             recyclePortOnProcessEnd: false,
+            generation,
         };
-        this.perRunMcpTunnels.set(key, entry);
-        process.on("close", () => this.handlePerRunMcpTunnelProcessEnd(key, entry));
-        process.on("exit", () => this.handlePerRunMcpTunnelProcessEnd(key, entry));
-        process.on("error", () => this.handlePerRunMcpTunnelProcessEnd(key, entry));
-        entry.readyPromise = this.confirmPerRunMcpTunnelReady(key, entry);
+        this.remoteMcpTunnelsByEndpoint.set(endpointKey, entry);
+        process.on("close", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
+        process.on("exit", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
+        process.on("error", () => this.handleRemoteMcpTunnelProcessEnd(entry, endpointKey));
+        entry.readyPromise = this.confirmRemoteMcpTunnelReady(entry);
         await this.waitForRemoteMcpTunnelReady(entry);
-        return this.createRemoteMcpTunnelLease(entry);
+        return entry;
     }
-    closeForRun(workerHost, runKey) {
-        const key = perRunKey(workerHost, runKey);
-        const entry = this.perRunMcpTunnels.get(key);
-        if (!entry)
+    dropRemoteMcpTunnelLease(entry, leaseId) {
+        if (!entry.leaseIds.has(leaseId))
             return;
-        // Each openForRun call on this run minted one lease; drop one per close
-        // and keep the tunnel while other holders of the same run remain.
-        const [leaseId] = entry.leaseIds;
-        if (leaseId !== undefined) {
-            entry.leaseIds.delete(leaseId);
-            this.remoteMcpTunnelEntriesByLeaseId.delete(leaseId);
-        }
+        this.remoteMcpTunnelEntriesByLeaseId.delete(leaseId);
+        entry.leaseIds.delete(leaseId);
         if (entry.leaseIds.size > 0)
             return;
-        this.closePerRunMcpTunnel(key, entry, true);
-    }
-    // Allocate a remote port, reusing a recycled candidate only when no live
-    // entry (host-keyed OR per-run) still holds it. This guards the
-    // recycled-port-vs-stale-entry interaction under N concurrent live ports.
-    allocateRemoteMcpPort() {
-        while (this.availableRemoteMcpPorts.length > 0) {
-            const candidate = this.availableRemoteMcpPorts.shift();
-            if (!this.isRemoteMcpPortLive(candidate))
-                return candidate;
-        }
-        return this.nextRemoteMcpPort;
-    }
-    isRemoteMcpPortLive(remotePort) {
-        for (const entry of this.remoteMcpTunnelsByEndpoint.values()) {
-            if (entry.remotePort === remotePort)
-                return true;
-        }
-        for (const entry of this.perRunMcpTunnels.values()) {
-            if (entry.remotePort === remotePort)
-                return true;
-        }
-        return false;
-    }
-    async confirmPerRunMcpTunnelReady(key, entry) {
-        const processEndWatcher = this.watchRemoteMcpTunnelSetupProcessEnd(entry);
-        try {
-            await Promise.race([
-                waitForRemoteTcpPort(entry.workerHost, entry.remotePort),
-                processEndWatcher.promise,
-            ]);
-        }
-        catch (error) {
-            this.closePerRunMcpTunnel(key, entry, true);
-            throw error;
-        }
-        finally {
-            processEndWatcher.dispose();
-        }
-    }
-    handlePerRunMcpTunnelProcessEnd(key, entry) {
-        if (entry.processEnded)
-            return;
-        entry.processEnded = true;
-        if (this.perRunMcpTunnels.get(key) === entry) {
-            this.closePerRunMcpTunnel(key, entry, true);
-            return;
-        }
-        if (entry.recyclePortOnProcessEnd)
-            this.recycleRemoteMcpPort(entry.remotePort);
-    }
-    closePerRunMcpTunnel(key, entry, recyclePort) {
-        if (this.perRunMcpTunnels.get(key) === entry) {
-            this.perRunMcpTunnels.delete(key);
-        }
-        for (const leaseId of entry.leaseIds) {
-            this.remoteMcpTunnelEntriesByLeaseId.delete(leaseId);
-        }
-        entry.leaseIds.clear();
-        if (recyclePort) {
-            if (entry.processEnded) {
-                this.recycleRemoteMcpPort(entry.remotePort);
-            }
-            else {
-                entry.recyclePortOnProcessEnd = true;
-            }
-        }
-        if (!entry.processEnded) {
-            entry.process.kill();
-        }
+        this.closeRemoteMcpTunnel(entry, true);
     }
     closeRemoteMcpTunnel(entry, recyclePort) {
         const endpointKey = this.remoteMcpTunnelEndpointKey(entry.workerHost, entry.localHost, entry.localPort);