@frockbot/plugin-shell 0.3.8 → 0.3.10

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,
@@ -409,6 +415,12 @@ import {
   type ClientRunV1,
   type ClientTurnV1,
 } from "./run-protocol.js";
+import { notificationIdV1 } from "./notification-id.js";
+import {
+  type CompositionManifestSourcesV1,
+  compositionMemberManifestDocumentV1,
+  compositionMemberManifestV1,
+} from "./composition-manifest.js";
 import {
   BOT_DEBUG_DEFAULT_RUN_LIMIT_V1,
   BOT_DEBUG_EVENT_BYTES_V1,
@@ -1227,15 +1239,44 @@ export class ShellBotBackendContribution {
     return { schemaVersion: 1, skills: entries };
   }
 
-  /** The one durable manifest lookup used by mounts, commands, and UI views. */
-  private async readCompositionMemberManifest(
+  /**
+   * The one durable manifest lookup used by mounts, commands, and UI views —
+   * as the **stored document**, byte-for-byte what `manifestHash` was taken
+   * over at authoring time.
+   *
+   * Decoding rebuilds the object (`decodeV5` always writes a `configuration`
+   * key, for one), so a decoded manifest does not canonicalize back to the
+   * recorded hash. Every mount re-verifies that hash
+   * (`botIsolatePackageDescriptorV1`), so the raw document is the only thing
+   * that can be handed to it; callers that want the typed shape decode it
+   * themselves through `readCompositionMemberManifest`.
+   */
+  private compositionManifestSources(): CompositionManifestSourcesV1 {
+    return {
+      stored: (manifestHash) =>
+        this.ctx.storage.get<AuthoredManifestRecordV1>(
+          authorshipManifestKey(manifestHash),
+        ),
+      application: (member) => this.readApplicationMemberManifest(member),
+    };
+  }
+
+  private readCompositionMemberManifestDocument(
+    member: CompositionMemberV1,
+  ): Promise<unknown | undefined> {
+    return compositionMemberManifestDocumentV1(
+      member,
+      this.compositionManifestSources(),
+    );
+  }
+
+  private readCompositionMemberManifest(
     member: CompositionMemberV1,
   ): Promise<FrockBotManifest | undefined> {
-    const stored = await this.ctx.storage.get<AuthoredManifestRecordV1>(
-      authorshipManifestKey(member.manifestHash),
+    return compositionMemberManifestV1(
+      member,
+      this.compositionManifestSources(),
     );
-    if (stored) return decodeFrockBotManifest(stored.manifest);
-    return await this.readApplicationMemberManifest(member);
   }
 
   /**
@@ -1264,6 +1305,19 @@ export class ShellBotBackendContribution {
     return declared.manifest;
   }
 
+  /** The stored manifest document a mount hashes, or a modelled failure. */
+  private async requireCompositionMemberManifestDocument(
+    member: CompositionMemberV1,
+  ): Promise<unknown> {
+    const document = await this.readCompositionMemberManifestDocument(member);
+    if (document === undefined) {
+      throw new Error(
+        `package "${member.packageId}" manifest "${member.manifestHash}" is unavailable`,
+      );
+    }
+    return document;
+  }
+
   private async requireCompositionMemberManifest(
     member: CompositionMemberV1,
   ): Promise<FrockBotManifest> {
@@ -1826,7 +1880,11 @@ export class ShellBotBackendContribution {
     fallback: CompositionGenerationV1,
   ): Promise<void> {
     await this.authority.recordNotification({
-      notificationId: `composition-failure:${failure.generationId}:${failure.attempt}`,
+      notificationId: notificationIdV1(
+        "composition-failure",
+        failure.generationId,
+        failure.attempt,
+      ),
       runId,
       createdAt: failure.at,
       title: `${settings.profile.name} kept its last working Packages`,
@@ -1877,7 +1935,8 @@ export class ShellBotBackendContribution {
         artifacts,
         this.bundledPackageArtifacts,
       ),
-      manifestFor: (member) => this.requireCompositionMemberManifest(member),
+      manifestFor: (member) =>
+        this.requireCompositionMemberManifestDocument(member),
       capabilitiesFor: (member) =>
         mintCapabilities({
           props: {
@@ -2686,7 +2745,12 @@ export class ShellBotBackendContribution {
     );
     if (!connection?.generation) {
       await this.authority.recordNotification({
-        notificationId: `package-connection-unavailable:${input.runId}:${input.packageId}:${input.request}`,
+        notificationId: notificationIdV1(
+          "package-connection-unavailable",
+          input.runId,
+          input.packageId,
+          input.request,
+        ),
         runId: input.runId,
         createdAt: new Date().toISOString(),
         title: "Connection unavailable",
@@ -2714,7 +2778,11 @@ export class ShellBotBackendContribution {
     }
     const request = decodeIsolateNotificationRequestV1(input.request);
     await this.authority.recordNotification({
-      notificationId: `package:${input.packageId}:${request.notificationId}`,
+      notificationId: notificationIdV1(
+        "package",
+        input.packageId,
+        request.notificationId,
+      ),
       runId: input.runId,
       createdAt: new Date().toISOString(),
       title: request.title,
@@ -3101,14 +3169,14 @@ export class ShellBotBackendContribution {
     await this.authority.recordNotification({
       // The same id shape the completion path uses, so one firing is one
       // intent however many times the alarm retries it.
-      notificationId: `routine-failed:${fire.fireId}`,
+      notificationId: notificationIdV1("routine-failed", fire.fireId),
       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 +3416,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 +3549,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 {
@@ -3620,7 +3722,7 @@ export class ShellBotBackendContribution {
     }
     if (!settings.notifications.enabled) return;
     await this.authority.recordNotification({
-      notificationId: `task-settled:${task.taskId}`,
+      notificationId: notificationIdV1("task-settled", task.taskId),
       runId: task.taskId,
       createdAt: at,
       title: `${settings.profile.name} finished a subagent task`,
@@ -5260,11 +5362,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,
     );
   }
 
@@ -5405,7 +5526,7 @@ export class ShellBotBackendContribution {
       // `automation_completion_inbox` row".
       if (handoff === undefined) return undefined;
       return {
-        notificationId: `routine-wake:${result.runId}`,
+        notificationId: notificationIdV1("routine-wake", result.runId),
         runId: result.runId,
         createdAt: new Date().toISOString(),
         title: `${settings.profile.name} finished a Routine`,

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 {
@@ -1222,6 +1228,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       packageDisplayName: catalogPackage?.displayName,
       connectionDisplayName: connection?.displayName,
       failure: effective.binding?.failure,
+      fallback: Boolean(effective.fallback),
     });
   }
 

package/src/client/model-presentation.test.ts

@@ -35,6 +35,20 @@ describe("model runtime presentation", () => {
     );
   });
 
+  test("names the stand-in model when the chosen one is unavailable", () => {
+    // The Bot is answering, so the line is not a failure — it names the model
+    // actually in use and says the User's own choice is not it.
+    expect(
+      modelRuntimeLabel({
+        source: "platform",
+        modelDisplayName: "Auto",
+        providerModelId: "@flock/auto",
+        packageDisplayName: "Flock AI",
+        fallback: true,
+      }),
+    ).toBe("Auto · Flock AI · your chosen model is unavailable");
+  });
+
   test("shows unavailable and backend failure states", () => {
     expect(modelRuntimeLabel({ source: "none" })).toBe(
       "No model available — set one up in Models",

package/src/client/model-presentation.ts

@@ -11,6 +11,11 @@ export function modelRuntimeLabel(input: {
   packageDisplayName?: string;
   connectionDisplayName?: string;
   failure?: string;
+  /**
+   * The chosen model could not bind — its provider Package is off, or its
+   * Connection is gone — and the platform default is answering in its place.
+   */
+  fallback?: boolean;
 }): string {
   if (input.failure) return input.failure;
   if (input.source === "none" || !input.providerModelId) {
@@ -22,5 +27,6 @@ export function modelRuntimeLabel(input: {
   const runtime = provider ? `${model} · ${provider}` : model;
   if (input.source === "bot") return `${runtime} · this Bot only`;
   if (input.source === "account") return `${runtime} · Account model`;
+  if (input.fallback) return `${runtime} · your chosen model is unavailable`;
   return runtime;
 }

package/src/composition-manifest.test.ts

@@ -0,0 +1,126 @@
+// Every Bot-authored Package failed to mount with `package "aud-usd" stored
+// manifest failed hash verification`, deterministically, on byte-identical
+// source. The mount hashed a *decoded* manifest against a hash taken over the
+// *raw* one, so journey 4 step 2 — "use the tool you just built" — was
+// impossible for anybody. First-party members mounted fine, because their
+// reader already returned the raw document.
+import { describe, expect, test } from "bun:test";
+import { authoredManifestV1 } from "@frockbot/plugin-authoring/shared";
+import { decodeFrockBotManifest } from "@frockbot/kernel-composition";
+import type { CompositionMemberV1 } from "@frockbot/kernel-composition/generation";
+import { botIsolatePackageDescriptorV1 } from "@frockbot/kernel-composition/isolate";
+import { canonicalJson, sha256 } from "@frockbot/kernel-composition/compiler";
+
+import {
+  type CompositionManifestSourcesV1,
+  compositionMemberManifestDocumentV1,
+  compositionMemberManifestV1,
+} from "./composition-manifest.js";
+
+/** What `package_author` writes, exactly as `backend-authoring.ts` builds it. */
+function authoredManifest(): unknown {
+  return authoredManifestV1({
+    packageId: "aud-usd",
+    displayName: "AUD/USD",
+    version: "0.0.1",
+    tools: [
+      {
+        name: "aud_usd_rate",
+        description: "The current AUD/USD rate.",
+        inputSchema: { type: "object", properties: {} },
+      },
+    ],
+  });
+}
+
+/** The durable store, as `authorship:manifest:<hash>` holds it. */
+async function storedMember(): Promise<{
+  member: CompositionMemberV1;
+  manifest: unknown;
+  sources: CompositionManifestSourcesV1;
+}> {
+  const manifest = authoredManifest();
+  // The one hash that matters: taken over the raw document at authoring time.
+  const manifestHash = await sha256(canonicalJson(manifest));
+  const member: CompositionMemberV1 = {
+    packageId: "aud-usd",
+    specifier: "bot:aud-usd",
+    version: "0.0.1",
+    manifestHash,
+    provenance: {
+      kind: "bot",
+      packageId: "aud-usd",
+      version: "0.0.1",
+      botId: "toolsmith",
+      sessionId: "user-1:toolsmith",
+      turnId: "turn-1",
+      runId: "run-1",
+      authoredAt: "2026-09-03T23:49:00.416Z",
+    },
+    artifact: {
+      contentHash: "b".repeat(64),
+      size: 128,
+      mediaType: "application/javascript",
+      bundlerVersion: "worker-bundler@0.2.3",
+    },
+  };
+  const sources: CompositionManifestSourcesV1 = {
+    stored: (hash) =>
+      Promise.resolve(hash === manifestHash ? { manifest } : undefined),
+    application: () => Promise.resolve(undefined),
+  };
+  return { member, manifest, sources };
+}
+
+describe("the manifest a mount is handed", () => {
+  test("hashes to what the Composition member recorded", async () => {
+    const { member, sources } = await storedMember();
+
+    const document = await compositionMemberManifestDocumentV1(member, sources);
+    const descriptor = await botIsolatePackageDescriptorV1(member, document);
+
+    expect(descriptor.manifest.id).toBe("aud-usd");
+    expect(descriptor.manifest.version).toBe("0.0.1");
+  });
+
+  test("is the stored document, not a rebuild of it", async () => {
+    const { member, manifest, sources } = await storedMember();
+
+    const document = await compositionMemberManifestDocumentV1(member, sources);
+
+    expect(document).toBe(manifest);
+  });
+
+  test("decoding first is what broke it, and still would", async () => {
+    // The guard this test exists for. `decodeFrockBotManifest` rebuilds the
+    // object — `decodeV5` always writes a `configuration` key — so the decoded
+    // manifest does not canonicalize back to the recorded hash. If the reader
+    // ever decodes again, the test above fails and this one says why.
+    const { member, manifest } = await storedMember();
+    const decoded = decodeFrockBotManifest(manifest);
+
+    expect(canonicalJson(decoded)).not.toBe(canonicalJson(manifest));
+    await expect(
+      botIsolatePackageDescriptorV1(member, decoded),
+    ).rejects.toThrow("stored manifest failed hash verification");
+  });
+
+  test("the typed reader still answers the shape its callers want", async () => {
+    const { member, sources } = await storedMember();
+
+    const typed = await compositionMemberManifestV1(member, sources);
+
+    expect(typed?.id).toBe("aud-usd");
+    expect(typed?.version).toBe("0.0.1");
+  });
+
+  test("a member with no stored manifest falls back to the application's", async () => {
+    const { member, manifest } = await storedMember();
+    const document = await compositionMemberManifestDocumentV1(member, {
+      stored: () => Promise.resolve(undefined),
+      application: () => Promise.resolve(manifest),
+    });
+
+    expect(document).toBe(manifest);
+  });
+});

package/src/composition-manifest.ts

@@ -0,0 +1,55 @@
+import {
+  type FrockBotManifest,
+  decodeFrockBotManifest,
+} from "@frockbot/kernel-composition";
+import type { CompositionMemberV1 } from "@frockbot/kernel-composition/generation";
+
+/**
+ * Where a Composition member's manifest can be found. `stored` is
+ * `authorship:manifest:<hash>` — written by the authoring path and by a
+ * Catalog install, so it covers every member a Bot or its User put into the
+ * Composition. `application` is the compiled-in manifest of a first-party
+ * artifact-backed member (ADR 0022 decision 8), which came from neither and is
+ * already in this bundle. Two *places*, never two answers: the `manifestHash`
+ * decides in both.
+ */
+export interface CompositionManifestSourcesV1 {
+  stored(manifestHash: string): Promise<{ manifest: unknown } | undefined>;
+  application(member: CompositionMemberV1): Promise<unknown | undefined>;
+}
+
+/**
+ * A member's manifest **as the stored document** — byte-for-byte what its
+ * `manifestHash` was taken over.
+ *
+ * This is the seam that broke every Bot-authored Package. Authoring hashes
+ * `canonicalJson(rawManifest)` and stores `rawManifest` verbatim; the mount
+ * re-hashes whatever it is handed and refuses a mismatch
+ * (`botIsolatePackageDescriptorV1`). Returning a *decoded* manifest here put a
+ * rebuilt object on the mount's side of that comparison — `decodeV5` always
+ * writes a `configuration` key, among other things — so the two hashes could
+ * never agree, and every authored Package failed with `stored manifest failed
+ * hash verification` while first-party members (which were already read raw)
+ * mounted fine.
+ *
+ * Callers that want the typed shape decode it themselves, downstream of the
+ * hash check.
+ */
+export async function compositionMemberManifestDocumentV1(
+  member: CompositionMemberV1,
+  sources: CompositionManifestSourcesV1,
+): Promise<unknown | undefined> {
+  const stored = await sources.stored(member.manifestHash);
+  if (stored) return stored.manifest;
+  return await sources.application(member);
+}
+
+/** The same manifest as the typed shape, for readers that are not mounts. */
+export async function compositionMemberManifestV1(
+  member: CompositionMemberV1,
+  sources: CompositionManifestSourcesV1,
+): Promise<FrockBotManifest | undefined> {
+  const document = await compositionMemberManifestDocumentV1(member, sources);
+  if (document === undefined) return undefined;
+  return decodeFrockBotManifest(document);
+}

package/src/notification-id.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+
+import { notificationIdV1 } from "./notification-id.js";
+import { decodeClientNotificationAcknowledgementCommandV1 } from "./run-protocol.js";
+
+/** What the acknowledge endpoint does with an id a notification carried. */
+function acknowledge(notificationId: string): string {
+  return decodeClientNotificationAcknowledgementCommandV1({
+    schemaVersion: 1,
+    action: "acknowledge",
+    notificationId,
+  }).notificationId;
+}
+
+describe("notificationIdV1", () => {
+  test("a Composition failure id round-trips through acknowledgement", () => {
+    // The shape that 400'd forever: a generation id is `<ISO instant>:<hash>`,
+    // and the acknowledge decoder admits no colons.
+    const id = notificationIdV1(
+      "composition-failure",
+      "2026-09-03T23:49:00.416Z:dc03a32d9b717619",
+      1,
+    );
+    expect(id).not.toContain(":");
+    expect(acknowledge(id)).toBe(id);
+  });
+
+  test("every minted id shape acknowledges", () => {
+    const minted = [
+      notificationIdV1(
+        "package-connection-unavailable",
+        crypto.randomUUID(),
+        "aud-usd",
+        "gmail",
+      ),
+      notificationIdV1("package", "aud-usd", "rate:moved"),
+      notificationIdV1("routine-failed", "2026-09-03T23:49:00.416Z:fire"),
+      notificationIdV1("task-settled", crypto.randomUUID()),
+      notificationIdV1("routine-wake", crypto.randomUUID()),
+    ];
+    for (const id of minted) expect(acknowledge(id)).toBe(id);
+  });
+
+  test("the same parts mint the same id, so a retry is one intent", () => {
+    const parts = [
+      "composition-failure",
+      "2026-09-03T23:49:00.416Z:abc",
+      2,
+    ] as const;
+    expect(notificationIdV1(...parts)).toBe(notificationIdV1(...parts));
+  });
+
+  test("distinct parts stay distinct, even past the length ceiling", () => {
+    const long = "x".repeat(400);
+    const a = notificationIdV1("package", long, "one");
+    const b = notificationIdV1("package", long, "two");
+    expect(a).not.toBe(b);
+    expect(a.length).toBeLessThanOrEqual(128);
+    expect(acknowledge(a)).toBe(a);
+    expect(acknowledge(b)).toBe(b);
+  });
+
+  test("parts that sanitize to nothing still mint an acknowledgeable id", () => {
+    const id = notificationIdV1(":::", "::");
+    expect(acknowledge(id)).toBe(id);
+  });
+});