@timqi/pier 0.0.29 → 0.1.0

package/dist/db.js

@@ -349,6 +349,36 @@ const MIGRATIONS = [
     ORDER BY sort, session_id LIMIT -1 OFFSET 8
   );
   ALTER TABLE session_state DROP COLUMN pinned;
+  `,
+    // 21 — unread is the workbench's own attention, so it is only its own rows.
+    `
+  -- The flag was written for every session whose turn ended, including the
+  -- ones no browser is the reader of: an IM session answers its chat, a run's
+  -- session answers its supervisor. Both are now skipped at the write
+  -- (web/server.ts), and neither could ever be acked — that needs the session
+  -- on screen — so the rows they left would stay set forever. On the instance
+  -- this was decided on, 195 of 196 marks were those. Cleared wholesale rather
+  -- than by owner: the one real row is a turn from before an upgrade nobody
+  -- was watching for, and a false amber dot costs less than the join.
+  UPDATE session_state SET unread = 0;
+  `,
+    // 22 — the palette finds what was said, not only what a session is called.
+    `
+  -- One row per user message and per assistant reply, keyed by the transcript
+  -- it came from so a file that is rewritten or gone drops its rows in one
+  -- statement (agent/listing.ts). Trigram tokens: a substring match with no
+  -- word segmentation, which CJK text has none of and a path or an identifier
+  -- in a prompt has too much of. Steps stay out — tool calls, their output,
+  -- thinking are the bulk of a transcript and nobody searches for what ran.
+  CREATE VIRTUAL TABLE session_fts USING fts5(
+    text, session_id UNINDEXED, path UNINDEXED, role UNINDEXED, at UNINDEXED,
+    tokenize = 'trigram'
+  );
+  -- Derived and disposable (migration 7): every row goes, so the next scan
+  -- reads every transcript from its first byte and fills the table above.
+  -- Resetting parsed_bytes alone would not — a row whose (size, mtime) still
+  -- match is trusted without opening the file.
+  DELETE FROM session_index;
   `,
 ];
 /**

package/dist/drain.js

@@ -11,7 +11,7 @@ import { logger } from "./log.js";
 const log = logger("drain");
 /** How long running turns may take before they are aborted. Generous: a turn
  *  can be a subagent fan-out, and an abort still persists the partial work. */
-export const DRAIN_DEADLINE_MS = 5 * 60_000;
+const DRAIN_DEADLINE_MS = 5 * 60_000;
 const POLL_MS = 1_000;
 /** Shared cleanup window after the deadline. All sessions use the same clock,
  *  so N hung seams still cost at most this long rather than N times as long. */

package/dist/extensions/web/content.js

@@ -49,7 +49,7 @@ export function sourcesFrom(content) {
     return [...sources.values()].map(({ title, url }) => ({ title, url }));
 }
 /** Only what the search itself returned, in the order it ranked them. */
-export function searchResultsFrom(content) {
+function searchResultsFrom(content) {
     const results = new Map();
     for (const block of content) {
         if (!isObject(block) || block.type !== "web_search_tool_result")
@@ -61,7 +61,7 @@ export function searchResultsFrom(content) {
     }
     return [...results.values()];
 }
-export function searchQueriesFrom(content) {
+function searchQueriesFrom(content) {
     const queries = [];
     for (const block of content) {
         if (!isObject(block) || block.type !== "server_tool_use" || block.name !== "web_search") {

package/dist/main.js

@@ -8,6 +8,7 @@ import { normalizeAgentSnapshot } from "./agent/config-sync.js";
 import { ConfigSync } from "./config-sync.js";
 import { configSyncTask } from "./config-sync-task.js";
 import { CredentialStore } from "./agent/credentials.js";
+import { IndexedListing } from "./agent/listing.js";
 import { PiAgentFactory } from "./agent/pi.js";
 import { defaultBoardsDir, registerBoardRoutes } from "./boards/boards.js";
 import { ChannelStore } from "./channels/config.js";
@@ -20,6 +21,7 @@ import { SlackDirectory } from "./channels/slack-directory.js";
 import { handleSlackTool, slackToolAvailable, slackToolSpec } from "./channels/slack-tool.js";
 import { parseConversation as parseSlackConversation } from "./channels/slack.js";
 import { EventHub } from "./core/hub.js";
+import { splitSpeaker } from "./core/identity.js";
 import { pierDb } from "./db.js";
 import { deliverLedger, drainForRestart, RestartLedger } from "./drain.js";
 import { bundledInfo } from "./extensions/index.js";
@@ -135,7 +137,12 @@ new CredentialStore(db, secrets), piConfig,
 () => settings.get().modelMenu, 
 // Bundled extensions the Console switched on; read per session open, so the
 // toggle reaches the next session the same way an edited agent file does.
-() => settings.get().extensions);
+() => settings.get().extensions, 
+// The title model, if the operator picked one; read when a first turn ends.
+() => settings.get().titleModel, 
+// The search index reads Pi's transcripts, which carry the speaker header
+// core wrote for the model; this is where the two areas meet.
+new IndexedListing(undefined, undefined, (text) => splitSpeaker(text).text));
 const hub = new EventHub();
 const router = new Router(hub, (key) => {
     // Web conversation ids ARE session ids; an IM conversation id is a chat or a

package/dist/secrets.js

@@ -172,7 +172,7 @@ function open(key, sealed, aad) {
 }
 /** The real vt CLI. Absent binary or denied approval both surface as the
  *  spawn/exit error — unlock() records it and the operator reads it. */
-export const vtCli = {
+const vtCli = {
     read: (record) => run("vt", ["read", record]),
     create: async (plaintext) => {
         const out = await run("vt", ["create"], plaintext);

package/dist/service.js

@@ -15,7 +15,7 @@ import { existsSync, mkdirSync, readFileSync, rmdirSync, rmSync, writeFileSync }
 import { homedir, userInfo } from "node:os";
 import { dirname, join } from "node:path";
 export const UNIT_NAME = "pier.service";
-export const UPDATE_UNIT_NAME = "pier-update.service";
+const UPDATE_UNIT_NAME = "pier-update.service";
 /** `~/.config/systemd/user/pier.service` — where a user unit belongs. */
 export const unitPath = (home = homedir()) => join(home, ".config", "systemd", "user", UNIT_NAME);
 /** The drop-in Pier writes once and never touches again: what the unit may
@@ -146,7 +146,7 @@ ExecStopPost=systemctl --user start ${UNIT_NAME}
  * exists to protect the OS and sshd outside it. Written commented so the
  * operator tuning it can see what each line buys.
  */
-export function renderLimits() {
+function renderLimits() {
     return `[Service]
 # Soft ceiling: past this the kernel reclaims hard and lets the unit crawl
 # instead of killing anything. This is the one that should bite first.

package/dist/settings.js

@@ -50,27 +50,40 @@ export function normalizeModelMenu(raw) {
         return null;
     const menu = [];
     for (const item of raw) {
-        if (typeof item !== "object" || item === null)
+        const ref = normalizeModelRef(item);
+        if (!ref)
             return null;
-        const { provider, id, thinking, note } = item;
-        if (typeof provider !== "string" || !provider.trim())
-            return null;
-        if (typeof id !== "string" || !id.trim())
-            return null;
-        if (thinking !== undefined && !isThinkingLevel(thinking))
+        const { thinking, note } = item;
+        // The one thing repaired rather than rejected, because it is not input:
+        // entries stored (or exported by an instance) before the level was
+        // required have none, and dropping the menu over it would lose the pins.
+        const level = thinking === undefined ? "medium" : thinking;
+        if (!isThinkingLevel(level))
             return null;
         if (note !== undefined && typeof note !== "string")
             return null;
         const cleaned = note?.trim().slice(0, 200);
         menu.push({
-            provider: provider.trim(),
-            id: id.trim(),
-            ...(thinking !== undefined ? { thinking } : {}),
+            ...ref,
+            thinking: level,
             ...(cleaned ? { note: cleaned } : {}),
         });
     }
     return menu;
 }
+/** One model reference, rejecting rather than repairing — the menu above is
+ *  built from these. Existence is not checked here: the catalog is the
+ *  agent's, and a model that went away is reported by the call that fails. */
+export function normalizeModelRef(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    const { provider, id } = raw;
+    if (typeof provider !== "string" || !provider.trim())
+        return null;
+    if (typeof id !== "string" || !id.trim())
+        return null;
+    return { provider: provider.trim(), id: id.trim() };
+}
 /**
  * Shape only — an unknown name is not an error here. This file must not know
  * what Pier bundles (that catalog is code, and importing it would drag the Pi
@@ -107,9 +120,11 @@ export class SettingsStore {
         this.#db = db;
     }
     get() {
+        const titleModel = this.#json("titleModel", normalizeModelRef, "a {provider, id}");
         return {
             publicUrl: this.#value("publicUrl") ?? "",
             modelMenu: this.#json("modelMenu", normalizeModelMenu, "a valid menu") ?? [],
+            ...(titleModel ? { titleModel } : {}),
             autoUpdate: this.#value("autoUpdate") === "1",
             extensions: this.#json("extensions", normalizeExtensions, "a list of names") ?? [],
             tools: this.#json("tools", normalizeTools, "a list of names") ?? [],
@@ -152,6 +167,12 @@ export class SettingsStore {
         this.#set("modelMenu", JSON.stringify(menu));
         return this.get();
     }
+    /** Same contract: hand this `normalizeModelRef`'s output; null switches
+     *  auto-titling off. */
+    setTitleModel(ref) {
+        this.#set("titleModel", ref ? JSON.stringify(ref) : "");
+        return this.get();
+    }
     setAutoUpdate(on) {
         this.#set("autoUpdate", on ? "1" : "0");
         return this.get();

package/dist/tasks/agent.js

@@ -4,11 +4,10 @@
 // agents specifically — a bash run costs a process, an agent run costs a
 // model's context and someone's rate limit.
 import { quietLabel, splitReply } from "../core/reply.js";
-import { Router } from "../core/router.js";
+import { logger } from "../log.js";
 import { runSource } from "./callbacks.js";
-import { TaskMessenger } from "./messages.js";
-import { TaskStore } from "./store.js";
 const MAX_ACTIVE_AGENTS = 4;
+const log = logger("tasks");
 /** What a child cannot know unless told. Every session gets the chat-surface
  * contract (<pier>/AGENTS.md), task runs included — so the delegation prompt
  * says which of it does not apply here, and a supervised run how to reach the
@@ -44,11 +43,18 @@ export class AgentTaskRunner {
         this.changed = changed;
     }
     async execute(run, action, signal, start) {
-        await this.acquireSlot(run, signal);
-        try {
-            const session = await this.resolveSession(run, action);
-            return await this.withSession(session.id, async () => {
+        // Reserve reuse order before resolving the session: a slow resume must not
+        // let a later run pass it. Fresh runs each have their own queue key.
+        return this.withSession(run.targetSessionId ?? run.id, signal, async () => {
+            const reused = run.targetSessionId ? await this.resolveSession(run, action, signal) : undefined;
+            if (reused)
+                await this.waitUntilIdle(reused, signal);
+            await this.acquireSlot(run, signal);
+            try {
+                const session = reused ?? await this.resolveSession(run, action, signal);
+                // A reused session may have become busy while we waited for a slot.
                 await this.waitUntilIdle(session, signal);
+                signal.throwIfAborted();
                 // Task requests come seconds apart — the 1h Anthropic cache-write premium
                 // never earns its 2× back, so task runs use the 5m TTL. Set here, not in
                 // resolveSession: this covers create, reuse and resume alike, on
@@ -85,22 +91,16 @@ export class AgentTaskRunner {
                         failure = event.error;
                     }
                 });
-                // The race below also settles this attempt if Pi ignores the abort:
-                // a hung turn must not hold one of the 4 slots (and its waiters)
-                // forever — the same guard execution.ts gives task-type children.
-                let rejectAborted = () => { };
-                const abortedTurn = new Promise((_, reject) => { rejectAborted = reject; });
-                abortedTurn.catch(() => { }); // handled via the race; never unhandled
+                // Cancel the SDK turn, but release our wait even if its abort hangs.
                 const abort = () => {
-                    void session.abort();
-                    rejectAborted(new Error("cancelled"));
+                    void Promise.resolve().then(() => session.abort())
+                        .catch((error) => log.warn(`run ${run.id} session abort failed`, error));
                 };
                 signal.addEventListener("abort", abort, { once: true });
-                // A pre-aborted signal never fires the listener: check before the
-                // prompt starts or a cancelled run would hang until its timeout.
-                if (signal.aborted)
-                    throw new Error("cancelled");
                 try {
+                    // Pre-abort does not fire a newly registered listener; keep the check
+                    // inside finally's scope so it also restores retention/subscriptions.
+                    signal.throwIfAborted();
                     const turn = session.systemInput(prompt, {
                         kind: "task-delegation",
                         taskId: run.taskId,
@@ -110,7 +110,7 @@ export class AgentTaskRunner {
                     }, "prompt");
                     await Promise.resolve();
                     this.messages.deliverPendingControls(run);
-                    await Promise.race([turn, abortedTurn]);
+                    await this.untilAborted(turn, signal);
                     if (signal.aborted)
                         throw new Error("cancelled");
                     // Before the fallback below: on a reused session that reads the
@@ -119,7 +119,7 @@ export class AgentTaskRunner {
                     if (failure)
                         throw new Error(failure);
                     if (!text) {
-                        const history = await session.history();
+                        const history = await this.untilAborted(session.history(), signal);
                         text = [...history].reverse().find((turn) => turn.role === "assistant")?.text ?? "";
                     }
                     // The chat contract is injected into task sessions too, so a child's
@@ -138,15 +138,16 @@ export class AgentTaskRunner {
                     signal.removeEventListener("abort", abort);
                     unsubscribe();
                 }
-            });
-        }
-        finally {
-            this.releaseSlot(run.id);
-        }
+            }
+            finally {
+                this.releaseSlot(run.id);
+            }
+        });
     }
-    async resolveSession(run, action) {
+    async resolveSession(run, action, signal) {
+        signal.throwIfAborted();
         if (run.targetSessionId) {
-            return this.router.ensure({ channelId: "task", conversationId: run.targetSessionId });
+            return this.untilAborted(this.router.ensure({ channelId: "task", conversationId: run.targetSessionId }), signal);
         }
         const policy = action.session;
         // Definitions stored before fork was removed still say `"fork"`. Refused by
@@ -157,7 +158,8 @@ export class AgentTaskRunner {
         }
         const cwd = policy.mode === "fresh"
             ? policy.cwd
-            : (await this.factory.find(policy.sessionId))?.cwd ?? "";
+            : (await this.untilAborted(this.factory.find(policy.sessionId), signal))?.cwd ?? "";
+        signal.throwIfAborted();
         if (!cwd)
             throw new Error("could not resolve child working directory");
         const opts = {
@@ -169,33 +171,52 @@ export class AgentTaskRunner {
                 (run.sourceSessionId ? this.router.modelOf(run.sourceSessionId) : undefined),
             thinking: action.launch?.thinking,
         };
-        const session = await this.factory.create(opts);
-        run.targetSessionId = session.id;
-        run.context.sessionId = session.id;
-        run.context.cwd = cwd;
-        this.store.saveRun(run);
-        this.router.attach({ channelId: "task", conversationId: session.id }, session);
-        this.changed(run);
+        const opening = this.factory.create(opts).then(async (session) => {
+            // SDK creation cannot be cancelled. A late session still belongs to
+            // this run; read back its terminal row so delivery updates are preserved.
+            // Remember it on the live run too: cancellation's final save can race
+            // this callback before it finishes writing the terminal record.
+            run.targetSessionId = session.id;
+            run.context.sessionId = session.id;
+            run.context.cwd = cwd;
+            const owner = signal.aborted ? this.store.getRun(run.id) ?? run : run;
+            owner.targetSessionId = run.targetSessionId;
+            owner.context = run.context;
+            try {
+                this.store.saveRun(owner);
+                this.changed(owner);
+            }
+            finally {
+                if (signal.aborted)
+                    await session.dispose();
+                else
+                    this.router.attach({ channelId: "task", conversationId: session.id }, session);
+            }
+            return session;
+        });
+        // A late rejection cannot reach execute's already-cancelled race.
+        void opening.catch((error) => {
+            if (signal.aborted)
+                log.warn(`session creation for cancelled run ${run.id} failed`, error);
+        });
+        const session = await this.untilAborted(opening, signal);
+        signal.throwIfAborted();
         return session;
     }
     async acquireSlot(run, signal) {
         while (this.active.size >= MAX_ACTIVE_AGENTS) {
-            if (signal.aborted)
-                throw new Error("cancelled");
-            await new Promise((resolve, reject) => {
-                const wake = () => {
-                    signal.removeEventListener("abort", abort);
-                    this.slotWaiters.delete(wake);
-                    resolve();
-                };
-                const abort = () => {
-                    this.slotWaiters.delete(wake);
-                    reject(new Error("cancelled"));
-                };
-                this.slotWaiters.add(wake);
-                signal.addEventListener("abort", abort, { once: true });
-            });
+            let wake = () => { };
+            try {
+                await this.untilAborted(new Promise((resolve) => {
+                    wake = resolve;
+                    this.slotWaiters.add(wake);
+                }), signal);
+            }
+            finally {
+                this.slotWaiters.delete(wake);
+            }
         }
+        signal.throwIfAborted();
         this.active.add(run.id);
     }
     releaseSlot(id) {
@@ -203,43 +224,58 @@ export class AgentTaskRunner {
         for (const wake of this.slotWaiters)
             wake();
     }
-    async withSession(sessionId, fn) {
+    async untilAborted(promise, signal) {
+        let abort = () => { };
+        const cancelled = new Promise((_, reject) => {
+            abort = () => reject(new Error("cancelled"));
+            signal.addEventListener("abort", abort, { once: true });
+            if (signal.aborted)
+                abort();
+        });
+        try {
+            return await Promise.race([promise, cancelled]);
+        }
+        finally {
+            signal.removeEventListener("abort", abort);
+        }
+    }
+    async withSession(sessionId, signal, fn) {
+        signal.throwIfAborted();
         const previous = this.sessionTails.get(sessionId) ?? Promise.resolve();
         let release = () => { };
         const gate = new Promise((resolve) => { release = resolve; });
         const tail = previous.then(() => gate);
         this.sessionTails.set(sessionId, tail);
-        await previous;
+        // Even if this waiter is cancelled, its tail still includes its predecessor.
+        // Only delete after that tail drains, or a new arrival could skip the queue.
+        void tail.then(() => {
+            if (this.sessionTails.get(sessionId) === tail)
+                this.sessionTails.delete(sessionId);
+        });
         try {
+            await this.untilAborted(previous, signal);
+            signal.throwIfAborted();
             return await fn();
         }
         finally {
             release();
-            if (this.sessionTails.get(sessionId) === tail)
-                this.sessionTails.delete(sessionId);
         }
     }
     async waitUntilIdle(session, signal) {
         // The session's own event stream is the only busy/idle signal — no polling.
         while (session.state === "streaming") {
-            if (signal.aborted)
-                throw new Error("cancelled");
-            await new Promise((resolve, reject) => {
-                const settle = (error) => {
-                    unsubscribe();
-                    signal.removeEventListener("abort", onAbort);
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                };
-                const onAbort = () => settle(new Error("cancelled"));
-                const unsubscribe = session.subscribe((event) => {
-                    if (event.type === "state" && event.state === "idle")
-                        settle();
-                });
-                signal.addEventListener("abort", onAbort, { once: true });
-            });
+            let unsubscribe = () => { };
+            try {
+                await this.untilAborted(new Promise((resolve) => {
+                    unsubscribe = session.subscribe((event) => {
+                        if (event.type === "state" && event.state === "idle")
+                            resolve();
+                    });
+                }), signal);
+            }
+            finally {
+                unsubscribe();
+            }
         }
     }
 }

package/dist/tasks/callbacks.js

@@ -1,8 +1,6 @@
 // What a finished run says to the session that delegated it. Delivery itself
 // belongs to outbox.ts; this file owns the run vocabulary and the batching.
-import { Router } from "../core/router.js";
 import { Outbox } from "./outbox.js";
-import { TaskStore } from "./store.js";
 /** How a run is named to the session that gets its result: the run id, and the
  *  session that did the work — a relayer's next move is a deep link to it
  *  (`#/session/<id>`), and without this line that costs a second tool call.
@@ -28,7 +26,7 @@ export function runResultText(run) {
     if (run.result?.type === "watch")
         result = "Watch condition did not match";
     if (result.length > 8000)
-        result = `${result.slice(0, 8000)}\n[truncated — task tool get run_id ${run.id} returns the full text]`;
+        result = `${result.slice(0, 8000)}\n[truncated — task tool recover run_id ${run.id} with a reason returns the full text]`;
     return result;
 }
 export class TaskCallbacks {

package/dist/tasks/command.js

@@ -5,6 +5,7 @@ import { spawn } from "node:child_process";
 import { logger } from "../log.js";
 const log = logger("tasks");
 const OUTPUT_LIMIT = 1024 * 1024;
+const KILL_GRACE_MS = 250;
 class CappedOutput {
     chunks = [];
     bytes = 0;
@@ -38,34 +39,52 @@ export function runBash(script, cwd, input, signal) {
         const stdout = new CappedOutput();
         const stderr = new CappedOutput();
         let settled = false;
-        const kill = () => {
+        let killTimer;
+        const kill = (signal) => {
             if (!child.pid)
                 return;
             try {
                 if (process.platform === "win32")
-                    child.kill("SIGTERM");
+                    child.kill(signal);
                 else
-                    process.kill(-child.pid, "SIGTERM");
+                    process.kill(-child.pid, signal);
             }
-            catch {
-                // The process may have exited between the state check and kill.
+            catch (err) {
+                // ESRCH means the owned process group already exited.
+                if (err.code !== "ESRCH")
+                    log.warn(`run ${signal} failed: ${String(err)}`);
             }
         };
-        signal.addEventListener("abort", kill, { once: true });
+        const abort = () => {
+            kill("SIGTERM");
+            killTimer = setTimeout(() => kill("SIGKILL"), KILL_GRACE_MS);
+            killTimer.unref();
+        };
+        const cleanup = () => {
+            clearTimeout(killTimer);
+            signal.removeEventListener("abort", abort);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
         child.stdout.on("data", (chunk) => stdout.add(chunk));
         child.stderr.on("data", (chunk) => stderr.add(chunk));
         child.on("error", (err) => {
             if (settled)
                 return;
             settled = true;
-            signal.removeEventListener("abort", kill);
+            cleanup();
             reject(err);
         });
         child.on("close", (code) => {
             if (settled)
                 return;
             settled = true;
-            signal.removeEventListener("abort", kill);
+            // A TERM trap may exit the shell while a descendant ignores TERM and
+            // has redirected its pipes. Closing the shell must not spare that group.
+            if (signal.aborted)
+                kill("SIGKILL");
+            cleanup();
             resolve({
                 exitCode: code,
                 stdout: stdout.text(),

package/dist/tasks/execution.js

@@ -3,11 +3,7 @@
 // while it goes, settled exactly once. Command and agent work lives in
 // command.ts and agent.ts; this file owns the lifecycle they share.
 import { logger } from "../log.js";
-import { AgentTaskRunner } from "./agent.js";
-import { TaskCallbacks } from "./callbacks.js";
 import { runBash } from "./command.js";
-import { TaskDefinitions } from "./definitions.js";
-import { TaskStore } from "./store.js";
 const log = logger("tasks");
 export class TaskExecution {
     store;
@@ -40,6 +36,8 @@ export class TaskExecution {
         let timedOut = false;
         let cause;
         const timeout = setTimeout(() => {
+            if (controller.signal.aborted)
+                return;
             timedOut = true;
             controller.abort();
         }, run.context.definition.timeoutSeconds * 1000);
@@ -58,6 +56,7 @@ export class TaskExecution {
             }
             if (run.matched !== false)
                 run.result = await this.executeAction(run, controller.signal);
+            controller.signal.throwIfAborted();
             run.state = "succeeded";
             if (definition.trigger.type === "watch" && !run.resumedFromRunId && definition.trigger.mode === "once" && run.matched) {
                 // As the definition's own creator: a one-shot watch retiring itself is
@@ -112,6 +111,7 @@ export class TaskExecution {
         }
     }
     async executeAction(run, signal) {
+        signal.throwIfAborted();
         const action = run.context.definition.action;
         if (action.type === "bash") {
             this.markRunning(run);
@@ -143,6 +143,8 @@ export class TaskExecution {
                 rejectWait(new Error("cancelled"));
             };
             signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
             try {
                 const done = await Promise.race([this.host.waitForRun(child.id), aborted]);
                 if (done.state !== "succeeded")