@frockbot/plugin-shell 0.3.4 → 0.3.6

package/src/backend.ts

@@ -328,7 +328,11 @@ import {
   type PendingBotInputV1,
   type RoutineInboxEntryV1,
 } from "@frockbot/plugin-routines/inbox";
-import type { RoutineScheduler } from "@frockbot/plugin-routines/scheduler";
+import type {
+  RoutineFireOutcomeV1,
+  RoutineScheduler,
+} from "@frockbot/plugin-routines/scheduler";
+import type { RoutineFireV1 } from "@frockbot/plugin-routines/firing";
 import {
   RoutineNotFoundError,
   type RoutineStore,
@@ -395,6 +399,7 @@ import {
   isVisibleRunV1,
   projectClientRunLookupV1,
   projectClientRunV1,
+  projectClientRunOrDegradedV1,
   projectClientAnnouncementsV1,
   projectClientTurnV1,
   type ClientRunLookupV1,
@@ -441,6 +446,25 @@ import {
 } from "./unread.js";
 import { defineBotBackendContribution } from "@frockbot/kernel-contracts/contributions";
 
+/**
+ * The providers that can be asked what happened to a model request they never
+ * answered — that is, the ones whose Package registers an
+ * `LlmReconciliationCapability` (ADR 0028).
+ *
+ * It is a list rather than a lookup because recovery consults it inside the
+ * durable transaction that settles the run, where nothing may be mounted or
+ * awaited. The cost is that a provider Package which gains retrieval has to
+ * name itself here; the ADR carries that obligation, and the failure mode of
+ * forgetting is a Turn settled as failed rather than one wedged forever, which
+ * is the direction this deployment wants to be wrong in.
+ *
+ * Today: the in-process foundation provider, and nothing else. Ollama Cloud
+ * exposes no provider-bound retrieval (ADR 0010) and neither does Flock AI.
+ */
+const RECONCILING_PROVIDER_IDS_V1: ReadonlySet<string> = new Set([
+  "foundation",
+]);
+
 export const BOT_CONFIGURATION_KEY = "bot-configuration";
 const CONFIGURATION_RECEIPT_PREFIX = "configuration-receipt:";
 const STOP_RECEIPT_PREFIX = "stop-receipt:";
@@ -779,6 +803,8 @@ export class ShellBotBackendContribution {
         deferScheduledWork: (transaction) =>
           this.deferScheduledWork(transaction),
         settleScheduledWork: () => this.settleScheduledWork(),
+        providerReconciles: (providerId) =>
+          RECONCILING_PROVIDER_IDS_V1.has(providerId),
       },
     });
   }
@@ -2975,17 +3001,24 @@ export class ShellBotBackendContribution {
   }
 
   private async settleScheduledWork(): Promise<void> {
-    await this.settleRoutineFirings();
-    await this.runOwedSubagentTurns();
-    await this.reconcileOverdueTasks();
-    await this.expireDueApprovals();
-    await this.replayPendingWakeNotifications();
-    await this.hostSettleScheduledWork?.();
-    // The alarm that woke this object has been consumed. Re-arm on whatever is
-    // owed next, or a Routine that fired once would never fire again.
-    await this.ctx.storage.transaction((transaction) =>
-      this.authority.refreshRecoveryAlarm(transaction),
-    );
+    // The re-arm is in a `finally` because it is the object's only way back.
+    // The alarm that woke this object has already been consumed by the
+    // platform; a throw in any one settler used to skip the re-arm, and then
+    // nothing — no Routine, no approval expiry, no owed subagent Turn — ever
+    // woke this Bot again except by a caller's luck. One producer failing must
+    // cost that producer its pass, never the clock.
+    try {
+      await this.settleRoutineFirings();
+      await this.runOwedSubagentTurns();
+      await this.reconcileOverdueTasks();
+      await this.expireDueApprovals();
+      await this.replayPendingWakeNotifications();
+      await this.hostSettleScheduledWork?.();
+    } finally {
+      await this.ctx.storage.transaction((transaction) =>
+        this.authority.refreshRecoveryAlarm(transaction),
+      );
+    }
   }
 
   /**
@@ -3005,21 +3038,73 @@ export class ShellBotBackendContribution {
     // here whenever the Turn is executing in this isolate, but a durable active
     // run outlives an eviction, and admitting a firing against one would burn
     // the occurrence on an error instead of holding the debt.
-    if (await this.authority.readActiveRunId()) return;
+    //
+    // Returning was not enough: the debt stayed past-due, so `deadlines()`
+    // re-armed on a moment already gone and the alarm spun straight back into
+    // this same bail-out — which is how a Routine racing a long chat Turn
+    // failed once a minute for ever. The hold is what turns the bail-out into
+    // a deferral: `dueAt` does not move, so the firing still lands.
+    if (await this.authority.readActiveRunId()) {
+      await this.ctx.storage.transaction((transaction) =>
+        this.routineScheduler.defer(transaction),
+      );
+      return;
+    }
     await this.routineScheduler.settle(async (fire) => {
-      try {
-        await this.authority.run(
-          routineTurnCommandV1(identity, fire, new Date().toISOString()),
-        );
-      } catch (error) {
-        return routineFireOutcomeV1(
-          await this.authority.readStoredRun(fire.fireId),
-          error,
-        );
-      }
+      const outcome = await this.runOneFiring(identity, fire);
+      await this.notifyFailedFiring(identity, fire, outcome);
+      return outcome;
+    });
+  }
+
+  private async runOneFiring(
+    identity: BotIdentity,
+    fire: RoutineFireV1,
+  ): Promise<RoutineFireOutcomeV1> {
+    try {
+      await this.authority.run(
+        routineTurnCommandV1(identity, fire, new Date().toISOString()),
+      );
+    } catch (error) {
       return routineFireOutcomeV1(
         await this.authority.readStoredRun(fire.fireId),
+        error,
       );
+    }
+    return routineFireOutcomeV1(
+      await this.authority.readStoredRun(fire.fireId),
+    );
+  }
+
+  /**
+   * Tell the person that a firing did not work.
+   *
+   * The scheduler has already written the durable completion-inbox entry in
+   * the transaction that settled the firing; this is the delivery half — the
+   * same seam a hand-off uses, so a Routine that breaks reaches the same place
+   * a Routine that finishes does instead of only a `failed` row nobody opens.
+   * `notifications.enabled` is honoured: it is the mute on updates, and a
+   * broken Routine is an update, not a decision the Bot is waiting on.
+   */
+  private async notifyFailedFiring(
+    identity: BotIdentity,
+    fire: RoutineFireV1,
+    outcome: RoutineFireOutcomeV1,
+  ): Promise<void> {
+    if (outcome.status === "ok") return;
+    const settings = await this.getSettings(identity);
+    if (!settings.notifications.enabled) return;
+    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}`,
+      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,
+      ),
     });
   }
   // -------------------------------------------------------------------------
@@ -4508,13 +4593,13 @@ export class ShellBotBackendContribution {
     if (!effectiveModel) {
       throw new Error(
         effective.binding?.failure ??
-          "No model is configured; enable a model Package or restore the platform model",
+          "No model is set up yet. Choose one in Models.",
       );
     }
     const binding: ResolvedModelBindingV1 = effective.binding ?? {
       model: structuredClone(effectiveModel),
       state: "unavailable",
-      failure: "The resolved model Connection is unavailable",
+      failure: "This Bot's model isn't available. Pick one in Models.",
     };
     if (
       binding.state === "unavailable" ||
@@ -4523,7 +4608,8 @@ export class ShellBotBackendContribution {
       !binding.packageId
     ) {
       throw new Error(
-        binding.failure ?? "The resolved model Connection is unavailable",
+        binding.failure ??
+          "This Bot's model isn't available. Pick one in Models.",
       );
     }
     if (
@@ -4536,7 +4622,9 @@ export class ShellBotBackendContribution {
         admittedRequest.modelBinding.connectionGeneration !==
           binding.connection.generation)
     ) {
-      throw new Error("Admitted model binding is unavailable");
+      throw new Error(
+        "This Bot's model changed mid-reply. Send your message again.",
+      );
     }
     const bindingPackageId = binding.packageId;
     agentPackages.push(
@@ -5370,7 +5458,9 @@ export class ShellBotBackendContribution {
       // still not part of the conversation: the visible transcript never
       // shows one, running or settled.
       if (active && isVisibleRunV1(active))
-        selected.set(active.runId, { run: projectClientRunV1(active) });
+        selected.set(active.runId, {
+          run: projectClientRunOrDegradedV1(active),
+        });
     }
     const available = candidates.slice(0, CLIENT_RUN_PAGE_LIMIT);
     let stoppedEarly = false;
@@ -5382,7 +5472,7 @@ export class ShellBotBackendContribution {
       }
       const stored = await this.authority.readStoredRun(candidate.runId);
       if (!stored || !isVisibleRunV1(stored)) continue;
-      const projected = projectClientRunV1(stored);
+      const projected = projectClientRunOrDegradedV1(stored);
       const tentative = [
         ...selected.values(),
         { cursor: candidate.cursor, run: projected },

package/src/client/AppletCanvas.vue

@@ -147,7 +147,7 @@ function generationLabel(generationId: string): string {
     hour: "numeric",
     minute: "2-digit",
   });
-  return `Live since ${when} · ${hash.slice(0, 7)}`;
+  return `Live since ${when}`;
 }
 
 function selectTab(next: "app" | "code"): void {
@@ -199,10 +199,8 @@ async function clearFocus(): Promise<void> {
       /></span>
       <div class="applet-canvas-title">
         <strong>{{ applet?.displayName ?? "Applet" }}</strong>
-        <small v-if="viewer" :title="viewer.generationId">{{
-          generationLabel(viewer.generationId)
-        }}</small>
-        <small v-else>No published version yet</small>
+        <small v-if="viewer">{{ generationLabel(viewer.generationId) }}</small>
+        <small v-else>Not published yet</small>
       </div>
       <div
         v-if="canShowApp"

package/src/client/FrockBotApp.vue

@@ -288,7 +288,7 @@ const threadHeading = computed(() => {
 const threadHint = computed(() => {
   if (!hasBot.value) return "Add your first sheep to start a conversation.";
   if (state.value.modelReady) {
-    return "Start with a conversation. Cordis plugins can add the rest.";
+    return "Say anything to get started.";
   }
   return state.value.modelLabel;
 });
@@ -405,6 +405,69 @@ function taskChipsOf(message: WebChatMessage): Array<{
   });
 }
 
+/**
+ * The tools this Turn ran, as the thread draws them.
+ *
+ * A tool whose Package draws its own surface is shown by that surface; every
+ * other one is a chip, because a Turn that spends a minute making tool calls
+ * used to show the User nothing at all but a spinning avatar.
+ */
+function toolChipsOf(message: WebChatMessage): WebToolActivity[] {
+  return message.tools.filter((tool) => iframeEntriesFor(tool).length === 0);
+}
+
+/**
+ * What a chip calls a tool, in the User's words rather than the model's.
+ *
+ * A tool name is an identifier — `send_to_user`, `user-Github--acme/search_issues`
+ * — and the transcript is a conversation, so the chip drops the namespace,
+ * un-snakes the rest and capitalises it.
+ */
+function toolChipLabel(tool: WebToolActivity): string {
+  const bare = tool.name.split("/").pop() ?? tool.name;
+  const words = bare.replace(/[_.-]+/g, " ").trim();
+  if (words.length === 0) return tool.name;
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+/**
+ * Whether a chip is drawn as a failure.
+ *
+ * A tool call the model recovered from is not a failure the User has anything
+ * to do with: a refused call followed by a Turn that went on to finish is the
+ * Bot correcting itself, and colouring it red reports a broken Turn that
+ * worked. Only a Turn that itself ended badly keeps the failed state.
+ */
+function toolChipState(
+  tool: WebToolActivity,
+  message: WebChatMessage,
+): "running" | "completed" | "failed" | "retried" {
+  if (tool.status !== "failed") return tool.status;
+  return message.status === "completed" || message.status === "streaming"
+    ? "retried"
+    : "failed";
+}
+
+/** What a chip says a tool is doing. Its status, in the User's words. */
+function toolChipStatus(
+  tool: WebToolActivity,
+  message: WebChatMessage,
+): string {
+  const state = toolChipState(tool, message);
+  if (state === "running") return "running";
+  if (state === "retried") return "retried";
+  return state === "failed" ? "failed" : "done";
+}
+
+/** Which tool chips the User has opened. Local, and per chip. */
+const expandedTools = ref(new Set<string>());
+
+function toggleTool(toolId: string): void {
+  const next = new Set(expandedTools.value);
+  if (!next.delete(toolId)) next.add(toolId);
+  expandedTools.value = next;
+}
+
 /** Which chips the User has opened. Local, and per chip. */
 const expandedTasks = ref(new Set<string>());
 
@@ -431,6 +494,7 @@ function isVisible(message: WebChatMessage): boolean {
   // visible act was dispatching a subagent.
   return (
     message.text.length > 0 ||
+    (message.notice?.length ?? 0) > 0 ||
     message.tools.some((tool) => iframeEntriesFor(tool).length > 0) ||
     message.sends.length > 0 ||
     (message.tasks?.length ?? 0) > 0 ||
@@ -856,105 +920,159 @@ function handleComposerKeydown(event: KeyboardEvent): void {
                 /></span>
                 <k-slot name="frockbot.bot-avatar" />
               </div>
-              <div v-if="message.text" class="message-bubble">
-                <UiMarkdown :text="message.text" />
-              </div>
-              <template v-for="tool in message.tools" :key="tool.id">
-                <PackageIframeHost
-                  v-for="entry in iframeEntriesFor(tool)"
-                  :key="`${tool.id}:${entry.contribution.packageId}:${entry.page.id}`"
-                  class="message-package-iframe"
-                  :contribution="entry.contribution"
-                  :page="entry.page"
-                  :slot="entry.slot"
-                  :states="{ [`tool:${tool.name}`]: toolResultState(tool) }"
-                />
-              </template>
               <!--
+                Everything the Turn produced stacks in one column beside the
+                avatar. The row holds exactly two children — avatar, column —
+                so a bubble, a notice and a chip are stacked lines rather than
+                side-by-side columns squeezing the reply to a few pixels.
+              -->
+              <div class="message-column">
+                <div v-if="message.text" class="message-bubble">
+                  <UiMarkdown :text="message.text" />
+                </div>
+                <!--
+                Why the Turn ends where it does, under whatever it had already
+                said rather than in place of it.
+              -->
+                <p v-if="message.notice" class="message-notice">
+                  {{ message.notice }}
+                </p>
+                <template v-for="tool in message.tools" :key="tool.id">
+                  <PackageIframeHost
+                    v-for="entry in iframeEntriesFor(tool)"
+                    :key="`${tool.id}:${entry.contribution.packageId}:${entry.page.id}`"
+                    class="message-package-iframe"
+                    :contribution="entry.contribution"
+                    :page="entry.page"
+                    :slot="entry.slot"
+                    :states="{ [`tool:${tool.name}`]: toolResultState(tool) }"
+                  />
+                </template>
+                <!--
                 A binary a tool filed in the Workspace, drawn from the
                 Workspace read route. The thread carries the path, never the
                 bytes, so a long conversation costs paths and the image is
                 fetched only when it is on screen.
               -->
-              <div
-                v-if="attachmentsOf(message).length > 0"
-                class="message-attachments"
-              >
-                <a
-                  v-for="attachment in attachmentsOf(message)"
-                  :key="attachment.contentHash"
-                  :href="workspaceFileUrl(attachment.path)"
-                  target="_blank"
-                  rel="noreferrer"
+                <div
+                  v-if="attachmentsOf(message).length > 0"
+                  class="message-attachments"
                 >
-                  <img
-                    :src="workspaceFileUrl(attachment.path)"
-                    :alt="`Attachment from ${message.runId}`"
-                    loading="lazy"
-                  />
-                </a>
-              </div>
-              <!--
+                  <a
+                    v-for="attachment in attachmentsOf(message)"
+                    :key="attachment.contentHash"
+                    :href="workspaceFileUrl(attachment.path)"
+                    target="_blank"
+                    rel="noreferrer"
+                  >
+                    <img
+                      :src="workspaceFileUrl(attachment.path)"
+                      :alt="`Attachment from ${message.runId}`"
+                      loading="lazy"
+                    />
+                  </a>
+                </div>
+                <!--
                 Sends sit beside the derived text rather than inside it: each
                 payload is its own block, and a widget-ended Turn has no text
                 bubble at all.
               -->
-              <div v-if="message.sends.length > 0" class="message-sends">
-                <SendPayloadView
-                  v-for="(send, sendIndex) in message.sends"
-                  :key="sendIndex"
-                  :send="send"
-                />
-              </div>
-              <!--
+                <div v-if="message.sends.length > 0" class="message-sends">
+                  <SendPayloadView
+                    v-for="(send, sendIndex) in message.sends"
+                    :key="sendIndex"
+                    :send="send"
+                  />
+                </div>
+                <!--
+                What the Bot did, while it is doing it. The chip is the
+                conversation's whole account of an ordinary tool call: its
+                name, whether it is running, and — when the User opens it —
+                what it returned.
+              -->
+                <div
+                  v-if="toolChipsOf(message).length > 0"
+                  class="message-tools"
+                >
+                  <button
+                    v-for="tool in toolChipsOf(message)"
+                    :key="tool.id"
+                    type="button"
+                    class="tool-chip"
+                    :class="`tool-chip-${toolChipState(tool, message)}`"
+                    :aria-expanded="expandedTools.has(tool.id)"
+                    @click="toggleTool(tool.id)"
+                  >
+                    <span class="tool-chip-name">{{
+                      toolChipLabel(tool)
+                    }}</span>
+                    <span class="tool-chip-status">{{
+                      toolChipStatus(tool, message)
+                    }}</span>
+                    <span
+                      v-if="
+                        expandedTools.has(tool.id) && tool.text !== undefined
+                      "
+                      class="tool-chip-result"
+                      >{{ tool.text }}</span
+                    >
+                  </button>
+                </div>
+                <!--
                 The subagents this Turn dispatched. The child's own Session is
                 never in this transcript, so the chip is the whole of what the
                 conversation says about it; opening one shows the summary the
                 child handed back and nothing else.
               -->
-              <div v-if="taskChipsOf(message).length > 0" class="message-tasks">
-                <button
-                  v-for="entry in taskChipsOf(message)"
-                  :key="entry.chip.taskId"
-                  type="button"
-                  class="task-chip"
-                  :class="`task-chip-${entry.status}`"
-                  :aria-expanded="expandedTasks.has(entry.chip.taskId)"
-                  @click="toggleTask(entry.chip.taskId)"
+                <div
+                  v-if="taskChipsOf(message).length > 0"
+                  class="message-tasks"
                 >
-                  <span class="task-chip-type">{{ entry.chip.taskType }}</span>
-                  <span class="task-chip-description">{{
-                    entry.chip.description
-                  }}</span>
-                  <span class="task-chip-status">{{ entry.status }}</span>
-                  <span class="task-chip-model">{{ entry.chip.model }}</span>
-                  <span
-                    v-if="expandedTasks.has(entry.chip.taskId)"
-                    class="task-chip-summary"
-                    >{{
-                      entry.summary ??
-                      "This subagent has not reported a summary yet."
-                    }}</span
+                  <button
+                    v-for="entry in taskChipsOf(message)"
+                    :key="entry.chip.taskId"
+                    type="button"
+                    class="task-chip"
+                    :class="`task-chip-${entry.status}`"
+                    :aria-expanded="expandedTasks.has(entry.chip.taskId)"
+                    @click="toggleTask(entry.chip.taskId)"
                   >
-                  <!--
+                    <span class="task-chip-type">{{
+                      entry.chip.taskType
+                    }}</span>
+                    <span class="task-chip-description">{{
+                      entry.chip.description
+                    }}</span>
+                    <span class="task-chip-status">{{ entry.status }}</span>
+                    <span class="task-chip-model">{{ entry.chip.model }}</span>
+                    <span
+                      v-if="expandedTasks.has(entry.chip.taskId)"
+                      class="task-chip-summary"
+                      >{{
+                        entry.summary ??
+                        "This subagent has not reported a summary yet."
+                      }}</span
+                    >
+                    <!--
                     Cancellation is the User's, explicit and authenticated. It
                     is offered only while the subagent is live: a settled one
                     has an outcome, and stopping it would rewrite it.
                   -->
-                  <span
-                    v-if="
-                      expandedTasks.has(entry.chip.taskId) &&
-                      isTaskLive(entry.status)
-                    "
-                    class="task-chip-stop"
-                    role="button"
-                    tabindex="0"
-                    @click.stop="stopTask(entry.chip.taskId)"
-                    @keydown.enter.stop.prevent="stopTask(entry.chip.taskId)"
-                    @keydown.space.stop.prevent="stopTask(entry.chip.taskId)"
-                    >Stop this subagent</span
-                  >
-                </button>
+                    <span
+                      v-if="
+                        expandedTasks.has(entry.chip.taskId) &&
+                        isTaskLive(entry.status)
+                      "
+                      class="task-chip-stop"
+                      role="button"
+                      tabindex="0"
+                      @click.stop="stopTask(entry.chip.taskId)"
+                      @keydown.enter.stop.prevent="stopTask(entry.chip.taskId)"
+                      @keydown.space.stop.prevent="stopTask(entry.chip.taskId)"
+                      >Stop this subagent</span
+                    >
+                  </button>
+                </div>
               </div>
             </template>
             <div v-else class="message-bubble">{{ message.text }}</div>
@@ -985,7 +1103,7 @@ function handleComposerKeydown(event: KeyboardEvent): void {
               type="button"
               @click="web.resumeRun(state.activeRun.runId)"
             >
-              Resolve Turn
+              Try again
             </button>
           </div>
         </Transition>

package/src/client/PackageIframeHost.vue

@@ -34,6 +34,13 @@ const providedWeb = inject(frockBotWebDataKey);
 if (!providedWeb) throw new Error("Package iframe host data was not provided");
 const web = providedWeb;
 const frame = ref<HTMLIFrameElement>();
+/** Where a page came from, said plainly. First-party pages say nothing. */
+const provenanceLabel = computed(() => {
+  if (props.contribution.provenance === "Bot-authored")
+    return "Built by this Bot";
+  if (props.contribution.provenance === "User-installed") return "Added by you";
+  return undefined;
+});
 const height = ref(240);
 const failure = ref<string>();
 const lastStateWireByName = new Map<string, string>();
@@ -123,7 +130,9 @@ function post(message: PackageIframeHostMessageV2): void {
     postPackageIframeHostMessage(target, message, lastStateWireByName);
   } catch (error) {
     failure.value =
-      error instanceof Error ? error.message : "Package page state is invalid";
+      error instanceof Error
+        ? error.message
+        : "This page sent something FrockBot couldn't read.";
   }
 }
 
@@ -179,7 +188,7 @@ async function onMessage(event: MessageEvent): Promise<void> {
   }
   if (message.type === "focus") {
     if (!packageIframeFocusAllowedV2(props.contribution)) {
-      failure.value = "This Package cannot change the focused Applet.";
+      failure.value = "This plugin can't change which Applet is open.";
       return;
     }
     failure.value = undefined;
@@ -189,7 +198,7 @@ async function onMessage(event: MessageEvent): Promise<void> {
   if (message.type === "openExternal") {
     const origin = catalog.value?.artifactOrigin;
     if (!origin || !packageIframeExternalUrlAllowedV2(message.url, origin)) {
-      failure.value = "This Package page can only open its own pages.";
+      failure.value = "This plugin can only open its own pages.";
       return;
     }
     failure.value = undefined;
@@ -197,7 +206,7 @@ async function onMessage(event: MessageEvent): Promise<void> {
     return;
   }
   if (!packageIframeToolAllowedV1(props.contribution, message.name)) {
-    failure.value = `This Package did not declare ${message.name}.`;
+    failure.value = `This plugin isn't allowed to use ${message.name}.`;
     return;
   }
   failure.value = undefined;
@@ -232,12 +241,12 @@ onBeforeUnmount(() => window.removeEventListener("message", onMessage));
   <section class="package-iframe-frame" :class="`package-iframe-${layout}`">
     <header v-if="attribution" class="package-iframe-attribution">
       <strong>{{ contribution.displayName }}</strong>
-      <span>{{ contribution.provenance }} Package</span>
+      <span v-if="provenanceLabel">{{ provenanceLabel }}</span>
     </header>
     <!-- Load eagerly because lazy iframes defer the init/resize handshake until the browser decides the frame is near the viewport, which headless Chromium may never do. -->
     <iframe
       ref="frame"
-      :title="`${contribution.displayName} Package page`"
+      :title="contribution.displayName"
       :src="source"
       :style="layout === 'fill' ? undefined : { height: `${height}px` }"
       sandbox="allow-scripts"