@frockbot/plugin-shell 0.3.7 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.7",
+  "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.7",
-    "@frockbot/application-foundation": "0.3.7",
-    "@frockbot/catalog-core": "0.3.7",
-    "@frockbot/client-core": "0.3.7",
-    "@frockbot/client-ui": "0.3.7",
-    "@frockbot/computer-core": "0.3.7",
-    "@frockbot/computer-host-protocol": "0.3.7",
-    "@frockbot/configuration-core": "0.3.7",
-    "@frockbot/connection-core": "0.3.7",
-    "@frockbot/kernel-agent-loop": "0.3.7",
-    "@frockbot/kernel-composition": "0.3.7",
-    "@frockbot/kernel-contracts": "0.3.7",
-    "@frockbot/kernel-do": "0.3.7",
-    "@frockbot/machine-protocol": "0.3.7",
-    "@frockbot/plugin-applets": "0.3.7",
-    "@frockbot/plugin-authoring": "0.3.7",
-    "@frockbot/plugin-bot-template": "0.3.7",
-    "@frockbot/plugin-computer": "0.3.7",
-    "@frockbot/plugin-flock": "0.3.7",
-    "@frockbot/plugin-image": "0.3.7",
-    "@frockbot/plugin-machine-messages": "0.3.7",
-    "@frockbot/plugin-mcp": "0.3.7",
-    "@frockbot/plugin-memory": "0.3.7",
-    "@frockbot/plugin-package-catalog": "0.3.7",
-    "@frockbot/plugin-routines": "0.3.7",
-    "@frockbot/plugin-skills": "0.3.7",
-    "@frockbot/plugin-subagents": "0.3.7",
-    "@frockbot/plugin-user-machine": "0.3.7",
-    "@frockbot/protocol": "0.3.7",
+    "@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.7",
+    "@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,
@@ -437,6 +443,7 @@ import {
   optionalSidebarMessagePreviewV1,
   optionalUnreadStateV1,
   projectBotUnreadViewV1,
+  sidebarMessagePreviewFromRunsV1,
   SIDEBAR_PREVIEW_KEY,
   unreadReceiptKeyV1,
   UNREAD_COUNT_CAP,
@@ -444,6 +451,8 @@ import {
   type BotUnreadCommandV1,
   type BotUnreadReceiptV1,
   type BotUnreadViewV1,
+  type SidebarMessagePreviewV1,
+  type SidebarPreviewRunV1,
 } from "./unread.js";
 import { defineBotBackendContribution } from "@frockbot/kernel-contracts/contributions";
 
@@ -3102,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),
     });
   }
   // -------------------------------------------------------------------------
@@ -3345,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({
@@ -3451,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 {
@@ -5254,18 +5297,67 @@ export class ShellBotBackendContribution {
         ]),
     );
     const state = optionalUnreadStateV1(storedState);
-    const preview = optionalSidebarMessagePreviewV1(storedPreview);
     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),
-      preview,
+      await this.sidebarPreview(storedPreview, index),
+      failures,
     );
   }
 
+  /**
+   * How many stored runs a read will open to recover a missing preview. The
+   * newest settled chat Turn is almost always the first entry; the bound is
+   * what keeps a Bot whose recent Turns are all automations from turning one
+   * sidebar read into a scan of its whole history.
+   */
+  private static readonly SIDEBAR_PREVIEW_BACKFILL_RUNS_V1 = 5;
+
+  /**
+   * The preview record, or the same line derived from the runs when there is
+   * none. A Bot whose Turns settled before the preview projection existed has
+   * a full transcript and no record, and the row read "No messages yet" over
+   * it. A read never writes what it derives: the next settlement stores it.
+   */
+  private async sidebarPreview(
+    storedPreview: unknown,
+    index: readonly { runId: string }[],
+  ): Promise<SidebarMessagePreviewV1 | undefined> {
+    const stored = optionalSidebarMessagePreviewV1(storedPreview);
+    if (stored) return stored;
+    const runs: SidebarPreviewRunV1[] = [];
+    for (const entry of index.slice(
+      0,
+      ShellBotBackendContribution.SIDEBAR_PREVIEW_BACKFILL_RUNS_V1,
+    )) {
+      const run = await this.authority.readRun(entry.runId);
+      if (run) runs.push(run);
+    }
+    return sidebarMessagePreviewFromRunsV1(runs);
+  }
+
   /**
    * `bot/mark-read` and `bot/mark-unread`. Idempotent on the command id and
    * monotonic in the cursor, so a replay or an out-of-order delivery can only
@@ -5294,9 +5386,7 @@ export class ShellBotBackendContribution {
         }
         return {
           state: optionalUnreadStateV1(existing.state),
-          preview: optionalSidebarMessagePreviewV1(
-            await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
-          ),
+          preview: await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
         };
       }
       const current = optionalUnreadStateV1(
@@ -5320,9 +5410,7 @@ export class ShellBotBackendContribution {
       });
       return {
         state: next,
-        preview: optionalSidebarMessagePreviewV1(
-          await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
-        ),
+        preview: await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
       };
     });
     const index = await this.authority.listRunIndex({
@@ -5336,7 +5424,10 @@ export class ShellBotBackendContribution {
         identity.botId,
         stored.state,
         index.map((entry) => entry.cursor),
-        stored.preview,
+        // The open Bot is the one that gets marked read, so this receipt is
+        // the sidebar row it renders from: it owes the same derived preview
+        // the fan-out gives every other Bot.
+        await this.sidebarPreview(stored.preview, index),
       ),
     };
   }

package/src/client/FrockBotApp.vue

@@ -26,6 +26,12 @@ import {
   type WebToolActivity,
 } from "../shared.js";
 import { ComposerDraftStore } from "./composer-draft.js";
+import {
+  TURN_TEXT_MAX_CHARACTERS_V1,
+  turnTextCounterVisibleV1,
+  turnTextRemainingV1,
+  turnTextTooLongV1,
+} from "./turn-limits.js";
 import SendPayloadView from "./SendPayloadView.vue";
 import AppletCanvas from "./AppletCanvas.vue";
 import PackageIframeHost from "./PackageIframeHost.vue";
@@ -305,12 +311,31 @@ const composerPlaceholder = computed(() => {
   if (!state.value.modelReady) return state.value.modelLabel;
   return botName.value ? `Message ${botName.value}` : "Message";
 });
+/*
+ * The send route's size rule, enforced where the person can still do something
+ * about it. Past the limit the server answers 413 and nothing is sent, so the
+ * composer says how much is left before the button closes rather than letting
+ * a long message make the round trip to be refused.
+ */
+const draftText = computed(() => draft.value.trim());
+const draftTooLong = computed(() => turnTextTooLongV1(draftText.value));
+const draftCounterVisible = computed(() =>
+  turnTextCounterVisibleV1(draftText.value),
+);
+const draftCounterLabel = computed(() => {
+  const remaining = turnTextRemainingV1(draftText.value);
+  const count = Math.abs(remaining).toLocaleString("en-US");
+  return remaining < 0
+    ? `${count} characters over the ${TURN_TEXT_MAX_CHARACTERS_V1.toLocaleString("en-US")} limit`
+    : `${count} characters left`;
+});
 const canSend = computed(
   () =>
     state.value.connection === "ready" &&
     state.value.modelReady &&
     Boolean(state.value.activeBotId) &&
-    draft.value.trim().length > 0,
+    draftText.value.length > 0 &&
+    !draftTooLong.value,
 );
 /**
  * Stop takes the button only while there is nothing to send. The moment the
@@ -937,6 +962,20 @@ function handleComposerKeydown(event: KeyboardEvent): void {
                 <p v-if="message.notice" class="message-notice">
                   {{ message.notice }}
                 </p>
+                <!--
+                  The way out of an ending the person cannot otherwise act on:
+                  the client could not reach the Bot, their text is back in the
+                  composer, and this sends it again.
+                -->
+                <button
+                  v-if="message.retry === 'resend'"
+                  type="button"
+                  class="message-retry"
+                  :disabled="!canSend"
+                  @click="sendMessage()"
+                >
+                  Retry
+                </button>
                 <template v-for="tool in message.tools" :key="tool.id">
                   <PackageIframeHost
                     v-for="entry in iframeEntriesFor(tool)"
@@ -1188,6 +1227,19 @@ function handleComposerKeydown(event: KeyboardEvent): void {
               @click="refreshSkillPopover"
               @blur="closeSkillPopover"
             />
+            <!--
+              Silent until the budget is nearly spent, then it says how much is
+              left — and, past the limit, how much has to go before the send
+              button opens again.
+            -->
+            <p
+              v-if="draftCounterVisible"
+              class="composer-counter"
+              :class="{ 'composer-counter-over': draftTooLong }"
+              aria-live="polite"
+            >
+              {{ draftCounterLabel }}
+            </p>
           </div>
           <!--
             Start a new conversation. Sits beside the composer because that is