@frockbot/plugin-shell 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "private": false,
   "type": "module",
   "exports": {
@@ -30,6 +30,7 @@
     "./frockbot.json": "./frockbot.json",
     "./host": "./src/host.ts",
     "./manifest": "./src/manifest.ts",
+    "./notification-id": "./src/notification-id.ts",
     "./package.json": "./package.json",
     "./run-cursor": "./src/run-cursor.ts",
     "./run-protocol": "./src/run-protocol.ts",
@@ -47,41 +48,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.10",
+    "@frockbot/application-foundation": "0.3.10",
+    "@frockbot/catalog-core": "0.3.10",
+    "@frockbot/client-core": "0.3.10",
+    "@frockbot/client-ui": "0.3.10",
+    "@frockbot/computer-core": "0.3.10",
+    "@frockbot/computer-host-protocol": "0.3.10",
+    "@frockbot/configuration-core": "0.3.10",
+    "@frockbot/connection-core": "0.3.10",
+    "@frockbot/kernel-agent-loop": "0.3.10",
+    "@frockbot/kernel-composition": "0.3.10",
+    "@frockbot/kernel-contracts": "0.3.10",
+    "@frockbot/kernel-do": "0.3.10",
+    "@frockbot/machine-protocol": "0.3.10",
+    "@frockbot/plugin-applets": "0.3.10",
+    "@frockbot/plugin-authoring": "0.3.10",
+    "@frockbot/plugin-bot-template": "0.3.10",
+    "@frockbot/plugin-computer": "0.3.10",
+    "@frockbot/plugin-flock": "0.3.10",
+    "@frockbot/plugin-image": "0.3.10",
+    "@frockbot/plugin-machine-messages": "0.3.10",
+    "@frockbot/plugin-mcp": "0.3.10",
+    "@frockbot/plugin-memory": "0.3.10",
+    "@frockbot/plugin-package-catalog": "0.3.10",
+    "@frockbot/plugin-routines": "0.3.10",
+    "@frockbot/plugin-skills": "0.3.10",
+    "@frockbot/plugin-subagents": "0.3.10",
+    "@frockbot/plugin-user-machine": "0.3.10",
+    "@frockbot/protocol": "0.3.10",
     "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.10",
     "@types/bun": "1.3.6",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",

package/src/backend-configuration.test.ts

@@ -600,8 +600,10 @@ describe("generic per-Turn model resolution", () => {
     });
     await expect(contribution.listNotifications()).resolves.toEqual([
       expect.objectContaining({
+        // Colons would fail the acknowledge decoder, so the mint replaces
+        // them; a notification nobody can acknowledge 400s forever.
         notificationId:
-          "package-connection-unavailable:run-1:bot-authored:flock-ai-ambient",
+          "package-connection-unavailable-run-1-bot-authored-flock-ai-ambient",
         title: "Connection unavailable",
       }),
     ]);

package/src/backend-package-catalog.ts

@@ -320,7 +320,7 @@ export function createPackageCatalogHost(
           change.action === "remove"
             ? change.input.packageId
             : change.input.catalogId,
-        ...(change.action === "remove"
+        ...(change.action === "remove" || change.input.contentHash === undefined
           ? {}
           : { contentHash: change.input.contentHash }),
       }),
@@ -520,9 +520,12 @@ export function createPackageCatalogHost(
           index,
           catalogId: provenance.catalogId,
         });
+        // A first-party member pins no bundle, so "the entry still offers
+        // what the target generation recorded" is the two hashes agreeing,
+        // both present or both absent.
         if (
-          !targetEntry?.bundle ||
-          targetEntry.bundle.contentHash !== provenance.contentHash
+          !targetEntry ||
+          targetEntry.bundle?.contentHash !== provenance.contentHash
         ) {
           return undoRefused(
             request,
@@ -538,7 +541,9 @@ export function createPackageCatalogHost(
           version: targetCatalogMember.version,
           catalogId: provenance.catalogId,
           catalogGeneration: provenance.catalogGeneration,
-          contentHash: provenance.contentHash,
+          ...(provenance.contentHash === undefined
+            ? {}
+            : { contentHash: provenance.contentHash }),
         };
       }
       const receipt = await options.user.execute(command);
@@ -673,17 +678,22 @@ export function createPackageCatalogHost(
           const resolved = await pinnedEntry(request.change.input.catalogId);
           user = resolved.user;
           entry = resolved.entry;
-          if (!entry.bundle) {
-            throw new Error(
-              `Catalog entry "${entry.catalogId}" does not carry installable code`,
-            );
-          }
-          if (entry.bundle.contentHash !== request.change.input.contentHash) {
+          // A first-party entry names reviewed compiled-in code and publishes
+          // no bundle: there is no artifact to verify and no hash to pin. The
+          // Plugins page has always installed such an entry; refusing it here
+          // is what made `package_install` by chat disagree with the UI (F4).
+          if (entry.bundle) {
+            if (entry.bundle.contentHash !== request.change.input.contentHash) {
+              throw new Error(
+                `Catalog entry "${entry.catalogId}" has content hash "${entry.bundle.contentHash}", not "${request.change.input.contentHash}"`,
+              );
+            }
+            await verifyArtifact(entry);
+          } else if (request.change.input.contentHash !== undefined) {
             throw new Error(
-              `Catalog entry "${entry.catalogId}" has content hash "${entry.bundle.contentHash}", not "${request.change.input.contentHash}"`,
+              `Catalog entry "${entry.catalogId}" does not carry a Package bundle`,
             );
           }
-          await verifyArtifact(entry);
           const member = base.members.find(
             (candidate) => candidate.packageId === entry.packageId,
           );
@@ -716,7 +726,7 @@ export function createPackageCatalogHost(
             version: entry.version,
             catalogId: entry.catalogId,
             catalogGeneration: resolved.generation,
-            contentHash: entry.bundle.contentHash,
+            ...(entry.bundle ? { contentHash: entry.bundle.contentHash } : {}),
             manifestHash: entry.manifestHash,
             summary:
               request.change.input.summary ??
@@ -744,16 +754,24 @@ export function createPackageCatalogHost(
       // Intent and manifest before the User settings effect. The manifest key
       // is the existing isolate loader seam used by authored Packages.
       if (!existingIntent) {
+        const bundle = entry.bundle;
         await options.storage.put({
           [packageCatalogChangeIntentKey(request.effectId)]: intent,
-          [authorshipManifestKey(intent.manifestHash)]: {
-            schemaVersion: 1,
-            manifestHash: intent.manifestHash,
-            packageId: intent.packageId,
-            version: intent.version,
-            manifest: entry.bundle!.manifest,
-            createdAt: intent.recordedAt,
-          } satisfies AuthoredManifestRecordV1,
+          // A bundle-less entry has no manifest document to store; the mount
+          // resolves it from the compiled-in application instead, still
+          // against the `manifestHash` the generation records.
+          ...(bundle
+            ? {
+                [authorshipManifestKey(intent.manifestHash)]: {
+                  schemaVersion: 1,
+                  manifestHash: intent.manifestHash,
+                  packageId: intent.packageId,
+                  version: intent.version,
+                  manifest: bundle.manifest,
+                  createdAt: intent.recordedAt,
+                } satisfies AuthoredManifestRecordV1,
+              }
+            : {}),
         });
         existingIntent = intent;
       }
@@ -776,7 +794,9 @@ export function createPackageCatalogHost(
               version: intent.version,
               catalogId: intent.catalogId,
               catalogGeneration: intent.catalogGeneration,
-              contentHash: intent.contentHash,
+              ...(intent.contentHash === undefined
+                ? {}
+                : { contentHash: intent.contentHash }),
             };
       const receipt = await options.user.execute(command);
       if (receipt.status === "rejected") {
@@ -789,7 +809,7 @@ export function createPackageCatalogHost(
         (member) => member.packageId !== intent.packageId,
       );
       if (action !== "remove") {
-        const bundle = entry.bundle!;
+        const bundle = entry.bundle;
         const member: CompositionMemberV1 = {
           packageId: entry.packageId,
           specifier: `catalog:${entry.catalogId}`,
@@ -801,14 +821,20 @@ export function createPackageCatalogHost(
             version: entry.version,
             catalogId: entry.catalogId,
             catalogGeneration: intent.catalogGeneration,
-            contentHash: bundle.contentHash,
-          },
-          artifact: {
-            contentHash: bundle.contentHash,
-            size: bundle.size,
-            mediaType: bundle.mediaType,
-            bundlerVersion: bundle.bundlerVersion,
+            ...(bundle ? { contentHash: bundle.contentHash } : {}),
           },
+          // No artifact ⇒ the member mounts in the kernel isolate from the
+          // compiled-in Package, exactly as the UI install records it.
+          ...(bundle
+            ? {
+                artifact: {
+                  contentHash: bundle.contentHash,
+                  size: bundle.size,
+                  mediaType: bundle.mediaType,
+                  bundlerVersion: bundle.bundlerVersion,
+                },
+              }
+            : {}),
         };
         members.push(member);
       }
@@ -850,7 +876,9 @@ export function createPackageCatalogHost(
         packageId: intent.packageId,
         displayName: intent.displayName,
         ...(action === "remove" ? {} : { version: intent.version }),
-        ...(action === "remove" ? {} : { contentHash: intent.contentHash }),
+        ...(action === "remove" || intent.contentHash === undefined
+          ? {}
+          : { contentHash: intent.contentHash }),
         generationId: generation.generationId,
         missingConnectionTypes: intent.missingConnectionTypes,
         recordedAt: intent.recordedAt,

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();
+  });
+});