@frockbot/plugin-shell 0.3.8 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "private": false,
   "type": "module",
   "exports": {
@@ -47,41 +47,41 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/agent-runtime": "0.3.8",
-    "@frockbot/application-foundation": "0.3.8",
-    "@frockbot/catalog-core": "0.3.8",
-    "@frockbot/client-core": "0.3.8",
-    "@frockbot/client-ui": "0.3.8",
-    "@frockbot/computer-core": "0.3.8",
-    "@frockbot/computer-host-protocol": "0.3.8",
-    "@frockbot/configuration-core": "0.3.8",
-    "@frockbot/connection-core": "0.3.8",
-    "@frockbot/kernel-agent-loop": "0.3.8",
-    "@frockbot/kernel-composition": "0.3.8",
-    "@frockbot/kernel-contracts": "0.3.8",
-    "@frockbot/kernel-do": "0.3.8",
-    "@frockbot/machine-protocol": "0.3.8",
-    "@frockbot/plugin-applets": "0.3.8",
-    "@frockbot/plugin-authoring": "0.3.8",
-    "@frockbot/plugin-bot-template": "0.3.8",
-    "@frockbot/plugin-computer": "0.3.8",
-    "@frockbot/plugin-flock": "0.3.8",
-    "@frockbot/plugin-image": "0.3.8",
-    "@frockbot/plugin-machine-messages": "0.3.8",
-    "@frockbot/plugin-mcp": "0.3.8",
-    "@frockbot/plugin-memory": "0.3.8",
-    "@frockbot/plugin-package-catalog": "0.3.8",
-    "@frockbot/plugin-routines": "0.3.8",
-    "@frockbot/plugin-skills": "0.3.8",
-    "@frockbot/plugin-subagents": "0.3.8",
-    "@frockbot/plugin-user-machine": "0.3.8",
-    "@frockbot/protocol": "0.3.8",
+    "@frockbot/agent-runtime": "0.3.9",
+    "@frockbot/application-foundation": "0.3.9",
+    "@frockbot/catalog-core": "0.3.9",
+    "@frockbot/client-core": "0.3.9",
+    "@frockbot/client-ui": "0.3.9",
+    "@frockbot/computer-core": "0.3.9",
+    "@frockbot/computer-host-protocol": "0.3.9",
+    "@frockbot/configuration-core": "0.3.9",
+    "@frockbot/connection-core": "0.3.9",
+    "@frockbot/kernel-agent-loop": "0.3.9",
+    "@frockbot/kernel-composition": "0.3.9",
+    "@frockbot/kernel-contracts": "0.3.9",
+    "@frockbot/kernel-do": "0.3.9",
+    "@frockbot/machine-protocol": "0.3.9",
+    "@frockbot/plugin-applets": "0.3.9",
+    "@frockbot/plugin-authoring": "0.3.9",
+    "@frockbot/plugin-bot-template": "0.3.9",
+    "@frockbot/plugin-computer": "0.3.9",
+    "@frockbot/plugin-flock": "0.3.9",
+    "@frockbot/plugin-image": "0.3.9",
+    "@frockbot/plugin-machine-messages": "0.3.9",
+    "@frockbot/plugin-mcp": "0.3.9",
+    "@frockbot/plugin-memory": "0.3.9",
+    "@frockbot/plugin-package-catalog": "0.3.9",
+    "@frockbot/plugin-routines": "0.3.9",
+    "@frockbot/plugin-skills": "0.3.9",
+    "@frockbot/plugin-subagents": "0.3.9",
+    "@frockbot/plugin-user-machine": "0.3.9",
+    "@frockbot/protocol": "0.3.9",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "latest",
-    "@frockbot/plugin-tools": "0.3.8",
+    "@frockbot/plugin-tools": "0.3.9",
     "@types/bun": "1.3.6",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",

package/src/backend-routines.ts

@@ -301,6 +301,10 @@ export function routineInboxEntryViewV1(
     ...(entry.acknowledgedAt === undefined
       ? {}
       : { acknowledgedAt: entry.acknowledgedAt }),
+    ...(entry.repeatCount === undefined
+      ? {}
+      : { repeatCount: entry.repeatCount }),
+    ...(entry.failure === undefined ? {} : { failure: entry.failure }),
   };
 }
 

package/src/backend-subagent-blocking.test.ts

@@ -0,0 +1,222 @@
+// The foreground `Task` wait (memory-v2 F4).
+//
+// A `Task {background:false}` that answered "dispatched" the instant anything
+// went wrong read to the model as a call that had finished with no output. It
+// then spent two more steps on `task_check` and `task_resume`. The wait must
+// hold until the child settles, and give up only when the record is really
+// unreadable.
+import { describe, expect, test } from "bun:test";
+import type { UserSettingsViewV1 } from "@frockbot/configuration-core";
+import type {
+  TaskOutcomeV1,
+  TaskRecordV1,
+} from "@frockbot/plugin-subagents/records";
+import { taskKeyV1 } from "@frockbot/plugin-subagents/storage-keys";
+import type { ShellBotBackendHost } from "./backend.js";
+
+const identity = { userId: "user-1", botId: "primary" };
+const TASK_ID = "task-1";
+
+class MemoryStorage {
+  readonly values = new Map<string, unknown>();
+  /** Reads to fail before the first success, to stand in for contention. */
+  failReads = 0;
+  reads = 0;
+
+  get<T>(key: string): Promise<T | undefined> {
+    this.reads += 1;
+    if (this.failReads > 0) {
+      this.failReads -= 1;
+      return Promise.reject(new Error("storage is busy"));
+    }
+    return Promise.resolve(
+      structuredClone(this.values.get(key)) as T | undefined,
+    );
+  }
+
+  put(key: string | Record<string, unknown>, value?: unknown): Promise<void> {
+    if (typeof key === "string") this.values.set(key, structuredClone(value));
+    else {
+      for (const [entry, item] of Object.entries(key)) {
+        this.values.set(entry, structuredClone(item));
+      }
+    }
+    return Promise.resolve();
+  }
+
+  delete(key: string): Promise<boolean> {
+    return Promise.resolve(this.values.delete(key));
+  }
+
+  list<T>(options: { prefix?: string }): Promise<Map<string, T>> {
+    return Promise.resolve(
+      new Map(
+        [...this.values.entries()].filter(([key]) =>
+          key.startsWith(options.prefix ?? ""),
+        ) as Array<[string, T]>,
+      ),
+    );
+  }
+
+  transaction<T>(callback: (storage: MemoryStorage) => Promise<T>): Promise<T> {
+    return callback(this);
+  }
+
+  setAlarm(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  deleteAlarm(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+const user: UserSettingsViewV1 = {
+  schemaVersion: 1,
+  revision: 0,
+  profile: { name: "User" },
+  packages: [],
+  connections: [],
+};
+
+function host(storage: MemoryStorage): ShellBotBackendHost {
+  return {
+    state: { storage } as unknown as DurableObjectState,
+    env: {
+      USER_CONFIGURATIONS: {
+        idFromName: () => "user-id",
+        get: () => ({ readConfiguration: () => Promise.resolve(user) }),
+      },
+    } as unknown as ShellBotBackendHost["env"],
+  };
+}
+
+interface Waiting {
+  sleeps: number;
+  materializeSettings(
+    identity: { userId: string; botId: string },
+    profile: { name: string },
+  ): Promise<unknown>;
+  wait(taskId: string): Promise<TaskOutcomeV1 | undefined>;
+}
+
+/**
+ * Exposes the wait and removes its sleep, which is the whole point of it.
+ *
+ * The class is reached through a dynamic import rather than a top-level one:
+ * the Shell's backend and the foundation application import each other, and a
+ * static import from a test module reads the class while it is still
+ * initializing.
+ */
+async function waiting(host: ShellBotBackendHost): Promise<Waiting> {
+  // The application first: it is the half of the cycle that has to finish
+  // initializing before the Shell's class is readable.
+  await import("@frockbot/application-foundation/contributions");
+  const { ShellBotBackendContribution } = await import("./backend.js");
+  return new (class extends ShellBotBackendContribution {
+    sleeps = 0;
+
+    protected override sleep(): Promise<void> {
+      this.sleeps += 1;
+      return Promise.resolve();
+    }
+
+    wait(taskId: string): Promise<TaskOutcomeV1 | undefined> {
+      return this.awaitBlockingTask(identity, taskId, taskId);
+    }
+  })(host) as unknown as Waiting;
+}
+
+function record(overrides: Partial<TaskRecordV1> = {}): TaskRecordV1 {
+  return {
+    schemaVersion: 1,
+    taskId: TASK_ID,
+    type: "executor",
+    description: "read it",
+    promptDigest: "sha256:digest",
+    model: {
+      binding: {
+        packageId: "models",
+        capabilityId: "llm",
+        connectionId: "connection-1",
+        provider: "foundation",
+        providerModelId: "foundation-model",
+      },
+      slug: "foundation-model",
+    },
+    compositionGenerationId: "generation-1",
+    background: false,
+    depth: 1,
+    status: "running",
+    dispatch: {
+      runId: "run-1",
+      turnId: "turn-1",
+      sessionId: "user-1:primary",
+    },
+    childSessionId: `task:${TASK_ID}`,
+    attachments: [],
+    createdAt: "2026-09-03T00:00:00.000Z",
+    deadlineAt: "2026-09-03T00:30:00.000Z",
+    ...overrides,
+  };
+}
+
+async function fixture(
+  stored: TaskRecordV1,
+): Promise<{ storage: MemoryStorage; contribution: Waiting }> {
+  const storage = new MemoryStorage();
+  const contribution = await waiting(host(storage));
+  await contribution.materializeSettings(identity, { name: "Primary" });
+  storage.values.set(taskKeyV1(stored.taskId), structuredClone(stored));
+  return { storage, contribution };
+}
+
+describe("the foreground Task wait", () => {
+  test("answers with the child's settled outcome", async () => {
+    const { contribution } = await fixture(
+      record({
+        status: "completed",
+        outcome: {
+          status: "completed",
+          settledAt: "2026-09-03T00:00:10.000Z",
+          summary: "The root has six entries.",
+        },
+      }),
+    );
+
+    expect(await contribution.wait(TASK_ID)).toMatchObject({
+      status: "completed",
+      summary: "The root has six entries.",
+    });
+  });
+
+  // The regression: one failed read used to end the wait, and the Task tool
+  // then told the model the child was still running — for a child that had
+  // already settled.
+  test("rides out a transient read failure instead of giving up", async () => {
+    const { storage, contribution } = await fixture(
+      record({
+        status: "completed",
+        outcome: {
+          status: "completed",
+          settledAt: "2026-09-03T00:00:10.000Z",
+          summary: "The root has six entries.",
+        },
+      }),
+    );
+    storage.failReads = 2;
+
+    expect(await contribution.wait(TASK_ID)).toMatchObject({
+      status: "completed",
+      summary: "The root has six entries.",
+    });
+    expect(contribution.sleeps).toBeGreaterThan(0);
+  });
+
+  test("gives up when the record stays unreadable", async () => {
+    const { storage, contribution } = await fixture(record());
+    storage.failReads = Number.MAX_SAFE_INTEGER;
+
+    expect(await contribution.wait(TASK_ID)).toBeUndefined();
+  });
+});

package/src/backend.ts

@@ -214,6 +214,12 @@ import {
 } from "./backend-routines.js";
 import { RoutineInboxStore } from "@frockbot/plugin-routines/inbox-store";
 import {
+  ROUTINE_INBOX_LIMIT,
+  ROUTINE_INBOX_PREFIX,
+} from "@frockbot/plugin-routines/storage-keys";
+import {
+  decodeRoutineInboxEntryV1,
+  routineFailureSentenceV1,
   subagentAttributionV1,
   ROUTINE_INBOX_TEXT_MAX,
   ROUTINE_WAKE_TITLE_MAX,
@@ -3105,10 +3111,10 @@ export class ShellBotBackendContribution {
       runId: fire.fireId,
       createdAt: new Date().toISOString(),
       title: `${settings.profile.name} could not run a Routine`,
-      body: (outcome.summary ?? "The firing ended without saying why.").slice(
-        0,
-        240,
-      ),
+      // The same sentence the inbox entry carries. A notification is the one
+      // surface a person reads without asking for it, so it is the last place
+      // a kernel invariant belongs.
+      body: routineFailureSentenceV1(outcome.summary).slice(0, 240),
     });
   }
   // -------------------------------------------------------------------------
@@ -3348,11 +3354,38 @@ export class ShellBotBackendContribution {
     }
     if (admission.status === "replayed") {
       // The same tool call, reconciled or retried: the task it already
-      // dispatched is the answer, never a second child.
+      // dispatched is the answer, never a second child. A foreground call
+      // still waits for it — the caller asked for the result, and returning
+      // "dispatched" the instant a replay is recognised is what made a
+      // `background:false` Task look like it completed with no output.
+      const replayed = admission.record;
+      const settled =
+        replayed.outcome ??
+        (request.background
+          ? undefined
+          : await this.awaitBlockingTask(
+              identity,
+              taskAnchorIdV1(replayed.childSessionId),
+              replayed.taskId,
+            ));
+      if (settled) {
+        return {
+          status: "settled",
+          taskId: replayed.taskId,
+          model: replayed.model.slug,
+          taskStatus: settled.status,
+          ...(settled.summary === undefined
+            ? {}
+            : { summary: settled.summary }),
+          ...(settled.failure === undefined
+            ? {}
+            : { failure: settled.failure }),
+        };
+      }
       return {
         status: "dispatched",
-        taskId: admission.record.taskId,
-        model: admission.record.model.slug,
+        taskId: replayed.taskId,
+        model: replayed.model.slug,
       };
     }
     const reservation = await this.subagentSlots(identity).reserve({
@@ -3454,20 +3487,27 @@ export class ShellBotBackendContribution {
    * Durable Object already does inside a Turn, and the outbound probe is the
    * same call reconciliation makes.
    */
-  private async awaitBlockingTask(
+  protected async awaitBlockingTask(
     identity: BotIdentity,
     anchorTaskId: string,
     taskId: string,
   ): Promise<TaskOutcomeV1 | undefined> {
     const binding = this.subagentBinding;
     const deadline = Date.now() + TASK_BLOCKING_TIMEOUT_MS_V1;
+    // A read that fails once is transient storage contention, not an answer:
+    // abandoning the wait on the first one returned "still running" for a
+    // child that was about to settle, and taught the model to poll. Only a
+    // record that stays unreadable ends the wait early.
+    const readFailureLimit = 3;
+    let readFailures = 0;
     for (;;) {
       try {
         const record = await this.tasks.read(taskId);
+        readFailures = 0;
         if (record.outcome) return record.outcome;
       } catch {
-        // A record that cannot be read is not a reason to hold the Turn.
-        return undefined;
+        readFailures += 1;
+        if (readFailures >= readFailureLimit) return undefined;
       }
       if (binding) {
         try {
@@ -5260,11 +5300,30 @@ export class ShellBotBackendContribution {
     const index = await this.authority.listRunIndex({
       limit: UNREAD_COUNT_CAP + 1,
     });
+    // Counted straight off the keys rather than through `RoutineInboxStore`:
+    // its `list()` trims the inbox, and the unread fan-out is a read every
+    // sidebar poll makes for every Bot — it must not write, least of all into
+    // an object that is running a Turn. An undecodable row is skipped, because
+    // a badge is never worth failing a read for.
+    const stored = await this.ctx.storage.list<unknown>({
+      prefix: ROUTINE_INBOX_PREFIX,
+      limit: ROUTINE_INBOX_LIMIT,
+    });
+    let failures = 0;
+    for (const value of stored.values()) {
+      try {
+        const entry = decodeRoutineInboxEntryV1(value);
+        if (entry.failure === true && !entry.acknowledged) failures += 1;
+      } catch {
+        continue;
+      }
+    }
     return projectBotUnreadViewV1(
       identity.botId,
       state,
       index.map((entry) => entry.cursor),
       await this.sidebarPreview(storedPreview, index),
+      failures,
     );
   }
 

package/src/client/index.test.ts

@@ -1631,6 +1631,79 @@ describe("active durable Turn projection", () => {
     });
   });
 
+  test("a running Turn's partial text fills the bubble it will settle into", () => {
+    const state: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "activeRun"
+    > = { messages: [] };
+
+    projectDurableRuns(
+      state,
+      [],
+      [
+        {
+          runId: "run-9",
+          input: "Explain",
+          events: [],
+          status: "running",
+          partialText: "Because it",
+        },
+      ],
+    );
+    expect(state.messages[1]).toMatchObject({
+      text: "Because it",
+      status: "streaming",
+    });
+
+    // One bubble: the settled answer replaces the partial one in place.
+    projectDurableRuns(
+      state,
+      [],
+      [
+        {
+          runId: "run-9",
+          input: "Explain",
+          events: [],
+          status: "completed",
+          responseText: "Because it is.",
+        },
+      ],
+    );
+    expect(state.messages).toHaveLength(2);
+    expect(state.messages[1]).toMatchObject({
+      text: "Because it is.",
+      status: "completed",
+    });
+  });
+
+  test("a Turn that has already delivered a send streams nothing beside it", () => {
+    const state: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "activeRun"
+    > = { messages: [] };
+
+    projectDurableRuns(
+      state,
+      [],
+      [
+        {
+          runId: "run-10",
+          input: "Explain",
+          events: [
+            {
+              type: "send/to-user",
+              payload: { type: "text", text: "Here you go." },
+            },
+          ],
+          status: "running",
+          partialText: "private scratch space",
+        },
+      ],
+    );
+    expect(state.messages[1]).toMatchObject({ text: "", status: "streaming" });
+    expect(state.messages[1]?.sends).toHaveLength(1);
+  });
+
   test("projects reconciliation-required recovery state", () => {
     const reconciliation: Pick<
       FrockBotWebData,

package/src/client/index.ts

@@ -283,10 +283,16 @@ function turnRefusalCopyV1(reason: ClientTurnRefusalReasonV1): string {
  * model's own assistant text is scratch space and the thread does not draw it
  * (issue 153): drawing both is how a one-word reply arrived twice, once as the
  * model's text and once as the bubble that was actually delivered.
+ *
+ * A running Turn has no `responseText` yet — that is written only at
+ * settlement — so it draws the words it has written so far. They occupy the
+ * same bubble the settled answer will, and the same send gate applies to
+ * both: a Turn that has already delivered a bubble streams nothing into a
+ * second one.
  */
 function visibleAssistantText(run: ClientRun, fallback = ""): string {
   if (sendsFrom(run.events).length > 0) return "";
-  return run.responseText ?? fallback;
+  return run.responseText ?? run.partialText ?? fallback;
 }
 
 function isTerminalRun(run: ClientRun): boolean {

package/src/run-protocol.test.ts

@@ -1476,6 +1476,87 @@ describe("dispatched subagents in the run projection", () => {
     }
   });
 
+  test("a running Turn projects the words it has written so far", () => {
+    const streamed: SessionEvent[] = [
+      event({
+        type: "assistant/chunk",
+        seq: 0,
+        timestamp,
+        turn: 1,
+        step: 1,
+        requestId: "request-1",
+        text: "Half a",
+      }),
+      event({
+        type: "assistant/chunk",
+        seq: 1,
+        timestamp,
+        turn: 1,
+        step: 1,
+        requestId: "request-1",
+        text: " thought",
+      }),
+    ];
+
+    const projected = projectClientRunV1(storedRun(streamed, "running"));
+    expect(projected.partialText).toBe("Half a thought");
+    expect(projected.outcome).toBeUndefined();
+
+    // And it survives the wire, so the thread draws it while the Turn runs.
+    const decoded = decodeClientRunPageV1(
+      createClientRunListV1([projected], { truncated: false }),
+    ).runs[0];
+    expect(decoded?.partialText).toBe("Half a thought");
+    expect(decoded?.responseText).toBeUndefined();
+  });
+
+  test("a running Turn that has said nothing carries no partial text", () => {
+    expect(projectClientRunV1(storedRun([], "running")).partialText).toBe(
+      undefined,
+    );
+  });
+
+  test("a later request restarts the partial answer", () => {
+    const streamed: SessionEvent[] = [
+      event({
+        type: "assistant/chunk",
+        seq: 0,
+        timestamp,
+        turn: 1,
+        step: 1,
+        requestId: "request-1",
+        text: "scratch",
+      }),
+      event({
+        type: "assistant/chunk",
+        seq: 1,
+        timestamp,
+        turn: 1,
+        step: 2,
+        requestId: "request-2",
+        text: "the answer",
+      }),
+    ];
+    expect(projectClientRunV1(storedRun(streamed, "running")).partialText).toBe(
+      "the answer",
+    );
+  });
+
+  test("a settled Turn carries its answer once, as an outcome", () => {
+    const projected = projectClientRunV1(storedRun([], "completed"));
+    expect(projected.partialText).toBeUndefined();
+    expect(projected.outcome).toMatchObject({ type: "completed" });
+
+    const page = createClientRunListV1([projected], { truncated: false });
+    const tampered = structuredClone(page) as unknown as {
+      runs: Array<Record<string, unknown>>;
+    };
+    tampered.runs[0]!.partialText = "words";
+    expect(() => decodeClientRunPageV1(tampered)).toThrow(
+      "only a running run may carry partial text",
+    );
+  });
+
   test("refuses a chip whose background flag is not a boolean", () => {
     const page = createClientRunListV1(
       [projectClientRunV1(storedRun([dispatched]))],

package/src/run-protocol.ts

@@ -220,6 +220,14 @@ export interface ClientRunV1 {
    * the flag is durable state, so a reload draws the same thing.
    */
   queued?: true;
+  /**
+   * The answer the Bot has written so far, present only while the run is still
+   * running and has produced text. The thread draws it in the bubble it is
+   * already drawing for the Turn, so a reply appears as it is written instead
+   * of arriving whole at settlement. A settled run carries its answer in
+   * `outcome` instead, and never both.
+   */
+  partialText?: string;
   outcome?: ClientRunOutcomeV1;
   recovery?: ClientRunRecoveryV1;
 }
@@ -738,10 +746,13 @@ function visibleEvents(
  * fact about what the person watched arrive, not a claim that the Turn
  * succeeded, and the thread keeps it instead of replacing it with a notice.
  */
-function interruptedOutcomeTextV1(run: StoredRun): { text?: string } {
+export function assistantTextSoFarV1(
+  events: readonly SessionEvent[],
+  responseText = "",
+): string {
   let requestId: string | undefined;
-  let text = run.responseText ?? "";
-  for (const event of run.events) {
+  let text = responseText;
+  for (const event of events) {
     if (event.type === "assistant/chunk") {
       if (event.requestId !== requestId) {
         requestId = event.requestId;
@@ -753,9 +764,31 @@ function interruptedOutcomeTextV1(run: StoredRun): { text?: string } {
       text = event.text;
     }
   }
+  return text;
+}
+
+function interruptedOutcomeTextV1(run: StoredRun): { text?: string } {
+  const text = assistantTextSoFarV1(run.events, run.responseText ?? "");
   return text ? { text: truncateWireString(text, MAX_OUTCOME_BYTES) } : {};
 }
 
+/**
+ * What a still-running Turn has said so far, read out of the same journal an
+ * interrupted one is read from.
+ *
+ * The kernel appends an `assistant/chunk` per provider text delta and each
+ * append lands on the run record, so the words are already durable while the
+ * Turn runs; nothing here is a second copy and nothing crosses the channel.
+ * Bounded exactly as an outcome is, because a long answer must not be able to
+ * grow the run list past its wire budget.
+ */
+function partialTextV1(run: StoredRun): { partialText?: string } {
+  const text = assistantTextSoFarV1(run.events);
+  return text
+    ? { partialText: truncateWireString(text, MAX_OUTCOME_BYTES) }
+    : {};
+}
+
 function runStatus(run: StoredRun): ClientRunStatusV1 {
   return requireStoredRunV1(run).status;
 }
@@ -810,6 +843,7 @@ export function projectClientRunV1(run: StoredRun): ClientRunV1 {
     input: truncateWireString(run.input, MAX_INPUT_BYTES),
     status,
     events: visibleEvents(run.events, status),
+    ...(status === "running" ? partialTextV1(run) : {}),
     ...(run.stopRequestedAt
       ? {
           stopRequestedAt: truncate(run.stopRequestedAt, MAX_TIMESTAMP_LENGTH),
@@ -1300,6 +1334,7 @@ function decodeRun(value: unknown): ClientRun {
       "events",
       "stopRequestedAt",
       "queued",
+      "partialText",
       "outcome",
       "recovery",
     ],
@@ -1347,6 +1382,16 @@ function decodeRun(value: unknown): ClientRun {
   if (run.queued === true && runStatus !== "running") {
     throw new Error("only a running run may be queued");
   }
+  let partialText: string | undefined;
+  if (run.partialText !== undefined) {
+    // A settled run's answer is its outcome. Carrying both would give the
+    // thread two sources for one bubble, which is the duplication the
+    // one-bubble contract exists to prevent.
+    if (runStatus !== "running") {
+      throw new Error("only a running run may carry partial text");
+    }
+    partialText = wireString(run, "partialText", MAX_OUTCOME_BYTES, "run");
+  }
   return {
     runId,
     admittedAt,
@@ -1355,6 +1400,7 @@ function decodeRun(value: unknown): ClientRun {
     events: decodeEvents(run.events),
     ...(stopRequestedAt ? { stopRequestedAt } : {}),
     ...(run.queued === true ? { queued: true as const } : {}),
+    ...(partialText ? { partialText } : {}),
     ...(outcome?.type === "completed" ? { responseText: outcome.text } : {}),
     ...(outcome?.type === "failed"
       ? {

package/src/unread.test.ts

@@ -236,6 +236,33 @@ describe("the unread projection", () => {
     expect(view).toMatchObject({ count: 0, capped: false, unread: false });
   });
 
+  // A Routine failing every minute left the badge at zero, because an
+  // automation Turn never advances the activity cursor.
+  test("badges a Bot whose Routine is failing, with nothing else unread", () => {
+    const view = projectBotUnreadViewV1(
+      "alpha",
+      emptyUnreadStateV1(),
+      index(3),
+      undefined,
+      2,
+    );
+    expect(view).toMatchObject({ count: 2, unread: true, capped: false });
+  });
+
+  test("adds Routine failures to the unread chat Turns", () => {
+    const state: UnreadStateV1 = {
+      schemaVersion: 1,
+      lastActivityCursor: cursor(3),
+      lastActivityAt: "2026-08-31T00:03:00.000Z",
+      lastSeenCursor: cursor(1),
+      lastViewedAt: "2026-08-31T00:01:00.000Z",
+      manuallyUnread: false,
+    };
+    expect(
+      projectBotUnreadViewV1("alpha", state, index(4), undefined, 1),
+    ).toMatchObject({ count: 3, unread: true });
+  });
+
   test("carries the already-bounded latest message without deriving it", () => {
     const preview = decodeSidebarMessagePreviewV1({
       schemaVersion: 1,

package/src/unread.ts

@@ -406,9 +406,17 @@ export function projectBotUnreadViewV1(
   state: UnreadStateV1,
   cursors: readonly string[],
   lastMessage?: SidebarMessagePreviewV1,
+  /**
+   * Unacknowledged Routine failures. An automation Turn deliberately does not
+   * advance the activity cursor, so a Routine failing every minute badged
+   * nothing at all — the one Bot the User most needed to look at was the one
+   * the sidebar stayed quiet about. A failure is the Bot addressing its User,
+   * so it counts here even though the firing that produced it does not.
+   */
+  automationFailures = 0,
 ): BotUnreadViewV1 {
   const ceiling = state.lastActivityCursor;
-  let counted = 0;
+  let counted = Math.max(0, automationFailures);
   if (ceiling !== undefined) {
     for (const cursor of cursors) {
       if (cursor > ceiling) continue;