@fitchmultz/pi-subagents 0.51.0 → 0.52.1

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

@@ -3,8 +3,9 @@ import { randomUUID } from "crypto";
 import { writeMessage } from "./framing.js";
 import { BrokerConnection, connectBrokerSocket } from "./connection.js";
 import { SnapshotReader } from "./snapshot-reader.js";
-import { LastMessageRequests } from "./client-last.js";
-import { isNativeReadQuery, isNativeReadResult } from "./last.js";
+import { LastMessageRequests, lastRequest } from "./client-last.js";
+import { ParkRequests } from "./client-park.js";
+import { isNativeReadResult } from "./last.js";
 import { errorMessage, isRecord, isUnknownArray, } from "../../shared/unknown.js";
 import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 /** Default delivery-ack timeout for `send` (broker acknowledges quickly). */
@@ -30,8 +31,7 @@ export class IntercomClient extends EventEmitter {
     connection = null;
     _sessionId = null;
     _topicsSupported = false;
-    lastMessagesSupported = false;
-    receiptReadsSupported = false;
+    parking = new ParkRequests();
     guardedDeliverySupported = false;
     lastRequests;
     pendingSends = new Map();
@@ -104,8 +104,7 @@ export class IntercomClient extends EventEmitter {
                     this.connection = null;
                     this._sessionId = null;
                     this._topicsSupported = false;
-                    this.lastMessagesSupported = false;
-                    this.receiptReadsSupported = false;
+                    this.parking.settle(false);
                     this.guardedDeliverySupported = false;
                     this.disconnecting = false;
                     this.failPending(error);
@@ -123,6 +122,7 @@ export class IntercomClient extends EventEmitter {
                     requestedId,
                     topicFrames: true,
                     lastMessages: true,
+                    parking: true,
                     receiptReads: 1,
                     guardedDelivery: 1,
                 });
@@ -183,11 +183,15 @@ export class IntercomClient extends EventEmitter {
             case "delivery_failed":
                 this.receiveDelivery(brokerMessage);
                 break;
+            case "parked":
+                this.parking.settle(true);
+                break;
+            case "wake":
             case "session_left":
                 if (typeof brokerMessage.sessionId !== "string") {
-                    throw new Error("Invalid session_left message");
+                    throw new Error(`Invalid ${type} message`);
                 }
-                this.emit("session_left", brokerMessage.sessionId);
+                this.emit(type, brokerMessage.sessionId);
                 break;
             default:
                 throw new Error(`Unknown broker message type: ${type}`);
@@ -202,19 +206,17 @@ export class IntercomClient extends EventEmitter {
         }
         this._sessionId = msg.sessionId;
         this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
-        this.lastMessagesSupported = msg.lastMessages === true;
-        this.receiptReadsSupported = msg.receiptReads === 1;
+        this.lastRequests.lastMessages = msg.lastMessages === true;
+        this.parking.supported = msg.parking === true;
+        this.lastRequests.receiptReads = msg.receiptReads === 1;
         this.guardedDeliverySupported = msg.guardedDelivery === 1;
         this.connection?.confirmRegistration();
         this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
     }
     receiveLastRequest(msg) {
-        const from = normalizeSessionInfo(msg.from);
-        if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {
-            throw new Error("Invalid last-message request");
-        }
-        if (!this.emit("last_request", { requestId: msg.requestId, from, query: msg.query })) {
-            this.respondLast(msg.requestId, { error: "Recipient has no last-message reader." });
+        const request = lastRequest(msg);
+        if (!this.emit("last_request", request)) {
+            this.respondLast(request.requestId, { error: "Recipient has no last-message reader." });
         }
     }
     receiveMessage(msg) {
@@ -269,6 +271,9 @@ export class IntercomClient extends EventEmitter {
             pending.resolve(pending.reader.finish());
         }
     }
+    park(on = true) {
+        return this.parking.request(() => this.requireActiveSocket(), on);
+    }
     async disconnect() {
         const connection = this.connection;
         if (!connection) {
@@ -282,20 +287,10 @@ export class IntercomClient extends EventEmitter {
         return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
     }
     async last(to, query = {}) {
-        return await this.lastRequests.last(this.readSocket(query), to, query);
+        return await this.lastRequests.last(this.requireActiveSocket(), to, query);
     }
     async receipt(to, query) {
-        return await this.lastRequests.receipt(this.readSocket(query), to, query);
-    }
-    readSocket(query) {
-        const socket = this.requireActiveSocket();
-        if (!this.lastMessagesSupported) {
-            throw new Error("This broker does not support last-message reads; reload after it exits.");
-        }
-        if ("messageId" in query && !this.receiptReadsSupported) {
-            throw new Error("publication_unavailable");
-        }
-        return socket;
+        return await this.lastRequests.receipt(this.requireActiveSocket(), to, query);
     }
     respondLast(requestId, result) {
         if (!isNativeReadResult(result)) {

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

@@ -12,13 +12,17 @@ interface LastPeer {
     readonly info: SessionInfo;
     readonly lastMessages: boolean;
     readonly receiptReads: boolean;
+    readonly parked?: {
+        readonly closed: boolean;
+    };
 }
 /** Correlation belongs to the broker, not the requester or the recipient's model queue. */
 export declare class LastMessageRelay {
     private readonly pending;
     private readonly sessions;
     constructor(sessions: ReadonlyMap<string, LastPeer>);
-    request(fromId: string, message: UnknownRecord): void;
+    /** `reader` names another peer that answers for an exited target from its captured history. */
+    request(fromId: string, input: UnknownRecord, reader: (id: string) => LastPeer | undefined): void;
     respond(fromId: string, message: UnknownRecord): void;
     disconnected(sessionId: string): void;
     private finish;

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

@@ -63,13 +63,28 @@ export function isLastMessageResult(value) {
     return (isRecord(value) &&
         (typeof value.error === "string" || (pageIdentity(value) && pageOffsets(value))));
 }
-function unavailable(targets, name, pending, query) {
+/** An exited parked child answers nothing itself; only its main holds the captured history. */
+function exitedRefusal(target, query, via) {
+    if (target.parked?.closed !== true) {
+        return undefined;
+    }
+    // No loaded journal owner answers receipts, with or without its main.
+    if ("messageId" in query) {
+        return "publication_unavailable";
+    }
+    return via === undefined ? "Parked session history is unavailable." : undefined;
+}
+function unavailable(targets, name, pending, { query, via }) {
     if (targets.length === 0) {
         return "Session not found";
     }
     if (targets.length > 1) {
         return `Multiple sessions named "${name}" are connected. Use the session ID instead.`;
     }
+    const exited = exitedRefusal(targets[0], query, via);
+    if (exited !== undefined) {
+        return exited;
+    }
     if (!targets[0].lastMessages) {
         return "Recipient does not support last-message reads; reload its extension.";
     }
@@ -102,6 +117,13 @@ function matchesLastPage(result, query, fromId) {
         (query.entryId === undefined || result.entryId === query.entryId) &&
         result.text.length <= (query.limit ?? LAST_MESSAGE_PAGE_LIMIT));
 }
+function lastRequest(message) {
+    const { requestId, to, query } = message;
+    if (typeof requestId !== "string" || typeof to !== "string" || !isNativeReadQuery(query)) {
+        throw new Error("Invalid last message request");
+    }
+    return { requestId, to, query };
+}
 /** Correlation belongs to the broker, not the requester or the recipient's model queue. */
 export class LastMessageRelay {
     pending = new Map();
@@ -109,12 +131,9 @@ export class LastMessageRelay {
     constructor(sessions) {
         this.sessions = sessions;
     }
-    request(fromId, message) {
-        if (typeof message.requestId !== "string" ||
-            typeof message.to !== "string" ||
-            !isNativeReadQuery(message.query)) {
-            throw new Error("Invalid last message request");
-        }
+    /** `reader` names another peer that answers for an exited target from its captured history. */
+    request(fromId, input, reader) {
+        const message = lastRequest(input);
         const targets = findSessions(this.sessions, message.to, fromId);
         const target = targets[0];
         const from = this.sessions.get(fromId);
@@ -122,13 +141,15 @@ export class LastMessageRelay {
             return;
         }
         const token = randomUUID();
+        const via = targets.length === 1 ? reader(target.info.id) : undefined;
         const frame = {
             type: "last_request",
             requestId: token,
             from: messageSender(from.info),
             query: message.query,
+            parked: via && messageSender(target.info),
         };
-        const error = unavailable(targets, message.to, this.pending.size, message.query) ??
+        const error = unavailable(targets, message.to, this.pending.size, { query: message.query, via }) ??
             validateIntercomMessageSize(frame)?.message;
         if (error !== undefined) {
             writeMessage(from.socket, {
@@ -143,12 +164,13 @@ export class LastMessageRelay {
         this.pending.set(token, {
             fromId,
             toId: target.info.id,
+            via: via?.info.id,
             requestId: message.requestId,
             query: message.query,
             timer,
         });
         try {
-            writeMessage(target.socket, frame);
+            writeMessage((via ?? target).socket, frame);
         }
         catch {
             this.finish(token, { error: "Recipient disconnected before last-message read" });
@@ -159,17 +181,17 @@ export class LastMessageRelay {
             throw new Error("Invalid last message response");
         }
         const pending = this.pending.get(message.requestId);
-        if (!pending || pending.toId !== fromId) {
+        if (!pending || (pending.via ?? pending.toId) !== fromId) {
             return;
         }
         const result = message.result;
-        this.finish(message.requestId, isNativeReadResult(result) && matchesPage(result, pending, fromId)
+        this.finish(message.requestId, isNativeReadResult(result) && matchesPage(result, pending, pending.toId)
             ? result
             : { error: "Recipient returned an invalid last-message page" });
     }
     disconnected(sessionId) {
         for (const [token, pending] of this.pending) {
-            if (pending.fromId === sessionId || pending.toId === sessionId) {
+            if ([pending.fromId, pending.toId, pending.via].includes(sessionId)) {
                 this.finish(token, { error: "Peer disconnected during last-message read" });
             }
         }

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

@@ -0,0 +1,107 @@
+import { randomUUID } from "crypto";
+import { nativePeerId } from "../session-targets.js";
+import { writeMessage } from "./framing.js";
+export function reachable(target) {
+    const socket = target?.socket;
+    return socket !== undefined && !socket.destroyed && socket.writable && !socket.writableEnded;
+}
+function requested(id) {
+    return typeof id === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(id) ? id : undefined;
+}
+/** A fenced child keeps its identity and queued input; it never departs while parked. */
+export class ParkedSessions {
+    sessions;
+    deliver;
+    constructor(sessions, deliver) {
+        this.sessions = sessions;
+        this.deliver = deliver;
+    }
+    park(socket, id, on) {
+        const session = this.sessions.get(id);
+        if (on && session?.parking === true) {
+            session.parked ??= { retained: [], closed: false };
+            // Frames already written to this socket precede the acknowledgement.
+            writeMessage(socket, { type: "parked" });
+        }
+        else if (!on && session?.parked?.closed === false) {
+            const { retained } = session.parked;
+            session.parked = undefined;
+            this.flush(id, retained);
+        }
+    }
+    /**
+     * Delivers retained input in order. A transport that fails mid-flush keeps the rest for its
+     * next generation; delivery refusals on a live transport follow resident delivery.
+     */
+    flush(id, retained) {
+        for (const [index, { from, message }] of retained.entries()) {
+            const session = this.sessions.get(id);
+            if (this.deliver(id, from, message) !== null && session?.socket.writable === false) {
+                session.parked = { retained: retained.slice(index), closed: false };
+                return;
+            }
+        }
+    }
+    /** A free requested identity, or a parked one resumed by the same child lineage. */
+    claim(requestedId, next) {
+        const id = requested(requestedId);
+        const previous = id === undefined ? undefined : this.sessions.get(id);
+        const resumes = previous?.parked !== undefined &&
+            previous.info.rootSessionId === next.rootSessionId &&
+            previous.info.parentSessionId === next.parentSessionId;
+        if (id === undefined || (previous && !resumes)) {
+            return { id: randomUUID() };
+        }
+        previous?.socket.destroy();
+        return { id, resumed: previous };
+    }
+    /** Flushes a restored child's input and re-sends wakes owed to a (re)registered main. */
+    registered(id, previous) {
+        this.flush(id, previous?.parked?.retained ?? []);
+        for (const child of this.sessions.values()) {
+            if (nativePeerId(child.info.rootSessionId ?? "") === id) {
+                this.wake(child);
+            }
+        }
+    }
+    /** A transport handoff, not a departure: no session_left and queued input stays. */
+    closed(session) {
+        const { parked } = session;
+        if (parked) {
+            parked.closed = true;
+            this.wake(session);
+        }
+        return parked !== undefined;
+    }
+    /**
+     * Exited parked children keep identities while some live session remains. Input already
+     * admitted for one keeps the broker until a returning main wakes it.
+     */
+    get exited() {
+        return [...this.sessions.values()].every(({ parked }) => parked?.closed === true && parked.retained.length === 0);
+    }
+    retain(target, from, message) {
+        target?.parked?.retained.push({ from, message });
+        if (target) {
+            this.wake(target);
+        }
+        return target?.parked !== undefined;
+    }
+    /** Reads of an exited parked child go to its main, which answers from captured history. */
+    reader(id) {
+        const child = this.sessions.get(id);
+        return child?.parked?.closed === true ? this.main(child) : undefined;
+    }
+    // Passive breadcrumbs and topic updates wait for a genuine wake; they never spawn the child.
+    wake(child) {
+        const main = this.main(child);
+        const wakes = child.parked?.retained.some(({ message }) => message.passive !== true && message.delivery !== "passive" && message.topic === undefined);
+        if (main && child.parked?.closed === true && wakes === true) {
+            writeMessage(main.socket, { type: "wake", sessionId: child.info.id });
+        }
+    }
+    main(child) {
+        const main = this.sessions.get(nativePeerId(child.info.rootSessionId ?? ""));
+        return main?.parking === true && main.parked === undefined ? main : undefined;
+    }
+}

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

@@ -28,7 +28,7 @@ export function acceptBrokerConnection(socket, handleMessage, disconnected) {
     }));
     socket.on("close", () => {
         if (sessionId !== null) {
-            disconnected(sessionId);
+            disconnected(sessionId, socket);
         }
     });
     socket.on("error", (error) => {

package/dist/pi-intercom/connection.js

@@ -7,6 +7,8 @@ import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./sessi
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
     client = null;
+    /** The transport whose broker retains this actor's input while it parks. */
+    parked = null;
     reconnectTimer = null;
     startupTimer = null;
     connecting = null;
@@ -23,6 +25,22 @@ export class IntercomConnection {
     get active() {
         return this.client;
     }
+    async park() {
+        const client = this.client;
+        this.parked = client !== null && (await client.park().catch(() => false)) ? client : null;
+        return this.parked !== null && this.parked === this.client;
+    }
+    get parking() {
+        return this.parked !== null;
+    }
+    get reconnected() {
+        return this.client !== null && this.client !== this.parked;
+    }
+    unpark() {
+        const client = this.parked === this.client ? this.client : null;
+        this.parked = null;
+        return client?.park(false).catch(() => false) ?? Promise.resolve(false);
+    }
     start(ctx, generation) {
         this.attempt = 0;
         this.clearTimers();
@@ -98,6 +116,47 @@ export class IntercomConnection {
             });
         }
     }
+    answerLast(next, request) {
+        const ctx = this.lifecycle.live();
+        const id = next.sessionId;
+        if (this.client !== next || !ctx || id === null) {
+            next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+            return;
+        }
+        const { parked, query } = request;
+        if ("messageId" in query) {
+            // The broker refuses receipt reads of an exited parked child before relaying them.
+            next.respondLast(request.requestId, parked ? { error: "publication_unavailable" } : this.hooks.receipt(query));
+            return;
+        }
+        if (parked) {
+            this.hooks
+                .parkedHistory(parked)
+                .then((history) => history
+                ? readLastMessage(history, parked, query)
+                : { error: "Parked session history is unavailable." })
+                .catch((error) => ({ error: asError(error).message }))
+                .then((result) => {
+                next.respondLast(request.requestId, result);
+            })
+                .catch(() => {
+                /* The requester's broker timeout reports a lost transport. */
+            });
+            return;
+        }
+        try {
+            next.respondLast(request.requestId, readLastMessage(ctx.sessionManager, {
+                id,
+                ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+                cwd: ctx.cwd,
+                model: ctx.model?.id ?? "unknown",
+                status: this.lifecycle.status(),
+            }, query));
+        }
+        catch (error) {
+            next.respondLast(request.requestId, { error: asError(error).message });
+        }
+    }
     createClient() {
         const next = new IntercomClient({
             sendTimeoutMs: this.config.sendTimeoutMs,
@@ -105,28 +164,7 @@ export class IntercomConnection {
         });
         this.client = next;
         next.on("last_request", (request) => {
-            const ctx = this.lifecycle.live();
-            const id = next.sessionId;
-            if (this.client !== next || !ctx || id === null) {
-                next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
-                return;
-            }
-            try {
-                if ("messageId" in request.query) {
-                    next.respondLast(request.requestId, this.hooks.receipt(request.query));
-                    return;
-                }
-                next.respondLast(request.requestId, readLastMessage(ctx.sessionManager, {
-                    id,
-                    ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
-                    cwd: ctx.cwd,
-                    model: ctx.model?.id ?? "unknown",
-                    status: this.lifecycle.status(),
-                }, request.query));
-            }
-            catch (error) {
-                next.respondLast(request.requestId, { error: asError(error).message });
-            }
+            this.answerLast(next, request);
         });
         next.on("message", (from, message) => {
             const ctx = this.lifecycle.live();
@@ -137,6 +175,11 @@ export class IntercomConnection {
                 console.error("Intercom inbound delivery failed:", error);
             });
         });
+        next.on("wake", (peer) => {
+            if (this.client === next) {
+                this.hooks.wake(peer);
+            }
+        });
         next.on("session_left", (id) => {
             if (this.client !== next) {
                 return;

package/dist/pi-intercom/inbound.js

@@ -70,7 +70,18 @@ export class IntercomInbound {
         }
         this.owners.delivery.queue(entry, "passive");
     }
+    /** Counted synchronously so a parking fence observes frames received before its ack. */
+    receiving = 0;
     async receive(ctx, from, input) {
+        this.receiving++;
+        try {
+            await this.receiveCounted(ctx, from, input);
+        }
+        finally {
+            this.receiving--;
+        }
+    }
+    async receiveCounted(ctx, from, input) {
         const generation = this.lifecycle.generation;
         const restore = this.owners.delivery.restoring;
         if (restore) {

package/dist/pi-intercom/index.js

@@ -12,6 +12,18 @@ import { IntercomInspection } from "./inspection.js";
 import { IntercomTools } from "./tools.js";
 import { IntercomSessionEvents } from "./session-events.js";
 import { registerIntercomTools } from "./tool-registration.js";
+import { isParkRequest, PARK, PARKED_HISTORY, WAKE } from "../shared/parking.js";
+/** The agent runtime answers for its exited parked child from the captured native session. */
+function parkedHistory(pi, peer) {
+    let history;
+    pi.events.emit(PARKED_HISTORY, {
+        peer,
+        reply: (found) => {
+            history = found;
+        },
+    });
+    return history ?? Promise.reject(new Error("No agent runtime owns parked history."));
+}
 export default function piIntercomExtension(pi) {
     const config = loadConfig();
     const lifecycle = new IntercomLifecycle(pi, config, readIntercomLineage());
@@ -30,6 +42,10 @@ export default function piIntercomExtension(pi) {
         disconnected: (error) => {
             wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
         },
+        parkedHistory: (peer) => parkedHistory(pi, peer.id),
+        wake: (peer) => {
+            pi.events.emit(WAKE, peer);
+        },
     });
     const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
         replies,
@@ -55,4 +71,26 @@ export default function piIntercomExtension(pi) {
         wait,
     }).register();
     registerIntercomTools(pi, tools);
+    pi.events.on(PARK, (request) => {
+        if (isParkRequest(request)) {
+            request.reply(request.park ? connection.park() : connection.unpark());
+        }
+    });
+    // Native fork sleep readiness; it vetoes only this package's own parking, never other saves.
+    Reflect.apply(pi.on.bind(pi), undefined, [
+        "working_session_save",
+        () => !connection.parking
+            ? undefined
+            : {
+                blockers: [
+                    inbound.receiving > 0 && "intercom is receiving a message",
+                    journal.size > 0 && "intercom inbound messages await delivery",
+                    replies.listPending().length > 0 && "intercom asks await replies",
+                    wait.waiting && "intercom is waiting for a reply",
+                    (delivery.restoring !== undefined || delivery.batching) &&
+                        "intercom delivery is restoring",
+                    connection.reconnected && "intercom reconnected while parking",
+                ].filter((blocker) => typeof blocker === "string"),
+            },
+    ]);
 }

package/dist/shared/parking.js

@@ -0,0 +1,12 @@
+import { isRecord } from "./unknown.js";
+/** A child actor asks its intercom to fence broker input before parking, or to release it. */
+export const PARK = "pi-subagents:park";
+/** A main intercom wakes or reads an exited parked child through the agent runtime. */
+export const WAKE = "pi-subagents:wake";
+export const PARKED_HISTORY = "pi-subagents:parked-history";
+export function isParkRequest(value) {
+    return isRecord(value) && typeof value.park === "boolean" && typeof value.reply === "function";
+}
+export function isHistoryRequest(value) {
+    return isRecord(value) && typeof value.peer === "string" && typeof value.reply === "function";
+}

package/dist/shared/post-exit-stdio-guard.js

@@ -3,6 +3,8 @@ import { readFileSync, readlinkSync } from "node:fs";
 import { isLinuxProcessReplaced, readLinuxProcess } from "../pi-intercom/broker/pid.js";
 import { hasErrorCode } from "./unknown.js";
 const BIRTH_FIELDS = ["lstart=", "pgid="];
+// macOS ships /bin/ps; resolving "ps" through PATH can spawn once per missing entry.
+export const PS_COMMAND = process.platform === "darwin" ? "/bin/ps" : "ps";
 /** Capture only a real, cross-process clock context; unavailable context proves nothing. */
 export function readProcessClock() {
     if (process.platform !== "android") {
@@ -45,7 +47,7 @@ function psOptions(zone) {
 }
 function readPsFields(pid, fields, zone) {
     try {
-        return execFileSync("ps", psArguments(pid, fields), {
+        return execFileSync(PS_COMMAND, psArguments(pid, fields), {
             ...psOptions(zone),
             stdio: ["ignore", "pipe", "ignore"],
         })
@@ -59,7 +61,7 @@ function readPsFields(pid, fields, zone) {
 /** Nonblocking `readPsFields`; a failed run likewise observes nothing. */
 function observePsFields(pid, fields, zone) {
     return new Promise((resolve) => {
-        execFile("ps", psArguments(pid, fields), psOptions(zone), (error, stdout) => {
+        execFile(PS_COMMAND, psArguments(pid, fields), psOptions(zone), (error, stdout) => {
             resolve(error ? undefined : stdout.trim().replace(/\s+/g, " "));
         });
     });

package/docs/code-quality.md

@@ -34,8 +34,8 @@ tests. CI separately qualifies the latest official Pi on GitHub-hosted Linux and
 the maintained fork on Linux and macOS. There is no custom checker build, probe
 suite or self-hosted runner requirement.
 
-CI's lint job also enforces the production line/byte shrink budget before
-qualification substitutes the selected host graph. The retired workflow schema
-generator and its patching dependency are not part of the new runtime.
-The active-child viewer has an approved aggregate budget of 19,000 source lines
-and 22,500 production lines. The 1 MiB byte ceiling and all lint limits stay unchanged.
+CI's lint job also enforces the production byte ceiling before qualification
+substitutes the selected host graph. The retired workflow schema generator and
+its patching dependency are not part of the new runtime. `npm run check:size`
+still reports source and production line counts for visibility; no line count
+is mandated. The 1 MiB byte ceiling and all lint limits stay unchanged.

package/docs/development.md

@@ -91,9 +91,9 @@ negative assertions. A sleep does not prove an owner processed its input.
 
 `scripts/measure-size.mjs` counts source, production scripts, generated code and
 schemas, including new untracked files. `--report` prints without enforcing.
-The ceilings are 19,000 source TypeScript lines, 22,500 total production lines,
-and 1 MiB total production bytes. Tests have no deletion quota. Moving machinery
-into generated/minified output does not evade the gate.
+The only enforced ceiling is 1 MiB total production bytes; source and production
+line counts are reported for visibility, not mandated. Tests have no deletion
+quota. Moving machinery into generated/minified output does not evade the gate.
 
 [The rebuild evidence](single-agent-rebuild.md) records the baseline, confirmed
 design, test-transfer obligations, and exact selected host identities. Update it

package/docs/intercom.md

@@ -342,7 +342,8 @@ the same runtime-root policy.
 
 The runtime directory is owned by the OS user, nonsymlink, and mode 0700; the
 socket is mode 0600. The broker starts on first use and exits after five seconds
-without connected sessions. Concurrent startup uses the shared spawn lock.
+without connected sessions, unless a parked child still holds admitted input; that
+input waits for its main to return and wake the child. Concurrent startup uses the shared spawn lock.
 
 `PI_INTERCOM_RUNTIME_DIR` explicitly selects an isolated deployment. It must be
 an absolute private directory with a socket path within 100 UTF-8 bytes. Invalid