@cline/core 0.0.74 → 0.0.75

package/dist/hub/daemon/index.d.ts

@@ -1,4 +1,23 @@
 import { type HubEndpointOverrides } from "../discovery/defaults";
+export declare const __test__: {
+    /** Retire attempts are module state keyed by URL; clear between cases. */
+    resetRetireAttempts(): void;
+};
+/**
+ * Reads the discovery record the npm postinstall set aside (see
+ * apps/cli/script/postinstall.mjs). Deliberately bypasses readHubDiscovery —
+ * the file is best-effort recovery metadata, not a live record — and stays
+ * synchronous so it adds no async boundary to the ensure flow.
+ *
+ * Exported for `cline doctor`, which must not mistake a shielded live hub for
+ * a stale daemon just because its record is set aside.
+ */
+export declare function readSupersededHubDiscovery(discoveryPath: string): {
+    url?: string;
+    authToken?: string;
+    pid?: number;
+} | undefined;
+export type HubRetirementOutcome = "reusable" | "retired" | "deferred_busy" | "failed";
 export declare function spawnDetachedHubServer(workspaceRoot: string, endpoint?: HubEndpointOverrides): void;
 export declare function spawnDetachedHubServerWithRetry(workspaceRoot: string, endpoint?: HubEndpointOverrides): Promise<void>;
 export declare function prewarmDetachedHubServer(workspaceRoot: string, endpoint?: HubEndpointOverrides & {

package/dist/hub/discovery/index.d.ts

@@ -65,23 +65,52 @@ export type ManagedHubCompatibilityResult = {
 export declare function getManagedHubCompatibility(record: HubProtocolMetadata & {
     buildId?: string;
 }, expectedBuildId?: string): ManagedHubCompatibilityResult;
+export interface HubBuildIdentity {
+    buildId?: string;
+    buildEpochMs?: number;
+    coreVersion?: string;
+}
+/**
+ * Total order over Hub builds: negative when `a` is older than `b`, positive
+ * when newer, zero when the two are indistinguishable.
+ *
+ * The ordering is what keeps concurrent installations from replacing each
+ * other's daemons. A one-sided "may I reuse this?" predicate lets both sides
+ * answer no, and two clients then retire each other's Hub forever; a total
+ * order is antisymmetric by construction, so at most one side can ever decide
+ * to retire. Every tier below preserves that: a field decides only when both
+ * records carry it, and the final fallback is "equal", which means reuse.
+ *
+ * Tiers, in order: identical build, embedded build epoch, core release
+ * version, then build id as a deterministic tiebreak.
+ */
+export declare function compareHubBuilds(a: HubBuildIdentity, b: HubBuildIdentity): number;
+/**
+ * This build's own identity, in the same shape a daemon publishes into its
+ * discovery record.
+ *
+ * Self and peer identities must be built from the same fields. Enriching only
+ * the local side - filling in a `coreVersion` the wire record can omit, say -
+ * makes a build's identity depend on which role it is playing, and two
+ * installations then decide the comparison on different tiers and each
+ * conclude that it is the newer one. Callers that need a synthetic identity
+ * pass it verbatim rather than layering overrides onto this.
+ */
+export declare function resolveHubBuildIdentity(): HubBuildIdentity;
 /**
  * Whether a client may keep using a managed local Hub instead of retiring it.
  *
- * Same build: always reusable. Different build: reusable only when the Hub
- * was produced *after* this client's own build (another installation
- * upgraded the shared Hub) - the daemon is then running newer code, so
- * replacing it would be a downgrade; the client attaches over the compatible
- * wire protocol and the build-mismatch watcher prompts the user to update.
- * A Hub that is older, unordered, or missing build metadata is not reusable
- * and gets retired and replaced, preserving the stale-daemon fix.
+ * A Hub is retired only when this client's build is *strictly newer* by
+ * {@link compareHubBuilds}. Same build, newer Hub, and indistinguishable
+ * builds all attach over the compatible wire protocol and let the
+ * build-mismatch watcher prompt the user to update. Because the decision is
+ * derived from a total order, two installations can never retire each other.
+ *
+ * Genuine protocol incompatibility is unaffected: those Hubs cannot be spoken
+ * to at all and are still replaced.
  */
-export declare function isManagedHubReusable(record: HubProtocolMetadata & {
-    buildId?: string;
-    buildEpochMs?: number;
-}, options?: {
-    expectedBuildId?: string;
-    expectedBuildEpochMs?: number;
+export declare function isManagedHubReusable(record: HubProtocolMetadata & HubBuildIdentity, options?: {
+    self?: HubBuildIdentity;
 }): boolean;
 export declare function resolveHubOwnerContext(ownerBasis?: string): HubOwnerContext;
 export declare function createInMemoryHubOwnerContext(label?: string): HubOwnerContext;

package/dist/hub/discovery/workspace.d.ts

@@ -1,4 +1,13 @@
 import { type HubOwnerContext } from ".";
 export declare function resolveWorkspaceHubOwnerContext(workspaceRoot: string): HubOwnerContext;
+/**
+ * Development builds change on every compile, so a single shared owner record
+ * puts every checkout and every rebuild in contention for one daemon - and the
+ * loser of that contention gets shut down mid-session. Scoping the owner by
+ * build id lets differing dev builds run their own Hub side by side instead of
+ * arbitrating over one. Production keeps a single owner (see
+ * {@link resolveProductionHubOwnerContext}), where the singleton matters and
+ * builds are ordered.
+ */
 export declare function resolveSharedHubOwnerContext(label?: string): HubOwnerContext;
 export declare function resolveProductionHubOwnerContext(): HubOwnerContext;