@oh-my-pi/pi-tui 18.4.9 → 18.4.11

package/src/components/markdown.ts

@@ -3,11 +3,11 @@ import {
 	Lexer,
 	Marked,
 	type Token,
-	Tokenizer,
 	type TokenizerAndRendererExtension,
+	type TokenizerThis,
 	type Tokens,
 } from "@oh-my-pi/pi-utils/marked";
-import { mathBlockAt, mathSpanAt, mathStartIndex } from "@oh-my-pi/pi-utils/math-delimiters";
+import { mathBlockAt, mathSpanInContext, mathStartIndex } from "@oh-my-pi/pi-utils/math-delimiters";
 import { latexToBlock } from "../latex-block";
 import { isBareMathEnvironment, latexToUnicode } from "../latex-to-unicode";
 import { plainText } from "../native/spans";
@@ -30,8 +30,6 @@ import {
 	wrapTextWithAnsi,
 } from "../utils";
 
-const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
-
 // Marked treats the backslash in an ST-terminated OSC 8 sequence (`ESC \\`) as
 // Markdown punctuation when it is immediately followed by markup such as a
 // codespan backtick. Normalize well-formed OSC 8 prefixes to the equivalent BEL
@@ -506,27 +504,85 @@ function hangWrapTreeGuideLines(text: string, width: number): string[] | undefin
 	return out;
 }
 
-class StrictStrikethroughTokenizer extends Tokenizer {
-	override del(src: string): Tokens.Del | undefined {
-		const match = STRICT_STRIKETHROUGH_REGEX.exec(src);
-		if (!match) {
-			return undefined;
-		}
+const WHITESPACE = /\s/;
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
 
-		const text = match[2];
-		return {
-			type: "del",
-			raw: match[0],
-			text,
-			tokens: this.lexer.inlineTokens(text),
-		};
+/**
+ * GFM strikethrough as upstream marked's rule reads it, with `~~` only: an opener not followed by whitespace or `~`,
+ * text read in units of one character or a backslash and the character after it (not a line break), and the first
+ * `~~` that follows a unit other than whitespace, `~` or a lone `\` and is not followed by another `~`. One scanner
+ * serves one inline source and the link labels and emphasis inside it. A scan also answers for every opener it
+ * passed, which meets the same closer or none, so a line of unclosed openers is read once, not once per opener.
+ */
+class StrikethroughScanner {
+	readonly #source: string;
+	// The last opener whose scan ran, where that scan stopped, and whether a closer stopped it there.
+	#open = -1;
+	#stop = -1;
+	#closed = false;
+
+	constructor(source: string) {
+		this.#source = source;
+	}
+
+	/** The offset of the `~~` closing the strikethrough opened at `open`, or -1. */
+	closeAt(open: number): number {
+		const src = this.#source;
+		const first = src[open + 2];
+		if (!src.startsWith("~~", open) || first === undefined || first === "~" || WHITESPACE.test(first)) return -1;
+		// Past the opener's own "~~" its units are the last scan's, so they meet the same closer or stop.
+		if (this.#open < open && open < this.#stop) return this.#closed ? this.#stop : -1;
+		let at = open + 2;
+		let close = -1;
+		while (at < src.length) {
+			let end: number;
+			let final: boolean;
+			if (src.charCodeAt(at) === 0x5c /* \ */) {
+				if (at + 1 === src.length || LINE_TERMINATOR.test(src[at + 1]!)) break;
+				end = at + 2;
+				final = true;
+			} else {
+				end = at + 1;
+				final = src[at] !== "~" && !WHITESPACE.test(src[at]!);
+			}
+			if (final && src.startsWith("~~", end) && src[end + 2] !== "~") {
+				close = end;
+				break;
+			}
+			at = end;
+		}
+		this.#open = open;
+		this.#stop = close === -1 ? at : close;
+		this.#closed = close !== -1;
+		return close;
 	}
 }
 
+const strikethroughScanners = new WeakMap<TokenizerThis, StrikethroughScanner>();
+
+// Registered after every other inline extension: at a `~~` no built-in rule before marked's `del` can match, so this
+// gives the tokens a `del` override would, and the `del` override below keeps marked's own looser rule out.
+const strikethroughExtension: TokenizerAndRendererExtension = {
+	name: "strictStrikethrough",
+	level: "inline",
+	// No start hint: inline text already stops at every `~`.
+	tokenizer(src) {
+		if (!src.startsWith("~~")) return undefined;
+		const source = this.source ?? src;
+		// Inside a link label or emphasis the text ends at `end`, before its closer (`]`, `*` or `_`), which is not a
+		// `~`, so a closer that ends there closes as it would at the end of the text.
+		const end = this.end ?? source.length;
+		let scanner = strikethroughScanners.get(this);
+		if (!scanner) strikethroughScanners.set(this, (scanner = new StrikethroughScanner(source)));
+		const open = end - src.length;
+		const close = scanner.closeAt(open);
+		if (close === -1 || close + 2 > end) return undefined;
+		const text = source.slice(open + 2, close);
+		return { type: "del", raw: source.slice(open, close + 2), text, tokens: this.lexer.inlineTokens(text) };
+	},
+};
+
 const markdownParser = new Marked();
-markdownParser.setOptions({
-	tokenizer: new StrictStrikethroughTokenizer(),
-});
 
 // Math spans (`$$…$$`, `\[…\]`, `$…$`, `\(…\)`) are tokenized as a dedicated
 // `math` inline token before markdown's escape/emphasis/link rules run, so
@@ -590,9 +646,9 @@ const customHrExtension: TokenizerAndRendererExtension = {
 const mathExtension: TokenizerAndRendererExtension = {
 	name: "math",
 	level: "inline",
-	start: mathStartIndex,
+	startFrom: mathStartIndex,
 	tokenizer(src) {
-		const span = mathSpanAt(src, 0);
+		const span = mathSpanInContext(this, src);
 		if (!span) return undefined;
 		return { type: "math", raw: src.slice(0, span.end), text: span.body, display: span.display };
 	},
@@ -676,64 +732,12 @@ const mathEnvBlockExtension: TokenizerAndRendererExtension = {
 // tokenizer at a valid start. Candidates at a legal boundary fall through
 // (return undefined) to marked's own autolink handling unchanged.
 const AUTOLINK_SCHEME_REGEX = /^(?:www\.|https?:\/\/|ftp:\/\/)/i;
-// Case-insensitive scheme scan replacing /www\.|https?:\/\/|ftp:\/\//i in
-// boundedAutolinkExtension.start — like `mathStartIndex`, this runs on the
-// remaining source at every inline position (part of a ~4.3% CPU start() scan
-// tail in profiles). charCode-only: no allocation, no toLowerCase copies.
-// `| 32` lower-cases ASCII letters; `.`/`:`/`/` are compared exactly, matching
-// the regex's ASCII-only `i` semantics. charCodeAt past the end returns NaN,
-// which fails every comparison, so no explicit bounds checks are needed.
-function isAutolinkSchemeAt(src: string, i: number): boolean {
-	const c = src.charCodeAt(i) | 32;
-	if (c === 119 /* w */) {
-		// www.
-		return (
-			(src.charCodeAt(i + 1) | 32) === 119 &&
-			(src.charCodeAt(i + 2) | 32) === 119 &&
-			src.charCodeAt(i + 3) === 46 /* . */
-		);
-	}
-	if (c === 104 /* h */) {
-		// http:// | https://
-		if (
-			(src.charCodeAt(i + 1) | 32) !== 116 /* t */ ||
-			(src.charCodeAt(i + 2) | 32) !== 116 /* t */ ||
-			(src.charCodeAt(i + 3) | 32) !== 112 /* p */
-		) {
-			return false;
-		}
-		let j = i + 4;
-		if ((src.charCodeAt(j) | 32) === 115 /* s */) j++;
-		return src.charCodeAt(j) === 58 /* : */ && src.charCodeAt(j + 1) === 47 /* / */ && src.charCodeAt(j + 2) === 47;
-	}
-	if (c === 102 /* f */) {
-		// ftp://
-		return (
-			(src.charCodeAt(i + 1) | 32) === 116 /* t */ &&
-			(src.charCodeAt(i + 2) | 32) === 112 /* p */ &&
-			src.charCodeAt(i + 3) === 58 /* : */ &&
-			src.charCodeAt(i + 4) === 47 /* / */ &&
-			src.charCodeAt(i + 5) === 47 /* / */
-		);
-	}
-	return false;
-}
-
-/** @internal exported for tests — must stay index-identical to the old regex scan. */
-export function autolinkSchemeScanIndex(src: string): number | undefined {
-	for (let i = 0; i < src.length; i++) {
-		const c = src.charCodeAt(i) | 32;
-		if ((c === 119 || c === 104 || c === 102) && isAutolinkSchemeAt(src, i)) return i;
-	}
-	return undefined;
-}
 const VALID_AUTOLINK_LEFT_BOUNDARY = /[\s*_~(]/;
 const boundedAutolinkExtension: TokenizerAndRendererExtension = {
 	name: "boundedAutolink",
 	level: "inline",
-	start(src) {
-		return autolinkSchemeScanIndex(src);
-	},
+	// No start hint: inline text already stops at every `www.`, `http://`, `https://` and `ftp://`, the only places
+	// this tokenizer matches.
 	tokenizer(src, tokens) {
 		const match = AUTOLINK_SCHEME_REGEX.exec(src);
 		if (!match) return undefined;
@@ -747,59 +751,16 @@ const boundedAutolinkExtension: TokenizerAndRendererExtension = {
 	},
 };
 markdownParser.use({
-	extensions: [customHrExtension, mathBlockExtension, mathEnvBlockExtension, mathExtension, boundedAutolinkExtension],
+	extensions: [
+		customHrExtension,
+		mathBlockExtension,
+		mathEnvBlockExtension,
+		mathExtension,
+		boundedAutolinkExtension,
+		strikethroughExtension,
+	],
 });
 
-// ---------------------------------------------------------------------------
-// GFM `url` tokenizer gate
-// ---------------------------------------------------------------------------
-// marked tries the bundled GFM `url` tokenizer at every inline tokenization
-// step, and its regex is expensive to FAIL: the email alternative
-// `^[A-Za-z0-9._+-]+(@)…` linearly consumes an identifier run, then backtracks
-// it one character at a time when no `@` follows. A 71414-sample / 1ms CPU
-// profile of the TUI put 73.3% of total CPU (74.9s of a 102s capture) inside
-// this single regex. The override below runs an O(bounded) charCode gate first
-// and only falls through to the built-in tokenizer — by returning `false`,
-// marked's tokenizer-override fallback contract — when a match is possible.
-//
-// Conservativeness argument. The built-in rule (no flags) is
-//   /^((?:[hH][tT][tT][pP][sS]?|[fF][tT][pP]):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*
-//    |^[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/
-// Both alternatives are anchored, so any match constrains the head of src:
-//  • Branch 1 requires src to start with `http://`, `https://`, `ftp://`
-//    (scheme letters in any case) or lowercase `www.`. The gate accepts all of
-//    these via isAutolinkSchemeAt(src, 0); it also over-accepts `WWW.`, a
-//    harmless false positive (the built-in regex simply fails to match).
-//  • Branch 2 requires src to start with one-or-more chars from
-//    `[A-Za-z0-9._+-]` immediately followed by `@`. The gate scans that exact
-//    class: if the run ends within URL_GATE_EMAIL_SCAN_LIMIT chars it accepts
-//    iff the terminator is `@`; a run reaching the limit is accepted
-//    unconditionally. Every src branch 2 can match is therefore accepted —
-//    the gate never rejects a src the built-in regex would match.
-const URL_GATE_EMAIL_SCAN_LIMIT = 320;
-
-/** @internal exported for tests — must never return false for a src the built-in url regex matches. */
-export function urlTokenPossible(src: string): boolean {
-	if (isAutolinkSchemeAt(src, 0)) return true;
-	let i = 0;
-	while (i < URL_GATE_EMAIL_SCAN_LIMIT) {
-		const c = src.charCodeAt(i);
-		const isLocalChar =
-			(c >= 97 && c <= 122) /* a-z */ ||
-			(c >= 65 && c <= 90) /* A-Z */ ||
-			(c >= 48 && c <= 57) /* 0-9 */ ||
-			c === 46 /* . */ ||
-			c === 95 /* _ */ ||
-			c === 43 /* + */ ||
-			c === 45; /* - */
-		if (!isLocalChar) break;
-		i++;
-	}
-	if (i === 0) return false;
-	if (i >= URL_GATE_EMAIL_SCAN_LIMIT) return true; // over-long run: give up conservatively
-	return src.charCodeAt(i) === 64; /* @ */
-}
-
 // Setext-underline pre-gate for marked's `lheading` rule. The rule's lazy body
 // `((?:.|\n(?!<block-start>))+?)` re-runs its block-start lookahead while
 // expanding character by character, so even a FAILING attempt at offset 0
@@ -826,12 +787,11 @@ markdownParser.use({
 	tokenizer: {
 		// `false` → marked falls back to the built-in tokenizer;
 		// `undefined` → no token here, built-in never runs.
-		url(src: string): Tokens.Link | undefined | false {
-			return urlTokenPossible(src) ? false : undefined;
-		},
 		lheading(src: string): Tokens.Heading | undefined | false {
 			return lheadingPossible(src) ? false : undefined;
 		},
+		// Strikethrough is `strikethroughExtension`'s: marked's own looser rule never runs.
+		del: () => undefined,
 	},
 });
 

package/src/keys.ts

@@ -24,7 +24,7 @@ import {
 	parseKey as parseKeyNative,
 	parseKittySequence as parseKittySequenceNative,
 } from "@oh-my-pi/pi-natives";
-import { isInsideTerminalMultiplexer } from "./terminal-capabilities";
+import { isInsideTerminalMultiplexer, isSshSession } from "./terminal-capabilities";
 
 // =============================================================================
 // Platform Detection
@@ -32,9 +32,7 @@ import { isInsideTerminalMultiplexer } from "./terminal-capabilities";
 
 /** Whether the local process is running directly under Windows Terminal. */
 export function isWindowsTerminalSession(): boolean {
-	return (
-		Boolean(process.env.WT_SESSION) && !process.env.SSH_CONNECTION && !process.env.SSH_CLIENT && !process.env.SSH_TTY
-	);
+	return Boolean(process.env.WT_SESSION) && !isSshSession();
 }
 
 /**

package/src/native/encode.ts

@@ -169,6 +169,8 @@ const EVENT_REQUIRED: Readonly<Record<string, Readonly<Record<string, "string" |
 	select: { id: "string", item: "string" },
 	activate: { id: "string", item: "string" },
 	action: { id: "string", act: "string" },
+	// `value` varies by control (boolean, number, string, string[], null): the handler checks it.
+	change: { id: "string", item: "string" },
 	edit: { id: "string", from: "number", to: "number", text: "string", cursor: "number", len: "number" },
 	focus: { id: "string" },
 	error: { msg: "string" },

package/src/overlays/advisor-config.ts

@@ -44,6 +44,12 @@ import { col, node, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
 import { actionHint, hintsRow, type NativeHint, overlayCard } from "../native/overlay";
 
+export const ADVISOR_REVIEW_MODES = ["turn", "agent-end"] as const;
+export const ADVISOR_SYNC_BACKLOG_MODES = ["off", "1", "3", "5", "strict"] as const;
+
+export type AdvisorReviewMode = (typeof ADVISOR_REVIEW_MODES)[number];
+export type AdvisorSyncBacklog = (typeof ADVISOR_SYNC_BACKLOG_MODES)[number];
+
 /** One advisor declared in `WATCHDOG.yml`; its instructions specialize the shared baseline. */
 export interface AdvisorConfig {
 	name: string;
@@ -56,6 +62,9 @@ export interface AdvisorConfig {
 	enabled?: boolean;
 	/** Maximum non-blocker notes per advisor prompt update (default 4); blockers are exempt. */
 	maxNotesPerUpdate?: number;
+	reviewMode?: AdvisorReviewMode;
+	reviewInterval?: number;
+	syncBacklog?: AdvisorSyncBacklog;
 }
 
 /** Which level a `WATCHDOG.yml` lives at: the project root or the user agent dir. */
@@ -115,6 +124,7 @@ export interface AdvisorConfigDeps {
 	externalEditor?: (text: string) => Promise<string | null>;
 	scopedModels: ReadonlyArray<{ model: Model; thinkingLevel?: ThinkingLevel }>;
 	availableToolNames: string[];
+	syncBacklog?: AdvisorSyncBacklog;
 	/** Formatted advisor-role model shown on the seeded default row (e.g. "anthropic/claude-..."). */
 	defaultModelLabel?: string;
 }
@@ -192,13 +202,44 @@ function formatAdvisorTools(tools: readonly string[] | undefined, emptyLabel: st
 	return tools.length > 0 ? tools.join(", ") : emptyLabel;
 }
 
+/** Choice value for "no per-advisor override"; matches no {@link ADVISOR_SYNC_BACKLOG_MODES} entry. */
+const SYNC_BACKLOG_INHERIT = "inherit";
+
+/** One-line cadence label: mode plus interval. */
+function formatReviewCadence(advisor: AdvisorConfig): string {
+	const reviewInterval = advisor.reviewInterval ?? 1;
+	return `${advisor.reviewMode ?? "turn"} · every ${reviewInterval} eligible update${reviewInterval === 1 ? "" : "s"}`;
+}
+
+/** Picker description for one explicit catch-up policy value. */
+function describeSyncBacklogMode(mode: AdvisorSyncBacklog): string {
+	switch (mode) {
+		case "off":
+			return "Never wait for this advisor's backlog.";
+		case "strict":
+			return "Wait for all of this advisor's scheduled reviews; no wall-clock cap.";
+		default:
+			return `Wait until fewer than ${mode} scheduled reviews remain (30s cap).`;
+	}
+}
+
 /** Soft-wrap plain text to `width`, returning at least one (possibly empty) line. */
 function wrap(text: string, width: number): string[] {
 	if (!text) return [""];
 	return Bun.wrapAnsi(text, Math.max(1, width), { trim: false }).split("\n");
 }
 
-type Screen = "list" | "detail" | "name" | "model" | "tools" | "thinking" | "instructions";
+type Screen =
+	| "list"
+	| "detail"
+	| "name"
+	| "model"
+	| "tools"
+	| "thinking"
+	| "review-mode"
+	| "review-interval"
+	| "sync-backlog"
+	| "instructions";
 
 /** Footer key hints per screen for the described overlay (the ANSI footer strings carry the same keys). */
 function screenHints(screen: Screen): (NativeHint | undefined)[] {
@@ -220,7 +261,11 @@ function screenHints(screen: Screen): (NativeHint | undefined)[] {
 				actionHint("tui.select.cancel", "back"),
 			];
 		case "thinking":
+		case "review-mode":
+		case "sync-backlog":
 			return [actionHint("tui.select.confirm", "pick"), actionHint("tui.select.cancel", "back")];
+		case "review-interval":
+			return [actionHint("tui.input.submit", "save"), actionHint("tui.select.cancel", "cancel")];
 		case "tools":
 			return [
 				actionHint("tui.select.confirm", "toggle"),
@@ -432,6 +477,44 @@ export class AdvisorConfigOverlayComponent implements Component {
 					defaultLabel: model ? (this.#defaultModelLabel ?? "advisor role default") : undefined,
 					control: { k: "action", label: model || this.#defaultModelLabel || "advisor role default", act: "edit" },
 				},
+				{
+					id: "reviewMode",
+					label: "Review mode",
+					hint: "turn reviews every primary turn; agent-end reviews only final yields.",
+					changed: advisor.reviewMode !== undefined ? true : undefined,
+					control: {
+						k: "choice",
+						value: advisor.reviewMode ?? "turn",
+						options: ADVISOR_REVIEW_MODES.map(mode => ({ value: mode, label: mode })),
+						style: "segmented",
+					},
+				},
+				{
+					id: "reviewInterval",
+					label: "Review interval",
+					hint: "Review every Nth eligible update; skipped updates join the next review.",
+					changed: advisor.reviewInterval !== undefined ? true : undefined,
+					control: { k: "number", value: advisor.reviewInterval ?? 1, min: 1, step: 1 },
+				},
+				{
+					id: "syncBacklog",
+					label: "Sync backlog",
+					hint: `Catch-up policy; inherit follows advisor.syncBacklog (currently ${this.#deps.syncBacklog ?? "off"}).`,
+					changed: advisor.syncBacklog !== undefined ? true : undefined,
+					control: {
+						k: "choice",
+						value: advisor.syncBacklog ?? SYNC_BACKLOG_INHERIT,
+						options: [
+							{ value: SYNC_BACKLOG_INHERIT, label: "inherit" },
+							...ADVISOR_SYNC_BACKLOG_MODES.map(mode => ({
+								value: mode,
+								label: mode,
+								detail: describeSyncBacklogMode(mode),
+							})),
+						],
+						style: "menu",
+					},
+				},
 				{
 					id: "tools",
 					label: "Tools",
@@ -499,6 +582,9 @@ export class AdvisorConfigOverlayComponent implements Component {
 		const overlay =
 			this.#screen === "model" ||
 			this.#screen === "thinking" ||
+			this.#screen === "review-mode" ||
+			this.#screen === "review-interval" ||
+			this.#screen === "sync-backlog" ||
 			this.#screen === "tools" ||
 			this.#screen === "instructions";
 		const editor = overlay ? this.#active : undefined;
@@ -573,6 +659,24 @@ export class AdvisorConfigOverlayComponent implements Component {
 					advisor.name = event.value.trim();
 					this.#dirty = true;
 					this.#showDetail(index);
+				} else if (event.item === "reviewMode" && (typeof event.value === "string" || event.value === null)) {
+					// `turn` is the default, stored as an omitted field; `null` resets to it.
+					const mode = event.value === null ? "turn" : ADVISOR_REVIEW_MODES.find(m => m === event.value);
+					if (!mode) return;
+					advisor.reviewMode = mode === "turn" ? undefined : mode;
+					this.#dirty = true;
+					this.#showDetail(index);
+				} else if (event.item === "reviewInterval" && (typeof event.value === "number" || event.value === null)) {
+					const interval = event.value ?? 1;
+					if (!Number.isSafeInteger(interval) || interval < 1) return;
+					advisor.reviewInterval = interval === 1 ? undefined : interval;
+					this.#dirty = true;
+					this.#showDetail(index);
+				} else if (event.item === "syncBacklog" && (typeof event.value === "string" || event.value === null)) {
+					// The inherit sentinel and `null` match no mode, so the override clears.
+					advisor.syncBacklog = ADVISOR_SYNC_BACKLOG_MODES.find(mode => mode === event.value);
+					this.#dirty = true;
+					this.#showDetail(index);
 				}
 				return;
 			}
@@ -689,6 +793,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 					{ k: "Enabled", v: advisor.enabled === false ? "○ off" : "● on" },
 					{ k: "Model", v: model },
 					{ k: "Tools", v: formatAdvisorTools(advisor.tools, "no tools") },
+					{ k: "Review", v: formatReviewCadence(advisor) },
+					{ k: "Sync backlog", v: this.#syncBacklogLabel(advisor) },
 				],
 			}),
 			text([span("Instructions:", "dim")]),
@@ -822,12 +928,15 @@ export class AdvisorConfigOverlayComponent implements Component {
 	#advisorPreview(advisor: AdvisorConfig, bodyWidth: number): string[] {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const tools = formatAdvisorTools(advisor.tools, "no tools");
+		const syncBacklog = this.#syncBacklogLabel(advisor);
 		const lines = [
 			theme.bold(advisor.name || "(unnamed)"),
 			"",
 			`${theme.fg("dim", "Enabled:")} ${advisor.enabled === false ? "○ off" : "● on"}`,
 			`${theme.fg("dim", "Model:")} ${model}`,
 			`${theme.fg("dim", "Tools:")} ${tools}`,
+			`${theme.fg("dim", "Review:")} ${formatReviewCadence(advisor)}`,
+			`${theme.fg("dim", "Sync backlog:")} ${syncBacklog}`,
 			"",
 			theme.fg("dim", "Instructions:"),
 		];
@@ -893,6 +1002,9 @@ export class AdvisorConfigOverlayComponent implements Component {
 			advisor?.name === "default" &&
 			!advisor.model?.trim() &&
 			advisor.tools === undefined &&
+			advisor.reviewMode === undefined &&
+			advisor.reviewInterval === undefined &&
+			advisor.syncBacklog === undefined &&
 			!advisor.instructions?.trim() &&
 			advisor.enabled !== false &&
 			advisor.maxNotesPerUpdate === undefined
@@ -902,7 +1014,12 @@ export class AdvisorConfigOverlayComponent implements Component {
 	#advisorSummary(advisor: AdvisorConfig): string {
 		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const tools = formatAdvisorTools(advisor.tools, "no tools");
-		return `${model} · ${tools}`;
+		return `${model} · ${tools} · review ${advisor.reviewMode ?? "turn"}/${advisor.reviewInterval ?? 1}`;
+	}
+
+	/** The advisor's explicit catch-up override, else the inherited global policy. */
+	#syncBacklogLabel(advisor: AdvisorConfig): string {
+		return advisor.syncBacklog ?? `${this.#deps.syncBacklog ?? "off"} (inherited)`;
 	}
 
 	#showList(): void {
@@ -1000,6 +1117,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 		this.#detailIndex = index;
 		const modelDescription = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
 		const toolsDescription = formatAdvisorTools(advisor.tools, "no tools");
+		const reviewMode = advisor.reviewMode ?? "turn";
+		const reviewInterval = advisor.reviewInterval ?? 1;
 		const items: SelectItem[] = [
 			{ value: "name", label: "Name", description: advisor.name },
 			{
@@ -1008,6 +1127,13 @@ export class AdvisorConfigOverlayComponent implements Component {
 				description: advisor.enabled === false ? "○ off" : "● on",
 			},
 			{ value: "model", label: "Model", description: modelDescription },
+			{ value: "reviewMode", label: "Review mode", description: reviewMode },
+			{ value: "reviewInterval", label: "Review interval", description: String(reviewInterval) },
+			{
+				value: "syncBacklog",
+				label: "Sync backlog",
+				description: this.#syncBacklogLabel(advisor),
+			},
 		];
 		if (advisor.model?.trim()) {
 			items.push({ value: "resetModel", label: "Reset model to advisor-role default" });
@@ -1043,6 +1169,15 @@ export class AdvisorConfigOverlayComponent implements Component {
 			case "model":
 				this.#showModelPicker(index);
 				return;
+			case "reviewMode":
+				this.#showReviewModePicker(index);
+				return;
+			case "reviewInterval":
+				this.#showReviewIntervalEditor(index);
+				return;
+			case "syncBacklog":
+				this.#showSyncBacklogPicker(index);
+				return;
 			case "tools":
 				this.#showToolsEditor(index, new Set(this.#doc.advisors[index].tools ?? this.#deps.defaultToolNames), 0);
 				return;
@@ -1137,6 +1272,97 @@ export class AdvisorConfigOverlayComponent implements Component {
 			`Thinking effort for ${selector} · ${editorKey("tui.select.confirm")} / click pick · ${editorKey("tui.select.cancel")} back`,
 		);
 	}
+	#showReviewModePicker(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const current = advisor.reviewMode ?? ADVISOR_REVIEW_MODES[0];
+		const items: SelectItem[] = ADVISOR_REVIEW_MODES.map(mode => ({
+			value: mode,
+			label: mode === current ? `${mode} (current)` : mode,
+			description:
+				mode === "turn"
+					? "Review every primary turn (tool-call round)."
+					: "Review only at agent end (once per run).",
+		}));
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.setSelectedIndex(ADVISOR_REVIEW_MODES.indexOf(current));
+		list.onSelect = item => {
+			advisor.reviewMode = item.value === "turn" ? undefined : "agent-end";
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		list.onCancel = () => this.#showDetail(index);
+		this.#setScreen(
+			"review-mode",
+			list,
+			`${editorKey("tui.select.confirm")} / click choose review mode · ${editorKey("tui.select.cancel")} back`,
+		);
+	}
+
+	#showReviewIntervalEditor(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const input = new Input();
+		input.setValue(String(advisor.reviewInterval ?? 1));
+		input.onSubmit = value => {
+			const interval = Number(value.trim());
+			if (!Number.isSafeInteger(interval) || interval < 1) {
+				this.#cb.notify("Review interval must be a positive integer.");
+				return;
+			}
+			advisor.reviewInterval = interval === 1 ? undefined : interval;
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		input.onEscape = () => this.#showDetail(index);
+		this.#setScreen(
+			"review-interval",
+			input,
+			`Type a positive integer · ${editorKey("tui.input.submit")} save · ${editorKey("tui.select.cancel")} cancel`,
+		);
+	}
+
+	#showSyncBacklogPicker(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const global = this.#deps.syncBacklog ?? "off";
+		const current = advisor.syncBacklog;
+		const items: SelectItem[] = [
+			{
+				value: SYNC_BACKLOG_INHERIT,
+				label: current === undefined ? "inherit (current)" : "inherit",
+				description: `Follow the global advisor.syncBacklog setting (currently "${global}").`,
+			},
+			...ADVISOR_SYNC_BACKLOG_MODES.map(mode => ({
+				value: mode,
+				label: mode === current ? `${mode} (current)` : mode,
+				description: describeSyncBacklogMode(mode),
+			})),
+		];
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.setSelectedIndex(current === undefined ? 0 : ADVISOR_SYNC_BACKLOG_MODES.indexOf(current) + 1);
+		list.onSelect = item => {
+			// The inherit sentinel matches no mode, so `find` yields undefined — the override clears.
+			advisor.syncBacklog = ADVISOR_SYNC_BACKLOG_MODES.find(mode => mode === item.value);
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		list.onCancel = () => this.#showDetail(index);
+		this.#setScreen(
+			"sync-backlog",
+			list,
+			`${editorKey("tui.select.confirm")} / click choose catch-up policy · ${editorKey("tui.select.cancel")} back`,
+		);
+	}
 
 	#showToolsEditor(index: number, selected: Set<string>, cursor: number): void {
 		const all = this.#availableToolNames;

package/src/overlays/ask-dialog.ts

@@ -528,6 +528,7 @@ export function normalizeDialogQuestions(questions: ExtensionAskDialogQuestion[]
 }
 
 export class AskDialogComponent implements Component {
+	readonly retireDisplacedTranscript = true;
 	#states: QuestionState[];
 	#activeTabIndex = 0;
 	#submitScrollOffset = 0;