@farmslot/protocol 0.74.4 → 0.74.5

package/CHANGELOG.md

@@ -6,6 +6,18 @@ All notable changes to `@farmslot/protocol` are tracked here.
 
 - Active-development baseline; add user-facing changes here before release or package publication.
 
+## 0.74.5 - 2026-10-31
+
+- `nativeSendLabel` gives a native composer's send action for a session state: "Send" when idle, "Queue message" for the next turn while a turn runs or waits on a request, none when the session takes no input. `nativeHistoryCanSend` is the held-data rule for sending a message: current, complete history of the conversation on screen (same generation, worker lease and task scope, not released), without `nativeHistoryCanAct`'s requirement that it be the exact snapshot on screen, so a newer read landing while a turn streams does not refuse a queued message.
+- `RunEngineState.taskInit` records whether a run's task still waits for node initialization after prepare (`pending`) or is `initialized`.
+- `NativeSessionEvent.tool` is `NativeSessionTool`, with optional `kind` (`NativeToolKind`: `command`, `file-edit`, `file-read`, `search`, `web`, `other`), `command` and `paths` set by the runner adapter. `nativeToolLabel` reads a tool call as "Run npm test", "Change a.ts, b.ts", "Read a.ts" or "Search src", or the runner's name; native timeline entries and `nativeWorkLabel` use it. `nativeCommandText` gives a command card's text: the command's first line and its last 10 output lines, cleaned as the terminal screen cleans them. `stripTerminalControls`, `terminalLinesFromText` and `terminalTailLinesFromText` move into the client cache from Companion; `stripTerminalControls` ends an OSC sequence at its own terminator, so a terminal hyperlink (OSC 8) keeps its text.
+- `NativeSessionEvent.response`, optional, on `approval.resolved`: the response the host delivered for the request (`decision` or `answers`); absent when the host did not deliver one. `nativeTimeline` keeps each resolved request as a `resolution` entry, "Approved: …", "Declined: …", "Answered: question → answer" or "Resolved: …". Cached native history keeps them, and a snapshot saved by an older reader is read again from its start, once.
+- `FamilyObservabilitySnapshot.latestRunId` is optional: a reference-only eval family has no runs yet.
+- `nativeTimelineRows` adds a summary row for each finished turn's tool calls ("Worked for 4m 12s · 6 tools", "Stopped after …", "Failed after …") just before the turn's end, and marks those tools with it; tools keep their keys, and messages, statuses and a running turn stay as they are. A turn also ends where its host stopped (`session.closed`). `nativeWatchTools` and `nativeFoldWatched` decide that a turn seen running in a live read starts open.
+- `nativeWork` finds the turn a native session is running, when it started and its current tool; `nativeWorkLabel` gives "Working · 1m 12s · Bash". Cached native history keeps the running turn's `turn.started`, which it dropped before as not a timeline entry.
+- `nativeMessagePreview` gives the first 8 lines (at most 600 characters) of a native conversation message over 12 lines or 900 characters, with its line count; `nativeEntryPreview` applies it to user messages only, and `nativeMessageToggleLabel` gives the "Show all · N lines" or "Show less" label.
+- `NativeFollow`, `NATIVE_FOLLOW_LATEST`, `nativeFollowScrolled`, `nativeFollowGrew` and `nativeFollowLabel` track whether a native conversation reader follows new output and how many entries arrived while they read further up.
+
 ## 0.74.4 - 2026-10-30
 
 - `buildGatewayPairingLink` turns a pairing QR payload into a Companion pair link (`farmslot://pair?payload=…`, or `farmslot-preview://` and `farmslot-development://` for those builds), encoded so it passes through `adb shell am start -d` unchanged.

package/dist/client-cache/index.d.ts

@@ -11,6 +11,7 @@ export * from './prefetch.js';
 export * from './registry.js';
 export { RUN_LIST_COLLECTION_ID, type RunListCollectionData } from './run-list-versions.js';
 export * from './store.js';
+export * from './terminal-text.js';
 export { createResourceCacheTransport, type ResourceClientConnection, type ResourceConnectionInputs, } from './transport.js';
 export * from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/client-cache/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client-cache/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC5F,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,4BAA4B,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AACxB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client-cache/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC5F,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EACL,4BAA4B,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/client-cache/index.js

@@ -11,6 +11,7 @@ export * from './prefetch.js';
 export * from './registry.js';
 export { RUN_LIST_COLLECTION_ID } from './run-list-versions.js';
 export * from './store.js';
+export * from './terminal-text.js';
 export { createResourceCacheTransport, } from './transport.js';
 export * from './types.js';
 //# sourceMappingURL=index.js.map

package/dist/client-cache/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client-cache/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAA8B,MAAM,wBAAwB,CAAC;AAC5F,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,4BAA4B,GAG7B,MAAM,gBAAgB,CAAC;AACxB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client-cache/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAA8B,MAAM,wBAAwB,CAAC;AAC5F,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EACL,4BAA4B,GAG7B,MAAM,gBAAgB,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/client-cache/native-history.d.ts

@@ -1,9 +1,9 @@
-import type { NativeCommandReceipt, NativeSessionEvent, NativeSessionReadResult, NativeSessionTargetParams } from '../rpc/native-session.js';
+import type { NativeCommandReceipt, NativeSessionEvent, NativeSessionReadResult, NativeSessionTargetParams, NativeSessionTool } from '../rpc/native-session.js';
 import { type ResourceQuery } from './registry.js';
 import type { ResourceQueryState, ResourceReadResult } from './types.js';
 export interface NativeTimelineEntry {
     key: number;
-    kind: 'user' | 'assistant' | 'tool' | 'status';
+    kind: 'user' | 'assistant' | 'tool' | 'resolution' | 'status';
     event: NativeSessionEvent;
     text: string;
 }
@@ -13,6 +13,7 @@ export interface NativeHistorySnapshot extends NativeSessionReadResult {
     historyRead: {
         pageReadCount: number;
         pageAfters: number[];
+        projection?: number;
     };
 }
 export declare const NATIVE_HISTORY_MESSAGES = 200;
@@ -58,9 +59,13 @@ export declare function nativeHistoryParams(value: unknown): NativeSessionTarget
 export declare function nativeHistoryStorageId(query: Pick<ResourceQuery, 'id' | 'method' | 'params'>): string;
 export declare function storedNativeHistoryMatches(target: NativeSessionTargetParams, value: unknown): value is NativeSessionReadResult;
 /**
- * The shared held-data action rule, for the exact history snapshot on screen. Native actions do
- * not reread first, so history restored from storage (no read stamp) waits for a live read.
+ * Sending a message: current, complete history of the conversation on screen. A newer read of it,
+ * landing while a turn streams, does not refuse the message; a resumed generation, another worker
+ * lease or a released task scope does. Native actions do not reread first, so history restored from
+ * storage (no read stamp) waits for a live read.
  */
+export declare function nativeHistoryCanSend(observation: ResourceQueryState<NativeSessionReadResult> | undefined, rendered: NativeSessionReadResult | undefined, connected: boolean, now?: number): boolean;
+/** An answer or stop acts on the exact history snapshot on screen. */
 export declare function nativeHistoryCanAct(observation: ResourceQueryState<NativeSessionReadResult> | undefined, rendered: NativeSessionReadResult | undefined, connected: boolean, now?: number): boolean;
 export interface NativeTranscript {
     events: NativeSessionEvent[];
@@ -68,10 +73,95 @@ export interface NativeTranscript {
 }
 /** Page sequence is authoritative. Ignore repeats; reject a gap rather than hide missing history. */
 export declare function appendNativePage(previous: NativeTranscript, page: NativeSessionReadResult): NativeTranscript;
+/**
+ * The composer's send action for a session in this state: "Send" when it is idle, "Queue message"
+ * for the next turn while a turn runs or waits on a request. Undefined: it takes no input now.
+ */
+export declare function nativeSendLabel(state: NativeSessionReadResult['session']['state'] | undefined): 'Send' | 'Queue message' | undefined;
 export declare function nativeDeliveryLabel(receipt?: NativeCommandReceipt): string;
 /** A confirmed replacement generation must not inherit the old browser input lock. */
 export declare function nativeCommandLockSettled(command: {
     commandId: string;
     generation: string;
 }, currentGeneration: string, receipt?: NativeCommandReceipt, events?: NativeSessionEvent[]): boolean;
+export interface NativeFollow {
+    /** The reader is at the end, so new output stays in view. */
+    following: boolean;
+    /** Timeline entries added while the reader was away from the end. */
+    unseen: number;
+}
+/** Opening a conversation, or jumping to its latest entry, follows again. */
+export declare const NATIVE_FOLLOW_LATEST: NativeFollow;
+/** The reader scrolled. Back at the end means caught up. */
+export declare function nativeFollowScrolled(state: NativeFollow, distanceFromEnd: number): NativeFollow;
+/** Entries arrived. A reader away from the end has that many more to catch up on. */
+export declare function nativeFollowGrew(state: NativeFollow, added: number): NativeFollow;
+/** The jump control's label, or none while the reader follows. */
+export declare function nativeFollowLabel(state: NativeFollow): string | undefined;
+export interface NativeMessagePreview {
+    text: string;
+    lines: number;
+}
+/** A long message (a worker's dispatch prompt) shows its start until the reader expands it. */
+export declare function nativeMessagePreview(text: string): NativeMessagePreview | undefined;
+/** Only the reader's own messages collapse; assistant, tool and status entries show in full. */
+export declare function nativeEntryPreview(entry: NativeTimelineEntry): NativeMessagePreview | undefined;
+export declare function nativeMessageToggleLabel(preview: NativeMessagePreview, expanded: boolean): string;
+export interface NativeWork {
+    /** When the open turn started, in ms. */
+    since: number;
+    /** The tool the turn is running now. */
+    tool?: string;
+}
+/** The turn in progress, if any: when it started and the tool it is running now. */
+export declare function nativeWork(events: NativeSessionEvent[]): NativeWork | undefined;
+/**
+ * "Working · 1m 12s · Bash": how long the turn has run, and its current tool.
+ * `since` is the execution host's clock: a client clock ahead of it overstates the time by the skew.
+ */
+export declare function nativeWorkLabel(work: NativeWork, now: number): string;
+/**
+ * A tool call as a reader reads it: "Run npm test", "Change a.ts, b.ts", "Read a.ts", "Search src",
+ * at most 120 characters before an ellipsis. A tool whose adapter gave no kind or subject keeps the
+ * runner's own name.
+ */
+export declare function nativeToolLabel(tool: NativeSessionTool | undefined): string;
+/**
+ * A command card's text: "$ npm test", then the last 10 lines it printed, with "… 12 earlier lines"
+ * above them; its raw input and output stay one tap away. Undefined for any other tool, whose card
+ * shows its raw input and output.
+ */
+export declare function nativeCommandText(tool: NativeSessionTool | undefined): string | undefined;
+export type NativeTimelineRow = 
+/** `fold`: the summary row that hides this tool while folded. */
+{
+    kind: 'entry';
+    key: number;
+    entry: NativeTimelineEntry;
+    fold?: number;
+}
+/** Keyed by the entry that ended its turn; `tools` are the keys it hides. */
+ | {
+    kind: 'work';
+    key: number;
+    label: string;
+    tools: number[];
+};
+/**
+ * The timeline with a summary row for each finished turn's tool calls, "Worked for 4m 12s ·
+ * 6 tools", just before the turn's end, and those tools marked with it. Nothing moves when a
+ * turn finishes: the tools keep their place and their keys, and the row is added below them.
+ * A turn ends at `turn.completed`, or at `session.closed` when its host stopped mid-turn.
+ * Messages and statuses stay; a running turn has no summary.
+ */
+export declare function nativeTimelineRows(entries: NativeTimelineEntry[]): NativeTimelineRow[];
+/**
+ * Tools shown running in a live read here. A turn the reader watched starts open when it
+ * finishes, so its tools don't fold away under them. A stored snapshot is not live: a turn that
+ * finished while the reader was away starts folded.
+ */
+export declare function nativeWatchTools(rows: NativeTimelineRow[], watched: Set<number>, live: boolean): void;
+export declare function nativeFoldWatched(row: Extract<NativeTimelineRow, {
+    kind: 'work';
+}>, watched: ReadonlySet<number>): boolean;
 //# sourceMappingURL=native-history.d.ts.map

package/dist/client-cache/native-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-history.d.ts","sourceRoot":"","sources":["../../src/client-cache/native-history.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"native-history.d.ts","sourceRoot":"","sources":["../../src/client-cache/native-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EAEvB,yBAAyB,EACzB,iBAAiB,EAElB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAAE,KAAK,aAAa,EAA0C,MAAM,eAAe,CAAC;AAE3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEzE,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,CAAC;IAC9D,KAAK,EAAE,kBAAkB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,mBAAmB,EAAE,CAqFlF;AA4BD,wEAAwE;AACxE,MAAM,WAAW,qBAAsB,SAAQ,uBAAuB;IACpE,WAAW,EAAE;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnF;AAKD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,iFAAiF;AACjF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,yBAAyB,EACjC,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,qBAAqB,CAAC,CAMtC;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,CAAC,CAAC,CAElB;AAED,gGAAgG;AAChG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAwBvF;AAED,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,uBAAuB,EAC1B,CAAC,EAAE,uBAAuB,GACzB,OAAO,CAcT;AAmBD,MAAM,WAAW,mBAAmB;IAClC,CACE,MAAM,EAAE,yBAAyB,GAAG;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EACrE,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,kBAAkB,CAAC,uBAAuB,CAAC,CAAC,CAAC;CACzD;AASD;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,yBAAyB,EACjC,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAC,CA+EpD;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM;;;;;;;;;;;;;;IA4B7F;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAqB7E;AAED,mGAAmG;AACnG,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,CAAC,GACrD,MAAM,CAIR;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,yBAAyB,EACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAalC;AAgBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,GAAG,SAAS,EACpE,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,SAAS,EAAE,OAAO,EAClB,GAAG,SAAa,GACf,OAAO,CAOT;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,GAAG,SAAS,EACpE,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,SAAS,EAAE,OAAO,EAClB,GAAG,SAAa,GACf,OAAO,CAET;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qGAAqG;AACrG,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,uBAAuB,GAC5B,gBAAgB,CAYlB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,GAAG,SAAS,GAC7D,MAAM,GAAG,eAAe,GAAG,SAAS,CAItC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAgB1E;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,CACtC,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAClD,iBAAiB,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,MAAM,GAAE,kBAAkB,EAAO,GAChC,OAAO,CAcT;AAKD,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,SAAS,EAAE,OAAO,CAAC;IACnB,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,EAAE,YAA6C,CAAC;AAEjF,4DAA4D;AAC5D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,GAAG,YAAY,CAG/F;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAEjF;AAED,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAGzE;AAQD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,+FAA+F;AAC/F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAQnF;AAWD,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,GAAG,oBAAoB,GAAG,SAAS,CAE/F;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAGjG;AAED,MAAM,WAAW,UAAU;IACzB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAaD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,UAAU,GAAG,SAAS,CAU/E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAuBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAa3E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBzF;AAgCD,MAAM,MAAM,iBAAiB;AAC3B,iEAAiE;AAC/D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE;AAC3E,6EAA6E;GAC3E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,iBAAiB,EAAE,CA+CtF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,QAK9F;AAED,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACjD,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,OAAO,CAET"}

package/dist/client-cache/native-history.js

@@ -1,6 +1,7 @@
 import { Methods } from '../rpc/registry.js';
 import { canActOn } from './held-data.js';
 import { resourceQuery } from './registry.js';
+import { terminalLinesFromText } from './terminal-text.js';
 export function nativeTimeline(events) {
     const entries = [];
     const userCommands = new Set();
@@ -37,27 +38,40 @@ export function nativeTimeline(events) {
             if (previous) {
                 const completed = previous.event.type === 'tool.completed' ? previous.event : event;
                 const started = event.type === 'tool.started' ? event : previous.event;
+                // Keep the entry's sequence: cached history keeps only this merged event, and the next read
+                // keys the tool by it, so a card the reader opened stays the same card when it finishes.
                 previous.event = {
                     ...completed,
+                    sequence: previous.key,
                     tool: {
                         ...started.tool,
                         ...completed.tool,
                         name: started.tool?.name ?? completed.tool?.name ?? 'Tool',
                     },
                 };
+                // A runner can name the command or files only after the call started (Cursor does).
+                previous.text = nativeToolLabel(previous.event.tool);
             }
             else {
                 const entry = {
                     key: event.sequence,
                     kind: 'tool',
                     event,
-                    text: event.tool?.name ?? 'Tool',
+                    text: nativeToolLabel(event.tool),
                 };
                 entries.push(entry);
                 if (identity)
                     tools.set(identity, entry);
             }
         }
+        else if (event.type === 'approval.resolved' && event.request) {
+            entries.push({
+                key: event.sequence,
+                kind: 'resolution',
+                event,
+                text: nativeResolutionText(event.request, event.response),
+            });
+        }
         else if (['turn.completed', 'session.closed', 'error'].includes(event.type)) {
             entries.push({
                 key: event.sequence,
@@ -74,6 +88,30 @@ export function nativeTimeline(events) {
     }
     return entries;
 }
+/**
+ * "Approved: rm -r build", "Declined: …", "Answered: Which file? → a.ts", or "Resolved: …" when
+ * the host did not deliver the response (the runner resolved it), so the decision is unknown.
+ */
+function nativeResolutionText(request, response) {
+    const questions = request.questions ?? [];
+    const answered = questions.flatMap((question) => {
+        const answer = response?.answers?.[question.id];
+        return answer?.length ? [`${question.prompt} → ${answer.join(', ')}`] : [];
+    });
+    if (answered.length)
+        return `Answered: ${answered.join('; ')}`;
+    const subject = questions.length
+        ? questions.map((question) => question.prompt).join('; ')
+        : (request.detail ?? request.tool?.name ?? request.title);
+    const outcome = response?.decision === 'approve'
+        ? 'Approved'
+        : response?.decision === 'deny'
+            ? 'Declined'
+            : 'Resolved';
+    return `${outcome}: ${subject}`;
+}
+/** Bumped when retention keeps more: a snapshot saved by an older reader is read again from its start, once. */
+const NATIVE_HISTORY_PROJECTION = 3;
 export const NATIVE_HISTORY_MESSAGES = 200;
 export const NATIVE_HISTORY_SESSIONS = 10;
 /** One durable observation per opened session/binding, never per cursor page. */
@@ -99,10 +137,17 @@ export function retainNativeMessages(events) {
         .reverse()
         .filter((entry) => entry.kind !== 'status' || ++statuses <= NATIVE_HISTORY_MESSAGES)
         .reverse();
-    return retained.map((entry) => ({
+    const kept = retained.map((entry) => ({
         ...entry.event,
         ...(entry.kind === 'assistant' || entry.kind === 'user' ? { text: entry.text } : {}),
     }));
+    // A running turn's start is not a timeline entry, but its working time is counted from it.
+    // Appended: the timeline skips it and nativeWork compares sequences, so its place does not
+    // matter, and sorting would move tool cards that finished out of order.
+    const turn = nativeOpenTurn(events);
+    if (!turn || kept.some((item) => item.sequence === turn.sequence))
+        return kept;
+    return [...kept, turn];
 }
 export function sameNativeHistoryIdentity(a, b) {
     const identity = (page) => JSON.stringify([
@@ -142,11 +187,13 @@ function assertHistoryNotAborted(signal) {
  * Cursor drains remain read-only. Neither receipts nor pending intents are dispatched here.
  */
 export async function readNativeHistory(target, previous, request, signal) {
-    let retained = previous;
-    let cursor = previous?.cursor;
+    const previousRead = previous?.historyRead;
+    // Saved by a reader that dropped the running turn's start: keep its identity, reread its events.
+    const replay = previousRead !== undefined && previousRead.projection !== NATIVE_HISTORY_PROJECTION;
+    let retained = previous && replay ? { ...previous, events: [] } : previous;
+    let cursor = replay ? undefined : previous?.cursor;
     let stamp;
     let first = true;
-    const previousRead = previous?.historyRead;
     let pageReadCount = previousRead?.pageReadCount ?? 0;
     let pageAfters = previousRead?.pageAfters ?? [];
     for (let pages = 0; pages < 1000; pages++) {
@@ -202,7 +249,10 @@ export async function readNativeHistory(target, previous, request, signal) {
         cursor = page.cursor;
         if (!page.hasMore)
             return {
-                data: { ...retained, historyRead: { pageReadCount, pageAfters } },
+                data: {
+                    ...retained,
+                    historyRead: { pageReadCount, pageAfters, projection: NATIVE_HISTORY_PROJECTION },
+                },
                 resourceState: stamp,
             };
     }
@@ -276,16 +326,28 @@ export function storedNativeHistoryMatches(target, value) {
                 page.session.workerLeaseId === target.worker.leaseId &&
                 page.session.generation === target.worker.generation)));
 }
-/**
- * The shared held-data action rule, for the exact history snapshot on screen. Native actions do
- * not reread first, so history restored from storage (no read stamp) waits for a live read.
- */
-export function nativeHistoryCanAct(observation, rendered, connected, now = Date.now()) {
+/** Current, complete history under the shared held-data rule. */
+function nativeHistoryCurrent(observation, connected, now) {
     return (!!observation?.resourceState &&
         canActOn(observation, connected, now) &&
+        !!observation.data &&
+        !observation.data.hasMore);
+}
+/**
+ * Sending a message: current, complete history of the conversation on screen. A newer read of it,
+ * landing while a turn streams, does not refuse the message; a resumed generation, another worker
+ * lease or a released task scope does. Native actions do not reread first, so history restored from
+ * storage (no read stamp) waits for a live read.
+ */
+export function nativeHistoryCanSend(observation, rendered, connected, now = Date.now()) {
+    return (nativeHistoryCurrent(observation, connected, now) &&
         !!rendered &&
-        observation.data === rendered &&
-        !rendered.hasMore);
+        sameNativeHistoryIdentity(observation.data, rendered) &&
+        !observation.data.scope?.released);
+}
+/** An answer or stop acts on the exact history snapshot on screen. */
+export function nativeHistoryCanAct(observation, rendered, connected, now = Date.now()) {
+    return nativeHistoryCurrent(observation, connected, now) && observation.data === rendered;
 }
 /** Page sequence is authoritative. Ignore repeats; reject a gap rather than hide missing history. */
 export function appendNativePage(previous, page) {
@@ -303,6 +365,17 @@ export function appendNativePage(previous, page) {
     }
     return cursor === previous.cursor ? previous : { events, cursor };
 }
+/**
+ * The composer's send action for a session in this state: "Send" when it is idle, "Queue message"
+ * for the next turn while a turn runs or waits on a request. Undefined: it takes no input now.
+ */
+export function nativeSendLabel(state) {
+    if (state === 'idle')
+        return 'Send';
+    if (state === 'running' || state === 'waiting')
+        return 'Queue message';
+    return undefined;
+}
 export function nativeDeliveryLabel(receipt) {
     if (!receipt)
         return 'Delivery unknown';
@@ -334,4 +407,250 @@ export function nativeCommandLockSettled(command, currentGeneration, receipt, ev
             event.commandId === command.commandId &&
             event.generation === command.generation));
 }
+/** A reader within this distance of the end of a conversation follows new output. */
+const NATIVE_FOLLOW_SLACK_PX = 80;
+/** Opening a conversation, or jumping to its latest entry, follows again. */
+export const NATIVE_FOLLOW_LATEST = { following: true, unseen: 0 };
+/** The reader scrolled. Back at the end means caught up. */
+export function nativeFollowScrolled(state, distanceFromEnd) {
+    if (distanceFromEnd < NATIVE_FOLLOW_SLACK_PX)
+        return NATIVE_FOLLOW_LATEST;
+    return state.following ? { following: false, unseen: 0 } : state;
+}
+/** Entries arrived. A reader away from the end has that many more to catch up on. */
+export function nativeFollowGrew(state, added) {
+    return state.following || added <= 0 ? state : { ...state, unseen: state.unseen + added };
+}
+/** The jump control's label, or none while the reader follows. */
+export function nativeFollowLabel(state) {
+    if (state.following)
+        return undefined;
+    return state.unseen ? `Latest · ${state.unseen} new` : 'Latest';
+}
+const NATIVE_MESSAGE_PREVIEW_LINES = 8;
+const NATIVE_MESSAGE_PREVIEW_CHARS = 600;
+// A message collapses only when that hides a real amount, never a line or a few characters.
+const NATIVE_MESSAGE_COLLAPSE_LINES = 12;
+const NATIVE_MESSAGE_COLLAPSE_CHARS = 900;
+/** A long message (a worker's dispatch prompt) shows its start until the reader expands it. */
+export function nativeMessagePreview(text) {
+    // A trailing newline is not a line the reader sees.
+    const body = text.replace(/\n+$/, '');
+    const lines = body.split('\n');
+    if (body.length <= NATIVE_MESSAGE_COLLAPSE_CHARS && lines.length <= NATIVE_MESSAGE_COLLAPSE_LINES)
+        return undefined;
+    const head = lines.slice(0, NATIVE_MESSAGE_PREVIEW_LINES).join('\n');
+    return { text: nativeClip(head, NATIVE_MESSAGE_PREVIEW_CHARS), lines: lines.length };
+}
+/** At most `max` characters, then "…" where it was cut, never splitting a surrogate pair. */
+function nativeClip(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text
+        .slice(0, max)
+        .replace(/[\uD800-\uDBFF]$/, '')
+        .trimEnd()}…`;
+}
+/** Only the reader's own messages collapse; assistant, tool and status entries show in full. */
+export function nativeEntryPreview(entry) {
+    return entry.kind === 'user' ? nativeMessagePreview(entry.text) : undefined;
+}
+export function nativeMessageToggleLabel(preview, expanded) {
+    if (expanded)
+        return 'Show less';
+    return `Show all · ${preview.lines} ${preview.lines === 1 ? 'line' : 'lines'}`;
+}
+/** The start of the turn still running, if any. A restarted host cannot continue a turn. */
+function nativeOpenTurn(events) {
+    let turn;
+    for (const event of events) {
+        if (event.type === 'turn.started')
+            turn = event;
+        else if (['turn.completed', 'session.closed', 'session.started'].includes(event.type))
+            turn = undefined;
+    }
+    return turn;
+}
+/** The turn in progress, if any: when it started and the tool it is running now. */
+export function nativeWork(events) {
+    const turn = nativeOpenTurn(events);
+    if (!turn)
+        return undefined;
+    const tools = new Map();
+    for (const event of events) {
+        if (event.sequence <= turn.sequence || !event.nativeId || !event.tool)
+            continue;
+        if (event.type === 'tool.started')
+            tools.set(event.nativeId, nativeToolLabel(event.tool));
+        else if (event.type === 'tool.completed')
+            tools.delete(event.nativeId);
+    }
+    return { since: Date.parse(turn.at), tool: [...tools.values()].at(-1) };
+}
+/**
+ * "Working · 1m 12s · Bash": how long the turn has run, and its current tool.
+ * `since` is the execution host's clock: a client clock ahead of it overstates the time by the skew.
+ */
+export function nativeWorkLabel(work, now) {
+    return `Working · ${nativeElapsed(now - work.since)}${work.tool ? ` · ${work.tool}` : ''}`;
+}
+/** "12s", "1m 12s", "1h 3m". */
+function nativeElapsed(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    const minutes = Math.floor(seconds / 60);
+    if (minutes >= 60)
+        return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+    return minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
+}
+const NATIVE_TOOL_LABEL_CHARS = 120;
+const NATIVE_TOOL_LABEL_FILES = 3;
+// Fits a tool card's box without scrolling, so the end of the output is what the reader sees.
+const NATIVE_TOOL_OUTPUT_LINES = 10;
+const NATIVE_COMMAND_CHARS = 200;
+// "Change", not "Edit": the kind also covers creating, deleting and moving a file.
+const NATIVE_TOOL_VERBS = {
+    command: 'Run',
+    'file-edit': 'Change',
+    'file-read': 'Read',
+    search: 'Search',
+};
+/**
+ * A tool call as a reader reads it: "Run npm test", "Change a.ts, b.ts", "Read a.ts", "Search src",
+ * at most 120 characters before an ellipsis. A tool whose adapter gave no kind or subject keeps the
+ * runner's own name.
+ */
+export function nativeToolLabel(tool) {
+    if (!tool)
+        return 'Tool';
+    const names = (tool.paths ?? []).map((path) => path.replace(/\/+$/, '').split('/').at(-1) || path);
+    const files = names.length > NATIVE_TOOL_LABEL_FILES
+        ? `${names.slice(0, NATIVE_TOOL_LABEL_FILES).join(', ')} and ${names.length - NATIVE_TOOL_LABEL_FILES} more`
+        : names.join(', ');
+    const verb = tool.kind && NATIVE_TOOL_VERBS[tool.kind];
+    const subject = tool.kind === 'command' ? tool.command?.trim().split(/\r?\n/)[0] : files;
+    if (!verb || !subject)
+        return tool.name;
+    return nativeClip(`${verb} ${subject}`, NATIVE_TOOL_LABEL_CHARS);
+}
+/**
+ * A command card's text: "$ npm test", then the last 10 lines it printed, with "… 12 earlier lines"
+ * above them; its raw input and output stay one tap away. Undefined for any other tool, whose card
+ * shows its raw input and output.
+ */
+export function nativeCommandText(tool) {
+    if (tool?.kind !== 'command' || !tool.command)
+        return undefined;
+    // One line of the command: a heredoc would push the output out of view. All of it is in Raw.
+    const lines = tool.command.trim().split(/\r?\n/);
+    const command = `$ ${nativeClip(lines.length > 1 ? `${lines[0]} …` : lines[0], NATIVE_COMMAND_CHARS)}`;
+    if (tool.output === undefined)
+        return command;
+    const text = nativeOutputText(tool.output);
+    // Output that is not text would look like no output here; its raw card shows it.
+    if (text === undefined)
+        return undefined;
+    const output = terminalLinesFromText(text.replace(/[\r\n]+$/, ''));
+    if (!output.join(''))
+        return command;
+    const hidden = Math.max(0, output.length - NATIVE_TOOL_OUTPUT_LINES);
+    return [
+        command,
+        ...(hidden ? [`… ${hidden} earlier ${hidden === 1 ? 'line' : 'lines'}`] : []),
+        ...output.slice(hidden),
+    ].join('\n');
+}
+/**
+ * Runners return output as a string, as text blocks (`{ text }` or `{ content: { text } }`), or as a
+ * process result (`{ stdout, stderr }`).
+ */
+function nativeOutputText(output) {
+    if (typeof output === 'string')
+        return output;
+    if (output && typeof output === 'object' && !Array.isArray(output)) {
+        const { stdout, stderr } = output;
+        const streams = [stdout, stderr].filter((stream) => typeof stream === 'string');
+        if (!streams.length)
+            return undefined;
+        return streams
+            .map((stream) => stream.replace(/[\r\n]+$/, ''))
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (!Array.isArray(output))
+        return undefined;
+    const texts = output.flatMap((block) => {
+        const value = block && typeof block === 'object' ? block : {};
+        const content = value.content && typeof value.content === 'object'
+            ? value.content
+            : {};
+        const text = typeof value.text === 'string' ? value.text : content.text;
+        return typeof text === 'string' ? [text] : [];
+    });
+    return texts.length ? texts.join('\n') : undefined;
+}
+/**
+ * The timeline with a summary row for each finished turn's tool calls, "Worked for 4m 12s ·
+ * 6 tools", just before the turn's end, and those tools marked with it. Nothing moves when a
+ * turn finishes: the tools keep their place and their keys, and the row is added below them.
+ * A turn ends at `turn.completed`, or at `session.closed` when its host stopped mid-turn.
+ * Messages and statuses stay; a running turn has no summary.
+ */
+export function nativeTimelineRows(entries) {
+    const rows = [];
+    let turn = [];
+    for (const entry of entries) {
+        const ends = entry.kind === 'status' && ['turn.completed', 'session.closed'].includes(entry.event.type);
+        if (!ends) {
+            turn.push(entry);
+            continue;
+        }
+        const tools = turn.filter((item) => item.kind === 'tool');
+        for (const item of turn)
+            rows.push({
+                kind: 'entry',
+                key: item.key,
+                entry: item,
+                ...(tools.length && item.kind === 'tool' ? { fold: entry.key } : {}),
+            });
+        if (tools.length) {
+            const prompt = turn.find((item) => item.kind === 'user' &&
+                entry.event.commandId !== undefined &&
+                item.event.commandId === entry.event.commandId) ?? turn.find((item) => item.kind === 'user');
+            // Without its prompt in the kept history, the turn's first kept entry is the best start.
+            const opened = prompt ?? turn[0];
+            const elapsed = nativeElapsed(Date.parse(entry.event.at) - Date.parse(opened.event.at));
+            const outcome = entry.event.type === 'session.closed' || entry.event.status === 'interrupted'
+                ? 'Stopped after'
+                : entry.event.status === 'failed'
+                    ? 'Failed after'
+                    : 'Worked for';
+            rows.push({
+                kind: 'work',
+                key: entry.key,
+                label: `${outcome} ${elapsed} · ${tools.length} ${tools.length === 1 ? 'tool' : 'tools'}`,
+                tools: tools.map((tool) => tool.key),
+            });
+        }
+        rows.push({ kind: 'entry', key: entry.key, entry });
+        turn = [];
+    }
+    for (const item of turn)
+        rows.push({ kind: 'entry', key: item.key, entry: item });
+    return rows;
+}
+/**
+ * Tools shown running in a live read here. A turn the reader watched starts open when it
+ * finishes, so its tools don't fold away under them. A stored snapshot is not live: a turn that
+ * finished while the reader was away starts folded.
+ */
+export function nativeWatchTools(rows, watched, live) {
+    if (!live)
+        return;
+    for (const row of rows)
+        if (row.kind === 'entry' && row.entry.kind === 'tool' && row.fold === undefined)
+            watched.add(row.key);
+}
+export function nativeFoldWatched(row, watched) {
+    return row.tools.some((key) => watched.has(key));
+}
 //# sourceMappingURL=native-history.js.map