@fitchmultz/pi-subagents 0.46.2 → 0.48.0

package/dist/pi-intercom/bridge-operations.js

@@ -0,0 +1,127 @@
+import { join } from "node:path";
+import { isRecord } from "../shared/unknown.js";
+import { Launcher } from "./bridge-launch.js";
+import { SessionCatalog, savedView, trustedJournal } from "./bridge-catalog.js";
+import { Groups } from "./bridge-groups.js";
+import { broadcastTargets } from "./bridge-broadcast.js";
+import { getPiAgentDir } from "./agent-dir.js";
+import { Fault } from "./bridge-protocol.js";
+import { resolveBridgeTarget } from "./bridge-target.js";
+import { readSavedTranscript } from "./saved-transcript.js";
+/** Request operations own launch/catalog/group state; transport owns admission and cancellation. */
+export class BridgeOperations {
+    catalog = new SessionCatalog();
+    launcher = new Launcher(this.catalog);
+    stateDir;
+    groups;
+    constructor(stateDir) {
+        this.stateDir = stateDir ?? join(getPiAgentDir(), "intercom", "bridge-state");
+    }
+    revoke(clients) {
+        return this.launcher.revoke(clients);
+    }
+    shutdown() {
+        return this.launcher.shutdown();
+    }
+    groupStore() {
+        this.groups ??= new Groups(this.stateDir);
+        return this.groups;
+    }
+    async execute(operation, session, context) {
+        const launchContext = {
+            identity: session.identity,
+            expires: context.expires,
+            signal: context.signal,
+            peers: (signal) => session.connectedPeers(signal),
+            submit: (peer, task) => session.send(peer, task, context),
+        };
+        switch (operation.route) {
+            case "POST /v1/start":
+                return this.launcher.start(operation.name, launchContext);
+            case "POST /v1/spawn":
+                return this.launcher.spawn(operation, launchContext);
+            case "POST /v1/resume":
+                return this.launcher.resume(operation, launchContext);
+            case "GET /v1/sessions":
+                return operation.query === undefined
+                    ? this.launcher.list(session.identity)
+                    : this.launcher.browse(operation.query, launchContext);
+            case "POST /v1/stop":
+            case "POST /v1/cancel":
+                return this.stop(operation, session, context);
+            case "GET /v1/groups":
+                return { groups: this.groupStore().list(session.identity.fingerprint256) };
+            case "POST /v1/groups":
+                return {
+                    groups: this.groupStore().upsert(session.identity.fingerprint256, operation.group),
+                };
+            case "POST /v1/broadcast":
+                return broadcastTargets(session, this.groupStore().targets(session.identity.fingerprint256, operation.group, await session.connectedPeers(context.signal)), operation.message, context);
+            case "POST /v1/control":
+                return session.nativeControl(operation, context.certificate, context);
+            case "GET /v1/transcript":
+                return this.transcript(operation, session, context);
+            case "GET /v1/inbox":
+            case "GET /v1/list":
+            case "POST /v1/ack":
+            case "POST /v1/ask":
+            case "POST /v1/register":
+            case "POST /v1/reply":
+            case "POST /v1/send":
+                return session.execute(operation, context);
+        }
+    }
+    async stop(operation, session, context) {
+        const cancel = operation.route === "POST /v1/cancel";
+        const control = {
+            signal: context.signal,
+            peers: (signal) => session.connectedPeers(signal),
+        };
+        try {
+            return cancel
+                ? await this.launcher.cancel(session.identity, operation.sessionId, control)
+                : await this.launcher.stop(session.identity, operation.sessionId, control);
+        }
+        catch (error) {
+            // Only a pre-effect ownership miss may dispatch elsewhere; never retry an unknown outcome.
+            if (!(error instanceof Fault) || error.code !== "unknown_session") {
+                throw error;
+            }
+        }
+        return session.nativeControl({ to: operation.sessionId, verb: cancel ? "cancel" : "stop", timeoutMs: operation.timeoutMs }, context.certificate, context);
+    }
+    async transcript(operation, session, context) {
+        const peers = await session.connectedPeers(context.signal);
+        try {
+            const peer = resolveBridgeTarget(peers, operation.target, null);
+            const result = await session.nativeControl({
+                to: peer.id,
+                verb: "transcript",
+                options: operation.options,
+                timeoutMs: operation.timeoutMs,
+            }, context.certificate, context);
+            return {
+                ...result,
+                source: "live",
+                transcript: isRecord(result.native) ? result.native.transcript : undefined,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Fault) || error.code !== "peer_offline") {
+                throw error;
+            }
+        }
+        const policy = session.identity.launch;
+        if (!policy) {
+            throw new Fault(403, "launch_disabled", "Saved transcripts require local resume policy.");
+        }
+        const saved = await this.catalog.resolve(policy, { target: operation.target }, context.signal);
+        trustedJournal(policy, saved.sessionFile);
+        const page = await readSavedTranscript(policy.packageRoot, saved.sessionFile, operation.options);
+        session.guard(context.signal);
+        if (page.sessionId !== saved.sessionId) {
+            throw new Fault(409, "session_changed", "Saved journal identity changed during reading.");
+        }
+        return { status: "ok", source: "saved", session: savedView(saved), transcript: page };
+    }
+}

package/dist/pi-intercom/bridge-presence.js

@@ -0,0 +1,100 @@
+import { join } from "node:path";
+import { isRecord } from "../shared/unknown.js";
+import { readBridgeFile, writeBridgeJson } from "./bridge-files.js";
+import { log } from "./bridge-protocol.js";
+export class PersistentPresence {
+    registrations = new Map();
+    stopped = false;
+    timer;
+    running;
+    owner;
+    constructor(owner) {
+        this.owner = owner;
+        for (const identity of owner.clients().values()) {
+            this.restore(identity);
+        }
+    }
+    path(fingerprint) {
+        return join(this.owner.stateDir, `presence-${fingerprint}.json`);
+    }
+    restore(identity) {
+        try {
+            const value = JSON.parse(readBridgeFile(this.path(identity.fingerprint256), true, 8192).toString("utf8"));
+            if (isRecord(value) &&
+                value.fingerprint === identity.fingerprint256 &&
+                value.name === identity.name &&
+                value.cwd === identity.cwd &&
+                typeof value.expires === "number" &&
+                Number.isFinite(value.expires) &&
+                value.expires > Date.now()) {
+                this.registrations.set(identity.fingerprint256, {
+                    fingerprint: identity.fingerprint256,
+                    name: identity.name,
+                    cwd: identity.cwd,
+                    expires: value.expires,
+                });
+            }
+        }
+        catch {
+            // An absent/invalid saved registration never grants a certificate identity.
+        }
+    }
+    authenticated(identity, expires) {
+        const previous = this.registrations.get(identity.fingerprint256);
+        if (previous?.expires === expires &&
+            previous.name === identity.name &&
+            previous.cwd === identity.cwd) {
+            return;
+        }
+        const registration = {
+            fingerprint: identity.fingerprint256,
+            name: identity.name,
+            cwd: identity.cwd,
+            expires,
+        };
+        writeBridgeJson(this.path(identity.fingerprint256), registration);
+        this.registrations.set(identity.fingerprint256, registration);
+        this.start();
+    }
+    start() {
+        if (!this.stopped && !this.running) {
+            clearTimeout(this.timer);
+            this.timer = setTimeout(() => {
+                this.running = this.maintain().finally(() => {
+                    this.running = undefined;
+                    if (!this.stopped) {
+                        this.timer = setTimeout(() => this.start(), 15000);
+                    }
+                });
+            }, 0);
+        }
+    }
+    async maintain() {
+        for (const registration of this.registrations.values()) {
+            if (this.stopped) {
+                return;
+            }
+            const identity = this.owner.clients().get(registration.fingerprint);
+            if (!identity ||
+                identity.name !== registration.name ||
+                identity.cwd !== registration.cwd ||
+                registration.expires <= Date.now()) {
+                this.registrations.delete(registration.fingerprint);
+                continue;
+            }
+            try {
+                // Each identity has one connection attempt; preserve the native broker's spawn safeguards.
+                // oxlint-disable-next-line no-await-in-loop
+                await this.owner.connect(identity, registration.expires);
+            }
+            catch {
+                log("presence_retry", { name: identity.name, result: "broker_unavailable" });
+            }
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        clearTimeout(this.timer);
+        await this.running;
+    }
+}

package/dist/pi-intercom/bridge-protocol.js

@@ -14,6 +14,13 @@ export class Fault extends Error {
         this.details = details;
     }
 }
+export class BroadcastFault extends Fault {
+    outcome;
+    constructor(fault, outcome) {
+        super(fault.status, fault.code, fault.message, fault.details);
+        this.outcome = { ...outcome, status: "partial" };
+    }
+}
 export function object(value, fields) {
     if (!isRecord(value)) {
         throw new Fault(400, "invalid_input", "Expected a JSON object.");

package/dist/pi-intercom/bridge-routes.js

@@ -1,6 +1,9 @@
 import { isUnknownArray } from "../shared/unknown.js";
 import { ASK_TIMEOUT, Fault, INBOX_COUNT, label, object, text } from "./bridge-protocol.js";
 import { body } from "./bridge-http.js";
+import { groupDefinition } from "./bridge-groups.js";
+import { isControlVerb } from "./native-control-protocol.js";
+import { transcriptOptions } from "./transcript.js";
 const fields = {
     "GET /v1/list": [],
     "GET /v1/inbox": [],
@@ -10,8 +13,18 @@ const fields = {
     "POST /v1/ask": ["to", "message", "timeoutMs"],
     "POST /v1/reply": ["replyTo", "message"],
     "POST /v1/start": ["name"],
+    "POST /v1/spawn": ["name", "cwd", "task", "provider", "model"],
+    "POST /v1/resume": ["sessionId", "name", "target", "task"],
     "GET /v1/sessions": [],
-    "POST /v1/stop": ["sessionId"],
+    "POST /v1/stop": ["sessionId", "target", "to", "mode", "timeoutMs"],
+    "POST /v1/cancel": ["sessionId", "target", "to", "timeoutMs"],
+    "GET /v1/groups": [],
+    "POST /v1/groups": ["name", "members", "namePattern", "cwdPattern", "match"],
+    "POST /v1/broadcast": ["message", "group"],
+    "POST /v1/control": ["to", "verb", "options", "timeoutMs"],
+    "POST /v1/capabilities": ["to", "timeoutMs"],
+    "POST /v1/transcript": ["to", "limit", "maxBytes", "cursor", "timeoutMs"],
+    "GET /v1/transcript": ["target", "limit", "maxBytes", "cursor", "timeoutMs"],
 };
 function isRoute(route) {
     return Object.hasOwn(fields, route);
@@ -21,42 +34,154 @@ export function routeFor(req) {
         Object.keys(req.headers).some((key) => key.startsWith("sec-fetch-"))) {
         throw new Fault(403, "browser_forbidden", "Browser access is not supported.");
     }
-    const route = `${req.method ?? ""} ${req.url ?? ""}`;
+    const route = `${req.method ?? ""} ${(req.url ?? "").split("?")[0]}`;
     if (!isRoute(route)) {
         throw new Fault(404, "not_found", "Unknown method or path.");
     }
+    if (req.url?.includes("?") === true &&
+        !["GET /v1/inbox", "GET /v1/sessions", "GET /v1/transcript"].includes(route)) {
+        throw new Fault(400, "invalid_input", "Query parameters are only supported for inbox, sessions and transcript.");
+    }
+    checkGetBody(req);
+    return route;
+}
+function checkGetBody(req) {
     if (req.method === "GET" &&
         (req.headers["transfer-encoding"] !== undefined ||
             (req.headers["content-length"] !== undefined && req.headers["content-length"] !== "0"))) {
         throw new Fault(400, "invalid_input", "GET requests must not have a body.");
     }
-    return route;
 }
-function timeout(value) {
-    const ms = value === undefined ? ASK_TIMEOUT : value;
-    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > ASK_TIMEOUT) {
-        throw new Fault(400, "invalid_input", "timeoutMs must be an integer from 100 to 120000.");
+function queryFor(req, allowed) {
+    const query = new URL(req.url ?? "", "https://127.0.0.1").searchParams;
+    if ([...query.keys()].some((key) => !allowed.includes(key) || query.getAll(key).length !== 1)) {
+        throw new Fault(400, "invalid_input", "Unknown or repeated query parameter.");
+    }
+    return query;
+}
+function inboxQuery(req) {
+    const query = queryFor(req, ["after", "limit"]);
+    const after = query.get("after") ?? "0";
+    const limit = query.get("limit") ?? String(INBOX_COUNT);
+    if (!/^(0|[1-9]\d{0,15})$/.test(after) ||
+        !Number.isSafeInteger(Number(after)) ||
+        !/^[1-9]\d{0,2}$/.test(limit) ||
+        Number(limit) > INBOX_COUNT) {
+        throw new Fault(400, "invalid_input", "after must be a nonnegative safe integer cursor; limit must be 1..256.");
+    }
+    return { route: "GET /v1/inbox", after: Number(after), limit: Number(limit) };
+}
+function pageNumber(value, fallback, min, max) {
+    const number = value === null ? fallback : Number(value);
+    if (value === "" || !Number.isSafeInteger(number) || number < min || number > max) {
+        throw new Fault(400, "invalid_input", "Invalid catalog pagination.");
+    }
+    return number;
+}
+function queryBoolean(value) {
+    if (value !== null && value !== "true" && value !== "false") {
+        throw new Fault(400, "invalid_input", "Catalog switches must be true or false.");
+    }
+    return value === "true";
+}
+function catalogQuery(req) {
+    if (req.url?.includes("?") !== true) {
+        return undefined;
+    }
+    const params = queryFor(req, ["live", "saved", "q", "offset", "limit"]);
+    return {
+        live: queryBoolean(params.get("live")),
+        saved: queryBoolean(params.get("saved")),
+        q: params.has("q") ? label(params.get("q"), "catalog filter", 128) : undefined,
+        offset: pageNumber(params.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER),
+        limit: pageNumber(params.get("limit"), 50, 1, 100),
+    };
+}
+function timeout(value, control = false) {
+    const defaultMs = control ? 3000 : ASK_TIMEOUT;
+    const ms = value === undefined ? defaultMs : value;
+    const max = control ? 10000 : ASK_TIMEOUT;
+    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100 || ms > max) {
+        throw new Fault(400, "invalid_input", `timeoutMs must be an integer from 100 to ${max}.`);
     }
     return ms;
 }
-export async function operationFor(req, route, signal) {
-    const input = req.method === "POST" ? object(await body(req, signal), fields[route]) : {};
+function resume(input) {
+    if (["sessionId", "name", "target"].filter((key) => input[key] !== undefined).length !== 1) {
+        throw new Fault(400, "invalid_input", "Resume requires exactly one of sessionId, name or target.");
+    }
+    const sessionId = input.sessionId === undefined ? undefined : label(input.sessionId, "native session ID", 128);
+    if (sessionId !== undefined && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(sessionId)) {
+        throw new Fault(400, "invalid_input", "Resume takes a native ID, never a journal path.");
+    }
+    return {
+        route: "POST /v1/resume",
+        sessionId,
+        target: input.target === undefined ? undefined : label(input.target, "resume target", 256).trim(),
+        name: input.name === undefined ? undefined : label(input.name, "saved session name", 256).trim(),
+        task: input.task === undefined ? undefined : text(input.task),
+    };
+}
+function stop(route, input) {
+    if (["sessionId", "target", "to"].filter((key) => input[key] !== undefined).length !== 1) {
+        throw new Fault(400, "invalid_input", "Control requires exactly one sessionId, target or to.");
+    }
+    const mode = input.mode ?? "kill";
+    if (mode !== "kill" && mode !== "cancel") {
+        throw new Fault(400, "invalid_input", "Stop mode must be cancel or kill.");
+    }
+    return {
+        route: mode === "cancel" ? "POST /v1/cancel" : route,
+        sessionId: label(input.sessionId ?? input.target ?? input.to, "session target", 256).trim(),
+        timeoutMs: timeout(input.timeoutMs, true),
+    };
+}
+function nativeControl(route, input) {
+    const verb = route === "POST /v1/control" ? input.verb : route.split("/").at(-1);
+    if (!isControlVerb(verb)) {
+        throw new Fault(400, "invalid_input", "Unknown native control verb.");
+    }
+    const timeoutMs = timeout(input.timeoutMs, true);
+    const to = label(input.to ?? input.target, "session target").trim();
+    if (verb === "transcript") {
+        const options = transcriptOptions(route === "POST /v1/control"
+            ? input.options
+            : { limit: input.limit, maxBytes: input.maxBytes, cursor: input.cursor });
+        return { route: "GET /v1/transcript", target: to, options, timeoutMs };
+    }
+    if (input.options !== undefined) {
+        throw new Fault(400, "invalid_input", "Only transcript accepts options.");
+    }
+    return { route: "POST /v1/control", verb, to, timeoutMs };
+}
+async function operationInput(req, route, signal) {
+    if (req.method === "POST") {
+        return object(await body(req, signal), fields[route]);
+    }
+    if (route !== "GET /v1/transcript") {
+        return {};
+    }
+    const input = {};
+    for (const [key, value] of queryFor(req, fields[route])) {
+        input[key] = ["limit", "maxBytes", "timeoutMs"].includes(key) ? Number(value) : value;
+    }
+    return input;
+}
+function messagingOperation(route, input, req) {
     switch (route) {
         case "GET /v1/list":
-        case "GET /v1/inbox":
         case "POST /v1/register":
-        case "GET /v1/sessions":
+        case "GET /v1/groups":
             return { route };
-        case "POST /v1/start":
-            return { route, name: label(input.name, "session name", 64).trim() };
-        case "POST /v1/stop":
-            return { route, sessionId: label(input.sessionId, "session ID", 128) };
-        case "POST /v1/ack": {
+        case "GET /v1/inbox":
+            return inboxQuery(req);
+        case "GET /v1/sessions":
+            return { route, query: catalogQuery(req) };
+        case "POST /v1/ack":
             if (!isUnknownArray(input.ids) || input.ids.length > INBOX_COUNT) {
                 throw new Fault(400, "invalid_input", "ids must be an array of at most 256 message IDs.");
             }
             return { route, ids: [...new Set(input.ids.map((id) => label(id, "message ID")))] };
-        }
         case "POST /v1/send":
             return { route, message: text(input.message), to: label(input.to, "to").trim() };
         case "POST /v1/ask":
@@ -68,5 +193,53 @@ export async function operationFor(req, route, signal) {
             };
         case "POST /v1/reply":
             return { route, message: text(input.message), replyTo: label(input.replyTo, "replyTo") };
+        case "GET /v1/transcript":
+        case "POST /v1/control":
+        case "POST /v1/transcript":
+        case "POST /v1/capabilities":
+            return nativeControl(route, input);
+    }
+}
+export async function operationFor(req, route, signal) {
+    const input = await operationInput(req, route, signal);
+    switch (route) {
+        case "POST /v1/start":
+            return { route, name: label(input.name, "session name", 64).trim() };
+        case "POST /v1/spawn":
+            return {
+                route,
+                name: label(input.name, "session name", 64).trim(),
+                cwd: input.cwd === undefined ? undefined : label(input.cwd, "cwd", 4096),
+                provider: input.provider === undefined ? undefined : label(input.provider, "provider", 128),
+                model: input.model === undefined ? undefined : label(input.model, "model reference", 512),
+                task: input.task === undefined ? undefined : text(input.task),
+            };
+        case "POST /v1/resume":
+            return resume(input);
+        case "POST /v1/stop":
+        case "POST /v1/cancel":
+            return stop(route, input);
+        case "POST /v1/groups":
+            return { route, group: groupDefinition(input) };
+        case "POST /v1/broadcast":
+            return {
+                route,
+                message: text(input.message),
+                group: input.group === undefined ? undefined : label(input.group, "group", 64).trim(),
+            };
+        case "GET /v1/groups":
+        case "GET /v1/inbox":
+        case "GET /v1/list":
+        case "GET /v1/sessions":
+        case "GET /v1/transcript":
+        case "POST /v1/ack":
+        case "POST /v1/ask":
+        case "POST /v1/capabilities":
+        case "POST /v1/control":
+        case "POST /v1/register":
+        case "POST /v1/reply":
+        case "POST /v1/send":
+        case "POST /v1/transcript":
+            return messagingOperation(route, input, req);
     }
 }

package/dist/pi-intercom/bridge-rpc-process.js

@@ -2,14 +2,14 @@ import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { trySignalChildTree } from "../shared/post-exit-stdio-guard.js";
 import { isRecord } from "../shared/unknown.js";
-import { Fault, log, wait } from "./bridge-protocol.js";
+import { Fault, cancelled, log, wait } from "./bridge-protocol.js";
 const FRAME_LIMIT = 4 * 1024 * 1024;
 function launchEnvironment(packageRoot) {
     const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("PI_SUBAGENT_")));
     return { ...environment, PI_PACKAGE_DIR: packageRoot };
 }
 // Native RpcClient lacks public EOF/exit/UI control and retains/reprints unbounded stderr.
-// This owner implements only get_state and dialog cancellation, never a remote RPC proxy.
+// This owner implements state, owned-run cancellation and dialog dismissal, never a raw RPC proxy.
 export class RpcProcess {
     child;
     exited;
@@ -23,8 +23,9 @@ export class RpcProcess {
     stopping;
     stderrBytes = 0;
     exitObserved = false;
-    constructor(policy, cwd, sessionFile) {
-        this.child = spawn(process.execPath, this.arguments(policy, sessionFile), {
+    cancelling = false;
+    constructor(policy, cwd, sessionFile, resuming = false) {
+        this.child = spawn(process.execPath, this.arguments(policy, sessionFile, resuming), {
             cwd,
             detached: true,
             env: launchEnvironment(policy.packageRoot),
@@ -65,19 +66,19 @@ export class RpcProcess {
     get pid() {
         return this.child.pid;
     }
-    arguments(policy, sessionFile) {
+    arguments(policy, sessionFile, resuming) {
         const args = [
             policy.cli,
             "--mode",
             "rpc",
             "--session",
             sessionFile,
-            "--provider",
-            policy.provider,
-            "--model",
-            policy.model,
             policy.trustProject ? "--approve" : "--no-approve",
         ];
+        // Resume leaves native model/thinking restoration authoritative; never force the launch default.
+        if (!resuming && policy.provider !== undefined && policy.model !== undefined) {
+            args.push("--provider", policy.provider, "--model", policy.model);
+        }
         if (!policy.discoverResources) {
             args.push("--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files");
         }
@@ -175,8 +176,10 @@ export class RpcProcess {
     response(data) {
         const pending = this.pending;
         this.pending = undefined;
-        if (data.success === true && data.command === "get_state" && isRecord(data.data)) {
-            pending?.resolve(data.data);
+        if (data.success === true &&
+            data.command === pending?.command &&
+            (pending?.command !== "get_state" || isRecord(data.data))) {
+            pending?.resolve(isRecord(data.data) ? data.data : {});
         }
         else {
             pending?.reject(new Fault(503, "rpc_failed", "Pi RPC state request failed."));
@@ -200,14 +203,18 @@ export class RpcProcess {
             this.cleanup();
         }
     }
-    async state(signal) {
+    async command(command, signal) {
+        cancelled(signal);
         if (this.failure) {
             throw this.failure;
         }
-        const id = `state-${++this.sequence}`;
+        if (this.pending) {
+            throw new Fault(409, "control_in_progress", "A native control operation is already in flight.");
+        }
+        const id = `control-${++this.sequence}`;
         const result = new Promise((resolve, reject) => {
-            this.pending = { id, resolve, reject };
-            this.write({ type: "get_state", id });
+            this.pending = { id, command, resolve, reject };
+            this.write({ type: command, id });
         });
         try {
             return await wait(result, signal);
@@ -216,6 +223,27 @@ export class RpcProcess {
             this.pending = undefined;
         }
     }
+    async state(signal) {
+        return this.command("get_state", signal);
+    }
+    async cancel(signal) {
+        if (this.cancelling) {
+            throw new Fault(409, "control_in_progress", "Native cancellation is already in flight.");
+        }
+        this.cancelling = true;
+        try {
+            await this.command("abort", signal);
+            const state = await this.state(signal);
+            if (state.isStreaming !== false) {
+                throw new Fault(409, "cancel_unconfirmed", "Native Pi has not reached idle after abort.");
+            }
+            this.status = "idle";
+            return { isStreaming: false, pendingMessageCount: state.pendingMessageCount };
+        }
+        finally {
+            this.cancelling = false;
+        }
+    }
     ready() {
         if (this.failure || this.exitObserved) {
             throw this.failure ?? new Fault(503, "session_exited", "Pi exited during startup.");