privateer-agent 0.15.4 → 0.15.5

package/src/remote/relayClient.ts

@@ -24,6 +24,7 @@ import type { EngineEvent } from "../engine/events.ts";
 import type { PermissionRequest } from "../permissions/gate.ts";
 import { noQuarterActive } from "../permissions/noQuarter.ts";
 import { authorizeControl } from "./controlAuth.ts";
+import type { SnapshotTool } from "./transcriptSnapshot.ts";
 import { CARGO_CHUNK_CHARS, type CargoSaveRequest, type CargoSaveResult } from "./cargoSave.ts";
 import {
   LIBRARY_CHUNK_CHARS,
@@ -1175,10 +1176,43 @@ export class RelayClient {
 
   // Catch-up history sent to a controller on attach. Structured (not markdown) so
   // the app renders it with the same styling as the live feed. Bounded: last 80
-  // entries, each clipped.
-  sendSnapshot(entries: { kind: string; text: string }[]): void {
-    const trimmed = entries.slice(-80).map((e) => ({ kind: e.kind, text: safe(String(e.text ?? ""), 4000) }));
-    this.rawSend({ type: "snapshot", entries: trimmed });
+  // entries, each clipped, and the whole frame kept well under the relay's 256 KB
+  // frame cap by dropping the OLDEST entries first.
+  //
+  // `full` marks the entries as the terminal's whole current transcript (see
+  // transcriptSnapshot.ts), so the app may REPLACE what it holds rather than only
+  // adopting into an empty feed; `running` says whether a turn is still going, which
+  // is how a reattaching app learns that the turn it last saw "Link dropped" on is
+  // over. Both absent = the old notice-only snapshot, which the app keeps treating as
+  // such.
+  sendSnapshot(
+    entries: { kind: string; text: string; tool?: SnapshotTool }[],
+    meta?: { full?: boolean; running?: boolean },
+  ): void {
+    const out: Record<string, unknown>[] = [];
+    let budget = 160 * 1024;
+    for (const e of entries.slice(-80).reverse()) {
+      const t = e.tool;
+      const entry: Record<string, unknown> = t
+        ? {
+            kind: e.kind,
+            text: "",
+            tool: {
+              id: t.id,
+              name: t.name,
+              input: safe(t.input, 500),
+              ...(t.output !== undefined ? { output: safe(t.output, 1500) } : {}),
+              ...(t.error !== undefined ? { error: safe(t.error, 1000) } : {}),
+              ...(t.running ? { running: true } : {}),
+            },
+          }
+        : { kind: e.kind, text: safe(String(e.text ?? ""), e.kind === "reasoning" ? 1500 : 4000) };
+      budget -= JSON.stringify(entry).length;
+      if (budget < 0) break;
+      out.push(entry);
+    }
+    out.reverse();
+    this.rawSend({ type: "snapshot", entries: out, ...(meta?.full ? { full: true, running: meta.running === true } : {}) });
   }
 
   // ── agent → app file transfer (chunked) ─────────────────────────────────────

package/src/remote/remoteBridge.ts

@@ -20,6 +20,7 @@ import { redactText } from "../util/redact.ts";
 import type { PermissionRequest } from "../permissions/gate.ts";
 import type { AskOutcome } from "../permissions/modeGate.ts";
 import type { RelayCallbacks } from "./relayClient.ts";
+import { requestAttentionPush } from "./attentionPush.ts";
 import type { CargoSaveRequest, CargoSaveResult } from "./cargoSave.ts";
 import type { LibrarySaveRequest, LibrarySaveResult } from "./librarySave.ts";
 import type { ChartOpRequest, ChartOpResult } from "./chartOps.ts";
@@ -168,6 +169,10 @@ export interface RemoteBridgeConfig {
   onFilesSearch?: (id: string, query: string) => void;
   // A controller (re)attached — the owner should push a transcript snapshot.
   onControllerAttached?: () => void;
+  // A question is open and no app is attached to see it. Defaults to a content-free
+  // push to the account's phones (attentionPush.ts); a test or an owner with its own
+  // channel may replace it.
+  onQuestionUnwatched?: () => void;
   // The last controller went away. Informational for the owner (the bridge already
   // fails pending approvals closed); a driven turn in flight keeps running.
   onControllerDetached?: () => void;
@@ -380,6 +385,7 @@ export class RemoteBridge {
       this.remote = false;
       this.rejectAllPending();
       this.holdOpenQuestions();
+      if (this.hasOpenQuestion()) this.questionUnwatched();
       this.cfg.onControllerDetached?.();
     },
     onAttachment: (file) => {
@@ -472,6 +478,9 @@ export class RemoteBridge {
         signal.addEventListener("abort", onAbort, { once: true });
       }
       this.relay!.requestSelect(id, req);
+      // Sent into a socket with no app on the other end: it is held and re-sent on
+      // reattach, but nobody knows to come back unless they are told.
+      if (this.relay!.hasController?.() === false) this.questionUnwatched();
     });
   };
 
@@ -495,6 +504,9 @@ export class RemoteBridge {
         signal.addEventListener("abort", onAbort, { once: true });
       }
       this.relay!.requestInput(id, req);
+      // Sent into a socket with no app on the other end: it is held and re-sent on
+      // reattach, but nobody knows to come back unless they are told.
+      if (this.relay!.hasController?.() === false) this.questionUnwatched();
     });
   };
 
@@ -711,6 +723,11 @@ export class RemoteBridge {
     return true;
   }
 
+  private questionUnwatched(): void {
+    if (this.cfg.onQuestionUnwatched) return this.cfg.onQuestionUnwatched();
+    requestAttentionPush();
+  }
+
   private resendOpenQuestions(): void {
     this.releaseQuestionGrace();
     for (const [id, q] of this.pendingSelects) this.relay?.requestSelect(id, q.req);

package/src/remote/transcriptSnapshot.ts

@@ -0,0 +1,104 @@
+// The catch-up transcript a controller gets when it (re)attaches.
+//
+// The app used to get a single "Privateer terminal connected." notice here, and kept
+// whatever feed it already held. So a phone that slept through the end of a turn came
+// back to a transcript frozen at the moment its socket died — a "Link dropped" marker
+// and nothing after it — while the answer sat in the terminal's session. The session
+// IS the transcript: this projects its current branch into the same entry kinds the
+// live feed uses, so the app can replace its stale copy with the real one.
+//
+// Pure (no Pi import) so it can be tested against plain entry objects.
+
+export interface SnapshotTool {
+  id: string;
+  name: string;
+  input: string;
+  output?: string;
+  error?: string;
+  // No result in the session yet: the call is running right now (or the turn was cut
+  // off mid-call, which `running: false` on the frame tells the app to settle).
+  running?: boolean;
+}
+
+export interface SnapshotEntry {
+  kind: "you" | "assistant" | "reasoning" | "tool" | "notice";
+  text: string;
+  tool?: SnapshotTool;
+}
+
+function asText(v: unknown): string {
+  if (typeof v === "string") return v;
+  try {
+    return JSON.stringify(v) ?? "";
+  } catch {
+    return String(v);
+  }
+}
+
+function partsText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((p: any) => (p?.type === "text" ? String(p.text ?? "") : p?.type === "image" ? "[image]" : ""))
+    .join("");
+}
+
+/**
+ * Session entries (SessionManager.getBranch(), root → leaf) → feed entries, oldest
+ * first. Tool calls are paired with their results by id into one entry, the way the
+ * live feed settles a card in place. Entries that carry nothing a reader would see
+ * (model/thinking-level changes, labels, custom state) are skipped.
+ */
+export function transcriptSnapshot(entries: readonly any[]): SnapshotEntry[] {
+  const out: SnapshotEntry[] = [];
+  const toolAt = new Map<string, number>();
+  for (const e of entries) {
+    if (e?.type === "compaction") {
+      out.length = 0; // what came before is no longer the conversation the agent has
+      toolAt.clear();
+      out.push({ kind: "notice", text: "Earlier conversation was compacted." });
+      continue;
+    }
+    if (e?.type !== "message") continue;
+    const m = e.message;
+    switch (m?.role) {
+      case "user": {
+        const text = partsText(m.content).trim();
+        if (text) out.push({ kind: "you", text });
+        break;
+      }
+      case "assistant": {
+        for (const p of Array.isArray(m.content) ? m.content : []) {
+          if (p?.type === "text" && String(p.text ?? "").trim()) out.push({ kind: "assistant", text: String(p.text) });
+          else if (p?.type === "thinking" && !p.redacted && String(p.thinking ?? "").trim()) {
+            out.push({ kind: "reasoning", text: String(p.thinking) });
+          } else if (p?.type === "toolCall" && p.id) {
+            const input = asText(p.arguments ?? {});
+            toolAt.set(String(p.id), out.length);
+            out.push({
+              kind: "tool",
+              text: `▸ ${p.name}${input ? `  ${input}` : ""}`,
+              tool: { id: String(p.id), name: String(p.name ?? ""), input, running: true },
+            });
+          }
+        }
+        if (m.stopReason === "error" && typeof m.errorMessage === "string" && m.errorMessage) {
+          out.push({ kind: "notice", text: `⚠ ${m.errorMessage}` });
+        }
+        break;
+      }
+      case "toolResult": {
+        const at = toolAt.get(String(m.toolCallId));
+        const text = partsText(m.content);
+        if (at === undefined) break; // a result whose call was compacted away
+        const entry = out[at];
+        const tool = { ...entry.tool!, running: false };
+        if (m.isError) tool.error = text;
+        else tool.output = text;
+        out[at] = { ...entry, text: `${entry.text}\n  ↳ ${text}`, tool };
+        break;
+      }
+    }
+  }
+  return out;
+}