@frockbot/plugin-shell 0.3.16 → 0.3.18

package/src/history.ts

@@ -175,7 +175,10 @@ export function chatWindowV1(
 ): ChatWindowV1 {
   const turns = messageTurnsV1(events);
   const types = turnTypesByTurnV1(events);
-  const chat = (turn: number) => (types.get(turn) ?? "chat") === "chat";
+  const chat = (turn: number) => {
+    const type = types.get(turn) ?? "chat";
+    return type === "chat" || type === "agent";
+  };
   const state = compactionStateV1(events);
   const current = currentTurnV1(events);
   // A compaction never covers the Turn being assembled, whatever the log says:
@@ -229,7 +232,10 @@ export function turnScopedMessagesV1(
   }
   const types = turnTypesByTurnV1(input.events);
   const current = currentTurnV1(input.events);
-  const chatTurn = (turn: number) => (types.get(turn) ?? "chat") === "chat";
+  const chatTurn = (turn: number) => {
+    const type = types.get(turn) ?? "chat";
+    return type === "chat" || type === "agent";
+  };
   if (chatTurn(current)) {
     const window = chatWindowV1(input.events, input.messages);
     // Tier 1 of ADR 0030, and the only one that costs nothing: a tool result

package/src/run-failure-copy.test.ts

@@ -1,3 +1,4 @@
+import { STEP_LIMIT_REASON_V1 } from "@frockbot/kernel-agent-loop";
 import { describe, expect, test } from "bun:test";
 import type { SessionEvent } from "@frockbot/kernel-contracts";
 import { MODEL_FIRST_BYTE_DEADLINE_REASON_V1 } from "@frockbot/kernel-contracts";
@@ -157,3 +158,13 @@ describe("runFailureCopyV1", () => {
     expect(projected.outcome.message).toBe(RUN_FAILURE_COPY_V1.interrupted);
   });
 });
+
+test("a reply that ran out of steps says so in plain words", () => {
+  // `kernel-do` wraps the loop's reason; the sentence survives the wrapper.
+  expect(
+    runFailureCopyV1({
+      failure: `Bot turn ended with outcome interrupted: ${STEP_LIMIT_REASON_V1}`,
+    }),
+  ).toBe(STEP_LIMIT_REASON_V1);
+  expect(knownFailureCopyV1(STEP_LIMIT_REASON_V1)).toBe(STEP_LIMIT_REASON_V1);
+});

package/src/run-failure-copy.ts

@@ -7,7 +7,10 @@ import {
   MODEL_FIRST_BYTE_DEADLINE_REASON_V1,
   MODEL_IDLE_DEADLINE_REASON_V1,
 } from "@frockbot/kernel-contracts";
-import { TURN_DEADLINE_REASON_V1 } from "@frockbot/kernel-agent-loop";
+import {
+  STEP_LIMIT_REASON_V1,
+  TURN_DEADLINE_REASON_V1,
+} from "@frockbot/kernel-agent-loop";
 import { UNRECONCILABLE_RUN_FAILURE_V1 } from "@frockbot/kernel-do";
 
 /**
@@ -47,6 +50,7 @@ export const USER_FACING_FAILURE_REASONS_V1: readonly string[] = [
   MODEL_FIRST_BYTE_DEADLINE_REASON_V1,
   MODEL_IDLE_DEADLINE_REASON_V1,
   TURN_DEADLINE_REASON_V1,
+  STEP_LIMIT_REASON_V1,
   UNRECONCILABLE_RUN_FAILURE_V1,
 ];
 

package/src/run-protocol.test.ts

@@ -24,6 +24,7 @@ import {
   projectClientRunLookupV1,
   projectClientRunListV1,
   projectClientRunV1,
+  isVisibleRunV1,
   projectClientRunOrDegradedV1,
   projectClientTurnV1,
   UNRECORDED_TOOL_RESULT_TEXT_V1,
@@ -88,6 +89,37 @@ function storedRun(
 }
 
 describe("client run protocol v1", () => {
+  test("projects an agent Turn with its Bot origin marker", () => {
+    const agent = {
+      ...storedRun([]),
+      admission: {
+        schemaVersion: 1 as const,
+        turnType: "agent" as const,
+        origin: {
+          kind: "bot" as const,
+          fromBotId: "researcher",
+          fromBotName: "Researcher",
+          messageId: "message-1",
+        },
+      },
+    };
+
+    expect(isVisibleRunV1(agent)).toBe(true);
+    const projected = projectClientRunV1(agent);
+    expect(projected).toMatchObject({
+      schemaVersion: 3,
+      input: "continue",
+      via: { kind: "bot", name: "Researcher", botId: "researcher" },
+    });
+    expect(
+      decodeClientRunListV1({
+        schemaVersion: 1,
+        runs: [projected],
+        page: { truncated: false },
+      })[0]?.via,
+    ).toEqual(projected.via);
+  });
+
   test("rejects durable runs missing current admission fields", () => {
     const complete = storedRun([], "running");
     for (const field of [
@@ -728,7 +760,7 @@ describe("client run protocol v1", () => {
       schemaVersion: 1,
       runs: [
         {
-          schemaVersion: 2,
+          schemaVersion: 3,
           runId: "run-1",
           admittedAt: timestamp,
           input: "continue",
@@ -977,9 +1009,8 @@ describe("client run protocol v1", () => {
       ]),
     );
 
-    // Version 2 is what carries the two new event types; a client pinned to 1
-    // still decodes the body it produces.
-    expect(projected.schemaVersion).toBe(2);
+    // Version 3 carries agent-origin markers; older bodies still decode.
+    expect(projected.schemaVersion).toBe(3);
     expect(projected.events).toEqual([
       { type: "send/to-user", payload: { type: "text", text: "On it." } },
       { type: "tool/call", call: { id: "tool-1", name: "lookup" } },
@@ -1614,3 +1645,41 @@ describe("dispatched subagents in the run projection", () => {
     );
   });
 });
+
+describe("Computer sync degradation in the run projection", () => {
+  const degraded: SessionEvent = {
+    type: "computer/sync",
+    seq: 4,
+    timestamp,
+    turn: 1,
+    reason: "open",
+    status: "degraded",
+    detail: "Excluded 2 reproducible Workspace items from sync.",
+    pulled: 0,
+    pushed: 1,
+    restored: 0,
+    removed: 0,
+    adopted: 0,
+    conflicts: 0,
+    failures: 0,
+    ignored: 2,
+    omitted: 0,
+  };
+
+  test("projects one plain-language event and round-trips it", () => {
+    const projected = projectClientRunV1(
+      storedRun([degraded, { ...degraded, seq: 5, reason: "turn-end" }]),
+    );
+    expect(projected.events).toEqual([
+      {
+        type: "computer/sync",
+        status: "degraded",
+        message: "Excluded 2 reproducible Workspace items from sync.",
+      },
+    ]);
+    const page = createClientRunListV1([projected], { truncated: false });
+    expect(
+      decodeClientRunPageV1(structuredClone(page)).runs[0]?.events,
+    ).toEqual(projected.events);
+  });
+});

package/src/run-protocol.ts

@@ -165,6 +165,11 @@ export type ClientRunEventV1 =
       type: "wake/parent";
       message: string;
     }
+  | {
+      type: "computer/sync";
+      status: "degraded" | "unavailable" | "refused" | "skipped";
+      message: string;
+    }
   /**
    * A subagent this Turn dispatched (ADR 0017). The child's Session never
    * enters the visible transcript, so this chip is the whole of what the
@@ -212,12 +217,12 @@ export interface ClientRunRecoveryV1 {
 }
 
 /**
- * The run projection. Version 2 adds `send/to-user` and `wake/parent` to
- * `events`; a version 1 body is a version 2 body that carries neither, so the
- * decoder accepts both and the projection emits 2.
+ * The run projection. Version 2 added structured `send/to-user` and
+ * `wake/parent` events; version 3 adds the bounded `via` marker for agent and
+ * Voice Turns without exposing the internal origin record.
  */
 export interface ClientRunV1 {
-  schemaVersion: 1 | 2;
+  schemaVersion: 1 | 2 | 3;
   runId: string;
   admittedAt: string;
   input: string;
@@ -241,6 +246,10 @@ export interface ClientRunV1 {
   partialText?: string;
   outcome?: ClientRunOutcomeV1;
   recovery?: ClientRunRecoveryV1;
+  /** Where an agent-lane question entered this Bot's transcript. */
+  via?:
+    | { kind: "bot"; name: string; botId: string }
+    | { kind: "voice"; name: "Voice" };
 }
 
 export interface ClientRunPageV1 {
@@ -624,6 +633,7 @@ function projectionUnits(
   const units: ProjectionUnitV1[] = [];
   const byOccurrence = new Map<string, ProjectionUnitV1>();
   let callCount = 0;
+  let projectedIncompleteSync = false;
   for (const event of events) {
     if (event.type === "tool/call") {
       if (byOccurrence.has(event.occurrenceId)) {
@@ -694,6 +704,22 @@ function projectionUnits(
         ],
         droppable: true,
       });
+    } else if (
+      event.type === "computer/sync" &&
+      event.status !== "ok" &&
+      !projectedIncompleteSync
+    ) {
+      projectedIncompleteSync = true;
+      units.push({
+        events: [
+          {
+            type: "computer/sync",
+            status: event.status,
+            message: computerSyncCopyV1(event),
+          },
+        ],
+        droppable: true,
+      });
     } else if (event.type === "task/dispatched") {
       units.push({
         events: [
@@ -736,6 +762,24 @@ function projectionUnits(
   return units;
 }
 
+function computerSyncCopyV1(
+  event: Extract<SessionEvent, { type: "computer/sync" }>,
+): string {
+  if (event.status === "degraded") {
+    return (
+      event.detail.trim() ||
+      "Some Workspace files did not sync during this turn."
+    );
+  }
+  if (event.status === "unavailable") {
+    return "Workspace files could not sync during this turn. Sync will retry the next time the Computer is used.";
+  }
+  if (event.status === "refused") {
+    return "Workspace sync could not run for this turn.";
+  }
+  return "Workspace sync was skipped for this turn.";
+}
+
 function visibleEvents(
   events: readonly SessionEvent[],
   status: ClientRunStatusV1,
@@ -876,10 +920,20 @@ export function projectClientRunV1(run: StoredRun): ClientRunV1 {
           message: RESUMABLE_RUN_MESSAGE_V1,
         } satisfies ClientRunRecoveryV1)
       : undefined;
+  const origin = run.admission?.origin;
+  const via =
+    origin?.kind === "bot"
+      ? {
+          kind: "bot" as const,
+          name: truncateWireString(origin.fromBotName, 100),
+          botId: truncate(origin.fromBotId, 128),
+        }
+      : origin?.kind === "voice"
+        ? { kind: "voice" as const, name: "Voice" as const }
+        : undefined;
   return {
-    // Version 2: the projection may now carry `send/to-user` and
-    // `wake/parent`. A client pinned to 1 keeps decoding a stored list.
-    schemaVersion: 2,
+    // Version 3 adds the origin marker for an agent-lane message.
+    schemaVersion: 3,
     runId: truncate(run.runId, MAX_RUN_ID_LENGTH),
     admittedAt: truncate(run.acceptedAt, MAX_TIMESTAMP_LENGTH),
     input: truncateWireString(run.input, MAX_INPUT_BYTES),
@@ -896,6 +950,7 @@ export function projectClientRunV1(run: StoredRun): ClientRunV1 {
       : {}),
     ...(outcome ? { outcome } : {}),
     ...(recovery ? { recovery } : {}),
+    ...(via ? { via } : {}),
   };
 }
 
@@ -921,7 +976,8 @@ function lookupState(
 export function isVisibleRunV1(run: {
   admission?: { turnType?: string };
 }): boolean {
-  return (run.admission?.turnType ?? "chat") === "chat";
+  const type = run.admission?.turnType ?? "chat";
+  return type === "chat" || type === "agent";
 }
 
 export function projectClientRunLookupV1(
@@ -1248,6 +1304,27 @@ function decodeEvent(value: unknown): ClientRunEventV1 {
       ),
     };
   }
+  if (event.type === "computer/sync") {
+    exactKeys(event, ["type", "status", "message"], "run event");
+    if (
+      event.status !== "degraded" &&
+      event.status !== "unavailable" &&
+      event.status !== "refused" &&
+      event.status !== "skipped"
+    ) {
+      throw new Error("run event.status is invalid");
+    }
+    return {
+      type: "computer/sync",
+      status: event.status,
+      message: wireString(
+        event,
+        "message",
+        MAX_EVENT_CONTENT_BYTES,
+        "run event",
+      ),
+    };
+  }
   if (event.type === "task/dispatched") {
     exactKeys(
       event,
@@ -1299,12 +1376,13 @@ function decodeEvents(values: unknown[]): ClientTurnEvent[] {
   const callIds = new Set<string>();
   while (index < events.length) {
     const call = events[index];
-    // A send and a hand-off stand alone: they pair with nothing, so the
-    // call/result walk steps straight over them.
+    // Sends, hand-offs, task chips, and sync notices stand alone: they pair
+    // with nothing, so the call/result walk steps straight over them.
     if (
       call?.type === "send/to-user" ||
       call?.type === "wake/parent" ||
-      call?.type === "task/dispatched"
+      call?.type === "task/dispatched" ||
+      call?.type === "computer/sync"
     ) {
       index += 1;
       continue;
@@ -1429,14 +1507,41 @@ function decodeRun(value: unknown): ClientRun {
       "partialText",
       "outcome",
       "recovery",
+      "via",
     ],
     "run",
   );
   // 1 and 2 differ only by the event types a version 2 body may carry, and a
   // version 1 body carries a subset of them, so one walk decodes both.
-  if (run.schemaVersion !== 1 && run.schemaVersion !== 2) {
+  if (
+    run.schemaVersion !== 1 &&
+    run.schemaVersion !== 2 &&
+    run.schemaVersion !== 3
+  ) {
     throw new Error("run.schemaVersion is invalid");
   }
+  let via: ClientRunV1["via"];
+  if (run.via !== undefined) {
+    if (run.schemaVersion !== 3) {
+      throw new Error("run.via requires schemaVersion 3");
+    }
+    const candidate = record(run.via, "run.via");
+    if (candidate.kind === "bot") {
+      exactKeys(candidate, ["kind", "name", "botId"], "run.via");
+      via = {
+        kind: "bot",
+        name: wireString(candidate, "name", 100, "run.via"),
+        botId: string(candidate, "botId", 128, "run.via"),
+      };
+    } else if (candidate.kind === "voice") {
+      exactKeys(candidate, ["kind", "name"], "run.via");
+      if (candidate.name !== "Voice")
+        throw new Error("run.via.name is invalid");
+      via = { kind: "voice", name: "Voice" };
+    } else {
+      throw new Error("run.via.kind is invalid");
+    }
+  }
   let runId: string;
   try {
     runId = decodeRunIdV1(string(run, "runId", MAX_RUN_ID_LENGTH, "run"));
@@ -1507,6 +1612,7 @@ function decodeRun(value: unknown): ClientRun {
         }
       : {}),
     ...(recovery ? { failure: recovery.message, recovery } : {}),
+    ...(via ? { via } : {}),
   };
 }
 

package/src/shared.ts

@@ -98,6 +98,9 @@ export interface WebChatMessage {
     | "error"
     | "interrupted"
     | "reconciliation-required";
+  via?:
+    | { kind: "bot"; name: string; botId: string }
+    | { kind: "voice"; name: "Voice" };
   /**
    * True while this line's Turn is admitted but has not started, because the
    * User sent it while the Bot was still on the previous one. The thread