@frockbot/plugin-shell 0.3.11 → 0.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "private": false,
   "type": "module",
   "exports": {
@@ -27,12 +27,14 @@
     "./client/FrockBotApp.vue": "./src/client/FrockBotApp.vue",
     "./client/notify": "./src/client/notify.ts",
     "./client/styles.css": "./src/client/styles.css",
+    "./focus": "./src/focus.ts",
     "./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-failure-copy": "./src/run-failure-copy.ts",
     "./run-protocol": "./src/run-protocol.ts",
     "./settings-links": "./src/settings-links.ts",
     "./shared": "./src/shared.ts",
@@ -48,46 +50,46 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/agent-runtime": "0.3.11",
-    "@frockbot/application-foundation": "0.3.11",
-    "@frockbot/catalog-core": "0.3.11",
-    "@frockbot/client-core": "0.3.11",
-    "@frockbot/client-ui": "0.3.11",
-    "@frockbot/computer-core": "0.3.11",
-    "@frockbot/computer-host-protocol": "0.3.11",
-    "@frockbot/configuration-core": "0.3.11",
-    "@frockbot/connection-core": "0.3.11",
-    "@frockbot/kernel-agent-loop": "0.3.11",
-    "@frockbot/kernel-composition": "0.3.11",
-    "@frockbot/kernel-contracts": "0.3.11",
-    "@frockbot/kernel-do": "0.3.11",
-    "@frockbot/machine-protocol": "0.3.11",
-    "@frockbot/plugin-applets": "0.3.11",
-    "@frockbot/plugin-authoring": "0.3.11",
-    "@frockbot/plugin-bot-template": "0.3.11",
-    "@frockbot/plugin-computer": "0.3.11",
-    "@frockbot/plugin-flock": "0.3.11",
-    "@frockbot/plugin-image": "0.3.11",
-    "@frockbot/plugin-machine-messages": "0.3.11",
-    "@frockbot/plugin-mcp": "0.3.11",
-    "@frockbot/plugin-memory": "0.3.11",
-    "@frockbot/plugin-package-catalog": "0.3.11",
-    "@frockbot/plugin-routines": "0.3.11",
-    "@frockbot/plugin-skills": "0.3.11",
-    "@frockbot/plugin-subagents": "0.3.11",
-    "@frockbot/plugin-user-machine": "0.3.11",
-    "@frockbot/protocol": "0.3.11",
+    "@frockbot/agent-runtime": "0.3.13",
+    "@frockbot/application-foundation": "0.3.13",
+    "@frockbot/catalog-core": "0.3.13",
+    "@frockbot/client-core": "0.3.13",
+    "@frockbot/client-ui": "0.3.13",
+    "@frockbot/computer-core": "0.3.13",
+    "@frockbot/computer-host-protocol": "0.3.13",
+    "@frockbot/configuration-core": "0.3.13",
+    "@frockbot/connection-core": "0.3.13",
+    "@frockbot/kernel-agent-loop": "0.3.13",
+    "@frockbot/kernel-composition": "0.3.13",
+    "@frockbot/kernel-contracts": "0.3.13",
+    "@frockbot/kernel-do": "0.3.13",
+    "@frockbot/machine-protocol": "0.3.13",
+    "@frockbot/plugin-applets": "0.3.13",
+    "@frockbot/plugin-authoring": "0.3.13",
+    "@frockbot/plugin-bot-template": "0.3.13",
+    "@frockbot/plugin-computer": "0.3.13",
+    "@frockbot/plugin-flock": "0.3.13",
+    "@frockbot/plugin-image": "0.3.13",
+    "@frockbot/plugin-machine-messages": "0.3.13",
+    "@frockbot/plugin-mcp": "0.3.13",
+    "@frockbot/plugin-memory": "0.3.13",
+    "@frockbot/plugin-package-catalog": "0.3.13",
+    "@frockbot/plugin-routines": "0.3.13",
+    "@frockbot/plugin-skills": "0.3.13",
+    "@frockbot/plugin-subagents": "0.3.13",
+    "@frockbot/plugin-user-machine": "0.3.13",
+    "@frockbot/protocol": "0.3.13",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "latest",
-    "@frockbot/plugin-prompt": "0.3.11",
-    "@frockbot/plugin-tools": "0.3.11",
+    "@frockbot/plugin-prompt": "0.3.13",
+    "@frockbot/plugin-tools": "0.3.13",
     "@types/bun": "1.3.6",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",
-    "typescript": "5.9.3",
+    "typescript": "npm:typescript-native-bridge@6.0.3-bridge.16.tsgo.7.0.2",
     "vite": "8.2.2",
     "vue-tsc": "3.3.10"
   },

package/src/agent.test.ts

@@ -448,3 +448,81 @@ describe("the conversation prompt section", () => {
     }
   });
 });
+
+// Two ends of one defect. The prompt tells the model to acknowledge with the
+// call; the promotion catches the model that acknowledges in text anyway. The
+// verification run watched a real model do exactly that — "On it — building
+// the 2027 countdown applet now." as plain assistant text, then three tool
+// calls — and nobody ever saw the line.
+describe("the acknowledgement reaches the user", () => {
+  test("the prompt names the call, not just the line", () => {
+    expect(CONVERSATION_PROMPT_TEXT_V1).toContain(
+      "Your own text is not shown to the user",
+    );
+    expect(CONVERSATION_PROMPT_TEXT_V1).toContain(
+      "your first action is a `send_to_user` call",
+    );
+  });
+
+  test("assistant text in a tool-calling step is promoted to one send", async () => {
+    const mounted = await mount();
+    try {
+      await mounted.root.serial(
+        "agent/assistant-text",
+        { session: mounted.session } as never,
+        "On it — building the 2027 countdown applet now.",
+        { turn: 4, step: 2, requestId: "request-1" },
+      );
+
+      const sends = mounted.session.events.filter(
+        (event) => event.type === "send/to-user",
+      );
+      expect(sends).toHaveLength(1);
+      expect(sends[0]).toMatchObject({
+        turn: 4,
+        step: 2,
+        occurrenceId: "assistant-text:request-1",
+        payload: {
+          type: "text",
+          text: "On it — building the 2027 countdown applet now.",
+        },
+      });
+    } finally {
+      await mounted.dispose();
+    }
+  });
+
+  test("a step that already spoke is left alone, and a replay adds nothing", async () => {
+    const mounted = await mount();
+    try {
+      await invoke(
+        mounted,
+        "chat",
+        call(SEND_TO_USER_TOOL_V1, {
+          payload: { type: "text", text: "On it." },
+        }),
+      );
+      await mounted.root.serial(
+        "agent/assistant-text",
+        { session: mounted.session } as never,
+        "On it — building the countdown applet now.",
+        { turn: 4, step: 2, requestId: "request-1" },
+      );
+      // The same step replayed after an eviction promotes nothing new either.
+      await mounted.root.serial(
+        "agent/assistant-text",
+        { session: mounted.session } as never,
+        "On it — building the countdown applet now.",
+        { turn: 4, step: 2, requestId: "request-1" },
+      );
+
+      const sends = mounted.session.events.filter(
+        (event) => event.type === "send/to-user",
+      );
+      expect(sends).toHaveLength(1);
+      expect(sends[0]).toMatchObject({ payload: { text: "On it." } });
+    } finally {
+      await mounted.dispose();
+    }
+  });
+});

package/src/agent.ts

@@ -39,7 +39,15 @@ import {
 } from "@frockbot/kernel-contracts";
 // Merges the Agent loop's event declarations into the cordis Context type.
 import type {} from "@frockbot/kernel-agent-loop/agent";
-import { automationParentPointerV1, turnScopedMessagesV1 } from "./history.js";
+import {
+  automationParentPointerV1,
+  chatWindowV1,
+  CHAT_HISTORY_BUDGET_CHARS_V1,
+  turnScopedMessagesV1,
+  turnTypesByTurnV1,
+} from "./history.js";
+import { runCompactionV1 } from "./compaction.js";
+import { compactionWorkV1 } from "./compaction-scheduler.js";
 import type { Plugin } from "cordis";
 import manifest from "../frockbot.json" with { type: "json" };
 
@@ -85,6 +93,11 @@ function refusal(reason: string): ToolExecutionResult {
   return { content: reason, isError: true };
 }
 
+/** Adapts a cordis fiber to the plain disposer this Package's list holds. */
+function disposeFiber(fiber: { dispose(): unknown }): () => void {
+  return () => void fiber.dispose();
+}
+
 /**
  * The open step a Shell event belongs to. The session log is the
  * reconstruction surface, so a send without its turn and step would not
@@ -111,6 +124,60 @@ function openStepPositionV1(
   return { turn: started.turn, step: started.step };
 }
 
+/** The longest acknowledgement worth promoting; longer is not an ack. */
+export const PROMOTED_ASSISTANT_TEXT_LIMIT_V1 = 600;
+
+/** The occurrence id a promoted send is recorded under, per model request. */
+export function promotedSendOccurrenceIdV1(requestId: string): string {
+  return `assistant-text:${requestId}`;
+}
+
+/**
+ * Promotes a step's assistant text to a send when the model wrote to the
+ * person and then called tools without sending.
+ *
+ * The verification run is the whole argument for this. The model did exactly
+ * what the contract asks — "On it — building the 2027 countdown applet now.",
+ * one short line, no narration — and then called its tools. It went nowhere:
+ * the thread draws one bubble per send (issue 153) and there was no send, so
+ * the person watched a spinner and then a failure, with the acknowledgement
+ * they were owed sitting in the log where only the debug surface could see it.
+ *
+ * A step that already sent is left alone: the model's own text is scratch
+ * space once it has spoken, and promoting it there is how the same line
+ * arrives twice. The occurrence id is derived from the model request, so a
+ * step replayed after an eviction promotes the same text to the same
+ * occurrence rather than a second bubble.
+ *
+ * The prompt asks for the call and this does not replace it — a model that
+ * calls `send_to_user` never reaches here.
+ */
+export async function promoteAssistantTextToSendV1(
+  session: Session,
+  text: string,
+  position: { turn: number; step: number; requestId: string },
+): Promise<void> {
+  const trimmed = text.trim();
+  if (trimmed.length === 0 || trimmed.length > PROMOTED_ASSISTANT_TEXT_LIMIT_V1)
+    return;
+  const occurrenceId = promotedSendOccurrenceIdV1(position.requestId);
+  const spokeThisStep = session.events.some(
+    (event) =>
+      event.type === "send/to-user" &&
+      event.turn === position.turn &&
+      event.step === position.step,
+  );
+  if (spokeThisStep) return;
+  session.append({
+    type: "send/to-user",
+    turn: position.turn,
+    step: position.step,
+    occurrenceId,
+    payload: { type: "text", text: trimmed },
+  });
+  await session.flush();
+}
+
 /** What a recorded send tells the model it did. */
 function sendAcknowledgement(payload: SendToUserPayloadV1): string {
   switch (payload.type) {
@@ -147,7 +214,11 @@ export const CONVERSATION_PROMPT_TEXT_V1 = [
   "## Talking to the user",
   "",
   "Everything the user sees is a `send_to_user` call; nothing else reaches them.",
-  'When a request will take more than a moment, send one short line first — "On it." or "Looking into that." — then go quiet and work.',
+  // The first line said sends are the only thing the user sees, and a model
+  // still wrote its acknowledgement as plain assistant text and went straight
+  // on to call tools — nobody saw it. So the acknowledgement names the call.
+  "Your own text is not shown to the user. Writing a line in your reply instead of calling `send_to_user` means nobody reads it.",
+  'When a request will take more than a moment, your first action is a `send_to_user` call with one short line — "On it." or "Looking into that." — and then you go quiet and work.',
   "After that, send only on a real beat: the result, a decision only the user can make, or a blocker you cannot get past.",
   "Never narrate what you are doing, what you are about to do, or which tool you are using.",
   "Never leave a question or a request hanging: before you stop, the user must have the answer, the result, or the reason there isn't one.",
@@ -348,6 +419,63 @@ export const shellAgentPlugin: Plugin.Function = (ctx) => {
       createWakeParentTool(ctx.sessions),
       parentHandoff ? { admissionCeiling: parentHandoff } : undefined,
     ),
+    // The safety net under the prompt: a model that acknowledges the request
+    // in its own text instead of calling `send_to_user` still reaches the
+    // person. See `promoteAssistantTextToSendV1`.
+    ctx.on("agent/assistant-text", async (agent, text, position) => {
+      await promoteAssistantTextToSendV1(agent.session, text, position);
+    }),
+    // ADR 0030. `ctx.inject` rather than a declared dependency: a host that
+    // mounts the Shell without a model still gets its tools and its transcript
+    // seam, and simply never compacts. The hook is evaluated after `turn/end`
+    // is on the log and flushed — but `agent/turn-stopping` is a hook the loop
+    // *awaits* inside its `finally`, so running the summariser here is exactly
+    // the latency ADR 0030 says a compaction never costs. It is handed to the
+    // detached scheduler instead and this returns at once: the Turn ends, the
+    // run settles, the response goes out, and the summariser carries on behind
+    // it. Nothing here may throw, and nothing here may wait.
+    disposeFiber(
+      ctx.inject(["llm"], (scoped) => {
+        scoped.on("agent/turn-stopping", async (agent, turn) => {
+          const session = agent.session;
+          const types = turnTypesByTurnV1(session.events);
+          if ((types.get(turn) ?? "chat") !== "chat") return;
+          compactionWorkV1(session.id).start(async (signal) => {
+            if (signal.aborted) return;
+            await runCompactionV1({
+              session,
+              window: chatWindowV1(session.events, session.deriveMessages()),
+              budget: CHAT_HISTORY_BUDGET_CHARS_V1,
+              currentTurn: turn,
+              newEffectId: () => `compaction-${crypto.randomUUID()}`,
+              summarise: async (request) => {
+                let text = "";
+                // Two deadlines, one call: the compaction's own, and the abort
+                // a newly admitted Turn raises when it takes the log back.
+                const cancelled = AbortSignal.any([request.signal, signal]);
+                for await (const event of scoped.llm.stream(
+                  {
+                    requestId: `compaction-${crypto.randomUUID()}`,
+                    provider: request.provider,
+                    model: request.model,
+                    system: request.system,
+                    messages: request.messages,
+                    tools: [],
+                    ...(request.modelBinding
+                      ? { modelBinding: request.modelBinding }
+                      : {}),
+                  },
+                  cancelled,
+                )) {
+                  if (event.type === "text-delta") text += event.text;
+                }
+                return text;
+              },
+            });
+          });
+        });
+      }),
+    ),
     // Applied after the rest of the chain, so this Package has the last word on
     // what history a request carries — the one rule the visible transcript
     // rests on.

package/src/backend-configuration.test.ts

@@ -150,7 +150,7 @@ function configuredUser(): UserSettingsViewV1 {
         connectionId: "flock-ai-ambient",
         packageId: "provider-flock-ai",
         connectionTypeId: "flock-ai-account",
-        displayName: "Flock AI",
+        displayName: "Frock AI",
         state: "ready",
         providerType: "flock-ai",
         generation: "foundation-generation-1",
@@ -160,7 +160,7 @@ function configuredUser(): UserSettingsViewV1 {
           state: "fresh",
           models: [
             {
-              providerModelId: "@flock/auto",
+              providerModelId: "@frock/auto",
               displayName: "Platform",
               capabilities: {
                 tools: true,
@@ -174,7 +174,7 @@ function configuredUser(): UserSettingsViewV1 {
         safeMetadata: {},
       },
     ],
-    platformModel: model("flock-ai-ambient", "@flock/auto"),
+    platformModel: model("flock-ai-ambient", "@frock/auto"),
   };
 }
 
@@ -194,7 +194,7 @@ function host(storage: MemoryStorage, readUser: () => UserSettingsViewV1) {
       },
       MEMORY_FILES: {},
       MEMORY_INDEX: {},
-      FLOCK_AI: {
+      FROCK_AI: {
         autoRoute: "flock-auto",
         runChatCompletion: () =>
           Promise.resolve(
@@ -527,7 +527,7 @@ describe("generic per-Turn model resolution", () => {
       connectionId: "flock-ai-ambient",
       packageId: "provider-flock-ai",
       provider: "flock-ai",
-      providerModelId: "@flock/auto",
+      providerModelId: "@frock/auto",
       connectionGeneration: "foundation-generation-1",
       catalogGeneration: "catalog-1",
     });
@@ -651,7 +651,7 @@ describe("generic per-Turn model resolution", () => {
       ),
     };
     expect(await contribution.resolveConfiguration(identity)).toMatchObject({
-      model: model("flock-ai-ambient", "@flock/auto"),
+      model: model("flock-ai-ambient", "@frock/auto"),
     });
     expect(await contribution.getSettings(identity)).toMatchObject({
       packageValues: {
@@ -701,16 +701,18 @@ describe("generic per-Turn model resolution", () => {
     };
     for (const bot of bots) {
       const runId = `${bot.botId}-disabled-package`;
-      await expect(
-        bot.contribution.run({
-          userId: "user-1",
-          botId: bot.botId,
-          runId,
-          sessionId: `user-1:${bot.botId}`,
-          acceptedAt: "2026-09-02T00:01:00.000Z",
-          text: "must fail",
-        }),
-      ).rejects.toThrow("Turn this model's plugin back on in Plugins");
+      // "Closed" is the durable record, not a rejected call. The Turn settles
+      // itself and the caller is handed that settlement: rethrowing over the
+      // top of it is what answered 500 and logged an uncaught error for a
+      // failure the Bot had already recorded properly.
+      await bot.contribution.run({
+        userId: "user-1",
+        botId: bot.botId,
+        runId,
+        sessionId: `user-1:${bot.botId}`,
+        acceptedAt: "2026-09-02T00:01:00.000Z",
+        text: "must fail",
+      });
       expect(await bot.storage.get(`run:${runId}`)).toMatchObject({
         status: "failed",
         failure: expect.stringContaining(
@@ -723,16 +725,14 @@ describe("generic per-Turn model resolution", () => {
     user.connections[0] = { ...user.connections[0]!, state: "revoked" };
     for (const bot of bots) {
       const runId = `${bot.botId}-revoked-connection`;
-      await expect(
-        bot.contribution.run({
-          userId: "user-1",
-          botId: bot.botId,
-          runId,
-          sessionId: `user-1:${bot.botId}`,
-          acceptedAt: "2026-09-02T00:02:00.000Z",
-          text: "must fail",
-        }),
-      ).rejects.toThrow("needs reconnecting");
+      await bot.contribution.run({
+        userId: "user-1",
+        botId: bot.botId,
+        runId,
+        sessionId: `user-1:${bot.botId}`,
+        acceptedAt: "2026-09-02T00:02:00.000Z",
+        text: "must fail",
+      });
       expect(await bot.storage.get(`run:${runId}`)).toMatchObject({
         status: "failed",
         failure: expect.stringContaining("needs reconnecting"),

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

@@ -344,16 +344,16 @@ describe("Bot recovery", () => {
     };
 
     failRequests = true;
-    await expect(
-      host().run({
-        userId: "user-1",
-        botId: "primary",
-        runId: "ollama-run-uncertain",
-        sessionId: "user-1:primary",
-        acceptedAt: "2026-08-30T00:02:00.000Z",
-        text: "uncertain",
-      }),
-    ).rejects.toThrow("response lost");
+    // The call resolves: the Turn settled itself, and the caller is handed
+    // that settlement rather than a rejection thrown over the top of it.
+    await host().run({
+      userId: "user-1",
+      botId: "primary",
+      runId: "ollama-run-uncertain",
+      sessionId: "user-1:primary",
+      acceptedAt: "2026-08-30T00:02:00.000Z",
+      text: "uncertain",
+    });
     // Ollama keeps no addressable copy of a completion, so a failure raised
     // before the first stream event is definitive rather than uncertain: the
     // run settles as a failed Turn instead of parking on a retrieval this

package/src/backend-runner.ts

@@ -17,6 +17,10 @@ import {
   BotTurnRecoveryRequiredError,
 } from "@frockbot/kernel-do";
 import type { BotTurnCommand, BotTurnCompletion } from "./backend-contracts.js";
+import {
+  compactionInFlightV1,
+  whenCompactionSettledV1,
+} from "./compaction-scheduler.js";
 
 export {
   BotTurnExecutionError,
@@ -370,11 +374,24 @@ export async function executeBotTurn(
     await runtime.agent.agent.whenIdle();
     return settleBotTurn(runtime.agent, command, previousEvents);
   } catch (error) {
-    turnExecutionError(error, previousEvents, [
+    return turnExecutionError(error, previousEvents, [
       ...runtime.agent.agent.session.events,
     ]);
   } finally {
-    await composition.dispose();
+    // ADR 0030: a compaction outlives the Turn that triggered it, and it runs
+    // on this Composition's model binding — so the Composition outlives the
+    // Turn too, and only by as long as the compaction does. Awaiting the
+    // disposal here would put the summariser back in the latency path, which
+    // is the whole defect. The next admission aborts anything still running,
+    // so this can never stack up.
+    if (compactionInFlightV1(command.sessionId)) {
+      void whenCompactionSettledV1(command.sessionId).then(
+        () => composition.dispose(),
+        () => composition.dispose(),
+      );
+    } else {
+      await composition.dispose();
+    }
   }
 }