@frockbot/plugin-shell 0.3.21 → 0.3.23

package/package.json

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

package/src/backend-applets.test.ts

@@ -8,6 +8,7 @@ import {
   resolveAppletCompositionV1,
   APPLET_DIRECTORY_REVISION_SEEN_KEY,
   type AppletInstanceBindingV1,
+  type AppletSourceSyncOutcomeV1,
   type AppletUserDirectoryV1,
 } from "./backend-applets.js";
 import {
@@ -344,6 +345,7 @@ describe("ctx.applets", () => {
     directory?: Partial<AppletUserDirectoryV1>;
     instance?: Partial<AppletInstanceBindingV1>;
     storage?: ReturnType<typeof memoryStorage>;
+    synced?: AppletSourceSyncOutcomeV1;
   }) {
     const storage = options.storage ?? memoryStorage();
     const recorded: unknown[] = [];
@@ -455,6 +457,9 @@ describe("ctx.applets", () => {
           stat: () =>
             Promise.resolve({ status: "not-found", reason: "" }) as never,
         },
+        ...(options.synced
+          ? { syncSourceRootNow: () => Promise.resolve(options.synced!) }
+          : {}),
         composition: {
           current: () => bootstrap(),
           lastKnownGood: () => bootstrap(),
@@ -488,6 +493,39 @@ describe("ctx.applets", () => {
     );
   });
 
+  // Production, 2026-09-04: a 470 KB `dist/ui.html` the Bot had just built was
+  // reported as `not-found: run \`applet build\` … first`, and the Bot ran the
+  // build again, three times. The build was fine; the sync could not carry the
+  // file. The publish says which of the two it was now.
+  test("publish says a built file did not reach the Workspace rather than blaming the build", async () => {
+    const { host: capability } = host({
+      files: {},
+      synced: {
+        status: "degraded",
+        detail:
+          '1 sync operation failed at "dist/ui.html": unavailable: the Computer could not answer.',
+      },
+    });
+    const outcome = await capability.publish({ appletId: APPLET }, scope);
+    expect(outcome.status).toBe("failed");
+    const reason = outcome.status === "failed" ? outcome.reason : "";
+    expect(reason).toBe(
+      '"dist/server.js" is on the Computer but did not reach the Workspace: 1 sync operation failed at "dist/ui.html": unavailable: the Computer could not answer.',
+    );
+    expect(reason).not.toMatch(/applet build/);
+  });
+
+  test("publish still blames the build when the pull of the source root was clean", async () => {
+    const { host: capability } = host({
+      files: {},
+      synced: { status: "ok", detail: "" },
+    });
+    const outcome = await capability.publish({ appletId: APPLET }, scope);
+    expect(outcome.status === "failed" && outcome.reason).toMatch(
+      /applet build/,
+    );
+  });
+
   test("publish refuses a manifest whose hashes do not match the bytes", async () => {
     const { host: capability } = host({
       files: {

package/src/backend-applets.ts

@@ -58,6 +58,20 @@ export const APPLET_PUBLISH_EFFECT_PREFIX = "applets:publish-effect:";
  */
 export const APPLET_DIRECTORY_REVISION_SEEN_KEY = "applets:directory-revision";
 
+/**
+ * How the pre-publish pull of the Applet's source root went.
+ *
+ * `ok` and `skipped` mean the store now holds what the Computer holds. Anything
+ * else means the two may differ, and a `dist/` file the publish cannot find is
+ * then far more likely to be one the sync could not carry than one `applet
+ * build` never wrote.
+ */
+export interface AppletSourceSyncOutcomeV1 {
+  status: "ok" | "degraded" | "unavailable" | "refused" | "skipped";
+  /** What the sync said went wrong, empty when it had nothing to say. */
+  detail: string;
+}
+
 /** The three files `applet build` writes, read from the durable root. */
 export const APPLET_DIST_FILES_V1 = [
   "dist/server.js",
@@ -293,8 +307,12 @@ export interface AppletCapabilityHostOptionsV1 {
    * store is read as it stands — correct but possibly stale — and the Bot is
    * told so in the failure when the files are missing, rather than the publish
    * silently using old bytes.
+   *
+   * What it answers is how that pull went. A build that is on the Computer but
+   * did not reach the store is a different failure from a build that was never
+   * run, and the publish can only say which when it is told.
    */
-  syncSourceRootNow?(appletId: string): Promise<void>;
+  syncSourceRootNow?(appletId: string): Promise<AppletSourceSyncOutcomeV1>;
   composition: Pick<CompositionStore, "current" | "lastKnownGood" | "propose">;
   now?(): Date;
 }
@@ -594,11 +612,20 @@ export function createAppletCapabilityHostV1(
     appletId: string,
     file: string,
     maximum: number,
+    synced?: AppletSourceSyncOutcomeV1,
   ): Promise<{ text: string } | { failure: string }> {
     const outcome = await options.workspace.read(
       appletDistPathV1(options.userId, appletId, file),
     );
     if (outcome.status !== "ok") {
+      // A pull that did not finish is the likelier explanation than an
+      // unbuilt Applet, and telling the Bot to build again would send it
+      // round a loop that cannot end.
+      if (synced && synced.status !== "ok" && synced.status !== "skipped") {
+        return {
+          failure: `"${file}" is on the Computer but did not reach the Workspace: ${synced.detail || "the sync could not carry it"}`,
+        };
+      }
       return {
         failure: `"${file}" is ${outcome.status}: run \`applet build\` in applets/${appletId} on the Computer first`,
       };
@@ -731,12 +758,13 @@ export function createAppletCapabilityHostV1(
 
       // Force a pull of the source root so the publish sees what the Bot just
       // built, not the last synced copy. See the seam note on the option.
-      await options.syncSourceRootNow?.(input.appletId);
+      const synced = await options.syncSourceRootNow?.(input.appletId);
 
       const server = await readFile(
         input.appletId,
         "dist/server.js",
         APPLET_MAX_SERVER_BYTES_V1,
+        synced,
       );
       if ("failure" in server) {
         return settle(failed(input.appletId, "unbuilt", server.failure));
@@ -745,6 +773,7 @@ export function createAppletCapabilityHostV1(
         input.appletId,
         "dist/ui.html",
         APPLET_MAX_UI_BYTES_V1,
+        synced,
       );
       if ("failure" in ui) {
         return settle(failed(input.appletId, "unbuilt", ui.failure));
@@ -753,6 +782,7 @@ export function createAppletCapabilityHostV1(
         input.appletId,
         "dist/manifest.json",
         APPLET_MAX_MANIFEST_BYTES_V1,
+        synced,
       );
       if ("failure" in manifestFile) {
         return settle(failed(input.appletId, "unbuilt", manifestFile.failure));

package/src/backend-recovery-integration.test.ts

@@ -19,6 +19,7 @@ import { planBotRunRecovery } from "./backend-recovery.js";
 import {
   CLIENT_RUN_LIST_MAX_BYTES,
   CLIENT_RUN_PAGE_LIMIT,
+  CLIENT_RUN_SCAN_LIMIT,
   clientRunListWireBytes,
 } from "./run-protocol.js";
 
@@ -1475,6 +1476,139 @@ describe("Bot recovery", () => {
     ).toBe(false);
   });
 
+  /**
+   * The run index is global; the transcript is one conversation. These cover
+   * the shape that used to answer "this conversation is empty" whenever the
+   * newest page of the index happened to hold nothing the reader could see.
+   */
+  async function writeRunHistory(
+    storage: MemoryStorage,
+    runs: Array<{
+      runId: string;
+      sessionId: string;
+      turnType?: "chat" | "automation";
+    }>,
+  ): Promise<void> {
+    const baseTime = Date.parse("2026-09-01T00:00:00.000Z");
+    for (const [index, entry] of runs.entries()) {
+      const acceptedAt = new Date(baseTime + index * 1_000).toISOString();
+      const run = {
+        runId: entry.runId,
+        commandFingerprint: `fingerprint-${index}`,
+        sessionId: entry.sessionId,
+        acceptedAt,
+        input: "hello",
+        events: [],
+        effectAdmissions: [],
+        status: "completed",
+        phase: "executing",
+        compositionGenerationId: "test-composition-generation",
+        configurationSnapshot: initializeBotSettingsV1("primary"),
+        previousEventCount: 0,
+        responseText: "answer",
+        ...(entry.turnType && entry.turnType !== "chat"
+          ? { admission: { schemaVersion: 1, turnType: entry.turnType } }
+          : {}),
+      } satisfies StoredRun;
+      await storage.put({
+        [`run:${entry.runId}`]: run,
+        [`run-index:${acceptedAt}:${entry.runId}`]: entry.runId,
+      });
+    }
+  }
+
+  test("reaches an older conversation buried under newer Turns", async () => {
+    const storage = new MemoryStorage();
+    await writeRunHistory(storage, [
+      { runId: "run-older", sessionId: "user:primary:older" },
+      ...Array.from({ length: CLIENT_RUN_PAGE_LIMIT + 2 }, (_value, index) => ({
+        runId: `run-newer-${index.toString().padStart(3, "0")}`,
+        sessionId: "user:primary:newer",
+      })),
+    ]);
+    const contribution = createShellBotBackendContribution({
+      state: { storage } as unknown as DurableObjectState,
+      env: {} as never,
+    });
+
+    const page = await contribution.listRuns({
+      schemaVersion: 1,
+      conversationId: "user:primary:older",
+    });
+
+    expect(page.runs.map((run) => run.runId)).toEqual(["run-older"]);
+    expect(page.page.truncated).toBe(false);
+  });
+
+  test("keeps the visible chat reachable behind a page of automation", async () => {
+    const storage = new MemoryStorage();
+    await writeRunHistory(storage, [
+      { runId: "run-chat", sessionId: "user:primary" },
+      ...Array.from({ length: CLIENT_RUN_PAGE_LIMIT + 2 }, (_value, index) => ({
+        runId: `run-automation-${index.toString().padStart(3, "0")}`,
+        sessionId: "user:primary",
+        turnType: "automation" as const,
+      })),
+    ]);
+    const contribution = createShellBotBackendContribution({
+      state: { storage } as unknown as DurableObjectState,
+      env: {} as never,
+    });
+
+    const page = await contribution.listRuns({
+      schemaVersion: 1,
+      conversationId: "user:primary",
+    });
+
+    expect(page.runs.map((run) => run.runId)).toEqual(["run-chat"]);
+  });
+
+  test("offers a continuation when a scanned page selects nothing", async () => {
+    const storage = new MemoryStorage();
+    const buried = CLIENT_RUN_SCAN_LIMIT + CLIENT_RUN_PAGE_LIMIT;
+    await writeRunHistory(storage, [
+      { runId: "run-older", sessionId: "user:primary:older" },
+      ...Array.from({ length: buried }, (_value, index) => ({
+        runId: `run-newer-${index.toString().padStart(4, "0")}`,
+        sessionId: "user:primary:newer",
+      })),
+    ]);
+    const contribution = createShellBotBackendContribution({
+      state: { storage } as unknown as DurableObjectState,
+      env: {} as never,
+    });
+
+    let page = await contribution.listRuns({
+      schemaVersion: 1,
+      conversationId: "user:primary:older",
+    });
+    // The budget stops the scan short of the match, so the page must be empty
+    // *and* say where to resume. Answering `truncated: false` here is the
+    // defect: it told the client the conversation had nothing in it.
+    expect(page.runs).toEqual([]);
+    expect(page.page.truncated).toBe(true);
+    expect(page.page.nextCursor).toBeDefined();
+
+    const seen = new Set<string>();
+    let requests = 0;
+    while (page.runs.length === 0 && page.page.nextCursor) {
+      if (seen.has(page.page.nextCursor)) {
+        throw new Error("run list cursor stopped advancing");
+      }
+      seen.add(page.page.nextCursor);
+      requests += 1;
+      if (requests > 20) throw new Error("run list did not converge");
+      page = await contribution.listRuns({
+        schemaVersion: 1,
+        conversationId: "user:primary:older",
+        before: page.page.nextCursor,
+      });
+    }
+
+    expect(page.runs.map((run) => run.runId)).toEqual(["run-older"]);
+    expect(page.page.truncated).toBe(false);
+  });
+
   test("pages large run history with bounded indexed reads and wire bytes", async () => {
     const storage = new MemoryStorage();
     const baseTime = Date.parse("2026-08-28T00:00:00.000Z");

package/src/backend.ts

@@ -404,6 +404,7 @@ import {
 import {
   CLIENT_RUN_LIST_MAX_BYTES,
   CLIENT_RUN_PAGE_LIMIT,
+  CLIENT_RUN_SCAN_LIMIT,
   clientRunListWireBytes,
   createClientRunListV1,
   createClientRunStopReceiptV1,
@@ -2492,7 +2493,9 @@ export class ShellBotBackendContribution {
               sessions: typeof active.mounted.runtime.root.sessions;
             };
             const computerIdentity = { userId: identity.userId };
-            if (!root.computers?.assignment(computerIdentity)) return;
+            if (!root.computers?.assignment(computerIdentity)) {
+              return { status: "skipped", detail: "" } as const;
+            }
             const session = root.sessions.get(active.sessionId);
             const started = session?.events.findLast(
               (event) => event.type === "step/start",
@@ -2503,7 +2506,7 @@ export class ShellBotBackendContribution {
               { botId: identity.botId },
               { signal: active.signal },
             );
-            await syncWorkspaceRootNowV1({
+            const summary = await syncWorkspaceRootNowV1({
               computer,
               sessions: root.sessions,
               sessionId: active.sessionId,
@@ -2514,6 +2517,7 @@ export class ShellBotBackendContribution {
               ),
               signal: active.signal,
             });
+            return { status: summary.status, detail: summary.detail };
           }
         : undefined,
       composition: {
@@ -5830,7 +5834,7 @@ export class ShellBotBackendContribution {
 
     const selected = new Map<string, { cursor?: string; run: ClientRunV1 }>();
     if (activeRunId) {
-      const active = await this.authority.readStoredRun(activeRunId);
+      const active = await this.authority.readStoredRunForDisplay(activeRunId);
       // An automation firing occupies the object like any other run, and is
       // still not part of the conversation: the visible transcript never
       // shows one, running or settled.
@@ -5839,60 +5843,110 @@ export class ShellBotBackendContribution {
           run: projectClientRunOrDegradedV1(active),
         });
     }
-    const available = candidates.slice(0, CLIENT_RUN_PAGE_LIMIT);
+    // The run index is global and the transcript is one conversation, so a
+    // page of candidates is not a page of answers: 33 Turns of another
+    // conversation, or of automation, used to come back as an empty,
+    // *untruncated* page that told the client there was nothing older. The
+    // scan cursor now advances over every candidate this call consumed,
+    // whether or not it was kept, so a filtered-out page still says where to
+    // resume; and the scan keeps reading batches, up to a budget, so the
+    // common case answers in one request rather than making the client walk
+    // the history a page at a time. Filtering reads run records only —
+    // hydrating a Turn's journal is what selection costs, not what the scan
+    // costs.
     let stoppedEarly = false;
-    for (const candidate of available) {
-      if (selected.has(candidate.runId)) {
-        const current = selected.get(candidate.runId)!;
-        selected.set(candidate.runId, { ...current, cursor: candidate.cursor });
-        continue;
-      }
-      const stored = await this.authority.readStoredRun(candidate.runId);
-      if (!stored || !isVisibleRunV1(stored) || !inConversation(stored))
-        continue;
-      const projected = projectClientRunOrDegradedV1(stored);
-      const tentative = [
-        ...selected.values(),
-        { cursor: candidate.cursor, run: projected },
-      ];
-      const ordered = tentative
-        .map((entry) => entry.run)
-        .sort(
-          (left, right) =>
-            left.admittedAt.localeCompare(right.admittedAt) ||
-            left.runId.localeCompare(right.runId),
+    let exhausted = false;
+    let scanCursor: string | undefined;
+    let scanned = 0;
+    let batch = candidates;
+    for (;;) {
+      const available = batch.slice(0, CLIENT_RUN_PAGE_LIMIT);
+      const hasMore = batch.length > CLIENT_RUN_PAGE_LIMIT;
+      for (const candidate of available) {
+        if (selected.has(candidate.runId)) {
+          const current = selected.get(candidate.runId)!;
+          selected.set(candidate.runId, {
+            ...current,
+            cursor: candidate.cursor,
+          });
+          scanCursor = candidate.cursor;
+          continue;
+        }
+        const header = await this.authority.readRunHeader(candidate.runId);
+        if (!header || !isVisibleRunV1(header) || !inConversation(header)) {
+          scanCursor = candidate.cursor;
+          continue;
+        }
+        const stored = await this.authority.readStoredRunForDisplay(
+          candidate.runId,
         );
-      const tentativePage = createClientRunListV1(ordered, {
-        truncated: true,
-        nextCursor: candidate.cursor,
+        if (!stored) {
+          scanCursor = candidate.cursor;
+          continue;
+        }
+        const projected = projectClientRunOrDegradedV1(stored);
+        const tentative = [
+          ...selected.values(),
+          { cursor: candidate.cursor, run: projected },
+        ];
+        const ordered = tentative
+          .map((entry) => entry.run)
+          .sort(
+            (left, right) =>
+              left.admittedAt.localeCompare(right.admittedAt) ||
+              left.runId.localeCompare(right.runId),
+          );
+        const tentativePage = createClientRunListV1(ordered, {
+          truncated: true,
+          nextCursor: candidate.cursor,
+        });
+        const isNewestTerminal =
+          ![...selected.values()].some(
+            (entry) =>
+              entry.run.status === "completed" || entry.run.status === "failed",
+          ) &&
+          (projected.status === "completed" || projected.status === "failed");
+        if (
+          selected.size >= CLIENT_RUN_PAGE_LIMIT ||
+          (!isNewestTerminal &&
+            clientRunListWireBytes(tentativePage) > CLIENT_RUN_LIST_MAX_BYTES)
+        ) {
+          stoppedEarly = true;
+          break;
+        }
+        selected.set(stored.runId, {
+          cursor: candidate.cursor,
+          run: projected,
+        });
+        scanCursor = candidate.cursor;
+      }
+      scanned += available.length;
+      if (stoppedEarly) break;
+      if (!hasMore) {
+        exhausted = true;
+        break;
+      }
+      if (selected.size >= CLIENT_RUN_PAGE_LIMIT) break;
+      if (scanned >= CLIENT_RUN_SCAN_LIMIT || scanCursor === undefined) break;
+      batch = await this.authority.listRunIndex({
+        limit: CLIENT_RUN_PAGE_LIMIT + 1,
+        before: scanCursor,
       });
-      const isNewestTerminal =
-        ![...selected.values()].some(
-          (entry) =>
-            entry.run.status === "completed" || entry.run.status === "failed",
-        ) &&
-        (projected.status === "completed" || projected.status === "failed");
-      if (
-        selected.size >= CLIENT_RUN_PAGE_LIMIT ||
-        (!isNewestTerminal &&
-          clientRunListWireBytes(tentativePage) > CLIENT_RUN_LIST_MAX_BYTES)
-      ) {
-        stoppedEarly = true;
+      if (batch.length === 0) {
+        exhausted = true;
         break;
       }
-      selected.set(stored.runId, { cursor: candidate.cursor, run: projected });
     }
     const orderedEntries = [...selected.values()].sort(
       (left, right) =>
         left.run.admittedAt.localeCompare(right.run.admittedAt) ||
         left.run.runId.localeCompare(right.run.runId),
     );
-    const oldestCursor = orderedEntries.find((entry) => entry.cursor)?.cursor;
-    const truncated = stoppedEarly || candidates.length > CLIENT_RUN_PAGE_LIMIT;
+    const truncated = !exhausted;
     const page = createClientRunListV1(
       orderedEntries.map((entry) => entry.run),
-      truncated && oldestCursor
-        ? { truncated: true, nextCursor: oldestCursor }
+      truncated && scanCursor
+        ? { truncated: true, nextCursor: scanCursor }
         : { truncated: false },
       // Announcements belong to the Session, not to a page of Turns, so only
       // the newest page carries them.