@fitchmultz/pi-subagents 0.52.18 → 0.52.19

package/CHANGELOG.md

@@ -2,12 +2,46 @@
 
 ## [Unreleased]
 
+## 0.52.19 - 2026-11-07
+
+<!-- npm-release:unreleased:start -->
+
+- Make post-exit pipe cleanup terminal across waiting, draining and closed phases so later pipe events cannot restart smoke child cleanup.
+- Distinguish parked and failed actor exit outcomes; both have disposed the native runtime, exit the actor and permit no second ordinary disposal.
+- Bind native intercom context identity to inactive, live or invalidated lifecycle state; invalidated transport cleanup retains the session ID until cleared, separate from transport connection and native tool activity.
+- Bind parent attachment to explicit detached, waiting, attaching and attached phases; managed readiness attaches only its own still-current waiting binding and shutdown joins admitted publication before releasing the matching generation.
+- Add optional `delegate.thinking` to select child effort independently of the parent on all supported hosts, including official Pi 1.5.0. Omission keeps inherited effort. Native model suffixes must agree with an explicit field. Pi still clamps effort to model capabilities; guidance and saved continuations retain the child's saved effort.
+- Represent child accounting as unrecorded, verified, pending or unavailable while keeping execution status and saved result formats unchanged.
+- Make directory-watch availability and the coalesced wake's single-owner contract explicit without changing polling fallback.
+- Preserve stranded last-good builds until a complete replacement publishes, and report retained recovery paths when a later build fails.
+- Give prepared topic transactions action-specific payloads while preserving validate-before-commit and stale-restore normalization.
+
+<!-- npm-release:unreleased:end -->
+
+- fix: preserve live and uncertain broker startup ownership (#342) ([f6147dd](https://github.com/fitchmultz/pi-subagents/commit/f6147dd7a31775e8499a6fd77b4185d6d918d646))
+
+### What's Changed
+
+- fix: preserve live and uncertain broker startup ownership by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/342
+- refactor: make post-exit pipe cleanup terminal by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/346
+- refactor: distinguish parked and failed actor exit outcomes by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/348
+- refactor: bind intercom context identity to lifecycle state by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/351
+- refactor: bind parent attachment to explicit lifecycle phases by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/349
+- fix: preserve last-good builds across interrupted publication by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/343
+- refactor: make child accounting outcomes explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/352
+- refactor: make directory watch availability explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/350
+- refactor: make prepared topic transactions explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/353
+- Add explicit child thinking to delegate by @tribble in https://github.com/fitchmultz/pi-subagents/pull/338
+
+**Full Changelog**: https://github.com/fitchmultz/pi-subagents/compare/v0.52.18...v0.52.19
+
 ## 0.52.18 - 2026-11-06
 
 <!-- npm-release:unreleased:start -->
 
 - Keep replied or retired asks out of reply attribution when their queued input reaches a later native turn.
 - Preserve unanswered queued asks through abort recovery without sending a premature recipient-failure reply.
+- Preserve live or uncertain broker startup ownership; reclaim only exited spawn owners and release only the acquired claim.
 
 <!-- npm-release:unreleased:end -->
 

package/README.md

@@ -14,6 +14,7 @@ delegate({
   prompt:
     "Inspect the authentication changes. Return concrete defects with file and line evidence. Do not edit files.",
   name: "auth-review",
+  thinking: "low",
 });
 ```
 
@@ -22,6 +23,9 @@ arrives later as a notification. Do other work or end the turn; do not poll.
 `context: "fresh"` is the default; `context: "fork"` preserves the native
 conversation, including prior tool results. There is no hidden role prompt,
 report-writing suffix, profile selection, or model fallback catalog.
+Optional `thinking` sets the child's effort without changing the parent. Omit it
+to inherit parent effort. Pi clamps the request to the child's model capabilities.
+Guidance and saved continuations keep the child's saved effort.
 
 ```js
 agent_runs({ action: "list" });

package/dist/agent/host.js

@@ -12,6 +12,18 @@ import { findPackageJSON } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { readIntercomLineage } from "../pi-intercom/identity.js";
 export { errorMessage as errorText } from "../shared/unknown.js";
+export function managedHost(context) {
+    const host = Reflect.get(context, "managedHost");
+    if (typeof host !== "object" || host === null) {
+        return undefined;
+    }
+    const owner = Reflect.get(host, "owner");
+    const pid = typeof owner === "object" && owner !== null ? Reflect.get(owner, "pid") : undefined;
+    const ready = Reflect.get(host, "ready");
+    return typeof pid === "number" && Number.isSafeInteger(pid) && ready instanceof Promise
+        ? { owner: { pid }, ready: ready.then((accepted) => accepted === true) }
+        : undefined;
+}
 /** A launcher may still own children while handing off or replacing a worker. */
 export function retainsChildren(event) {
     const disposition = Reflect.get(event, "disposition");

package/dist/agent/index.js

@@ -4,7 +4,7 @@ import { randomUUID } from "node:crypto";
 import * as loadedSDK from "@earendil-works/pi-coding-agent";
 import { actor, alive, ensureActor, ownIdentity, parkFailure, requestStop, signalProcess, } from "./process.js";
 import { stopChildren } from "./shutdown.js";
-import { isChild, errorText, rememberSDK, retainsChildren } from "./host.js";
+import { isChild, errorText, managedHost, rememberSDK, retainsChildren, } from "./host.js";
 import { serveParked } from "./parking.js";
 import { resultSchema, attachmentSchema, admissionSchema, commandSchema, } from "./contracts.js";
 import { delegateSchema, runsSchema } from "./tool-schemas.js";
@@ -20,18 +20,6 @@ import { executionCwd } from "./cwd.js";
 import { getPiAgentDir } from "../pi-intercom/agent-dir.js";
 import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.js";
 import { BackgroundReporter } from "../shared/background-reporting.js";
-function managedHost(context) {
-    const host = Reflect.get(context, "managedHost");
-    if (typeof host !== "object" || host === null) {
-        return undefined;
-    }
-    const owner = Reflect.get(host, "owner");
-    const pid = typeof owner === "object" && owner !== null ? Reflect.get(owner, "pid") : undefined;
-    const ready = Reflect.get(host, "ready");
-    return typeof pid === "number" && Number.isSafeInteger(pid) && ready instanceof Promise
-        ? { owner: { pid }, ready: ready.then((accepted) => accepted === true) }
-        : undefined;
-}
 /** Legacy results are optional; their reconciliation reports an invalid configured root. */
 function legacyInput() {
     try {
@@ -42,14 +30,8 @@ function legacyInput() {
     }
 }
 class AgentRuntime {
-    ctx;
+    attachment = { kind: "detached" };
     reporter = new BackgroundReporter(() => this.ctx);
-    // A managed launcher owns children across worker replacement; otherwise this process does.
-    host;
-    accepted = false;
-    base = "";
-    owner = "";
-    generation = "";
     // Polling remains only while change hints are unavailable or a reconciliation failed.
     timer;
     woken;
@@ -59,7 +41,6 @@ class AgentRuntime {
     // Input stamps the last reconciliation saw; a one-second probe recovers dropped hints.
     observed = new Map();
     probe;
-    closing = false;
     reset = Promise.resolve();
     shutdown = new AbortController();
     child = isChild();
@@ -69,11 +50,28 @@ class AgentRuntime {
         this.pi = pi;
         this.watches = new CompletionWatches(this.reporter, this.wake);
     }
+    get binding() {
+        if (this.attachment.kind === "detached") {
+            throw new Error("Agent runtime is not attached.");
+        }
+        return this.attachment.binding;
+    }
+    get ctx() {
+        return this.attachment.kind === "attaching" || this.attachment.kind === "attached"
+            ? this.attachment.binding.context
+            : undefined;
+    }
+    get base() {
+        return this.binding.base;
+    }
+    get owner() {
+        return this.binding.owner;
+    }
     checkMain() {
         if (isChild()) {
             throw new Error("Only a main session may delegate or control agent runs.");
         }
-        if (this.closing || !this.ctx || this.base.length === 0) {
+        if (this.shutdown.signal.aborted || this.attachment.kind !== "attached") {
             throw new Error("Agent runtime is not attached.");
         }
     }
@@ -93,17 +91,18 @@ class AgentRuntime {
     };
     scan = () => {
         clearTimeout(this.timer);
-        if (this.closing || !this.ctx || this.child) {
+        if (this.shutdown.signal.aborted || this.attachment.kind !== "attached" || this.child) {
             return;
         }
+        const { context } = this.attachment.binding;
         const inputs = () => [this.base, ...legacyInput(), ...this.awaited];
         const before = new Map(inputs().map((file) => [file, pathStamp(file)]));
         let reconciled = true;
         try {
-            const { notices, awaited } = notifications(this.ctx, this.base, this.owner);
+            const { notices, awaited } = notifications(context, this.base, this.owner);
             this.awaited = awaited;
-            notices.unshift(...reconcileLegacy(this.ctx, this.reporter));
-            deliver(this.pi, this.ctx, notices);
+            notices.unshift(...reconcileLegacy(context, this.reporter));
+            deliver(this.pi, context, notices);
             this.reporter.recover("completion-scan");
         }
         catch (error) {
@@ -131,23 +130,32 @@ class AgentRuntime {
         this.awaited = new Set();
     }
     start(context) {
+        if (this.shutdown.signal.aborted) {
+            return;
+        }
         this.reporter.start();
-        this.host = managedHost(context);
-        if (this.host === undefined || this.accepted || this.child) {
-            this.reset = this.reset.then(() => this.attach(context));
+        const owner = context.sessionManager.getSessionId();
+        const host = managedHost(context);
+        const binding = { context, owner, base: ownerDirectory(this.agentDir, owner), host };
+        if (host === undefined ||
+            this.attachment.kind === "attached" ||
+            this.attachment.kind === "attaching" ||
+            this.child) {
+            this.reset = this.reset.then(() => this.attach(binding));
             return this.reset;
         }
         // Attach and publish only after the launcher retires rollback: an unready replacement
         // must neither adopt children nor append completions to a journal it may abandon.
         // Readiness follows session_start, so never await it here.
-        this.owner = context.sessionManager.getSessionId();
-        this.base = ownerDirectory(this.agentDir, this.owner);
-        this.host.ready
-            .then(async (accepted) => {
-            if (accepted && !this.closing) {
-                this.accepted = true;
-                await this.start(context);
+        const waiting = { kind: "waiting", binding };
+        this.attachment = waiting;
+        host.ready
+            .then((accepted) => {
+            if (accepted && !this.shutdown.signal.aborted && this.attachment === waiting) {
+                this.reset = this.reset.then(() => this.attach(binding));
+                return this.reset;
             }
+            return null;
         })
             .catch((error) => {
             this.reporter.report(undefined, `Agent runtime attachment: ${errorText(error)}`);
@@ -155,37 +163,36 @@ class AgentRuntime {
         return undefined;
     }
     ownerIdentity() {
-        return ownIdentity(this.host?.owner.pid);
+        return ownIdentity(this.binding.host?.owner.pid);
     }
-    async attach(context) {
+    async attach(binding) {
         this.unwatch();
-        this.ctx = context;
+        const attaching = { kind: "attaching", binding, generation: randomUUID() };
+        this.attachment = attaching;
         if (this.child) {
+            this.attachment = { ...attaching, kind: "attached" };
             return;
         }
-        this.owner = context.sessionManager.getSessionId();
-        this.base = ownerDirectory(this.agentDir, this.owner);
-        this.generation = randomUUID();
-        await fs.promises.mkdir(this.base, { recursive: true, mode: 0o700 });
-        write(path.join(this.base, "attachment.json"), {
-            ...this.ownerIdentity(),
-            generation: this.generation,
+        await fs.promises.mkdir(binding.base, { recursive: true, mode: 0o700 });
+        write(path.join(binding.base, "attachment.json"), {
+            ...ownIdentity(binding.host?.owner.pid),
+            generation: attaching.generation,
             attached: true,
         });
-        if (this.closing) {
+        if (this.shutdown.signal.aborted) {
             return;
         }
+        this.attachment = { ...attaching, kind: "attached" };
         // Recovery and watch setup stay off the awaited startup path.
         this.timer = setTimeout(this.scan, 200).unref();
         this.probe = setInterval(this.recover, 1000).unref();
     }
     async dispose(retain) {
         this.reporter.shutdown();
-        this.closing = true;
         this.unwatch();
         this.shutdown.abort();
         await this.reset;
-        if (!retain && this.base.length > 0) {
+        if (!retain && !this.child && this.attachment.kind !== "detached") {
             const file = path.join(this.base, "attachment.json");
             const attachment = read(file, attachmentSchema);
             if (attachment !== undefined && this.releases(attachment)) {
@@ -197,14 +204,20 @@ class AgentRuntime {
                 await stopChildren(this.base, this.owner, (message) => this.reporter.report(undefined, message));
             }
         }
-        this.ctx = undefined;
+        this.attachment = { kind: "detached" };
     }
     releases(attachment) {
-        if (attachment.generation === this.generation) {
-            return true;
+        const state = this.attachment;
+        switch (state.kind) {
+            case "detached":
+                return false;
+            case "waiting":
+                // An unready replacement can release the launcher's existing generation on quit.
+                return attachment.attached && attachment.pid === state.binding.host?.owner.pid;
+            case "attaching":
+            case "attached":
+                return attachment.generation === state.generation;
         }
-        // An unready replacement never attached, but exiting still releases the launcher-owned children.
-        return (this.generation.length === 0 && attachment.attached && attachment.pid === this.host?.owner.pid);
     }
     stop(launch) {
         const base = this.base;
@@ -368,7 +381,8 @@ class AgentRuntime {
         this.pi.on("session_start", (_event, context) => this.start(context));
         this.pi.on("turn_end", (event, context) => {
             // The public pending flag covers user input; the preview also includes custom messages.
-            if (settle(this.owner, context.hasPendingMessages() || event.context.pendingMessages.length > 0)) {
+            if (this.attachment.kind === "attached" &&
+                settle(this.owner, context.hasPendingMessages() || event.context.pendingMessages.length > 0)) {
                 // Released admissions may have been dropped from the queue rather than published.
                 this.wake();
             }
@@ -389,7 +403,7 @@ class AgentRuntime {
         this.pi.registerTool({
             name: "delegate",
             label: "Delegate",
-            description: "Run a child on exactly this prompt; main sessions only. Fork copies the full conversation; default is fresh. Returns a receipt; completion is notified later: do other work or end the turn, don't poll.",
+            description: "Run a child on exactly this prompt; main sessions only. Fork copies the full conversation; default is fresh. Optional thinking overrides inherited effort for this child. Returns a receipt; completion is notified later: do other work or end the turn, don't poll.",
             parameters: delegateSchema,
             exposure: this.child ? "hidden" : "direct",
             renderResult: renderCompactResult,

package/dist/agent/launch.js

@@ -3,12 +3,18 @@ import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { loadSDK, packageRoot, runtimeEntry } from "./host.js";
 import { runDirectory, write } from "./storage.js";
+function selectedThinking(requested, inherited, suffix) {
+    if (requested !== undefined && suffix !== undefined && requested !== suffix) {
+        throw new Error("thinking conflicts with the model's thinking suffix.");
+    }
+    return suffix ?? requested ?? inherited;
+}
 function selectedModel(input, context, thinking, sdk) {
     if (input.model === undefined) {
         if (!context.model) {
             throw new Error("No selected model; no fallback was used.");
         }
-        return { model: context.model, thinking };
+        return { model: context.model, thinking: selectedThinking(input.thinking, thinking) };
     }
     const slash = input.model.indexOf("/");
     if (slash < 1) {
@@ -16,7 +22,7 @@ function selectedModel(input, context, thinking, sdk) {
     }
     const model = context.modelRegistry.find(input.model.slice(0, slash), input.model.slice(slash + 1));
     if (model) {
-        return { model, thinking };
+        return { model, thinking: selectedThinking(input.thinking, thinking) };
     }
     if (typeof sdk.resolveModelReference !== "function") {
         throw new Error(`Model ${input.model} is unavailable; no fallback was used. Check the provider/model ID. This host supports literal IDs only. If you intended a thinking suffix, update Pi for native thinking-suffix support.`);
@@ -30,7 +36,10 @@ function selectedModel(input, context, thinking, sdk) {
     if (resolved.status !== "resolved") {
         throw new Error(`Model ${input.model} is unavailable; no fallback was used.`);
     }
-    return { model: resolved.model, thinking: resolved.thinkingLevel ?? thinking };
+    return {
+        model: resolved.model,
+        thinking: selectedThinking(input.thinking, thinking, resolved.thinkingLevel),
+    };
 }
 function targetTrust(sdk, cwd, context, agentDir) {
     if (fs.realpathSync(cwd) === fs.realpathSync(context.cwd)) {

package/dist/agent/notifications.js

@@ -4,7 +4,7 @@ import { completionReceipts } from "./receipts.js";
 import { readOutputPage } from "../shared/output-page.js";
 import { journalStamp } from "../shared/native-journal.js";
 import { launchAt, list, runDirectory } from "./storage.js";
-import { readCanonicalResult, readResult } from "./usage.js";
+import { accountingState, readCanonicalResult, readResult } from "./usage.js";
 function isStringSet(value) {
     if (!(value instanceof Set)) {
         return false;
@@ -126,7 +126,7 @@ function unchangedPending(pending) {
 function load(base, id, owner) {
     const launch = launchAt(base, id, owner);
     const result = readCanonicalResult(base, launch);
-    if (result?.accountingPending === undefined) {
+    if (accountingState(result).kind !== "pending") {
         return { launch, result };
     }
     // Only pending runs need this pre-read stamp to observe concurrent publication.
@@ -135,7 +135,7 @@ function load(base, id, owner) {
     return { launch, result: readResult(base, launch), journal };
 }
 function cacheableResult(loaded) {
-    return loaded.result?.accountingPending === undefined || loaded.journal !== undefined;
+    return accountingState(loaded.result).kind !== "pending" || loaded.journal !== undefined;
 }
 function completedRun({ base, owner, known, settled }, id) {
     const directory = runDirectory(base, id);
@@ -156,7 +156,7 @@ function completedRun({ base, owner, known, settled }, id) {
     const order = { endedAt: loaded.result.endedAt, createdAt: loaded.launch.createdAt };
     // Pending accounting retries on child changes, even after the completion receipt.
     // Ordinary settled history retains its launch/result-only idle probes.
-    const pending = loaded.result.accountingPending === undefined ? undefined : loaded;
+    const pending = accountingState(loaded.result).kind === "pending" ? loaded : undefined;
     if (launch !== undefined && result !== undefined && cacheableResult(loaded)) {
         settled.set(id, { launch, result, pending, ...order });
     }
@@ -175,7 +175,7 @@ function completed(base, owner, awaited) {
         if (run === undefined) {
             awaited.add(path.join(runDirectory(base, id), "result.json"));
         }
-        else if (run.loaded?.result?.accountingPending !== undefined) {
+        else if (run.loaded && accountingState(run.loaded.result).kind === "pending") {
             awaited.add(run.loaded.launch.sessionFile);
         }
         return run ?? [];

package/dist/agent/parking.js

@@ -85,10 +85,7 @@ export function parkedState(dir, launch, restore) {
 }
 /** One actor generation's idle parking and exact restore; commands stay with the runner. */
 export class Parking {
-    saved;
-    /** Set before entering either native open, whose effects may outlive an exception. */
-    opened = false;
-    restored;
+    restore = { kind: "unopened" };
     since = 0;
     leaf;
     shell;
@@ -108,36 +105,48 @@ export class Parking {
     get file() {
         return path.join(this.dir, "parked.json");
     }
+    get saved() {
+        return this.restore.kind !== "unopened" && this.restore.source.kind === "parked"
+            ? this.restore.source.saved
+            : undefined;
+    }
+    /** Set before entering either native open, whose effects may outlive an exception. */
+    get opened() {
+        return this.restore.kind !== "unopened";
+    }
     /** Parked authority is exact state or nothing; never a journal-only reopen. */
     open() {
         const { sdk, launch } = this;
         const { openWorkingSession: restore } = sdk;
         const parked = parkedState(this.dir, launch, restore && sdk.readWorkingSession);
-        this.opened = true;
+        this.restore = {
+            kind: "opening",
+            source: parked ? { kind: "parked", ...parked } : { kind: "journal" },
+        };
         if (!parked || !restore) {
             return sdk.SessionManager.open(launch.sessionFile, undefined, launch.cwd);
         }
-        this.saved = parked.saved;
-        this.restored = parked.state;
         return restore(parked.saved);
     }
     /** The ready restored generation owns this state now; a later park writes a new cut. */
     adopt() {
-        if (this.restored !== undefined) {
+        if (this.restore.kind !== "opening") {
+            return;
+        }
+        const { source } = this.restore;
+        if (source.kind === "parked") {
             fs.rmSync(this.file);
-            fs.rmSync(this.restored, { force: true });
+            fs.rmSync(source.state, { force: true });
         }
+        this.restore = { kind: "adopted", source };
     }
-    /** True once this generation has exited its runtime with or without parked authority. */
+    /** Both exit outcomes have disposed the runtime; only one publishes parked authority. */
     async park(runtime, actor) {
         if (!actor.pi || !this.due(runtime.session, actor.busy) || this.hasShell()) {
-            return false;
+            return "resident";
         }
         const hold = await this.prepare(runtime, actor.pi, actor);
-        if (hold) {
-            await this.commit(runtime, hold, actor.errors);
-        }
-        return hold !== undefined;
+        return hold ? this.commit(runtime, hold, actor.errors) : "resident";
     }
     hasShell() {
         const witness = this.shell === undefined ? undefined : shell(this.shell, this.token);
@@ -201,7 +210,9 @@ export class Parking {
         if (read(this.file, parkedSchema)?.token !== this.token) {
             // Truthful boundary: retained input stays queued and nothing restarts implicitly.
             write(path.join(this.dir, "park-failed.json"), { token: this.token, errors });
+            return "exit-failed";
         }
+        return "exit-parked";
     }
     async capture(session, save) {
         if (!parkable(session)) {

package/dist/agent/runner.js

@@ -5,7 +5,7 @@ import { launchAt, missing, read, runDirectory, write } from "./storage.js";
 import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.js";
 import { errorText, loadSDK } from "./host.js";
 import { Parking } from "./parking.js";
-import { UsageIndex } from "./usage.js";
+import { accountingFields, UsageIndex } from "./usage.js";
 import { initializeCwd } from "./cwd.js";
 import { childRuntime } from "./child-runtime.js";
 import { ActorObservation } from "./observation.js";
@@ -40,7 +40,7 @@ class Actor {
     stopping = false;
     stopDeadline;
     nextParentCheck = 0;
-    parking = false;
+    parking = "resident";
     parent = new ParentCheck();
     // Raised when durable commands may need admission: change hints and stop.
     wake = new Wake();
@@ -91,10 +91,7 @@ class Actor {
             owner: launch.owner,
             status: completionStatus(this.stopping, message, error),
             endedAt: Date.now(),
-            ...(accounting.accountingError === undefined && terminal?.id !== undefined
-                ? { terminalEntryId: terminal.id }
-                : {}),
-            ...accounting,
+            ...accountingFields(accounting),
             ...(failure !== undefined ? { error: failure } : {}),
         };
         fs.writeFileSync(path.join(runDirectory(this.base, launch.id), "output.txt"), output, {
@@ -104,16 +101,21 @@ class Actor {
     }
     usage(launch, baseline, terminal) {
         try {
-            return { contributions: this.accounting.read(launch, baseline, terminal) };
-        }
-        catch (error) {
             return {
-                accountingError: errorText(error),
-                ...(terminal !== undefined
-                    ? { accountingPending: { terminalCandidate: terminal, baseline: [...baseline] } }
-                    : {}),
+                kind: "verified",
+                contributions: this.accounting.read(launch, baseline, terminal),
+                terminalEntryId: terminal,
             };
         }
+        catch (error) {
+            return terminal === undefined
+                ? { kind: "unavailable", error: errorText(error), terminalEntryId: undefined }
+                : {
+                    kind: "pending",
+                    error: errorText(error),
+                    pending: { terminalCandidate: terminal, baseline: [...baseline] },
+                };
+        }
     }
     output(message) {
         return (message?.content
@@ -352,7 +354,7 @@ class Actor {
         finally {
             clearInterval(watch);
         }
-        return this.parking;
+        return this.parking !== "resident";
     }
     failure(error, unopened) {
         const launch = this.current ?? this.initial;
@@ -465,7 +467,7 @@ class Actor {
         process.off("SIGTERM", this.stop);
         process.off("SIGINT", this.stop);
         const observation = this.observation?.close();
-        if (!this.parking) {
+        if (this.parking === "resident") {
             await runtime?.dispose();
         }
         if (this.stopping) {
@@ -477,7 +479,7 @@ class Actor {
             errors: this.errors,
             ...(observation === undefined ? {} : { observation }),
         });
-        if (this.parking) {
+        if (this.parking !== "resident") {
             // Parked authority requires actual exit; no leftover extension handle may keep it alive.
             process.exit();
         }

package/dist/agent/tool-schemas.js

@@ -1,5 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "./typebox.js";
+import { thinkingSchema } from "./contracts.js";
 // Main-session tool parameters only; the detached runner must not load pi-ai values.
 export const delegateSchema = Type.Object({
     prompt: Type.String({ minLength: 1 }),
@@ -9,6 +10,7 @@ export const delegateSchema = Type.Object({
         minLength: 1,
         description: "Exact provider/model ID (:thinking and any case need host support); no fuzzy match or fallback.",
     })),
+    thinking: Type.Optional(thinkingSchema),
     context: Type.Optional(StringEnum(["fresh", "fork"])),
 }, { additionalProperties: false });
 export const runsSchema = Type.Object({