@fitchmultz/pi-subagents 0.52.18 → 0.52.20

package/dist/pi-intercom/broker/snapshot-reader.d.ts

@@ -1,8 +1,9 @@
 import { type SessionSnapshot } from "../types.ts";
 /** Multipart frames build a private cache; only a complete validated snapshot escapes. */
 export declare class SnapshotReader {
-    private readonly sessions;
-    private readonly receipts;
+    private phase;
+    private open;
+    fail(): void;
     private addSession;
     append(sessions: readonly unknown[], receipts: unknown): void;
     finish(): SessionSnapshot;

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

@@ -48,15 +48,25 @@ function appendRows(previous, rows, supplied) {
 }
 /** Multipart frames build a private cache; only a complete validated snapshot escapes. */
 export class SnapshotReader {
-    sessions = new Map();
-    receipts = [];
-    addSession(row) {
+    phase = { kind: "open", sessions: new Map(), receipts: [] };
+    open() {
+        if (this.phase.kind !== "open") {
+            throw new Error(`Session snapshot is ${this.phase.kind}`);
+        }
+        return this.phase;
+    }
+    fail() {
+        if (this.phase.kind === "open") {
+            this.phase = { kind: "failed" };
+        }
+    }
+    addSession(state, row) {
         if (!isRecord(row) || typeof row.id !== "string") {
             throw new Error("Invalid session snapshot row");
         }
         const topics = optionalArray(row.topics);
         const subscriptions = optionalArray(row.subscriptions);
-        const previous = this.sessions.get(row.id);
+        const previous = state.sessions.get(row.id);
         const info = normalizeSessionInfo({
             ...previous?.info,
             ...row,
@@ -67,33 +77,42 @@ export class SnapshotReader {
             throw new Error("Invalid session snapshot");
         }
         const { topics: newTopics, subscriptions: newSubscriptions, ...identity } = info;
-        this.sessions.set(info.id, {
+        state.sessions.set(info.id, {
             info: identity,
             topics: appendRows(previous?.topics, newTopics, "topics" in row),
             subscriptions: appendRows(previous?.subscriptions, newSubscriptions, "subscriptions" in row),
         });
     }
     append(sessions, receipts) {
-        for (const row of sessions) {
-            this.addSession(row);
-        }
-        if (receipts === undefined) {
-            return;
+        const state = this.open();
+        try {
+            for (const row of sessions) {
+                this.addSession(state, row);
+            }
+            if (receipts === undefined) {
+                return;
+            }
+            if (!isUnknownArray(receipts)) {
+                throw new Error("Invalid topic delivery receipts");
+            }
+            state.receipts.push(...receipts.map(receipt));
         }
-        if (!isUnknownArray(receipts)) {
-            throw new Error("Invalid topic delivery receipts");
+        catch (error) {
+            this.fail();
+            throw error;
         }
-        this.receipts.push(...receipts.map(receipt));
     }
     finish() {
+        const state = this.open();
         const sessions = [];
-        for (const { info, topics, subscriptions } of this.sessions.values()) {
+        for (const { info, topics, subscriptions } of state.sessions.values()) {
             sessions.push({
                 ...info,
                 ...(topics !== undefined ? { topics } : {}),
                 ...(subscriptions !== undefined ? { subscriptions } : {}),
             });
         }
-        return { sessions, receipts: this.receipts };
+        this.phase = { kind: "finished" };
+        return { sessions, receipts: state.receipts };
     }
 }

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.`);
 }

package/dist/pi-intercom/lifecycle.js

@@ -8,12 +8,8 @@ export function isContextRequest(value) {
 }
 /** Owns native context validity and occupancy, never journal or socket state. */
 export class IntercomLifecycle {
-    context = null;
-    sessionId = null;
+    state = { kind: "inactive", epoch: 0 };
     model = "unknown";
-    disposed = true;
-    epoch = 0;
-    incarnation = null;
     peerId = null;
     guardedDelivery = false;
     applicationGuard;
@@ -29,10 +25,10 @@ export class IntercomLifecycle {
         this.lineage = lineage;
     }
     get generation() {
-        return this.epoch;
+        return this.state.epoch;
     }
     get currentSessionId() {
-        return this.sessionId;
+        return this.state.kind === "inactive" ? null : this.state.sessionId;
     }
     get toolCount() {
         return this.tools.size;
@@ -64,7 +60,7 @@ export class IntercomLifecycle {
         request.respond(this.snapshot());
     }
     snapshot() {
-        if (!this.live()) {
+        if (this.state.kind !== "live" || !this.live()) {
             return {
                 version: 1,
                 rootSessionId: null,
@@ -76,10 +72,10 @@ export class IntercomLifecycle {
         }
         return {
             version: 1,
-            rootSessionId: this.lineage?.rootSessionId ?? this.sessionId,
+            rootSessionId: this.lineage?.rootSessionId ?? this.state.sessionId,
             parentSessionId: this.lineage?.parentSessionId,
             peerId: this.peerId,
-            incarnation: this.incarnation,
+            incarnation: this.state.incarnation,
             connected: this.peerId !== null,
             guardedDelivery: this.guardedDelivery ? 1 : null,
             applicationGuard: this.applicationGuard,
@@ -107,36 +103,40 @@ export class IntercomLifecycle {
             this.applicationGuard === guard.applicationGuard);
     }
     start(ctx) {
-        this.disposed = false;
-        this.epoch += 1;
-        this.context = ctx;
-        this.sessionId = ctx.sessionManager.getSessionId();
-        this.incarnation = randomUUID();
+        this.state = {
+            kind: "live",
+            epoch: this.state.epoch + 1,
+            context: ctx,
+            sessionId: ctx.sessionManager.getSessionId(),
+            incarnation: randomUUID(),
+        };
         this.applicationGuard = undefined;
         this.model = ctx.model?.id ?? "unknown";
         this.running = false;
         this.activity = 0;
         this.tools.clear();
         this.transport(null);
-        return this.epoch;
+        return this.state.epoch;
     }
     invalidate() {
-        this.disposed = true;
-        this.epoch += 1;
+        const epoch = this.state.epoch + 1;
+        this.state =
+            this.state.kind === "inactive"
+                ? { kind: "inactive", epoch }
+                : { kind: "invalidated", epoch, sessionId: this.state.sessionId };
         this.running = false;
         this.tools.clear();
         this.publishContext();
     }
     clear() {
-        this.context = null;
-        this.sessionId = null;
+        this.state = { kind: "inactive", epoch: this.state.epoch };
     }
-    live(ctx = this.context, generation = this.epoch) {
-        if (this.disposed || generation !== this.epoch || !ctx) {
+    live(ctx = this.state.kind === "live" ? this.state.context : null, generation = this.state.epoch) {
+        if (this.state.kind !== "live" || generation !== this.state.epoch || !ctx) {
             return null;
         }
         try {
-            if (this.sessionId !== null && ctx.sessionManager.getSessionId() !== this.sessionId) {
+            if (ctx.sessionManager.getSessionId() !== this.state.sessionId) {
                 return null;
             }
             // Reading a native property detects invalidated contexts without modifying them.
@@ -209,12 +209,12 @@ export class IntercomLifecycle {
     }
     async registration(pendingAsks) {
         const live = this.live();
-        if (!live || this.sessionId === null) {
+        if (!live || this.state.kind !== "live") {
             throw new Error("Intercom runtime not initialized");
         }
         return {
-            ...this.identity(this.sessionId),
-            incarnation: this.incarnation ?? undefined,
+            ...this.identity(this.state.sessionId),
+            incarnation: this.state.incarnation,
             guardedDelivery: 1,
             applicationGuard: this.applicationGuard,
             cwd: live.cwd,