pi-jar 0.1.7 → 0.1.8

package/README.md

@@ -254,14 +254,14 @@ This is a pi-jar enhancement: [pi-advisor](https://github.com/philipbrembeck/pi-
   ```
   Use `parent` with `append` to add a genuinely new subtask to active work; `start`, `done`, `open`, `edit`, `list`, `add` and `delete` remain available.
 - **`jar_ask`** — structured questions: numbered options with descriptions, single or multi-select, *Type your own answer* (multi-line, paste-friendly) and *Chat about this* to discuss before choosing.
-- **`/diff`** — review what the agent (and its editing subagents) changed since the first edit to each file: files with `+/−` counts on the left, a full-path header and numbered, colored diff on the right. `/` filters files; `t` switches unified/split views and `n`/`p` navigates hunks. Large changes offer summary or explicit windowed review (`v`), with clearly labeled coarse fallback and existing safety limits—not arbitrary-file streaming. See [diff review](docs/DIFF-REVIEW.md). `a` accept (keep, stop tracking), `r` then `y` revert (restore the original, or remove a file it created), `A`/`R` for all. The footer shows `± N files · /diff` while anything is unreviewed; each file counts once no matter who edited it. Only `edit`/`write` changes inside the project are tracked; shell-made changes are not.
+- **`/diff`** — review what the agent (and its editing subagents) changed since the first edit to each file: files with `+/−` counts on the left, a full-path header and numbered, colored diff on the right. Changed lines get a colored rail and tinted background, replaced lines highlight the changed words, code is syntax-highlighted for known languages, and collapsed regions are labeled `┄ N unchanged lines ┄`. `/` filters files; `t` switches unified and aligned side-by-side views (unified below 70 columns), `←`/`→` (or `[`/`]`) change the context from 0 lines to the whole file, `w` wraps long lines, and `n`/`p`, `Home`/`End` navigate. Large changes offer summary or explicit windowed review (`v`), with clearly labeled coarse fallback and existing safety limits—not arbitrary-file streaming. See [diff review](docs/DIFF-REVIEW.md). `a` accept (keep, stop tracking), `r` then `y` revert (restore the original, or remove a file it created), `A`/`R` for all. The footer shows `± N files · /diff` while anything is unreviewed; each file counts once no matter who edited it. Only `edit`/`write` changes inside the project are tracked; shell-made changes are not.
 - **`jar_shell`** — `start` (with optional `name`, `watch` regex, `notify` and task/service `purpose`), `list`, `peek`, bounded `wait`, `output`, `kill`. Output is ANSI-stripped and bounded (2000 lines). Watch/exit notifications are compact and coalesced; reads acknowledge observed events so obsolete completions do not replay. Relevant finite checks should be verified with `wait`/`peek` before claiming success; services should not block completion. Each running shell gets a footer row; the activity view (`/jar shells`, a click on the row) tails it live (`x` kill, `f` follow). All shells stop when the session ends.
 - **`jar_delegate`** — spawns **retained session-scoped** subagents up to **Max subagents** in `/jar settings` (2, 4, 6, 8 or 16; default 4). Idle/paused children and live legacy workers count toward the shared limit, not the parent; over-cap batches are rejected before launch. Lowering the limit does not terminate existing children, but blocks new launches until there is room. The parent is given moderator context and should coordinate rather than duplicate their work. `mode: "scout"` is fresh/read-only and defaults to the `scout` role; `fork` is a true Pi session fork, read-only, and defaults to `reviewer`; `worktree` forks context and defaults to `worker`, editing inside a path-guarded disposable Git worktree. A settled retained agent becomes `idle`, keeping its process, model context and workspace for reuse. Launch returns before startup or the first turn completes, including the old one-shot `write: true` shared-workspace mode retained for compatibility.
 - **`jar_subagent`** — moderator control plane: `peek` returns only task progress (done/total, the in-progress task, activity, the next open tasks), read from memory; `steer` redirects a running worker; `resume` wakes that same agent with an optional instruction. `ask`, `pause` and `stop` return **accepted operation receipts immediately**, never waiting for a child turn, Git reconciliation, or process shutdown; their answers and final handoffs arrive as `pi-jar.subagent` events. Acceptance does not mean a worker is already stopped or its files applied. Equivalent in-flight requests share an operation ID; conflicting controls are rejected, while `stop` can preempt an outstanding ask/pause. `pause` preserves context/workspace and `stop` reports progress, work directory, changed/applied files and what remains. When an initial or resumed turn ends, a visible `pi-jar.subagent` event-bus message wakes the moderator (or queues for its current run) with progress and the turn's report, so it can keep responding to user steering and never polls `peek`. Subagents use Pi's native `--mode rpc` JSONL protocol with streamed lifecycle events, not polling. Input queues and transcript buffers are bounded; shutdown signals the entire process group and drains inherited pipes for a bounded interval. Background control failures also produce a terminal event. A pause attempt settles or reports failure after 15 s, and a working child with no RPC activity for 10 minutes is stopped as hung.
 - **Subagent capabilities** — each task can set `tools` or `inheritTools: true`; known-tool mode filters and child guards remain in force. See [tool capabilities](docs/SUBAGENT-TOOLS.md).
 - **Worktree finalization** — worktree edits do **not** touch the parent merely because a worker becomes idle. They remain private across pause/resume cycles. On `jar_subagent stop`, pi-jar verifies parent drift and reviewability, applies safe changes, and adds them to `/diff`; conflicts remain isolated and the workspace path is reported. Resolve parent drift and retry `stop` to reconcile; failed workspaces are retained rather than trimmed out of report history. Process closure is awaited before finalization. All replacements/rollback backups are prepared before parent mutation; failed multi-file application rolls back rather than silently leaving a partial result.
 - **`jar_democracy`** — **exceptional only**, for a persistent **super-complex** issue with several viable options and evidence of at least two distinct failed approaches. The moderator opens 2–8 evidence-backed options, resumes explicitly relevant idle/paused **fresh-context read-only scouts** or spawns fresh scouts within the same pool limit, and collects one private ballot per voter before publishing the tally. A **strict majority of the invited electorate** wins; ties, plurality without majority, and missing/invalid ballots require the user to choose among leading options, with evidence/tradeoffs rather than invented probabilities. TUI uses the structured question picker; RPC returns `needs-user` for the moderator to resolve with `jar_ask`. Voting returns a recommendation and **never implements it** or bypasses safety/approval. Prefer new scouts if past discussions could bias reused agents. Do not use democracy for ordinary complexity or routine decisions. A round is bounded: a 10-minute ballot deadline records unfinished voters as failures, rationales are capped at 600 characters, and scouts spawned for the round are retired when it ends.
-- **`jar_discuss`** — a bounded shared discussion paper for virtual agent-to-agent discussion. Questions and answers have stable IDs plus author/target metadata; entries are capped at 1600 characters, the newest 64 are retained, and serialized UTF-8 is capped at 64 KiB (older entries are evicted until it fits). `list` replies are capped at 4000 characters; `since` rereads only newer entries and `questionId` reads one thread in full. Agents use it for narrow Q/A, not as another transcript.
+- **`jar_discuss`** — a bounded shared discussion paper for virtual agent-to-agent discussion. Questions and answers have stable IDs plus author/target metadata; entries are capped at 1600 characters, the newest 64 are retained, and serialized UTF-8 is capped at 64 KiB (older entries are evicted until it fits). `ask`/`answer` reply with the new id only (never the text) plus, when they fit, unseen answers to your questions and questions addressed to you. `list` returns only entries by others that this agent has not seen yet (capped at 4000 characters; one line when nothing changed); `since: "d0"` rereads everything and `questionId` reads one thread in full. Agents use it for narrow Q/A, not as another transcript.
 - **Activity view** — one split view (<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd>, `/jar activity`, or a click on a footer row) for subagents, background shells and other extensions' teammates: list on the left, live details on the right (auto-follows; scroll up to pause, `f` to follow again). For a subagent the details show its task, its own checklist with subtasks, and a transcript like omp's: each tool call and message is one collapsed line that expands on demand (`Tab` into it, `↑↓`, `Enter`, or click) to show arguments and output, while streaming text shows live. `s` opens a steering input: type a message and press `Enter` to redirect the running subagent. `x` stops just that one. Finished runs stay listed for review.
 - **`/jar history`** — separate, read-only timeline of the active branch (paging, search, expandable details). Pi's native transcript is untouched.
 - Pi's built-in read/shell/edit/write tool cards render compactly: collapsed, each is one padded, state-colored card with its call line and a one-line summary (edit included), and partially streamed arguments never flicker to a fallback; the full output or diff stays one click or <kbd>Ctrl</kbd>+<kbd>O</kbd> away. Background sources (subagent streams, shell output) repaint the footer at most every 250 ms and the activity view every 100 ms, because every requested frame re-renders the whole transcript. The sliding bar some terminals show in the tab while the agent works is Pi's own `OSC 9;4` progress (`terminal.showTerminalProgress` in Pi settings), not pi-jar.
@@ -299,7 +299,7 @@ pi-jar/
 │   ├── commit.ts         /jar commit
 │   ├── usage-view.ts     /usage; context-view.ts is /context; panel.ts frames both
 │   ├── split-view.ts     shared two-pane frame
-│   ├── changes.ts        change tracker and line diff; diff-view.ts is /diff
+│   ├── changes.ts        change tracker, line diff and split layout; diff-view.ts is /diff, diff-inline.ts its word highlights
 │   ├── shells.ts         background shells and jar_shell
 │   ├── delegate.ts       retained subagents, moderator controls and RPC lifecycle
 │   ├── delegate-worktree.ts isolated Git worktrees, path guard and safe reconciliation
@@ -319,7 +319,7 @@ pi-jar/
 
 ## Git executable and subprocess safety
 
-pi-jar runs worktree Git plumbing asynchronously with a 30-second per-command deadline and terminates the process group on timeout or cancellation. To bypass a Git proxy/wrapper (for example, git-ai), set `PI_JAR_GIT_PATH` to the real Git executable before starting Pi:
+pi-jar runs worktree Git plumbing asynchronously with a 30-second per-command deadline and terminates the process group on timeout or cancellation. Worktree snapshots and change inspection hash files in bounded batches (at most 1,000 files or 128 MiB per Git call), so startup and finalization cost a handful of Git processes rather than several per repository file. To bypass a Git proxy/wrapper (for example, git-ai), set `PI_JAR_GIT_PATH` to the real Git executable before starting Pi:
 
 ```bash
 PI_JAR_GIT_PATH=/usr/bin/git pi

package/docs/DIFF-REVIEW.md

@@ -4,8 +4,11 @@
 
 - Type `/` in the file list to filter by absolute/relative path or change status (content search is intentionally omitted to keep keystrokes bounded over large retained snapshots). Press Enter to keep the filter, Escape to clear it, and `n`/`N` to move through matching files.
 - The right pane starts with the selected file's absolute path and change summary.
-- Normal previews render a viewport of unified Git-style hunks. `PgUp`/`PgDn`, `g`/`G`, or the mouse wheel move through the preview; `n`/`p` jump hunks. `t` toggles unified and side-by-side Original/Updated columns. Rendering windows the requested rows instead of constructing a rendered row for every file line.
+- Normal previews render a viewport of Git-style hunks. Each hunk header is preceded by a `┄ N unchanged lines ┄` label for the region it skips. `PgUp`/`PgDn`, `g`/`G`, `Home`/`End`, or the mouse wheel move through the preview; `n`/`p` jump hunks. Rendering windows the requested rows instead of constructing a rendered row for every file line.
+- `t` toggles unified rows and aligned side-by-side Original/Updated columns: within a replacement, the k-th removed line sits beside the k-th added line, and a longer side continues alone. Panes narrower than 70 columns keep the unified layout. Toggling keeps the hunk at the top of the viewport.
+- `←`/`→` (or `[`/`]`) step the context through 0, 1, 3 (default), 5, 10, 25 lines and the whole file. `w` wraps long lines onto continuation rows instead of truncating them; with wrapping, `End` shows the last full page.
+- Changed lines carry a colored `▌` rail and the theme's tool success/error background. For a replaced line pair, the changed words are shown in inverse video, computed by a bounded token LCS (lines that share no word, very long lines and coarse previews are not emphasized). Files whose language Pi recognizes are syntax-highlighted per line with the active theme; lines over 1,000 characters keep plain diff colours.
 - Changes over 256 KiB or 1,500 combined lines initially show summary counts. Press `v` to explicitly review a bounded preview or return to summary. Previews are capped at 100,000 combined lines per file. When exact LCS diff exceeds its existing CPU/memory budget, the full-review choice uses a clearly marked coarse replacement hunk that preserves common prefix/suffix and line order.
 - Safe revert tracking remains capped at 1 MiB per file and 8 MiB of retained baselines. Binary, oversized, or otherwise untracked files cannot be reverted from this UI. The summary does not imply content beyond those safety caps is reviewable.
 
-The implementation uses the pi-tui custom component and windowed split-frame renderer already used by pi-jar. Upstream visual reference: [xRyul/pi-show-diffs README](https://github.com/xRyul/pi-show-diffs#diff-review-ux), MIT-licensed. No upstream source was copied.
+The implementation uses the pi-tui custom component and windowed split-frame renderer already used by pi-jar. Upstream visual reference: [xRyul/pi-show-diffs README](https://github.com/xRyul/pi-show-diffs#diff-review-ux), MIT-licensed: aligned split rows, intraline highlights, rail markers, labeled collapsed regions, adjustable context and wrapping. No upstream source was copied, and pi-show-diffs' pre-apply approval and inline editing are not part of `/diff`, which reviews changes after they are applied.

package/docs/WORKFLOWS.md

@@ -120,7 +120,7 @@ Manual choices win: a model or effort you select yourself (model picker, cycling
 ## Change review
 
 - A `tool_call` hook records a file's content right before the agent's **first** `edit` or `write` to it (project files only, up to 200 files, 1 MB each, text only). Later edits keep that baseline, so the review always shows everything since the agent started on the file.
-- `/diff` (or <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>D</kbd>) compares the baseline with the file on disk using a line diff with 3 lines of context. Files that are back to their baseline drop out.
+- `/diff` (or <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>D</kbd>) compares the baseline with the file on disk using a line diff with 3 lines of context by default (`←`/`→` change it, up to the whole file). Files that are back to their baseline drop out.
 - **Accept** forgets the baseline. **Revert** writes the baseline back (or removes a file the agent created) after a second key press to confirm. Errors are reported and the file stays listed.
 - Baselines live in memory for the session; changes made through `bash` or by you are not tracked.
 - **Subagent edits** join the same review in two ways. Retained `worktree` writers remain isolated while working, idle or paused. Only `jar_subagent stop` finalizes them: pi-jar verifies that each parent target still equals the private baseline snapshot, copies reviewable safe results back, then captures/marks those parent files in the normal `ChangeTracker`. The deprecated one-shot `write: true` shared-workspace mode keeps its older `PI_JAR_BASELINE_DIR` bridge for compatibility.
@@ -146,7 +146,7 @@ watch matches  or  process exits  →  pi-jar.shell message  →  agent wakes (o
 - The moderator never has to poll: when a turn started by `jar_subagent resume` ends, pi-jar coalesces the settled agents into one visible `pi-jar.subagent` message (their `peek` progress plus the turn's report, clipped to 1200 characters) that triggers or queues a moderator turn. `pause`, `ask` and `stop` cancel that wake-up because the moderator is handling the agent directly.
 - Nothing in the moderator path waits unbounded. `jar_subagent` returns as soon as the tool call is aborted (the child keeps its state); `pause` reports "not settled yet" after 15 s if the child ignores abort and still pauses when it settles; a working child that sends no RPC event for 10 minutes is killed as hung. After a child exits, its stdio gets 2 s to drain: a grandchild (MCP server, shell) that inherited the pipes cannot keep `stop` or session shutdown waiting for `close`.
 - Worktree setup snapshots the exact starting workspace: `HEAD` plus tracked dirty changes and non-ignored untracked files are committed only inside the detached worktree. The worktree persists across idle/pause/resume. On stop, the parent target must still byte/mode-match the snapshot and the change must be trackable by `/diff`; otherwise nothing is overwritten and the workspace/error is reported. Conflicted workspaces survive report-history trimming; after resolving parent drift, retry `stop`. Finalization waits for RPC stdio closure. Snapshot blobs preserve filesystem bytes without executing clean/smudge filters or hooks. The path guard handles Pi path normalization, rejects lexical/symlink/dangling-link escapes and Git control metadata, checks read-tool filename fallbacks (NFD, curly apostrophes, AM/PM spaces), and rechecks both source and destination ancestors during reconciliation. All replacements/rollback backups are prepared before parent mutation; failed multi-file application restores earlier files. Exceptional rollback failures explicitly report actual applied paths for recovery. Worktree children receive only `read,edit,write,grep,find,ls,jar_todo,jar_discuss`; shell tools are absent. This is filesystem-write isolation, not a network/process sandbox.
-- `jar_discuss` gives moderator and children a session-scoped structured paper. `ask` appends a question with stable id/from/to fields and `answer` references the question id (validated under the same lock as the write). `list` returns the newest entries within a 4000-character reply, each clipped to 400 characters, and says how many older entries it omitted; `since: "d12"` returns only newer entries (a no-change reread costs one line) and `questionId` reads one thread in full. Text is capped at 1600 characters per entry, at most 64 entries are retained, and the compact UTF-8 JSON paper is strictly bounded to 64 KiB with oldest-entry eviction and atomic rewrites. The file lock waits by yielding to the event loop (at most ~1 s), never blocking the UI. It is intentionally for terse inter-agent Q/A rather than another transcript; agents are told not to poll it.
+- `jar_discuss` gives moderator and children a session-scoped structured paper. `ask` appends a question with stable id/from/to fields and `answer` references the question id (validated under the same lock as the write); both reply with the new id only, never echoing the text. Each process keeps an in-memory read cursor (the highest entry id it has been shown, reset when the paper path changes). `list` returns only unseen entries written by others — the newest that fit a 4000-character reply, each clipped to 400 characters, stating how many older entries it omitted — and advances the cursor; with nothing new it replies `No new entries (latest dN).` `since: "d12"` lists everything newer than that id instead (`since: "d0"` rereads the whole paper) and `questionId` reads one thread in full without moving the cursor. An `ask`/`answer` reply attaches unseen entries (≤1000 characters) only when all of them are relevant to the caller — answers to its questions or questions addressed to it — otherwise it adds `(N new entries; list to read)` and leaves the cursor alone, so nothing is skipped. Text is capped at 1600 characters per entry, at most 64 entries are retained, and the compact UTF-8 JSON paper is strictly bounded to 64 KiB with oldest-entry eviction and atomic rewrites. The file lock waits by yielding to the event loop (at most ~1 s), never blocking the UI. It is intentionally for terse inter-agent Q/A rather than another transcript; agents are told not to poll it.
 - Fork/worktree children inherit the parent model conversation but reset pi-jar goal/plan/todo automation. All child modes inherit explicit extension flags, set `PI_JAR_CHILD=1` to prevent recursive delegation, and share the discussion-paper path/name through environment variables.
 - Progress (current tool, streaming text, tools used, turns, cost) stays in the activity view. Retained `idle` and `paused` agents remain visible in the footer/activity fleet; the newest eight ordinary retired reports remain for review, while unresolved private workspaces remain recoverable until explicit finalization/session cleanup. `s` in the activity view still steers a working subagent and `x` stops the selected agent through the same registry.
 - The deprecated `write: true` mode remains a one-shot shared-workspace compatibility path. New delegated implementation should use `mode: "worktree"`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jar",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "A warm, role-aware Pi terminal workspace with animated UI, plan and goal workflows, tasks, change review, model roles, background shells and subagents.",
   "type": "module",
   "license": "MIT",

package/src/changes.ts

@@ -15,7 +15,11 @@ const MAX_DIFF_MIDDLE_LINES = 4_000;
 export type ChangeStatus = "added" | "modified" | "deleted";
 export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number; diff?: DiffOp[] | null }
 export type DiffOp = { op: " " | "+" | "-"; text: string };
-export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number };
+/** `hidden` counts unchanged lines skipped before a hunk; `pair` is the aligned replacement line for intraline diffs. */
+export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number; hidden?: number; pair?: string };
+export type SplitSide = { line: number; text: string; changed: boolean };
+/** One aligned Original/Updated row: a replacement run pairs its k-th removed and k-th added line. */
+export type SplitRow = { kind: "hunk"; text: string; hidden: number } | { kind: "pair"; left?: SplitSide; right?: SplitSide };
 
 /** Text content, `null` when the file is missing, or `undefined` when it cannot be tracked. */
 function readText(path: string): string | null | undefined {
@@ -104,7 +108,8 @@ export function diffHunkOffsets(ops: readonly DiffOp[], context = 3): number[] {
     while (to < ops.length) {
       let next = to + 1;
       while (next < ops.length && ops[next]!.op === " ") next++;
-      if (next < ops.length && next - to <= context * 2) { to = next; continue; }
+      // Merge when the unchanged gap fits inside both hunks' context (adjacent changes at context 0).
+      if (next < ops.length && next - to - 1 <= context * 2) { to = next; continue; }
       break;
     }
     const end = Math.min(ops.length, to + context + 1);
@@ -122,14 +127,7 @@ export function diffRowCount(ops: readonly DiffOp[], context = 3): number {
   return hunkCache.get(ops)!.rows;
 }
 
-/** Compute only the requested output window; diff operations stay indexed without a second full row array. */
-export function diffRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0, limit = Number.MAX_SAFE_INTEGER): DiffRow[] {
-  const rows: DiffRow[] = [];
-  const firstRow = Math.max(0, offset);
-  const lastRow = firstRow + Math.max(0, limit);
-  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
-  const layout = hunkCache.get(ops)!;
-  if (firstRow >= layout.rows || lastRow <= firstRow) return rows;
+const linePositions = (ops: readonly DiffOp[]) => {
   let positions = linePositionCache.get(ops);
   if (!positions) {
     const old = new Uint32Array(ops.length + 1), next = new Uint32Array(ops.length + 1);
@@ -145,6 +143,57 @@ export function diffRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0,
     positions = { old, next };
     linePositionCache.set(ops, positions);
   }
+  return positions;
+};
+
+/**
+ * Replacement runs (maximal non-context spans) as flat typed arrays, independent of context:
+ * `order[start..start+removes)` lists the run's removed ops and the rest its added ops, so the
+ * k-th removal pairs with the k-th addition. `split` prefixes aligned rows (a run takes max(r, a)).
+ */
+type RunLayout = { start: Uint32Array; removes: Uint32Array; length: Uint32Array; order: Uint32Array; ordinal: Uint32Array; split: Uint32Array };
+const runCache = new WeakMap<readonly DiffOp[], RunLayout>();
+
+const runLayout = (ops: readonly DiffOp[]): RunLayout => {
+  const cached = runCache.get(ops);
+  if (cached) return cached;
+  const n = ops.length;
+  const layout: RunLayout = { start: new Uint32Array(n), removes: new Uint32Array(n), length: new Uint32Array(n),
+    order: new Uint32Array(n), ordinal: new Uint32Array(n), split: new Uint32Array(n + 1) };
+  const { start, removes, length, order, ordinal, split } = layout;
+  for (let at = 0; at < n;) {
+    if (ops[at]!.op === " ") { order[at] = at; split[at + 1] = split[at]! + 1; at++; continue; }
+    let end = at;
+    while (end < n && ops[end]!.op !== " ") end++;
+    let r = 0, a = 0;
+    for (let i = at; i < end; i++) if (ops[i]!.op === "-") { ordinal[i] = r; order[at + r++] = i; }
+    for (let i = at; i < end; i++) if (ops[i]!.op === "+") { ordinal[i] = a; order[at + r + a++] = i; }
+    for (let i = at; i < end; i++) { start[i] = at; removes[i] = r; length[i] = end - at; split[i + 1] = split[at]!; }
+    split[at + 1] = split[at]! + Math.max(r, a);
+    for (let i = at + 1; i < end; i++) split[i + 1] = split[at + 1]!;
+    at = end;
+  }
+  runCache.set(ops, layout);
+  return layout;
+};
+
+/** The aligned counterpart of a changed op (k-th removal ↔ k-th addition in its run), if any. */
+const partner = (ops: readonly DiffOp[], at: number): number | undefined => {
+  const { start, removes, length, order, ordinal } = runLayout(ops);
+  const s = start[at]!, r = removes[at]!, a = length[at]! - r, k = ordinal[at]!;
+  if (ops[at]!.op === "-") return k < a ? order[s + r + k] : undefined;
+  return k < r ? order[s + k] : undefined;
+};
+
+/** Compute only the requested output window; diff operations stay indexed without a second full row array. */
+export function diffRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0, limit = Number.MAX_SAFE_INTEGER): DiffRow[] {
+  const rows: DiffRow[] = [];
+  const firstRow = Math.max(0, offset);
+  const lastRow = firstRow + Math.max(0, limit);
+  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
+  const layout = hunkCache.get(ops)!;
+  if (firstRow >= layout.rows || lastRow <= firstRow) return rows;
+  const positions = linePositions(ops);
   // Binary-search the first intersecting hunk, then visit only visible operations. In
   // particular, a 100k-line replacement must not slice/filter/allocate 100k rows per frame.
   let lo = 0, hi = layout.hunks.length;
@@ -157,13 +206,99 @@ export function diffRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0,
   for (let index = lo; index < layout.hunks.length; index++) {
     const { from, end, offset: start } = layout.hunks[index]!;
     if (start >= lastRow) break;
-    if (start >= firstRow) rows.push({ kind: "hunk", text: `@@ -${positions.old[from]!},${positions.old[end]! - positions.old[from]!} +${positions.next[from]!},${positions.next[end]! - positions.next[from]!} @@` });
+    if (start >= firstRow) rows.push({ kind: "hunk", text: hunkHeader(positions, from, end), hidden: from - (layout.hunks[index - 1]?.end ?? 0) });
     const visibleFrom = from + Math.max(0, firstRow - start - 1);
     const visibleEnd = Math.min(end, from + lastRow - start - 1);
     for (let at = visibleFrom; at < visibleEnd; at++) {
       const op = ops[at]!;
+      const pair = op.op === " " ? undefined : partner(ops, at);
       rows.push({ kind: op.op === "+" ? "add" : op.op === "-" ? "remove" : "context", text: op.text,
-        ...(op.op !== "+" ? { oldLine: positions.old[at]! } : {}), ...(op.op !== "-" ? { newLine: positions.next[at]! } : {}) });
+        ...(op.op !== "+" ? { oldLine: positions.old[at]! } : {}), ...(op.op !== "-" ? { newLine: positions.next[at]! } : {}),
+        ...(pair !== undefined ? { pair: ops[pair]!.text } : {}) });
+    }
+  }
+  return rows;
+}
+
+/** Git convention: an empty side (pure insertion/deletion) names the line before the change. */
+const hunkHeader = (positions: { old: Uint32Array; next: Uint32Array }, from: number, end: number) => {
+  const range = (lines: Uint32Array) => {
+    const count = lines[end]! - lines[from]!;
+    return `${count ? lines[from]! : lines[from]! - 1},${count}`;
+  };
+  return `@@ -${range(positions.old)} +${range(positions.next)} @@`;
+};
+
+type SplitHunk = DiffHunk & { split: number };
+const splitCache = new WeakMap<readonly DiffOp[], { context: number; hunks: SplitHunk[]; offsets: number[]; rows: number }>();
+
+const splitLayout = (ops: readonly DiffOp[], context: number) => {
+  const cached = splitCache.get(ops);
+  if (cached?.context === context) return cached;
+  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
+  const { split } = runLayout(ops);
+  const hunks: SplitHunk[] = [];
+  let rows = 0;
+  // Hunks start and end on context ops, so a replacement run never straddles two hunks.
+  for (const hunk of hunkCache.get(ops)!.hunks) {
+    hunks.push({ ...hunk, split: rows });
+    rows += 1 + split[hunk.end]! - split[hunk.from]!;
+  }
+  const layout = { context, hunks, offsets: hunks.map(hunk => hunk.split), rows };
+  splitCache.set(ops, layout);
+  return layout;
+};
+
+/** Aligned side-by-side row offsets of each hunk header. */
+export function diffSplitHunkOffsets(ops: readonly DiffOp[], context = 3): number[] {
+  return splitLayout(ops, context).offsets.slice();
+}
+
+export function diffSplitRowCount(ops: readonly DiffOp[], context = 3): number {
+  return splitLayout(ops, context).rows;
+}
+
+/** Window of aligned Original/Updated rows; like `diffRowsWindow`, it visits only visible operations. */
+export function diffSplitRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0, limit = Number.MAX_SAFE_INTEGER): SplitRow[] {
+  const rows: SplitRow[] = [];
+  const firstRow = Math.max(0, offset);
+  const lastRow = firstRow + Math.max(0, limit);
+  const layout = splitLayout(ops, context);
+  if (firstRow >= layout.rows || lastRow <= firstRow) return rows;
+  const positions = linePositions(ops);
+  const { split, order, removes, length } = runLayout(ops);
+  const size = (hunk: SplitHunk) => 1 + split[hunk.end]! - split[hunk.from]!;
+  let lo = 0, hi = layout.hunks.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    if (layout.hunks[mid]!.split + size(layout.hunks[mid]!) <= firstRow) lo = mid + 1;
+    else hi = mid;
+  }
+  for (let index = lo; index < layout.hunks.length; index++) {
+    const hunk = layout.hunks[index]!;
+    if (hunk.split >= lastRow) break;
+    if (hunk.split >= firstRow) rows.push({ kind: "hunk", text: hunkHeader(positions, hunk.from, hunk.end), hidden: hunk.from - (layout.hunks[index - 1]?.end ?? 0) });
+    const visibleFrom = Math.max(0, firstRow - hunk.split - 1);
+    const visibleEnd = Math.min(size(hunk) - 1, lastRow - hunk.split - 1);
+    for (let row = visibleFrom; row < visibleEnd; row++) {
+      const target = split[hunk.from]! + row;
+      // First op whose aligned-row interval contains target; only run starts carry run rows.
+      let low = hunk.from, high = hunk.end - 1;
+      while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (split[mid + 1]! > target) high = mid; else low = mid + 1;
+      }
+      const op = ops[low]!;
+      if (op.op === " ") {
+        rows.push({ kind: "pair", left: { line: positions.old[low]!, text: op.text, changed: false }, right: { line: positions.next[low]!, text: op.text, changed: false } });
+        continue;
+      }
+      const k = target - split[low]!, r = removes[low]!, a = length[low]! - r;
+      const removed = k < r ? order[low + k]! : undefined;
+      const added = k < a ? order[low + r + k]! : undefined;
+      rows.push({ kind: "pair",
+        ...(removed !== undefined ? { left: { line: positions.old[removed]!, text: ops[removed]!.text, changed: true } } : {}),
+        ...(added !== undefined ? { right: { line: positions.next[added]!, text: ops[added]!.text, changed: true } } : {}) });
     }
   }
   return rows;

package/src/delegate-worktree.ts

@@ -154,6 +154,31 @@ const writeSnapshot = async (root: string, rel: string, bytes: Buffer, stat: Sta
   }
 };
 
+// Each git call has its own GIT_TIMEOUT_MS deadline, so bound the work per batched call.
+const HASH_BATCH_FILES = 1000;
+const HASH_BATCH_BYTES = 128 * 1024 * 1024;
+
+/** Object ids for regular files, in order, from bounded `hash-object --stdin-paths` chunks. */
+const hashPaths = async (root: string, files: readonly { path: string; size: number }[], write: boolean,
+  signal?: AbortSignal): Promise<string[]> => {
+  const oids: string[] = [];
+  for (let start = 0; start < files.length;) {
+    let end = start;
+    let bytes = 0;
+    // A file larger than the byte budget still gets its own chunk, matching per-file hashing.
+    while (end < files.length && end - start < HASH_BATCH_FILES && (end === start || bytes + files[end]!.size <= HASH_BATCH_BYTES)) {
+      bytes += files[end++]!.size;
+    }
+    const chunk = files.slice(start, end);
+    const output = (await gitText(root, ["hash-object", ...(write ? ["-w"] : []), "--no-filters", "--stdin-paths"],
+      chunk.map(file => file.path).join("\n") + "\n", signal)).split("\n").filter(Boolean);
+    if (output.length !== chunk.length) throw new Error("git hash-object returned incomplete hashes");
+    oids.push(...output);
+    start = end;
+  }
+  return oids;
+};
+
 /**
  * Create a detached disposable worktree and commit a private baseline snapshot containing the
  * parent's tracked modifications plus non-ignored untracked files. The parent index/branch is not
@@ -173,6 +198,10 @@ export async function createDelegateWorktree(cwd: string, signal?: AbortSignal):
     added = true;
     await gitText(root, ["read-tree", "--empty"], undefined, signal);
     const paths = new Set(nulList(await gitText(repoRoot, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], undefined, signal)));
+    // Git process startup (often behind wrappers such as git-ai) dominates setup time, so hash
+    // and stage in bounded batches rather than two git processes per repository file.
+    const entries: { rel: string; mode: string; oid: string }[] = [];
+    const batched: { entry: (typeof entries)[number]; path: string; size: number }[] = [];
     for (const rel of paths) {
       if (!safeFilePath(repoRoot, rel)) throw new Error("unsafe snapshot path: " + rel);
       const source = resolve(repoRoot, rel);
@@ -180,11 +209,22 @@ export async function createDelegateWorktree(cwd: string, signal?: AbortSignal):
       if (!stat) continue;
       if (!stat.isFile() && !stat.isSymbolicLink()) throw new Error("unsupported snapshot file: " + rel);
       const bytes = stat.isSymbolicLink() ? Buffer.from(await readlink(source)) : await readFile(source);
-      const oid = (await gitText(root, ["hash-object", "-w", "--no-filters", "--stdin"], bytes, signal)).trim();
-      const mode = stat.isSymbolicLink() ? "120000" : (stat.mode & 0o111) ? "100755" : "100644";
-      await gitText(root, ["update-index", "--add", "--cacheinfo", mode, oid, rel], undefined, signal);
       signal?.throwIfAborted();
       await writeSnapshot(root, rel, bytes, stat);
+      const entry = { rel, mode: stat.isSymbolicLink() ? "120000" : (stat.mode & 0o111) ? "100755" : "100644", oid: "" };
+      entries.push(entry);
+      // The private copy holds exactly the bytes read above. Hashing it by path would follow a
+      // symlink, and --stdin-paths is line-based, so those entries hash their bytes directly.
+      const path = resolve(root, rel);
+      if (stat.isSymbolicLink() || path.includes("\n")) {
+        entry.oid = (await gitText(root, ["hash-object", "-w", "--no-filters", "--stdin"], bytes, signal)).trim();
+      } else batched.push({ entry, path, size: bytes.length });
+    }
+    const oids = await hashPaths(root, batched, true, signal);
+    batched.forEach((item, index) => { item.entry.oid = oids[index]!; });
+    if (entries.length) {
+      await gitText(root, ["update-index", "-z", "--index-info"],
+        entries.map(entry => `${entry.mode} ${entry.oid}\t${entry.rel}\0`).join(""), signal);
     }
     const tree = (await gitText(root, ["write-tree"], undefined, signal)).trim();
     const baseline = (await gitText(root, ["-c", "user.name=pi-jar", "-c", "user.email=pi-jar@local",
@@ -205,12 +245,37 @@ export async function createDelegateWorktree(cwd: string, signal?: AbortSignal):
 
 /** Files whose final worktree state differs from the snapshot, including new untracked files. */
 export async function worktreeChangedFiles(worktree: DelegateWorktree, signal?: AbortSignal): Promise<string[]> {
-  const baselinePaths = nulList(await gitText(worktree.root, ["ls-tree", "-r", "--name-only", "-z", worktree.baseline], undefined, signal));
+  const baseline = new Map<string, { mode: string; oid: string }>();
+  for (const record of nulList(await gitText(worktree.root, ["ls-tree", "-r", "-z", worktree.baseline], undefined, signal))) {
+    const tab = record.indexOf("\t");
+    const [mode, type, oid] = record.slice(0, tab).split(" ");
+    if (type !== "blob" || !mode || !oid) throw new Error("unsupported baseline entry: " + record.slice(tab + 1));
+    baseline.set(record.slice(tab + 1), { mode, oid });
+  }
   const currentPaths = nulList(await gitText(worktree.root, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], undefined, signal));
   const changed: string[] = [];
-  for (const rel of new Set([...baselinePaths, ...currentPaths])) {
-    if (!await parentMatchesBaseline(worktree, worktree.root, rel, signal)) changed.push(rel);
+  // Compare object ids from bounded hash-object batches instead of two git processes per file.
+  const batched: { rel: string; oid: string; path: string; size: number }[] = [];
+  const hashBytes = async (bytes: Buffer) => (await gitText(worktree.root, ["hash-object", "--no-filters", "--stdin"], bytes, signal)).trim();
+  for (const rel of new Set([...baseline.keys(), ...currentPaths])) {
+    const entry = baseline.get(rel);
+    const target = resolve(worktree.root, rel);
+    if (!safeFilePath(worktree.root, rel)) { changed.push(rel); continue; }
+    const stat = statIfPresent(target);
+    if (!entry || !stat) {
+      if (entry || stat) changed.push(rel);
+      continue;
+    }
+    if (entry.mode === "120000") {
+      if (!stat.isSymbolicLink() || await hashBytes(Buffer.from(await readlink(target))) !== entry.oid) changed.push(rel);
+      continue;
+    }
+    if (!stat.isFile() || (entry.mode === "100755") !== ((stat.mode & 0o111) !== 0)) changed.push(rel);
+    else if (target.includes("\n")) { if (await hashBytes(await readFile(target)) !== entry.oid) changed.push(rel); }
+    else batched.push({ rel, oid: entry.oid, path: target, size: stat.size });
   }
+  const oids = await hashPaths(worktree.root, batched, false, signal);
+  batched.forEach((item, index) => { if (oids[index] !== item.oid) changed.push(item.rel); });
   return changed.sort();
 }
 
@@ -224,9 +289,6 @@ const baselineEntry = async (worktree: DelegateWorktree, rel: string, signal?: A
   return { mode, content: await gitBuffer(worktree.root, ["cat-file", "blob", oid], signal) };
 };
 
-const parentMatchesBaseline = async (worktree: DelegateWorktree, parentRoot: string, rel: string, signal?: AbortSignal): Promise<boolean> =>
-  matchesBaseline(await baselineEntry(worktree, rel, signal), parentRoot, rel);
-
 const matchesBaseline = (baseline: BaselineEntry, parentRoot: string, rel: string): boolean => {
   const target = resolve(parentRoot, rel);
   if (!safeFilePath(parentRoot, rel)) return false;

package/src/delegate.ts

@@ -976,9 +976,15 @@ const remainingTasks = (run: DelegateRun): string[] => {
   return leaves.filter((todo) => todo.status !== "completed").map((todo) => todo.title).slice(0, 20);
 };
 
+const taskLabel = (task: string): string => {
+  const text = cleanText(task, 4096);
+  return text.length > 160 ? text.slice(0, 159) + "…" : text;
+};
+
 const controlReport = (report: SubagentStopReport): string => [
   `${report.key} · ${report.name} · ${report.state}`,
-  `task: ${report.task}`,
+  // The moderator already holds the full task in its own jar_delegate call; echo only a label.
+  `task: ${taskLabel(report.task)}`,
   `workspace: ${report.workspace ?? "none"}`,
   `changed: ${report.changed.length ? report.changed.join(", ") : "none"}`,
   `applied: ${report.applied.length ? report.applied.join(", ") : "none"}`,

package/src/diff-inline.ts

@@ -0,0 +1,80 @@
+/** Word-level changes inside one replaced line, for intraline emphasis in /diff. */
+
+export type Span = readonly [start: number, end: number];
+
+/** Token LCS stays tiny: long or wholly rewritten lines are shown without intraline emphasis. */
+const MAX_INLINE_CELLS = 40_000;
+const TOKEN = /\w+|\s+|[^\w\s]/gu;
+
+const tokens = (text: string) => Array.from(text.matchAll(TOKEN), match => ({ text: match[0], at: match.index! }));
+
+/**
+ * Changed `[start, end)` code-unit spans of `before` and `after`. Undefined when the lines are equal,
+ * too long to compare cheaply, or share no non-whitespace token (emphasizing everything adds nothing).
+ */
+export function inlineChanges(before: string, after: string): { before: Span[]; after: Span[] } | undefined {
+  if (before === after) return undefined;
+  const a = tokens(before), b = tokens(after);
+  let start = 0;
+  while (start < a.length && start < b.length && a[start]!.text === b[start]!.text) start++;
+  let endA = a.length, endB = b.length;
+  while (endA > start && endB > start && a[endA - 1]!.text === b[endB - 1]!.text) { endA--; endB--; }
+  const n = endA - start, m = endB - start;
+  if (n * m > MAX_INLINE_CELLS) return undefined;
+  // lcs[i][j] = LCS length of a[start+i..endA) and b[start+j..endB), flattened.
+  const lcs = new Uint16Array((n + 1) * (m + 1));
+  for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
+    lcs[i * (m + 1) + j] = a[start + i]!.text === b[start + j]!.text ? lcs[(i + 1) * (m + 1) + j + 1]! + 1
+      : Math.max(lcs[(i + 1) * (m + 1) + j]!, lcs[i * (m + 1) + j + 1]!);
+  }
+  const changedA = new Uint8Array(n), changedB = new Uint8Array(m);
+  let common = /\S/.test(a.slice(0, start).map(token => token.text).join("") + a.slice(endA).map(token => token.text).join(""));
+  for (let i = 0, j = 0; i < n || j < m;) {
+    if (i < n && j < m && a[start + i]!.text === b[start + j]!.text) {
+      if (/\S/.test(a[start + i]!.text)) common = true;
+      i++; j++;
+    } else if (j < m && (i >= n || lcs[i * (m + 1) + j + 1]! >= lcs[(i + 1) * (m + 1) + j]!)) changedB[j++] = 1;
+    else changedA[i++] = 1;
+  }
+  if (!common) return undefined;
+  return { before: spans(a, start, changedA), after: spans(b, start, changedB) };
+}
+
+/** Merge consecutive changed tokens into spans; whitespace between two changes joins them. */
+function spans(list: readonly { text: string; at: number }[], offset: number, changed: Uint8Array): Span[] {
+  const result: [number, number][] = [];
+  let previous = -1;
+  for (let index = 0; index < changed.length; index++) {
+    if (!changed[index]) continue;
+    const token = list[offset + index]!;
+    let joined = previous >= 0;
+    for (let gap = previous + 1; joined && gap < index; gap++) if (/\S/.test(list[offset + gap]!.text)) joined = false;
+    if (joined) result.at(-1)![1] = token.at + token.text.length;
+    else result.push([token.at, token.at + token.text.length]);
+    previous = index;
+  }
+  return result;
+}
+
+const SGR = /\x1b\[[0-?]*[ -/]*[@-~]/y;
+const INVERSE_ON = "\x1b[7m";
+const INVERSE_OFF = "\x1b[27m";
+
+/**
+ * Insert inverse-video markers around `spans` of the visible text inside an SGR-styled string.
+ * Offsets count visible code units, so styling (syntax colours) never shifts the emphasis.
+ */
+export function emphasize(styled: string, spans: readonly Span[]): string {
+  if (!spans.length) return styled;
+  let out = "", visible = 0, span = 0, open = false;
+  for (let at = 0; at < styled.length;) {
+    SGR.lastIndex = at;
+    const escape = SGR.exec(styled);
+    if (escape) { out += escape[0]; at += escape[0].length; continue; }
+    while (span < spans.length && open && visible >= spans[span]![1]) { out += INVERSE_OFF; open = false; span++; }
+    if (span < spans.length && !open && visible >= spans[span]![0]) { out += INVERSE_ON; open = true; }
+    out += styled[at++];
+    visible++;
+  }
+  return open ? out + INVERSE_OFF : out;
+}

package/src/diff-view.ts

@@ -1,6 +1,8 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { coarseLineDiff, diffHunkOffsets, diffLineCount, diffRowCount, diffRowsWindow, lineDiff, MAX_REVIEW_DIFF_LINES, type ChangeTracker, type DiffOp, type DiffRow, type FileChange } from "./changes.ts";
+import { getLanguageFromPath, highlightCode, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { coarseLineDiff, diffHunkOffsets, diffLineCount, diffRowCount, diffRowsWindow, diffSplitHunkOffsets, diffSplitRowCount, diffSplitRowsWindow,
+  lineDiff, MAX_REVIEW_DIFF_LINES, type ChangeTracker, type DiffOp, type FileChange } from "./changes.ts";
+import { emphasize, inlineChanges } from "./diff-inline.ts";
 import { CHILD_BASELINE_ENV, writeChildBaseline } from "./child-baselines.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 
@@ -48,51 +50,118 @@ export function fullReviewSupported(change: FileChange): boolean {
 export const safeLine = (text: string) => text.slice(0, 4000).replace(/\t/g, "  ")
   .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)?|\x1b\[[0-?]*[ -/]*[@-~]|\x1b./g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "·");
 
+/** Optional styling hooks; tests and plain output omit them. */
+export interface DiffPaint {
+  /** Syntax colours (foreground SGR only) for one display line, or undefined to use diff colours. */
+  syntax?: (text: string) => string | undefined;
+  /** SGR background sequence that tints a changed line's text. */
+  tint?: (kind: "add" | "remove") => string;
+}
+
+/** Context sizes cycled by ←/→ (and [/]); Infinity shows whole files. */
+export const CONTEXT_STEPS = [0, 1, 3, 5, 10, 25, Infinity] as const;
+/** Split columns narrower than this fall back to unified rows. */
+export const MIN_SPLIT_WIDTH = 70;
+
+export interface DiffRenderOptions {
+  fullReview?: boolean; scroll?: number; rows?: number; unified?: boolean; ops?: readonly DiffOp[]; coarse?: boolean;
+  context?: number; wrap?: boolean; paint?: DiffPaint;
+}
+/** Rendered page plus how many logical rows it consumed (wrapping can show fewer than `rows`). */
+export interface DiffWindow { lines: string[]; shown: number; total: number }
+
+type Kind = "add" | "remove" | "context";
+const RESET = "\x1b[0m";
+const KIND_COLOR = { add: "success", remove: "error", context: "muted" } as const;
+const SIGN = { add: "+", remove: "-", context: " " } as const;
+
 /** Styled diff rows for one file, with a gutter of old/new line numbers. */
-export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string,
-  options: { fullReview?: boolean; scroll?: number; rows?: number; unified?: boolean; ops?: readonly DiffOp[]; coarse?: boolean } = {}): string[] {
+export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string, options: DiffRenderOptions = {}): string[] {
+  return renderDiffWindow(change, width, fg, options).lines;
+}
+
+export function renderDiffWindow(change: FileChange, width: number, fg: (color: string, text: string) => string, options: DiffRenderOptions = {}): DiffWindow {
   const large = fullReviewRequired(change);
-  if (large && (!options.fullReview || !fullReviewSupported(change))) return [
+  if (large && (!options.fullReview || !fullReviewSupported(change))) return { shown: 0, total: 0, lines: [
     fg("warning", `Summary preview · +${change.added} −${change.removed} · ${(Buffer.byteLength(change.before) + Buffer.byteLength(change.after)) / 1024 | 0} KiB`),
     fg("dim", fullReviewSupported(change) ? "Press v for a windowed full review, or keep this summary." : "Full review unavailable: preview is bounded to 100,000 combined lines."),
     fg("dim", "Older/binary/over-1 MiB files are not tracked for safe revert.")
-  ];
+  ] };
   const exact = options.ops ? change.diff : (change.diff === null ? undefined : (change.diff ?? lineDiff(change.before, change.after)));
   const ops = options.ops ?? exact ?? coarseLineDiff(change.before, change.after);
-  const rows = Math.min(options.rows ?? PREVIEW_WINDOW, PREVIEW_WINDOW);
+  const rows = Math.max(1, Math.min(options.rows ?? PREVIEW_WINDOW, PREVIEW_WINDOW));
   const scroll = Math.max(0, options.scroll ?? 0);
-  const visible = diffRowsWindow(ops, 3, scroll, rows);
-  if (!visible.length) return [fg("dim", scroll ? "End of diff." : "No textual changes.")];
+  const context = options.context ?? 3;
+  const unified = options.unified !== false;
+  const wrap = options.wrap === true;
+  const paint = options.paint ?? {};
+  const total = unified ? diffRowCount(ops, context) : diffSplitRowCount(ops, context);
+  const unifiedRows = unified ? diffRowsWindow(ops, context, scroll, rows) : [];
+  const splitRows = unified ? [] : diffSplitRowsWindow(ops, context, scroll, rows);
+  if (!unifiedRows.length && !splitRows.length) return { lines: [fg("dim", scroll ? "End of diff." : "No textual changes.")], shown: 0, total };
   const bounded = options.coarse ?? (change.diff === null || (!options.ops && exact === undefined));
-  const gutter = Math.max(3, String(Math.max(...visible.map((row) => Math.max(row.oldLine ?? 0, row.newLine ?? 0)))).length);
+  let widest = 0;
+  for (const row of unifiedRows) widest = Math.max(widest, row.oldLine ?? 0, row.newLine ?? 0);
+  for (const row of splitRows) if (row.kind === "pair") widest = Math.max(widest, row.left?.line ?? 0, row.right?.line ?? 0);
+  const gutter = Math.max(3, String(widest).length);
   const num = (value?: number) => (value ? String(value) : "").padStart(gutter);
-  if (options.unified === false) {
+
+  // Coarse replacement groups pair unrelated lines, so intraline emphasis would mislead there.
+  const style = (text: string, kind: Kind, pair: string | undefined) => {
+    const display = safeLine(text);
+    const styled = paint.syntax?.(display) ?? fg(KIND_COLOR[kind], display);
+    if (bounded || kind === "context" || pair === undefined) return styled;
+    const changes = kind === "remove" ? inlineChanges(display, safeLine(pair)) : inlineChanges(safeLine(pair), display);
+    return changes ? emphasize(styled, kind === "remove" ? changes.before : changes.after) : styled;
+  };
+  // Rail, numbers and sign, then text truncated or wrapped into the cell; continuation lines keep
+  // the rail only. Truncation emits full resets, so a tint is re-applied after each one.
+  const cell = (kind: Kind, lead: string, text: string, width: number, pair?: string): string[] => {
+    const leadWidth = visibleWidth(lead);
+    const textWidth = Math.max(1, width - leadWidth - 2);
+    const rail = kind === "context" ? " " : fg(KIND_COLOR[kind], "▌");
+    const tint = kind === "context" ? undefined : paint.tint?.(kind);
+    const styled = style(text, kind, pair);
+    return (wrap ? wrapTextWithAnsi(styled, textWidth) : [truncateToWidth(styled, textWidth, "…")]).map((body, index) => {
+      const prefix = index ? " ".repeat(leadWidth + 1) : fg("dim", lead) + fg(KIND_COLOR[kind], SIGN[kind]);
+      const content = body + " ".repeat(Math.max(0, textWidth - visibleWidth(body)));
+      return rail + prefix + (tint ? tint + content.replaceAll(RESET, RESET + tint) : content) + RESET;
+    });
+  };
+  const hunkLine = (text: string, hidden: number | undefined) => truncateToWidth(
+    (hidden ? fg("dim", `┄ ${hidden} unchanged line${hidden === 1 ? "" : "s"} ┄ `) : "") + fg("accent", text), width, "…");
+
+  const blocks: string[][] = unified
+    ? unifiedRows.map(row => row.kind === "hunk" ? [hunkLine(row.text, row.hidden)]
+      : cell(row.kind === "add" ? "add" : row.kind === "remove" ? "remove" : "context", `${num(row.oldLine)} ${num(row.newLine)} `, row.text, width, row.pair))
+    : splitRows.map(row => {
+      if (row.kind === "hunk") return [hunkLine(row.text, row.hidden)];
+      const column = Math.max(8, Math.floor((width - 3) / 2));
+      const replaced = row.left?.changed && row.right?.changed;
+      const left = row.left ? cell(row.left.changed ? "remove" : "context", num(row.left.line) + " ", row.left.text, column, replaced ? row.right!.text : undefined) : [];
+      const right = row.right ? cell(row.right.changed ? "add" : "context", num(row.right.line) + " ", row.right.text, column, replaced ? row.left!.text : undefined) : [];
+      return Array.from({ length: Math.max(left.length, right.length) }, (_, index) =>
+        (left[index] ?? " ".repeat(column)) + fg("dim", " │ ") + (right[index] ?? ""));
+    });
+  const lines: string[] = [];
+  if (bounded) lines.push(fg("warning", unified ? "Coarse preview: LCS budget exceeded; full review preserves file order but replacement groups are approximate."
+    : "Coarse preview: replacement groups are approximate."));
+  if (!unified) {
     const column = Math.max(8, Math.floor((width - 3) / 2));
-    return [
-      truncateToWidth(fg("accent", "Original"), column, "…", true) + fg("dim", " │ ") + fg("accent", "Updated"),
-      ...(bounded ? [fg("warning", "Coarse preview: replacement groups are approximate.")] : []),
-      ...visible.map(row => {
-        if (row.kind === "hunk") return fg("accent", row.text);
-        const oldText = row.kind === "add" ? "" : `${num(row.oldLine)} ${row.kind === "remove" ? "-" : " "}${safeLine(row.text)}`;
-        const newText = row.kind === "remove" ? "" : `${num(row.newLine)} ${row.kind === "add" ? "+" : " "}${safeLine(row.text)}`;
-        const left = truncateToWidth(oldText, column, "…", true);
-        const right = truncateToWidth(newText, column, "…", true);
-        return (row.kind === "remove" ? fg("error", left) : fg("muted", left)) + fg("dim", " │ ")
-          + (row.kind === "add" ? fg("success", right) : fg("muted", right));
-      })
-    ];
+    lines.push(truncateToWidth(fg("accent", "Original"), column, "…", true) + fg("dim", " │ ") + fg("accent", "Updated"));
   }
-  const rendered = visible.map((row) => {
-    if (row.kind === "hunk") return fg("accent", row.text);
-    const text = truncateToWidth(safeLine(row.text), Math.max(1, width - gutter * 2 - 4));
-    const prefix = fg("dim", `${num(row.oldLine)} ${num(row.newLine)} `);
-    if (row.kind === "add") return prefix + fg("success", "+" + text);
-    if (row.kind === "remove") return prefix + fg("error", "-" + text);
-    return prefix + fg("muted", " " + text);
-  });
-  if (bounded) rendered.unshift(fg("warning", "Coarse preview: LCS budget exceeded; full review preserves file order but replacement groups are approximate."));
-  if (change.added + change.removed > rows) rendered.push(fg("dim", `Windowed preview at row ${scroll + 1} · PgUp/PgDn or j/k`));
-  return rendered;
+  // Fill the viewport with whole logical rows; a first row taller than the viewport is clipped.
+  let used = 0, shown = 0;
+  for (const block of blocks) {
+    if (shown && used + block.length > rows) break;
+    const visible = block.slice(0, rows - used);
+    lines.push(...visible);
+    used += visible.length;
+    shown++;
+    if (used >= rows) break;
+  }
+  if (scroll > 0 || scroll + shown < total) lines.push(fg("dim", `Windowed preview · rows ${scroll + 1}–${scroll + shown} of ${total} · PgUp/PgDn`));
+  return { lines, shown, total };
 }
 
 /**
@@ -111,15 +180,54 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
     let searchMode = false;
     let fullReview = false;
     let unified = true;
+    let contextIndex = CONTEXT_STEPS.indexOf(3);
+    let wrap = false;
     let bodyRows = 0;
+    let bodyWidth = 80;
     let viewportRows = 1;
     let width = 80;
     let armed: "one" | "all" | undefined;
     let message = "";
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
-    let cache: { key: string; lines: string[] } | undefined;
-    let opCache: { key: string; ops: readonly DiffOp[]; hunks: number[]; rows: number; coarse: boolean } | undefined;
+    let cache: { key: string; lines: string[]; shown: number } | undefined;
+    let opCache: { key: string; ops: readonly DiffOp[]; coarse: boolean } | undefined;
+    let paintCache: { path: string; paint: DiffPaint } | undefined;
     const fg = (color: string, text: string) => theme.fg(color as never, text);
+    const context = () => CONTEXT_STEPS[contextIndex]!;
+    const contextLabel = () => Number.isFinite(context()) ? `${context()} line${context() === 1 ? "" : "s"}` : "whole file";
+    // Split columns need room; narrower panes keep the unified layout instead of unreadable halves.
+    const splitMode = () => !unified && bodyWidth >= MIN_SPLIT_WIDTH;
+    const rowLayout = () => {
+      if (!opCache) return { hunks: [] as number[], rows: 0 };
+      return splitMode()
+        ? { hunks: diffSplitHunkOffsets(opCache.ops, context()), rows: diffSplitRowCount(opCache.ops, context()) }
+        : { hunks: diffHunkOffsets(opCache.ops, context()), rows: diffRowCount(opCache.ops, context()) };
+    };
+    // Row offsets change with context and split mode; keep the hunk at the top of the viewport.
+    const relayout = (change: () => void) => {
+      const before = rowLayout().hunks;
+      let hunk = -1;
+      for (let index = 0; index < before.length && before[index]! <= scroll; index++) hunk = index;
+      change();
+      scroll = hunk >= 0 ? rowLayout().hunks[hunk] ?? 0 : 0;
+      cache = undefined;
+    };
+    const paintFor = (change: FileChange): DiffPaint => {
+      if (paintCache?.path !== change.path) {
+        const language = getLanguageFromPath(change.path);
+        const bg = (theme as { getBgAnsi?: (color: "toolSuccessBg" | "toolErrorBg") => string }).getBgAnsi?.bind(theme);
+        paintCache = { path: change.path, paint: {
+          // Per-line highlighting is bounded; very long lines, or a host without Pi's highlighter
+          // theme initialised, keep plain diff colours instead of failing the review.
+          ...(language ? { syntax: (text: string) => {
+            if (text.length > 1000) return undefined;
+            try { return highlightCode(text, language)[0]; } catch { return undefined; }
+          } } : {}),
+          ...(bg ? { tint: (kind: "add" | "remove") => bg(kind === "add" ? "toolSuccessBg" : "toolErrorBg") } : {})
+        } };
+      }
+      return paintCache.paint;
+    };
     const refresh = () => {
       changes = tracker.changes();
       cache = undefined;
@@ -136,10 +244,24 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
     const visibleChanges = () => filterChanges(changes, query).files;
     const currentChange = () => visibleChanges()[selected];
     const select = (index: number) => { selected = Math.max(0, Math.min(visibleChanges().length - 1, index)); scroll = 0; fullReview = false; cache = undefined; opCache = undefined; };
+    const windowAt = (change: FileChange, at: number) => renderDiffWindow(change, bodyWidth, fg, { fullReview, scroll: at, rows: viewportRows,
+      ops: opCache?.ops, coarse: opCache?.coarse, unified: !splitMode(), context: context(), wrap, paint: paintFor(change) });
+    // Wrapped rows vary in height: the last page starts at the first row whose tail fits the
+    // viewport. Measured only when scrolling past the cheap bound, at most one viewport of renders.
+    const lastScroll = () => {
+      const total = rowLayout().rows;
+      let at = Math.max(0, total - viewportRows);
+      const current = currentChange();
+      if (!wrap || !current) return at;
+      while (at < total - 1 && at + windowAt(current, at).shown < total) at++;
+      return at;
+    };
     const scrollBody = (delta: number) => {
-      const max = Math.max(0, (opCache?.rows ?? 0) - viewportRows);
-      scroll = Math.max(0, Math.min(max, scroll + delta)); cache = undefined;
+      const target = scroll + delta;
+      const cheap = Math.max(0, rowLayout().rows - viewportRows);
+      scroll = Math.max(0, target <= cheap ? target : Math.min(target, lastScroll())); cache = undefined;
     };
+    const page = () => Math.max(1, (wrap ? cache?.shown ?? 1 : viewportRows) - 1);
     const component = {
       invalidate() { cache = undefined; },
       handleInput(data: string) {
@@ -168,7 +290,17 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         if (data === "/") { searchMode = true; query = ""; }
         else if (data === "n" && query) select(selected + 1);
         else if (data === "N" && query) select(selected - 1);
-        else if (data === "t") { unified = !unified; cache = undefined; message = unified ? "Unified diff" : "Side-by-side diff"; }
+        else if (data === "t") {
+          relayout(() => { unified = !unified; });
+          message = unified ? "Unified diff" : bodyWidth >= MIN_SPLIT_WIDTH ? "Side-by-side diff" : `Side-by-side needs ${MIN_SPLIT_WIDTH} columns; showing unified`;
+        }
+        else if (matchesKey(data, Key.left) || data === "[") {
+          relayout(() => { contextIndex = Math.max(0, contextIndex - 1); }); message = `Context: ${contextLabel()}`;
+        }
+        else if (matchesKey(data, Key.right) || data === "]") {
+          relayout(() => { contextIndex = Math.min(CONTEXT_STEPS.length - 1, contextIndex + 1); }); message = `Context: ${contextLabel()}`;
+        }
+        else if (data === "w") { wrap = !wrap; cache = undefined; message = wrap ? "Wrapping long lines" : "Truncating long lines"; }
         else if (data === "v" && current && fullReviewRequired(current) && fullReviewSupported(current)) {
           fullReview = !fullReview; scroll = 0; cache = undefined; opCache = undefined; message = fullReview ? "Full windowed review · LCS budget may label a coarse replacement" : "Summary preview";
         }
@@ -178,16 +310,18 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         else if (data === "R" && current) { armed = "all"; message = `revert all ${changes.length} files? press R or y to confirm`; }
         else if (matchesKey(data, Key.up) || data === "k") select(selected - 1);
         else if (matchesKey(data, Key.down) || data === "j") select(selected + 1);
-        else if (matchesKey(data, Key.pageDown) || data === " ") scrollBody(Math.max(1, bodyRows - 2));
-        else if (matchesKey(data, Key.pageUp)) scrollBody(-Math.max(1, bodyRows - 2));
-        else if (data === "n" && !query && opCache?.hunks.length) {
-          scroll = opCache.hunks.find(offset => offset > scroll) ?? opCache.hunks[0]!; cache = undefined;
+        else if (matchesKey(data, Key.pageDown) || data === " ") scrollBody(page());
+        else if (matchesKey(data, Key.pageUp)) scrollBody(-page());
+        else if (data === "n" && !query && rowLayout().hunks.length) {
+          const hunks = rowLayout().hunks;
+          scroll = hunks.find(offset => offset > scroll) ?? hunks[0]!; cache = undefined;
         }
-        else if (data === "p" && opCache?.hunks.length) {
-          scroll = [...opCache.hunks].reverse().find(offset => offset < scroll) ?? opCache.hunks.at(-1)!; cache = undefined;
+        else if (data === "p" && rowLayout().hunks.length) {
+          const hunks = rowLayout().hunks;
+          scroll = [...hunks].reverse().find(offset => offset < scroll) ?? hunks.at(-1)!; cache = undefined;
         }
-        else if (data === "g") scrollBody(-Infinity);
-        else if (data === "G") scrollBody(Infinity);
+        else if (data === "g" || matchesKey(data, Key.home)) scrollBody(-Infinity);
+        else if (data === "G" || matchesKey(data, Key.end)) scrollBody(Infinity);
         tui.requestRender();
       },
       handleMouse(event: TuiMouseEvent) {
@@ -208,23 +342,24 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         width = Math.max(24, available);
         bodyRows = contentRows(7 + ACTIONS.length, 6);
         const listWidth = sidebarWidth(width, 20, 36);
-        const bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
+        bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
         const filtered = visibleChanges();
         const current = filtered[selected];
         if (!current) return [fg("dim", `No files match /${safeLine(query)}`), fg("dim", "Press / to edit the filter or Esc to clear it.")];
         const opKey = `${current.path}:${current.before.length}:${current.after.length}`;
         if (opCache?.key !== opKey && (!fullReviewRequired(current) || fullReview)) {
           const exact = current.diff === null ? undefined : (current.diff ?? lineDiff(current.before, current.after));
-          const coarse = exact === undefined;
-          const ops = exact ?? coarseLineDiff(current.before, current.after);
-          opCache = { key: opKey, ops, hunks: diffHunkOffsets(ops), rows: diffRowCount(ops), coarse };
+          opCache = { key: opKey, ops: exact ?? coarseLineDiff(current.before, current.after), coarse: exact === undefined };
         }
         const pathLines = wrapPath(current.path.replace(/[\x00-\x1f\x7f-\x9f]/g, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`), bodyWidth);
         // Reserve wrapped path, metadata, split/coarse headers and the optional window footer.
-        viewportRows = Math.max(1, bodyRows - pathLines.length - 1 - (unified ? 0 : 1) - (opCache?.coarse ? 1 : 0) - 1);
-        scroll = Math.min(scroll, Math.max(0, (opCache?.rows ?? 0) - viewportRows));
-        const key = `${current.path}:${bodyWidth}:${bodyRows}:${viewportRows}:${unified}:${fullReview}:${scroll}`;
-        if (cache?.key !== key) cache = { key, lines: renderDiff(current, bodyWidth, fg, { fullReview, scroll, rows: viewportRows, ops: opCache?.ops, coarse: opCache?.coarse, unified }) };
+        viewportRows = Math.max(1, bodyRows - pathLines.length - 1 - (splitMode() ? 1 : 0) - (opCache?.coarse ? 1 : 0) - 1);
+        scroll = Math.min(scroll, Math.max(0, rowLayout().rows - (wrap ? 1 : viewportRows)));
+        const key = `${current.path}:${bodyWidth}:${bodyRows}:${viewportRows}:${splitMode()}:${fullReview}:${scroll}:${contextIndex}:${wrap}`;
+        if (cache?.key !== key) {
+          const page = windowAt(current, scroll);
+          cache = { key, lines: page.lines, shown: page.shown };
+        }
         // The absolute path is intentionally the first row of the right pane, even in split mode.
         const content = [...pathLines.map(path => fg("accent", path)),
           fg("dim", `${selected + 1}/${filtered.length} · ${current.status} · +${current.added} −${current.removed}`), ...cache.lines];
@@ -240,8 +375,10 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         const title = `± CHANGES · ${filtered.length}/${changes.length} files · +${totals[0]} −${totals[1]}`;
         const footer = [
           ...optionList(theme, ACTIONS.map((item) => item.label), -1, ACTIONS.map((item) => item.key)),
-          fg(searchMode ? "accent" : "dim", searchMode ? `/${query} · Enter apply · Esc clear` : query ? `/${query} · n/N next match · / new search` : `${SEARCH_HINT} · n/p hunk · t split/unified · v full preview`),
-          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn scroll · a accept · r revert · Esc close")
+          fg(searchMode ? "accent" : "dim", searchMode ? `/${query} · Enter apply · Esc clear`
+            : query ? `/${query} · n/N next match · / new search`
+            : `${SEARCH_HINT} · n/p hunk · t split · ←/→ context (${contextLabel()}) · w wrap${wrap ? " on" : ""} · v full`),
+          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn/Home/End scroll · a accept · r revert · Esc close")
         ];
         const split = splitFrame(theme, width, title, list, content.slice(0, bodyRows), footer, bodyRows, listWidth);
         layout = split.layout;

package/src/discussion.ts

@@ -88,9 +88,10 @@ async function withPaperLock<T>(file: string, run: () => T): Promise<T> {
   throw new Error("discussion paper is busy");
 }
 
-/** Append under the lock; `accept` validates against the same snapshot, so there is one read per write. */
+/** Append under the lock; `accept` validates against the same snapshot, so there is one read per write.
+ *  The written snapshot is returned too, so the caller can piggyback unseen entries without a second read. */
 function append(file: string, actor: string, entry: Omit<DiscussionEntry, "id" | "from" | "at">,
-  accept: (paper: DiscussionPaper) => string | undefined = () => undefined): Promise<DiscussionEntry | string> {
+  accept: (paper: DiscussionPaper) => string | undefined = () => undefined): Promise<{ entry: DiscussionEntry; paper: DiscussionPaper } | string> {
   return withPaperLock(file, () => {
     const paper = readPaper(file);
     const rejected = accept(paper);
@@ -106,7 +107,7 @@ function append(file: string, actor: string, entry: Omit<DiscussionEntry, "id" |
     paper.entries.push(next);
     if (paper.entries.length > MAX_DISCUSSION_ENTRIES) paper.entries.splice(0, paper.entries.length - MAX_DISCUSSION_ENTRIES);
     writePaper(file, paper);
-    return next;
+    return { entry: next, paper };
   });
 }
 
@@ -133,57 +134,94 @@ const render = (entries: readonly DiscussionEntry[], limit: number): string => {
   }
   const omitted = entries.length - lines.length;
   return (omitted ? `(${omitted} older entries omitted; use questionId to read one thread)\n` : "") + lines.join("\n")
-    + `\n(newest: ${entries.at(-1)!.id}; pass since=${entries.at(-1)!.id} to read only newer entries)`;
+    + `\n(latest ${entries.at(-1)!.id})`;
 };
 
+/** Unseen entries piggybacked on an ask/answer reply never exceed this. */
+const MAX_PIGGYBACK_CHARS = 1000;
+
 export function registerDiscussionTool(pi: ExtensionAPI, file: () => string | undefined,
   actor: () => string = () => safeActor(process.env[SUBAGENT_NAME_ENV] ?? process.env[SUBAGENT_KEY_ENV])): void {
+  // Every Pi process (moderator or child) registers its own tool, so this closure is one actor's read
+  // cursor: the highest seq it has been shown on the current paper. A different path, or a paper whose
+  // seq went backwards (recreated), starts over at zero.
+  let cursor = { path: "", seq: 0 };
+  const unseen = (path: string, paper: DiscussionPaper, me: string) => {
+    if (cursor.path !== path || paper.seq < cursor.seq) cursor = { path, seq: 0 };
+    const after = cursor.seq;
+    return paper.entries.filter((entry) => (seqOf(entry.id) ?? 0) > after && entry.from !== me);
+  };
+  const advance = (seq: number) => { cursor.seq = Math.max(cursor.seq, seq); };
+  // The cursor is one max-seq, so it may only move past everything unseen. An ask/answer reply therefore
+  // attaches unseen entries (and advances) only when every unseen non-own entry is relevant to the caller
+  // (a question addressed to it, or an answer to one of its questions) and all of them fit
+  // MAX_PIGGYBACK_CHARS; otherwise it adds a one-line count and leaves them for `list`. The question being
+  // answered (`known`) counts as seen: the caller already has it.
+  const piggyback = (path: string, paper: DiscussionPaper, me: string, known?: string): string => {
+    const fresh = unseen(path, paper, me).filter((entry) => entry.id !== known);
+    if (!fresh.length) { advance(paper.seq); return ""; }
+    const asked = new Set(paper.entries.filter((entry) => entry.kind === "question" && entry.from === me).map((entry) => entry.id));
+    const relevant = fresh.filter((entry) => entry.kind === "question" ? entry.to === me : asked.has(entry.questionId ?? ""));
+    const shown = relevant.map((entry) => entryLine(entry, MAX_LISTED_TEXT)).join("\n");
+    if (relevant.length === fresh.length && shown.length <= MAX_PIGGYBACK_CHARS) { advance(paper.seq); return "\n" + shown; }
+    return `\n(${fresh.length} new ${fresh.length === 1 ? "entry" : "entries"}${relevant.length ? `, ${relevant.length} for you` : ""}; list to read)`;
+  };
   const parameters = Type.Object({
     action: Type.Union([Type.Literal("list"), Type.Literal("ask"), Type.Literal("answer")]),
     text: Type.Optional(Type.String()),
     to: Type.Optional(Type.String()),
     questionId: Type.Optional(Type.String({ description: "answer: the question being answered. list: read only that question and its answers, in full." })),
-    since: Type.Optional(Type.String({ description: "list: only entries newer than this id (e.g. d12), so rereads cost nothing when nothing changed." }))
+    since: Type.Optional(Type.String({ description: "list: entries newer than this id (e.g. d12) instead of only unseen ones; \"d0\" rereads everything." }))
   });
   pi.registerTool?.<typeof parameters, { path?: string; entry?: DiscussionEntry }>({
     name: "jar_discuss",
     label: "discuss",
-    description: `Use the session's bounded shared discussion paper for terse cross-agent questions and answers. Prefer one precise question or answer per call; do not use it as a transcript or scratchpad. list replies are capped at ${MAX_LIST_CHARS} characters.`,
-    promptSnippet: "Use jar_discuss when another subagent needs a concrete question answered without routing a long conversation through the moderator.",
+    description: `Shared bounded Q/A paper between this session's agents; not a transcript. ask/answer reply with the new id only. list returns only entries you have not seen (≤${MAX_LIST_CHARS} chars).`,
+    promptSnippet: "Ask or answer one concrete cross-agent question on the shared discussion paper.",
     promptGuidelines: [
-      "Keep discussion entries short and decision-oriented. Read the paper before answering if the question id is unfamiliar.",
-      "When answering, address only the requested question and cite the question id. Do not continue unrelated task work inside the discussion entry.",
-      "Do not poll list while waiting for an answer: continue your task and check again later with since set to the newest id you saw; use questionId to read one thread."
+      "jar_discuss: one precise question or answer per call; answer only the given questionId. Replies never echo your text.",
+      "Answers to your questions also arrive on your next ask/answer. list shows only unseen entries; questionId reads one thread. Don't poll."
     ],
     parameters,
     async execute(_id, params) {
       const path = file();
       if (!path) return { content: [{ type: "text", text: "No shared discussion paper is active." }], details: {} };
+      const me = safeActor(actor());
       if (params.action === "list") {
-        const entries = discussionEntries(path);
+        const paper = readPaper(path);
         const thread = params.questionId ? cleanText(params.questionId, 24) : undefined;
         if (thread) {
-          const items = entries.filter((entry) => entry.id === thread || entry.questionId === thread);
+          const items = paper.entries.filter((entry) => entry.id === thread || entry.questionId === thread);
           return { content: [{ type: "text", text: render(items, MAX_DISCUSSION_TEXT) }], details: { path } };
         }
         const since = seqOf(params.since);
-        const newer = since === undefined ? entries : entries.filter((entry) => (seqOf(entry.id) ?? 0) > since);
-        if (since !== undefined && !newer.length) return { content: [{ type: "text", text: `No entries newer than ${params.since}.` }], details: { path } };
-        return { content: [{ type: "text", text: render(newer, MAX_LISTED_TEXT) }], details: { path } };
+        const fresh = unseen(path, paper, me);
+        advance(paper.seq);
+        if (since !== undefined) {
+          const newer = paper.entries.filter((entry) => (seqOf(entry.id) ?? 0) > since);
+          const text = newer.length ? render(newer, MAX_LISTED_TEXT) : `No entries newer than ${params.since}.`;
+          return { content: [{ type: "text", text }], details: { path } };
+        }
+        const latest = paper.entries.at(-1)?.id;
+        const text = fresh.length ? render(fresh, MAX_LISTED_TEXT) : `No new entries${latest ? ` (latest ${latest})` : ""}.`;
+        return { content: [{ type: "text", text }], details: { path } };
       }
       const text = cleanText(params.text ?? "", MAX_DISCUSSION_TEXT);
       if (!text) return { content: [{ type: "text", text: "Discussion text is required." }], details: {}, isError: true };
       if (params.action === "ask") {
-        const entry = await append(path, actor(), { kind: "question", text, ...(params.to ? { to: safeActor(params.to) } : {}) });
-        if (typeof entry === "string") return { content: [{ type: "text", text: entry }], details: {}, isError: true };
-        return { content: [{ type: "text", text: `Added ${entry.id}: ${entry.text}` }], details: { path, entry } };
+        const added = await append(path, me, { kind: "question", text, ...(params.to ? { to: safeActor(params.to) } : {}) });
+        if (typeof added === "string") return { content: [{ type: "text", text: added }], details: {}, isError: true };
+        const { entry, paper } = added;
+        const reply = `Added ${entry.id}${entry.to ? ` (→ ${entry.to})` : ""}.` + piggyback(path, paper, me);
+        return { content: [{ type: "text", text: reply }], details: { path, entry } };
       }
       const questionId = cleanText(params.questionId ?? "", 24);
       if (!questionId) return { content: [{ type: "text", text: "questionId is required for an answer." }], details: {}, isError: true };
-      const entry = await append(path, actor(), { kind: "answer", questionId, text }, (paper) =>
+      const added = await append(path, me, { kind: "answer", questionId, text }, (paper) =>
         paper.entries.some((item) => item.kind === "question" && item.id === questionId) ? undefined : "Unknown discussion question: " + questionId);
-      if (typeof entry === "string") return { content: [{ type: "text", text: entry }], details: {}, isError: true };
-      return { content: [{ type: "text", text: `Answered ${questionId}: ${entry.text}` }], details: { path, entry } };
+      if (typeof added === "string") return { content: [{ type: "text", text: added }], details: {}, isError: true };
+      const { entry, paper } = added;
+      return { content: [{ type: "text", text: `Answered ${questionId} as ${entry.id}.` + piggyback(path, paper, me, questionId) }], details: { path, entry } };
     }
   });
 }

package/src/quota.ts

@@ -84,7 +84,18 @@ export async function fetchQuota(provider: QuotaProvider, resolveAuth: (provider
         const item = window as Record<string, unknown>;
         return windowValue({ used: item.used_percent, resetsAt: typeof item.reset_at === "number" ? item.reset_at * 1000 : undefined });
       };
-      return parseQuota({ fiveHour: parse(rate.primary_window), week: parse(rate.secondary_window) });
+      // Window slots are not fixed: Plus accounts get a single weekly `primary_window` and a null
+      // secondary. Classify by `limit_window_seconds` (≤ 1 day is the short window), falling back
+      // to position only when the duration is absent.
+      const quota: Quota = {};
+      for (const [window, fallback] of [[rate.primary_window, "fiveHour"], [rate.secondary_window, "week"]] as const) {
+        const value = parse(window);
+        if (!value) continue;
+        const seconds = (window as Record<string, unknown>).limit_window_seconds;
+        const slot = typeof seconds === "number" && seconds > 0 ? (seconds <= 24 * 60 * 60 ? "fiveHour" : "week") : fallback;
+        if (!quota[slot]) quota[slot] = value;
+      }
+      return parseQuota(quota);
     }
     const parse = (window: unknown): QuotaWindow | undefined => {
       if (!window || typeof window !== "object") return undefined;