@fitchmultz/pi-subagents 0.52.18 → 0.52.19

package/dist/agent/usage.js

@@ -7,6 +7,37 @@ import { isRecord } from "../shared/unknown.js";
 import { Assert } from "./typebox.js";
 import { contributionsSchema, resultSchema, } from "./contracts.js";
 import { read, runDirectory, write } from "./storage.js";
+/** Pending repair remains authoritative until its native terminal is published and validated. */
+export function accountingState(result) {
+    if (result?.accountingPending !== undefined) {
+        return { kind: "pending", pending: result.accountingPending, error: result.accountingError };
+    }
+    const terminalEntryId = result?.terminalEntryId;
+    if (result?.contributions !== undefined) {
+        return { kind: "verified", contributions: result.contributions, terminalEntryId };
+    }
+    return result?.accountingError === undefined
+        ? { kind: "unrecorded", terminalEntryId }
+        : { kind: "unavailable", error: result.accountingError, terminalEntryId };
+}
+export function accountingFields(state) {
+    const terminal = state.kind !== "pending" && state.terminalEntryId !== undefined
+        ? { terminalEntryId: state.terminalEntryId }
+        : {};
+    switch (state.kind) {
+        case "unrecorded":
+            return terminal;
+        case "verified":
+            return { contributions: state.contributions, ...terminal };
+        case "pending":
+            return {
+                accountingPending: state.pending,
+                ...(state.error === undefined ? {} : { accountingError: state.error }),
+            };
+        case "unavailable":
+            return { accountingError: state.error, ...terminal };
+    }
+}
 /** Billing evidence of one native entry. Missing required usage is an error only outside a baseline. */
 function billing(entry) {
     if (entry.checkpoint === true) {
@@ -143,10 +174,11 @@ export function readResult(base, launch) {
     if (!result) {
         return;
     }
-    const pending = result.accountingPending;
-    if (pending === undefined) {
+    const accounting = accountingState(result);
+    if (accounting.kind !== "pending") {
         return result;
     }
+    const { pending } = accounting;
     let contributions;
     try {
         contributions = childUsage(launch, new Set(pending.baseline), pending.terminalCandidate);
@@ -156,7 +188,14 @@ export function readResult(base, launch) {
         return result;
     }
     const { accountingPending: _pending, accountingError: _error, ...execution } = result;
-    const repaired = { ...execution, terminalEntryId: pending.terminalCandidate, contributions };
+    const repaired = {
+        ...execution,
+        ...accountingFields({
+            kind: "verified",
+            terminalEntryId: pending.terminalCandidate,
+            contributions,
+        }),
+    };
     write(path.join(runDirectory(base, launch.id), "result.json"), repaired);
     return repaired;
 }

package/dist/agent/view.js

@@ -5,25 +5,25 @@ import { actor, alive, observeAlive } from "./process.js";
 import { admissionSchema, commandSchema, exitSchema, successorSchema, wakeFailureSchema, } from "./contracts.js";
 import { conversation, read, runDirectory } from "./storage.js";
 import { published } from "./notifications.js";
-import { readCanonicalResult, readResult } from "./usage.js";
+import { accountingFields, accountingState, readCanonicalResult, readResult } from "./usage.js";
 import { Type } from "./typebox.js";
 const commandMetadataSchema = Type.Pick(commandSchema, ["id", "runId", "action", "createdAt"]);
 function toolResult(value, text) {
     return { content: [{ type: "text", text }], details: value };
 }
 function receiptResult(result) {
-    return result === undefined
-        ? undefined
-        : {
-            id: result.id,
-            owner: result.owner,
-            status: result.status,
-            endedAt: result.endedAt,
-            terminalEntryId: result.terminalEntryId,
-            error: result.error,
-            accountingError: result.accountingError,
-            accountingPending: result.accountingPending,
-        };
+    if (result === undefined) {
+        return;
+    }
+    const { contributions: _contributions, ...accounting } = accountingFields(accountingState(result));
+    return {
+        id: result.id,
+        owner: result.owner,
+        status: result.status,
+        endedAt: result.endedAt,
+        error: result.error,
+        ...accounting,
+    };
 }
 /** `observed` holds batched liveness by actor token; any other actor gets a fresh check. */
 function processView(base, launch, observed) {

package/dist/agent/wake.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import assert from "node:assert/strict";
 import { journalStamp } from "../shared/native-journal.js";
 import { missing } from "./storage.js";
 /** Identity and change stamp of a path; "" when absent. */
@@ -13,10 +14,10 @@ export function pathStamp(file) {
 }
 /** Native change hints for one directory identity; owners still reconcile canonical files. */
 export class DirectoryWatch {
-    watcher;
-    armed = "";
+    state = {
+        kind: "unarmed",
+    };
     checked = "";
-    failed = false;
     directory;
     relevant;
     wake;
@@ -30,41 +31,41 @@ export class DirectoryWatch {
         const identity = stat?.isDirectory() === true ? `${stat.dev}:${stat.ino}` : "";
         const checked = this.checked;
         this.checked = stat === undefined ? "" : `${identity}:${stat.mtimeNs}:${stat.ctimeNs}`;
-        if (this.watcher !== undefined && identity === this.armed) {
+        if (this.state.kind === "armed" && identity === this.state.identity) {
             return checked === this.checked ? "watching" : "changed";
         }
         // A replaced directory leaves an inode watch silent on Linux.
         this.close();
-        return identity === "" || this.failed ? "unwatched" : this.arm(identity);
+        return identity === "" || this.state.kind === "polling" ? "unwatched" : this.arm(identity);
     }
     arm(identity) {
         try {
             const watcher = fs.watch(this.directory, { persistent: false }, (_event, file) => {
-                if (watcher === this.watcher && this.relevant(file)) {
+                if (this.state.kind === "armed" && watcher === this.state.watcher && this.relevant(file)) {
                     this.wake();
                 }
             });
             watcher.on("error", () => {
-                if (watcher === this.watcher) {
-                    this.failed = true;
-                    this.close();
+                if (this.state.kind === "armed" && watcher === this.state.watcher) {
+                    watcher.close();
+                    this.state = { kind: "polling" };
                     this.wake();
                 }
             });
-            this.watcher = watcher;
-            this.armed = identity;
+            this.state = { kind: "armed", watcher, identity };
             return "armed";
         }
         catch (error) {
             // Unsupported platforms and watch limits keep their owner's polling fallback.
-            this.failed = !missing(error);
+            this.state = { kind: missing(error) ? "unarmed" : "polling" };
             return "unwatched";
         }
     }
     close() {
-        this.watcher?.close();
-        this.watcher = undefined;
-        this.armed = "";
+        if (this.state.kind === "armed") {
+            this.state.watcher.close();
+            this.state = { kind: "unarmed" };
+        }
     }
 }
 /** A coalesced wake for one owner loop; raised until that loop takes it. */
@@ -82,6 +83,7 @@ export class Wake {
     }
     /** Returns at once for a wake raised since the last take. */
     async sleep(ms) {
+        assert.equal(this.resolve, undefined, "A Wake belongs to one waiting owner loop.");
         if (this.raised) {
             return;
         }

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.52.18","sha256":"83db07f9acbdd6ff5985c46e1f5f5411f68b6766697a2dfab019b3d00dbba1c1"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.19","sha256":"a5cb823f7d9194659bb3c3e53c68e90032ef520a962758d896dccee78a3bd2c5"});

package/dist/pi-intercom/broker/broker.js

@@ -13,7 +13,7 @@ import { acceptBrokerConnection, registeredSessionInfo } from "./server-connecti
 import { guardedDeliveryError } from "./guard.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 import { errorMessage, isRecord } from "../../shared/unknown.js";
-import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
+import { messageSender, snapshotFrames, TopicSnapshot, publicationMessage, preparedPublication, deliveryAcknowledgement, shouldReplaceDelivery, } from "./snapshots.js";
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 class IntercomBroker {
@@ -192,7 +192,7 @@ class IntercomBroker {
                 ? session.info
                 : session.topics.snapshot(session.info, prepared);
             const from = messageSender(nextInfo);
-            const deliveries = this.planPublications(currentId, from, prepared.publication);
+            const deliveries = this.planPublications(currentId, from, preparedPublication(prepared));
             // Validate every frame before committing state or delivering publications.
             if (prepared.restore) {
                 session.topics.validateRestore(session.info, prepared, requestId);

package/dist/pi-intercom/broker/snapshots.d.ts

@@ -2,15 +2,33 @@ import { type SessionInfo, type TopicUpdate, type Message, type BrokerMessage, t
 /** Direct messages and old clients receive identity, not potentially large topic state. */
 export declare function messageSender(info: SessionInfo): SessionInfo;
 export declare function snapshotFrames(requestId: string, infos: readonly SessionInfo[], stream: boolean): BrokerMessage[];
-interface PreparedTopicChange {
-    readonly topic?: TopicUpdate;
-    readonly subscription?: TopicSubscription;
-    readonly unsubscribe?: string;
-    readonly publication?: TopicUpdate;
+type PreparedTopicChange = {
+    readonly kind: "unchanged";
+    readonly restore: false;
+} | {
+    readonly kind: "normalize";
+    readonly restore: true;
+} | {
+    readonly kind: "publish";
+    readonly restore: false;
+    readonly topic: TopicUpdate;
+    readonly bytes: number;
+} | {
+    readonly kind: "restore-topic";
+    readonly restore: true;
+    readonly topic: TopicUpdate;
+    readonly bytes: number;
+} | {
+    readonly kind: "subscription";
     readonly restore: boolean;
-    readonly changed: boolean;
+    readonly subscription: TopicSubscription;
     readonly bytes: number;
-}
+} | {
+    readonly kind: "unsubscribe";
+    readonly restore: false;
+    readonly topic: string;
+};
+export declare function preparedPublication(prepared: PreparedTopicChange): TopicUpdate | undefined;
 /** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
 export declare class TopicSnapshot {
     private readonly topics;

package/dist/pi-intercom/broker/snapshots.js

@@ -157,7 +157,26 @@ class SnapshotRecords {
         return values;
     }
 }
-const UNCHANGED = { restore: false, changed: false, bytes: 0 };
+const UNCHANGED = { kind: "unchanged", restore: false };
+function updatedTopic(prepared) {
+    return prepared.kind === "publish" || prepared.kind === "restore-topic" ? prepared : undefined;
+}
+function subscriptionKey(prepared) {
+    switch (prepared.kind) {
+        case "subscription":
+            return prepared.subscription.topic;
+        case "unsubscribe":
+            return prepared.topic;
+        case "unchanged":
+        case "normalize":
+        case "publish":
+        case "restore-topic":
+            return undefined;
+    }
+}
+export function preparedPublication(prepared) {
+    return prepared.kind === "publish" ? prepared.topic : undefined;
+}
 /** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
 export class TopicSnapshot {
     topics;
@@ -177,47 +196,53 @@ export class TopicSnapshot {
             throw new Error("Topic snapshots unavailable for this client");
         }
         const mutation = topicMutation(change);
-        const base = { restore: change.action === "restore", changed: true, bytes: 0 };
         switch (mutation.kind) {
             case "publication":
-                return this.preparePublication(mutation, base);
+                return this.preparePublication(mutation);
             case "subscription":
                 return {
-                    ...base,
+                    kind: "subscription",
+                    restore: change.action === "restore",
                     subscription: mutation.subscription,
                     bytes: intercomMessageSizeBytes(mutation.subscription),
                 };
             case "unsubscribe":
-                return { ...base, unsubscribe: mutation.topic };
+                return { kind: "unsubscribe", restore: false, topic: mutation.topic };
         }
     }
-    preparePublication(mutation, base) {
+    preparePublication(mutation) {
         const previous = this.topics.get(mutation.topic.topic);
         const update = publicationUpdate(mutation.topic, previous, mutation.publish);
         if (!mutation.publish && (previous?.revision ?? 0) >= update.revision) {
-            return base;
+            return { kind: "normalize", restore: true };
         }
         return {
-            ...base,
+            ...(mutation.publish
+                ? { kind: "publish", restore: false }
+                : { kind: "restore-topic", restore: true }),
             topic: update,
             bytes: intercomMessageSizeBytes(update),
-            ...(mutation.publish ? { publication: update } : {}),
         };
     }
     snapshot(info, prepared = UNCHANGED) {
-        const topics = this.topics.valuesAfter(prepared.topic?.topic, prepared.topic, prepared.changed);
-        const subscriptions = this.subscriptions.valuesAfter(prepared.subscription?.topic ?? prepared.unsubscribe, prepared.subscription, prepared.changed);
+        const topic = updatedTopic(prepared)?.topic;
+        const subscription = prepared.kind === "subscription" ? prepared.subscription : undefined;
+        const changed = prepared.kind !== "unchanged";
+        const topics = this.topics.valuesAfter(topic?.topic, topic, changed);
+        const subscriptions = this.subscriptions.valuesAfter(subscriptionKey(prepared), subscription, changed);
         return {
             ...info,
             ...(topics !== undefined ? { topics } : {}),
             ...(subscriptions !== undefined ? { subscriptions } : {}),
-            ...(prepared.publication ? { lastIntercomActivity: Date.now() } : {}),
+            ...(preparedPublication(prepared) ? { lastIntercomActivity: Date.now() } : {}),
         };
     }
     validateRestore(info, prepared, requestId) {
         snapshotFrames(requestId, [{ ...info, topics: [], subscriptions: [] }], true);
-        const topicBytes = this.topics.maximumAfter(prepared.topic?.topic, prepared.topic ? prepared.bytes : 0);
-        const subscriptionBytes = this.subscriptions.maximumAfter(prepared.subscription?.topic, prepared.subscription ? prepared.bytes : 0);
+        const topic = updatedTopic(prepared);
+        const subscription = prepared.kind === "subscription" ? prepared : undefined;
+        const topicBytes = this.topics.maximumAfter(topic?.topic.topic, topic?.bytes ?? 0);
+        const subscriptionBytes = this.subscriptions.maximumAfter(subscription?.subscription.topic, subscription?.bytes ?? 0);
         for (const [field, bytes] of [
             ["topics", topicBytes],
             ["subscriptions", subscriptionBytes],
@@ -234,18 +259,24 @@ export class TopicSnapshot {
         }
     }
     commit(prepared) {
-        if (prepared.changed) {
-            this.topics.accept();
-            this.subscriptions.accept();
-        }
-        if (prepared.topic) {
-            this.topics.set(prepared.topic, prepared.bytes);
-        }
-        else if (prepared.subscription) {
-            this.subscriptions.set(prepared.subscription, prepared.bytes);
+        if (prepared.kind === "unchanged") {
+            return;
         }
-        else if (prepared.unsubscribe !== undefined) {
-            this.subscriptions.delete(prepared.unsubscribe);
+        this.topics.accept();
+        this.subscriptions.accept();
+        switch (prepared.kind) {
+            case "publish":
+            case "restore-topic":
+                this.topics.set(prepared.topic, prepared.bytes);
+                return;
+            case "subscription":
+                this.subscriptions.set(prepared.subscription, prepared.bytes);
+                return;
+            case "unsubscribe":
+                this.subscriptions.delete(prepared.topic);
+                return;
+            case "normalize":
+                return;
         }
     }
 }

package/dist/pi-intercom/broker/spawn-claim.js

@@ -0,0 +1,89 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { hasErrorCode } from "../../shared/unknown.js";
+import { brokerPidRecord, isLinuxProcessReplaced } from "./pid.js";
+function ownerState(fd) {
+    try {
+        const lines = readFileSync(fd, "utf8").split("\n");
+        const first = lines[0] ?? "";
+        const pid = Number(first);
+        if (!/^[1-9]\d*$/.test(first) || !Number.isSafeInteger(pid)) {
+            return "uncertain";
+        }
+        process.kill(pid, 0);
+        return isLinuxProcessReplaced(pid, lines.slice(2).join("\n")) ? "exited" : "live";
+    }
+    catch (error) {
+        return hasErrorCode(error, "ESRCH") ? "exited" : "uncertain";
+    }
+}
+/** The open descriptor pins the original inode until its own cleanup finishes. */
+function removeOwned(file, fd) {
+    try {
+        const owned = fstatSync(fd, { bigint: true });
+        const current = lstatSync(file, { bigint: true, throwIfNoEntry: false });
+        if (current?.dev !== owned.dev || current.ino !== owned.ino) {
+            return false;
+        }
+        unlinkSync(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function reclaimExited(file) {
+    let fd;
+    try {
+        fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        return hasErrorCode(error, "ENOENT");
+    }
+    try {
+        return ownerState(fd) === "exited" && removeOwned(file, fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function publishClaim(file, fd) {
+    const release = () => {
+        try {
+            removeOwned(file, fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+    try {
+        // Keep legacy PID/timestamp lines; qualified native identity can prove later PID reuse.
+        const record = brokerPidRecord();
+        const identity = record.slice(record.indexOf("\n") + 1);
+        writeFileSync(fd, `${process.pid}\n${Date.now()}\n${identity}`);
+        return release;
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
+}
+/** An acquired claim returns its release operation; live or uncertain claims remain untouched. */
+export function acquireSpawnClaim(file) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        let fd;
+        try {
+            fd = openSync(file, "wx", 0o600);
+        }
+        catch (error) {
+            if (!hasErrorCode(error, "EEXIST")) {
+                throw error;
+            }
+            if (reclaimExited(file)) {
+                continue;
+            }
+            return;
+        }
+        return publishClaim(file, fd);
+    }
+    return;
+}

package/dist/pi-intercom/broker/spawn.js

@@ -1,11 +1,12 @@
 import { spawn } from "child_process";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import net from "net";
 import { getPiAgentDir } from "../agent-dir.js";
 import { getBrokerRuntimeDir, getBrokerSocketPath, getPreviousBrokerSocketPaths, isOwnedBrokerSocket, prepareBrokerSocketPath, } from "./paths.js";
 import { isBrokerPidReused } from "./pid.js";
+import { acquireSpawnClaim } from "./spawn-claim.js";
 import { errorMessage, hasErrorCode } from "../../shared/unknown.js";
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 const BROKER_PID = join(getBrokerRuntimeDir(), "broker.pid");
@@ -54,8 +55,8 @@ export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, warning = (
     if (await isBrokerRunning()) {
         return;
     }
-    const ownsLock = acquireSpawnLock();
-    if (!ownsLock) {
+    const release = acquireSpawnClaim(BROKER_SPAWN_LOCK);
+    if (release === undefined) {
         await waitForBroker();
         return;
     }
@@ -99,7 +100,7 @@ export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, warning = (
         });
     }
     finally {
-        releaseSpawnLock();
+        release();
     }
 }
 export async function isBrokerRunning() {
@@ -111,28 +112,30 @@ export async function assertBrokerCanStart() {
     }
     await stopUnhealthyBrokerBeforeSpawn();
 }
-function readLivePid(pidPath) {
-    if (!existsSync(pidPath)) {
-        return null;
-    }
+function readBrokerOwner(pidPath) {
     let raw;
     try {
         raw = readFileSync(pidPath, "utf-8");
     }
-    catch {
-        return null;
+    catch (error) {
+        return hasErrorCode(error, "ENOENT")
+            ? { kind: "absent" }
+            : { kind: "uncertain", reason: `Cannot read broker PID record: ${errorMessage(error)}` };
     }
-    const pid = parseInt(raw.trim(), 10);
-    if (!Number.isFinite(pid) || pid <= 0) {
-        return null;
+    const first = raw.trim().split("\n")[0] ?? "";
+    const pid = Number(first);
+    if (!/^[1-9]\d*$/.test(first) || !Number.isSafeInteger(pid)) {
+        return { kind: "uncertain", reason: "Broker PID record is invalid" };
     }
     try {
         process.kill(pid, 0);
     }
     catch (error) {
-        return hasErrorCode(error, "EPERM") ? pid : null;
+        return hasErrorCode(error, "ESRCH")
+            ? { kind: "absent" }
+            : { kind: "uncertain", reason: `Cannot establish broker PID ${pid}: ${errorMessage(error)}` };
     }
-    return isBrokerPidReused(pid, raw) ? null : pid;
+    return isBrokerPidReused(pid, raw) ? { kind: "absent" } : { kind: "live", pid };
 }
 async function previousBrokerWarning() {
     const previousSockets = getPreviousBrokerSocketPaths();
@@ -142,9 +145,10 @@ async function previousBrokerWarning() {
             return "An older agent-directory Intercom broker is still running. Its peers are not part of shared same-user discovery until they reload with the updated extension. Existing sessions and accepted work are untouched; no legacy fallback is used.";
         }
     }
-    const previousPid = readLivePid(join(getPiAgentDir(), "intercom", "broker.pid"));
-    if (previousPid !== null) {
-        return `Older Intercom broker PID ${previousPid} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`;
+    const previous = readBrokerOwner(join(getPiAgentDir(), "intercom", "broker.pid"));
+    if (previous.kind !== "absent") {
+        const owner = previous.kind === "live" ? `PID ${previous.pid}` : "with uncertain PID identity";
+        return `Older Intercom broker ${owner} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`;
     }
     return undefined;
 }
@@ -152,11 +156,15 @@ export async function stopUnhealthyBrokerBeforeSpawn() {
     if (await checkSocketConnectable()) {
         return;
     }
-    const pid = readLivePid(BROKER_PID);
-    if (pid === null) {
-        return;
+    const owner = readBrokerOwner(BROKER_PID);
+    switch (owner.kind) {
+        case "absent":
+            return;
+        case "live":
+            throw new Error(`Intercom broker PID ${owner.pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`);
+        case "uncertain":
+            throw new Error(`${owner.reason}; refusing to spawn a second broker while ownership is uncertain.`);
     }
-    throw new Error(`Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`);
 }
 async function checkSocketConnectable() {
     const socketPath = getBrokerSocketPath();
@@ -180,61 +188,6 @@ function checkOneSocket(brokerSocket) {
         timeout.unref();
     });
 }
-function acquireSpawnLock() {
-    const maxRetries = 5;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            writeFileSync(BROKER_SPAWN_LOCK, `${process.pid}\n${Date.now()}\n`, { flag: "wx" });
-            return true;
-        }
-        catch (error) {
-            if (!hasErrorCode(error, "EEXIST")) {
-                throw error;
-            }
-            if (isSpawnLockStale()) {
-                releaseSpawnLock();
-                continue;
-            }
-            return false;
-        }
-    }
-    return false;
-}
-function isSpawnLockStale() {
-    if (!existsSync(BROKER_SPAWN_LOCK)) {
-        return false;
-    }
-    try {
-        const [pidLine = "", createdAtLine = "0"] = readFileSync(BROKER_SPAWN_LOCK, "utf-8")
-            .trim()
-            .split("\n");
-        const pid = Number.parseInt(pidLine, 10);
-        const createdAt = Number.parseInt(createdAtLine, 10);
-        const ageMs = Date.now() - createdAt;
-        if (Number.isFinite(pid)) {
-            try {
-                process.kill(pid, 0);
-            }
-            catch {
-                // The process that created the lock is gone.
-                return true;
-            }
-        }
-        return !Number.isFinite(createdAt) || ageMs > 10_000;
-    }
-    catch {
-        // Unreadable lock contents are treated as stale so a new broker can start.
-        return true;
-    }
-}
-function releaseSpawnLock() {
-    try {
-        unlinkSync(BROKER_SPAWN_LOCK);
-    }
-    catch {
-        // Another cleanup path may already have removed the lock.
-    }
-}
 async function waitForBroker(timeoutMs = 5000) {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
@@ -245,5 +198,5 @@ async function waitForBroker(timeoutMs = 5000) {
         // Polling waits between probes rather than starting an unbounded batch.
         await sleep(100);
     }
-    throw new Error("Broker failed to start within timeout");
+    throw new Error(`Broker failed to start within timeout. Startup claim: ${BROKER_SPAWN_LOCK}. Live or uncertain owners are not reclaimed.`);
 }