@frockbot/plugin-shell 0.3.22 → 0.3.24

package/src/backend.ts

@@ -126,12 +126,14 @@ import {
   planBotRunRecovery,
   planInterruptedRunRecoveryV1,
 } from "./backend-recovery.js";
+import { COMPOSITION_CURRENT_KEY } from "@frockbot/kernel-do";
 import {
   bootstrapCompositionGeneration,
   createShellCompositionHost,
   type ShellAppletMountOptions,
   type ShellIsolateMountOptions,
   type ShellMountedComposition,
+  resolveDeploymentCompositionV1,
 } from "./backend-composition.js";
 import {
   createAppletCapabilityHostV1,
@@ -404,6 +406,7 @@ import {
 import {
   CLIENT_RUN_LIST_MAX_BYTES,
   CLIENT_RUN_PAGE_LIMIT,
+  CLIENT_RUN_SCAN_LIMIT,
   clientRunListWireBytes,
   createClientRunListV1,
   createClientRunStopReceiptV1,
@@ -1229,7 +1232,8 @@ export class ShellBotBackendContribution {
     // from the previous Turn has already handed the log back (ADR 0030).
     await yieldCompactionWorkV1(command.sessionId);
     // Before admission, so the pin this Turn takes already carries whatever the
-    // User's Applet directory says now.
+    // deployment ships and whatever the User's Applet directory says now.
+    await this.followDeploymentComposition();
     await this.resolveAppletComposition(
       { userId: command.userId, botId: command.botId },
       command,
@@ -1244,6 +1248,7 @@ export class ShellBotBackendContribution {
     await this.validateIdentity(identity);
     const catalog = await this.listPackageUi(identity);
     const contribution = requirePackageUiToolDeclarationV1(catalog, command);
+    await this.followDeploymentComposition();
     return projectClientTurnV1(
       await this.authority.run({
         ...identity,
@@ -2722,6 +2727,39 @@ export class ShellBotBackendContribution {
     return focused;
   }
 
+  /**
+   * Bring this Bot's built-in members up to the deployment before a Turn is
+   * admitted, so a release that changed a first-party manifest or artifact is
+   * a new generation rather than a Bot that cannot mount (2026-09-05, when
+   * every Bot failed every Turn after the Applets list page changed). Outside
+   * the admission transaction like the Applet resolve below; a failure here
+   * leaves the Bot on the generation it has and is visible where that
+   * generation fails to mount.
+   */
+  private async followDeploymentComposition(): Promise<void> {
+    try {
+      // A Bot with nothing pinned yet bootstraps from this deployment when
+      // its first Turn is admitted; reading the current generation here would
+      // materialize that bootstrap early, and a refused command must leave
+      // storage exactly as it found it.
+      if (
+        (await this.ctx.storage.get<unknown>(COMPOSITION_CURRENT_KEY)) ===
+        undefined
+      )
+        return;
+      await resolveDeploymentCompositionV1({
+        plan: await this.compileApplication(),
+        composition: {
+          current: () => this.authority.composition.current(),
+          propose: (generation, options) =>
+            this.authority.composition.propose(generation, options),
+        },
+      });
+    } catch {
+      // The mount records why; never a wedged Turn on its own.
+    }
+  }
+
   /**
    * Resolve the User's Applet directory into this Bot's next Composition
    * generation, before a Turn is admitted.
@@ -3261,6 +3299,7 @@ export class ShellBotBackendContribution {
     fire: RoutineFireV1,
   ): Promise<RoutineFireOutcomeV1> {
     try {
+      await this.followDeploymentComposition();
       await this.authority.run(
         routineTurnCommandV1(identity, fire, new Date().toISOString()),
       );
@@ -4196,6 +4235,7 @@ export class ShellBotBackendContribution {
       await this.ctx.storage.put(key, { ...context, status: "running" });
       let outcome: TaskOutcomeV1;
       try {
+        await this.followDeploymentComposition();
         await this.authority.run({
           ...identity,
           runId: context.taskId,
@@ -5833,7 +5873,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.
@@ -5842,60 +5882,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.

package/src/client/AppletCanvas.vue

@@ -22,6 +22,11 @@ import {
   appletSourceFingerprintV1,
   mostRecentlyChangedFileV1,
 } from "./applets-client.js";
+import {
+  appletIsBeingBuiltV1,
+  appletProgressToolsV1,
+  appletProgressV1,
+} from "./applet-progress.js";
 import { packageIframePagesForSlotV1 } from "./package-iframe-entries.js";
 import PackageIframeHost from "./PackageIframeHost.vue";
 
@@ -46,6 +51,26 @@ const isRunning = computed(() => Boolean(web.value.activeRunId));
 const canvasState = computed(() => web.value.appletCanvas);
 const failure = computed(() => web.value.appletCanvasError);
 
+/*
+ * What the Bot is doing to this Applet, in one line.
+ *
+ * A publish is minutes away from a create, and for all of it there is nothing
+ * to run. The panel used to answer that with one fixed line about the Applet
+ * not being live and a file list, which never changed and never said whether
+ * anything was happening. This is the sentence in between, projected from what
+ * the thread already shows: no new read, no new durable state.
+ */
+const progress = computed(() =>
+  appletProgressV1({
+    applet: applet.value ?? null,
+    source: source.value,
+    build: build.value,
+    tools: appletProgressToolsV1(web.value.messages),
+    running: isRunning.value,
+  }),
+);
+const beingBuilt = computed(() => appletIsBeingBuiltV1(progress.value));
+
 /** The Applets Package's right-panel page, when its Composition carries one. */
 const panelPage = computed(
   () => packageIframePagesForSlotV1(web.value.packageUi, RIGHT_PANEL_SLOT)[0],
@@ -212,8 +237,11 @@ async function clearFocus(): Promise<void> {
       /></span>
       <div class="applet-canvas-title">
         <strong>{{ applet?.displayName ?? "Applet" }}</strong>
+        <!--
+          While it is being built the line under the name is the pinned
+          building view below, not a copy of it here.
+        -->
         <small v-if="viewer">{{ generationLabel(viewer.generationId) }}</small>
-        <small v-else>Not published yet</small>
       </div>
       <div
         v-if="canShowApp"
@@ -255,6 +283,39 @@ async function clearFocus(): Promise<void> {
       />
     </header>
 
+    <!--
+      Where the work has got to, pinned under the header while the Applet is
+      still being built: one line a person can read, the reason it stopped when
+      it stopped, and the tail of whatever the check or the build printed —
+      which is the only thing that helps when the Bot is going round in circles
+      on a type error. It sits outside the scrolling column deliberately: a
+      person reading the source still wants to know what is happening to it.
+    -->
+    <section
+      v-if="applet && !loading && progress && beingBuilt"
+      class="applet-canvas-progress"
+      :class="{ 'applet-canvas-progress-wrong': Boolean(progress.failure) }"
+      data-testid="applet-canvas-progress"
+      role="status"
+    >
+      <p class="applet-canvas-progress-line">
+        <span
+          v-if="progress.working"
+          class="applet-canvas-progress-dot"
+          aria-hidden="true"
+        />
+        <UiIcon v-else-if="progress.failure" name="close" size="sm" />
+        <span>{{ progress.label }}</span>
+      </p>
+      <p v-if="progress.failure" class="applet-canvas-progress-failure">
+        {{ progress.failure }}
+      </p>
+      <pre
+        v-if="progress.output"
+        class="applet-canvas-progress-output"
+      ><code>{{ progress.output.join("\n") }}</code></pre>
+    </section>
+
     <div class="applet-canvas-body">
       <!-- Loading: the shape of what is coming, with a caption that says so. -->
       <div v-if="loading" class="applet-canvas-loading">
@@ -297,21 +358,6 @@ async function clearFocus(): Promise<void> {
             <span>This is taking longer than it should.</span>
             <button type="button" @click="retry">Try again</button>
           </div>
-          <p
-            v-if="build && build.status !== 'unknown'"
-            class="applet-canvas-build"
-            :class="`applet-canvas-build-${build.status}`"
-          >
-            <UiIcon
-              :name="build.status === 'passed' ? 'check' : 'close'"
-              size="sm"
-            />
-            <span
-              >{{ build.command === "build" ? "Build" : "Check" }}
-              {{ build.status
-              }}{{ build.summary ? `: ${build.summary}` : "" }}</span
-            >
-          </p>
           <div v-if="sortedFiles.length > 0" class="applet-canvas-files">
             <button
               v-for="file in sortedFiles"
@@ -573,28 +619,76 @@ async function clearFocus(): Promise<void> {
   white-space: pre;
 }
 
-.applet-canvas-build {
+/* Where the work has got to: the panel's own header for the building state. */
+.applet-canvas-progress {
+  display: flex;
+  flex: 0 0 auto;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--frock-border);
+  background: var(--frock-surface-subtle);
+}
+
+.applet-canvas-progress-wrong {
+  border-bottom-color: var(--frock-danger-border);
+  background: var(--frock-danger-surface);
+}
+
+.applet-canvas-progress-line {
   display: flex;
   align-items: center;
-  gap: 6px;
+  gap: 8px;
   margin: 0;
-  padding: 6px 10px;
-  border: 1px solid var(--frock-border);
-  border-radius: var(--frock-radius-control);
-  color: var(--frock-text-muted);
-  font-size: var(--frock-text-xs);
+  color: var(--frock-text);
+  font-size: var(--frock-text-sm);
+  font-weight: 600;
+}
+
+.applet-canvas-progress-wrong .applet-canvas-progress-line {
+  color: var(--frock-danger-text);
+}
+
+/* The same "something is happening" the thread uses, at the size of a word. */
+.applet-canvas-progress-dot {
+  width: 8px;
+  height: 8px;
+  flex: 0 0 auto;
+  border-radius: 999px;
+  background: var(--frock-action-primary);
+  animation: applet-progress-pulse 1.4s ease-in-out infinite;
 }
 
-.applet-canvas-build-passed {
-  border-color: var(--frock-success-border);
-  color: var(--frock-success);
-  background: var(--frock-success-surface);
+@keyframes applet-progress-pulse {
+  0%,
+  100% {
+    opacity: 0.35;
+  }
+
+  50% {
+    opacity: 1;
+  }
 }
 
-.applet-canvas-build-failed {
-  border-color: var(--frock-danger-border);
+.applet-canvas-progress-failure {
+  margin: 0;
   color: var(--frock-danger-text);
-  background: var(--frock-danger-surface);
+  font-size: var(--frock-text-sm);
+}
+
+.applet-canvas-progress-output {
+  max-height: 180px;
+  margin: 0;
+  overflow: auto;
+  padding: 8px 10px;
+  border: 1px solid var(--frock-border);
+  border-radius: var(--frock-radius-control);
+  color: var(--frock-text-muted);
+  background: var(--frock-surface);
+  font-family: var(--frock-font-mono);
+  font-size: var(--frock-text-xs);
+  line-height: var(--frock-leading-snug);
+  white-space: pre;
 }
 
 .applet-canvas-failure {
@@ -686,5 +780,9 @@ async function clearFocus(): Promise<void> {
   .applet-app-leave-active {
     transition: none;
   }
+
+  .applet-canvas-progress-dot {
+    animation: none;
+  }
 }
 </style>

package/src/client/FrockBotApp.vue

@@ -56,6 +56,7 @@ import {
 } from "./turn-limits.js";
 import SendPayloadView from "./SendPayloadView.vue";
 import AppletCanvas from "./AppletCanvas.vue";
+import { appletProgressToolsV1, appletProgressV1 } from "./applet-progress.js";
 import PackageIframeHost from "./PackageIframeHost.vue";
 import type { ClientSkillCatalogEntryV1 } from "../skill-protocol.js";
 import {
@@ -67,6 +68,14 @@ import {
   textWithoutSkillTriggerV1,
   type SkillPopoverStateV1,
 } from "./skill-invocation.js";
+import {
+  DEPLOYMENT_RELOAD_LABEL_V1,
+  DEPLOYMENT_UPDATED_MESSAGE_V1,
+  deploymentFollowV1,
+  deploymentReloadStoreV1,
+  readDeploymentReloadV1,
+  writeDeploymentReloadV1,
+} from "./deployment.js";
 
 const injectedWeb = inject(frockBotWebDataKey);
 if (!injectedWeb) throw new Error("shell client data was not provided");
@@ -264,6 +273,25 @@ const appletChip = computed(() =>
     ? (state.value.focusedApplet?.displayName ?? "Applet")
     : undefined,
 );
+/*
+ * What the Bot is doing to it, on the phone.
+ *
+ * There is no room beside the conversation here, so the chip carries the line
+ * the canvas would have shown and opens the canvas over the whole screen. It
+ * is the same projection and the same words: a person who moves between their
+ * phone and a laptop reads one story, not two.
+ */
+const appletChipStatus = computed(() => {
+  if (!appletChip.value) return undefined;
+  const progress = appletProgressV1({
+    applet: state.value.focusedApplet ?? null,
+    source: state.value.appletSource,
+    build: state.value.appletBuild,
+    tools: appletProgressToolsV1(state.value.messages),
+    running: Boolean(state.value.activeRunId),
+  });
+  return progress && progress.stage !== "published" ? progress : undefined;
+});
 /*
  * Skill invocation. `/` or `@` at a word boundary opens a popover over the
  * Bot's catalog; choosing one attaches a ref chip and removes the trigger from
@@ -411,6 +439,57 @@ let voiceTail = "";
 let voiceSendOnFinal = false;
 
 const dictating = computed(() => voiceState.value !== "idle");
+
+/*
+ * Following a release.
+ *
+ * A reload is destructive, so the shell only does it on its own when there is
+ * nothing to lose, and otherwise says so and waits. The bar is not an alert:
+ * nothing is wrong, there is just newer code to pick up.
+ */
+const reloadStore = deploymentReloadStoreV1();
+const lastReloadedAt = readDeploymentReloadV1(reloadStore);
+const updateBarVisible = ref(false);
+
+function followDeployment(): void {
+  const decision = deploymentFollowV1({
+    stale: state.value.deploymentStale,
+    turnRunning: Boolean(state.value.runningRunId),
+    draft: draft.value,
+    overlayOpen: Boolean(overlaySurface.value),
+    listening: dictating.value,
+    holds: state.value.reloadHolds,
+    now: Date.now(),
+    ...(lastReloadedAt === undefined ? {} : { reloadedAt: lastReloadedAt }),
+  });
+  updateBarVisible.value = decision === "offer";
+  if (decision !== "reload") return;
+  reloadNow();
+}
+
+function reloadNow(): void {
+  writeDeploymentReloadV1(reloadStore, Date.now());
+  /*
+   * `location.reload()` and nothing else. The Android shell runs this very
+   * bundle inside a WebView served from its own origin, so re-navigating to a
+   * URL this code built would leave that origin behind; reloading in place
+   * works the same way in both.
+   */
+  window.location.reload();
+}
+
+watch(
+  [
+    () => state.value.deploymentStale,
+    () => state.value.runningRunId,
+    () => state.value.reloadHolds,
+    draft,
+    overlaySurface,
+    dictating,
+  ],
+  () => followDeployment(),
+  { immediate: true },
+);
 const voiceButtonLabel = computed(() => voiceButtonLabelV1(voiceState.value));
 /**
  * The wave button takes the slot only when the slot is otherwise idle: an
@@ -1574,6 +1653,23 @@ function handleComposerKeydown(event: KeyboardEvent): void {
           </div>
         </Transition>
 
+        <Transition name="banner">
+          <!--
+            One bar at a time in this spot. A failed Turn is the more urgent
+            thing to read, and newer code is still there once it is dealt with.
+          -->
+          <div
+            v-if="updateBarVisible && !state.error && !state.activeRun"
+            class="update-banner"
+            role="status"
+          >
+            <span>{{ DEPLOYMENT_UPDATED_MESSAGE_V1 }}</span>
+            <button type="button" @click="reloadNow()">
+              {{ DEPLOYMENT_RELOAD_LABEL_V1 }}
+            </button>
+          </div>
+        </Transition>
+
         <!--
           No Bot, no composer. A disabled input under a made-up Bot name reads
           as a broken Bot; the first-run pane above points at making one.
@@ -1618,11 +1714,24 @@ function handleComposerKeydown(event: KeyboardEvent): void {
             v-if="appletChip"
             type="button"
             class="applet-chip"
+            data-testid="applet-chip"
             @click="toggleRightPanel"
           >
             <UiIcon name="applets" size="sm" />
-            <span class="applet-chip-name">Applet: {{ appletChip }}</span>
-            <span class="applet-chip-action">Open</span>
+            <span class="applet-chip-text">
+              <span class="applet-chip-name">Applet: {{ appletChip }}</span>
+              <span v-if="appletChipStatus" class="applet-chip-status">
+                <span
+                  v-if="appletChipStatus.working"
+                  class="applet-chip-dot"
+                  aria-hidden="true"
+                />
+                {{ appletChipStatus.failure ?? appletChipStatus.label }}
+              </span>
+            </span>
+            <span class="applet-chip-action">{{
+              appletChipStatus ? "Watch" : "Open"
+            }}</span>
           </button>
           <div class="composer-body">
             <ul v-if="attachedSkills.length > 0" class="skill-chips">