privateer-agent 0.15.3 → 0.15.5

package/src/config/moatManifest.json

@@ -26,6 +26,7 @@
     { "entry": "extensions/privateer-update.ts", "name": "privateer-update", "note": "tool pack updates in place — banner flag + /update" },
     { "entry": "extensions/privateer-truncation.ts", "name": "privateer-truncation", "note": "picks the task back up when a reply is cut off at the output limit" },
     { "entry": "extensions/privateer-fresh.ts", "name": "privateer-fresh", "note": "/fresh — replace the agent with a new one and stop everything it started" },
+    { "entry": "extensions/privateer-recovery.ts", "name": "privateer-recovery", "note": "crash recovery — the live marker the supervisor resumes from, the note that tells the model its last action may have half-run, and session-sealing warnings" },
     { "entry": "extensions/privateer-speak.ts", "name": "privateer-speak", "note": "spoken responses (/speak) + voice input (/talk) — pi-speak + confidential account TTS/STT" },
     { "entry": "extensions/privateer-web.ts", "name": "privateer-web", "note": "web_search/web_fetch — account search when signed in, else the user's own provider (rpiv-web-tools); crypto_lookup — account market data, in both cases" },
     { "dep": ["@juicesharp/rpiv-ask-user-question", "index.ts"], "name": "rpiv-ask-user-question", "note": "ask_user_question" },

package/src/config/whatsNew.json

@@ -1,10 +1,10 @@
 {
   "$comment": "The banner's What's New list, newest first: the two to four things a returning user should notice, not a changelog. `reviewedFor` is the release this list was last looked at for. A release can't ship until it equals package.json's version (scripts/check-whats-new.mjs, run by `npm test` and by release.yml before anything builds), so every release, patches included, is a deliberate look at this list. If nothing new is worth a line, bumping `reviewedFor` alone is the answer. `since` is the release an entry arrived in. `cmd` is shown in the accent colour.",
-  "reviewedFor": "0.15.3",
+  "reviewedFor": "0.15.5",
   "items": [
+    { "text": "If the agent crashes mid-task it comes back into your session, and saved sessions are now encrypted on disk", "since": "0.15.5" },
+    { "text": "Slow images, speech and music run as background jobs — a dropped connection no longer loses a paid result", "since": "0.15.4" },
     { "text": "Driving from the app: a message sent mid-turn steers it, and questions survive a dropped link", "since": "0.15.1" },
-    { "text": "MCP on Pi's built-in support — sign OAuth connectors back in with", "cmd": "/mcp", "since": "0.15.0" },
-    { "text": "Sub-agents are back: hand work to bounded parallel agents", "since": "0.15.0" },
-    { "text": "API keys can expire and carry their own credit limit — set them in the app", "since": "0.14.6" }
+    { "text": "MCP on Pi's built-in support — sign OAuth connectors back in with", "cmd": "/mcp", "since": "0.15.0" }
   ]
 }

package/src/permissions/classify.ts

@@ -234,6 +234,14 @@ const MEDIA_TITLES: Record<string, string> = {
 // rather than their names (see `resuming` below).
 const RESUME_VIDEO_TITLE = "Save a video already generated (nothing further is billed)";
 const RESUME_SPRITE_TITLE = "Save a sprite animation already generated (nothing further is billed)";
+const RESUME_TITLES: Record<string, string> = {
+  generate_video: RESUME_VIDEO_TITLE,
+  generate_sprite: RESUME_SPRITE_TITLE,
+  generate_image: "Save an image already generated (nothing further is billed)",
+  generate_speech: "Save speech already generated (nothing further is billed)",
+  generate_music: "Save music already generated (nothing further is billed)",
+  generate_sfx: "Save a sound effect already generated (nothing further is billed)",
+};
 
 // Pi's MCP resource tools (core/mcp-servers.js). They list and read resources from
 // every connected server — network reads from connectors the user configured.
@@ -533,11 +541,10 @@ export function classifyToolCall(
     // cheaper path than re-generating. Getting that backwards is what teaches a model
     // to pay twice — and it costs the most on a sprite, where the alternative to a
     // resume is a whole second fan-out of up to five video generations.
-    const resumable = name === "generate_video" || name === "generate_sprite";
+    // Image, speech, music and sfx became deferred jobs too, so the same holds for them.
+    const resumable = RESUME_TITLES[name] !== undefined;
     const resuming = resumable && typeof obj.resumeJobId === "string" && !!obj.resumeJobId.trim();
-    const mediaTitle = resuming
-      ? (name === "generate_sprite" ? RESUME_SPRITE_TITLE : RESUME_VIDEO_TITLE)
-      : MEDIA_TITLES[name];
+    const mediaTitle = resuming ? RESUME_TITLES[name] : MEDIA_TITLES[name];
     const inputs = [
       ...(Array.isArray(obj.inputs) ? (obj.inputs as unknown[]).map(str) : []),
       str(obj.input),

package/src/remote/attentionPush.ts

@@ -0,0 +1,40 @@
+// "Your agent is asking you something" — a push to the account's phones when a
+// question (ask_user_question, a select, a text prompt) is put to an app that isn't
+// there to see it.
+//
+// A question sent up the relay only reaches a LIVE socket. A phone that backgrounded
+// a minute ago has none, so the question sat held on this machine (remoteBridge's
+// holdOpenQuestions) with nothing telling anyone it was waiting — the user found it
+// by chance, or after the hold ran out and the tool came back as an error.
+//
+// Content-free on purpose, like the Inbox nudge (server services/pushService.js): the
+// question itself never leaves the relay, so the push says only that one is waiting.
+// Fire-and-forget and throttled — a failed or skipped push must never touch the turn.
+
+const COOLDOWN_MS = 30_000;
+let lastAt = 0;
+let sink: (() => void) | null = null;
+
+export function requestAttentionPush(): void {
+  const now = Date.now();
+  if (now - lastAt < COOLDOWN_MS) return;
+  lastAt = now;
+  if (sink) return sink();
+  void (async () => {
+    try {
+      const { apiRequest, hasCredentials } = await import("../auth/privateer.ts");
+      if (!hasCredentials()) return;
+      await apiRequest("/api/push/attention", { method: "POST", signal: AbortSignal.timeout(10_000) });
+    } catch {
+      /* best effort — the question is still held and re-sent when the app comes back */
+    }
+  })();
+}
+
+/** Test seam: count pushes instead of sending them (null restores the real one), and
+ *  forget the cooldown. Tests run on machines that are signed in — without this a
+ *  bridge test would buzz the developer's phone. */
+export function setAttentionPushSink(fn: (() => void) | null): void {
+  sink = fn;
+  lastAt = 0;
+}

package/src/remote/liveTaskSession.ts

@@ -25,6 +25,7 @@ import { rememberAccountCredential, persistAccountCredential, dropPersistedAccou
 import { modelRegistryOf } from "../providers/piAuthStore.ts";
 import { RelayClient, type TaskSpec } from "./relayClient.ts";
 import { RemoteBridge } from "./remoteBridge.ts";
+import { transcriptSnapshot, type SnapshotEntry } from "./transcriptSnapshot.ts";
 import { AttachmentStore, type StoredAttachment } from "../util/attachmentStore.ts";
 import { spawnAccountCredentials, revokeAccountSession } from "../auth/privateer.ts";
 import { createUIContext } from "../ext/headlessUi.ts";
@@ -190,7 +191,12 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
     onControllerAttached: () => {
       attached = true;
       if (attachTimer) { clearTimeout(attachTimer); attachTimer = undefined; }
-      relay?.sendSnapshot([]);
+      // The session's transcript, so an app back from sleep catches up (transcriptSnapshot.ts).
+      {
+        let entries: SnapshotEntry[] = [];
+        try { entries = transcriptSnapshot(session?.sessionManager?.getBranch?.() ?? []); } catch { /* no session yet */ }
+        relay?.sendSnapshot(entries, { full: entries.length > 0, running: turnActive });
+      }
       // cwd rides along here (and nowhere else — see RelayClient.sendContext): this
       // session's working directory was either named by the driver in the spawn form
       // or defaulted to the harbor's own, and they have no other way to see which.

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;
+}