@oh-my-pi/pi-coding-agent 16.1.0 → 16.1.2

package/src/lsp/client.ts

@@ -5,6 +5,7 @@ import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
 	LspClient,
+	LspJsonRpcId,
 	LspJsonRpcNotification,
 	LspJsonRpcRequest,
 	LspJsonRpcResponse,
@@ -416,7 +417,6 @@ function currentWorkspaceFolders(client: LspClient): Array<{ uri: string; name:
  * Handle workspace/workspaceFolders requests from the server.
  */
 async function handleWorkspaceFoldersRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	await sendResponse(client, message.id, currentWorkspaceFolders(client), "workspace/workspaceFolders");
 }
 
@@ -424,7 +424,6 @@ async function handleWorkspaceFoldersRequest(client: LspClient, message: LspJson
  * Handle workspace/configuration requests from the server.
  */
 async function handleConfigurationRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	const params = message.params as { items?: Array<{ section?: string }> };
 	const items = params?.items ?? [];
 	const result = items.map(item => {
@@ -438,7 +437,6 @@ async function handleConfigurationRequest(client: LspClient, message: LspJsonRpc
  * Handle workspace/applyEdit requests from the server.
  */
 async function handleApplyEditRequest(client: LspClient, message: LspJsonRpcRequest): Promise<void> {
-	if (typeof message.id !== "number") return;
 	const params = message.params as { edit?: WorkspaceEdit };
 	if (!params?.edit) {
 		await sendResponse(
@@ -475,13 +473,15 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
 		return;
 	}
 	if (message.method === "window/workDoneProgress/create") {
-		// Accept progress token registration from the server
-		if (typeof message.id === "number") {
-			await sendResponse(client, message.id, null, message.method);
-		}
+		// Accept progress token registration from the server.
+		await sendResponse(client, message.id, null, message.method);
+		return;
+	}
+	if (message.method === "client/registerCapability" || message.method === "client/unregisterCapability") {
+		// Some servers block semantic requests until dynamic registration succeeds.
+		await sendResponse(client, message.id, null, message.method);
 		return;
 	}
-	if (typeof message.id !== "number") return;
 	await sendResponse(client, message.id, null, message.method, {
 		code: -32601,
 		message: `Method not found: ${message.method}`,
@@ -493,7 +493,7 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
  */
 async function sendResponse(
 	client: LspClient,
-	id: number,
+	id: LspJsonRpcId,
 	result: unknown,
 	method: string,
 	error?: { code: number; message: string; data?: unknown },

package/src/lsp/types.ts

@@ -399,7 +399,7 @@ export interface LspClient {
 	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;
 	openFiles: Map<string, OpenFile>;
-	pendingRequests: Map<number, PendingRequest>;
+	pendingRequests: Map<number | string, PendingRequest>;
 	messageBuffer: Uint8Array;
 	isReading: boolean;
 	/** Lifecycle state: "connecting" until initialize completes, then "ready"; "error" on init failure or reader death. */
@@ -420,16 +420,19 @@ export interface LspClient {
 // JSON-RPC Protocol Types
 // =============================================================================
 
+/** JSON-RPC request/response identifier accepted by LSP peers. */
+export type LspJsonRpcId = number | string;
+
 export interface LspJsonRpcRequest {
 	jsonrpc: "2.0";
-	id: number;
+	id: LspJsonRpcId;
 	method: string;
 	params: unknown;
 }
 
 export interface LspJsonRpcResponse {
 	jsonrpc: "2.0";
-	id?: number;
+	id?: LspJsonRpcId;
 	result?: unknown;
 	error?: { code: number; message: string; data?: unknown };
 }

package/src/main.ts

@@ -11,6 +11,7 @@ import { EventLoopKeepalive } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import {
 	$env,
+	directoryExists,
 	getLogPath,
 	getProjectDir,
 	logger,
@@ -575,7 +576,11 @@ async function moveMissingCwdSessionIfNeeded(
 		return { status: "declined" };
 	}
 
-	const manager = await SessionManager.open(session.path, sessionDir);
+	// Open anchored at the (now-missing) recorded cwd: `open` otherwise falls back
+	// to the launch cwd, which would make the `moveTo` below a no-op whenever the
+	// move target equals the current project dir. moveTo never chdirs, so the
+	// stale cwd is only a relocation source, not a directory we enter.
+	const manager = await SessionManager.open(session.path, sessionDir, undefined, { initialCwd: sourceCwd });
 	await manager.moveTo(cwd, sessionDir);
 	return { status: "moved", manager };
 }
@@ -751,6 +756,20 @@ function discoverAppendSystemPromptFile(): string | undefined {
 	return undefined;
 }
 
+/** Apply resolved CLI/discovered prompt files without bypassing system prompt templates. */
+export function applyResolvedSystemPromptInputs(
+	options: CreateAgentSessionOptions,
+	resolvedSystemPrompt: string | undefined,
+	resolvedAppendPrompt: string | undefined,
+): void {
+	if (resolvedSystemPrompt) {
+		options.customSystemPrompt = resolvedSystemPrompt;
+	}
+	if (resolvedAppendPrompt) {
+		options.appendSystemPrompt = resolvedAppendPrompt;
+	}
+}
+
 async function buildSessionOptions(
 	parsed: Args,
 	scopedModels: ScopedModel[],
@@ -875,13 +894,7 @@ async function buildSessionOptions(
 	// (handled by caller before createAgentSession)
 
 	// System prompt
-	if (resolvedSystemPrompt && resolvedAppendPrompt) {
-		options.systemPrompt = defaultPrompt => [resolvedSystemPrompt, resolvedAppendPrompt, ...defaultPrompt.slice(1)];
-	} else if (resolvedSystemPrompt) {
-		options.systemPrompt = defaultPrompt => [resolvedSystemPrompt, ...defaultPrompt.slice(1)];
-	} else if (resolvedAppendPrompt) {
-		options.systemPrompt = defaultPrompt => [...defaultPrompt, resolvedAppendPrompt];
-	}
+	applyResolvedSystemPromptInputs(options, resolvedSystemPrompt, resolvedAppendPrompt);
 
 	// Tools
 	if (parsed.noTools) {
@@ -1141,7 +1154,14 @@ export async function runRootCommand(
 		// Resuming a session from another project: switch the process into that
 		// project's directory and refresh cwd-derived caches before the session is
 		// built, so settings discovery, plugins, and capabilities all scope to it.
-		if (selected.cwd && normalizePathForComparison(selected.cwd) !== normalizePathForComparison(getProjectDir())) {
+		// Skip the chdir when the recorded project directory is gone: `setProjectDir`
+		// would throw on the missing path. `SessionManager.open` then falls back to
+		// the launch cwd, so the resumed session simply stays where the user is.
+		if (
+			selected.cwd &&
+			normalizePathForComparison(selected.cwd) !== normalizePathForComparison(getProjectDir()) &&
+			(await directoryExists(selected.cwd))
+		) {
 			// Let the original (launch-cwd) plugin-root preload settle first so its
 			// late resolution can't clobber the re-warm we trigger below.
 			await pluginPreloadPromise.catch(() => {});

package/src/modes/components/assistant-message.ts

@@ -16,6 +16,59 @@ import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cach
  */
 const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
+/**
+ * A GFM table delimiter row (`| --- | :--: |`, with or without bounding pipes).
+ * The header row alone does not render a table — this delimiter is what makes
+ * Markdown lay one out, and a streaming table re-aligns its columns as rows
+ * arrive. Requires at least one column pipe so a bare thematic break (`---`)
+ * does not match.
+ */
+const MARKDOWN_TABLE_DELIMITER = /^ {0,3}\|?(?:[ \t]*:?-+:?[ \t]*\|)+[ \t]*:?-*:?[ \t]*$/;
+
+/** Opening or closing fence of a code block: ≥3 backticks/tildes plus info string. */
+const CODE_FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+
+/**
+ * Whether `text` currently contains reflowing Markdown whose layout is not yet
+ * permanent: an open ` ```mermaid ` fence (the diagram reshapes as source
+ * arrives) or a GFM table (columns re-align as rows arrive). Used by
+ * {@link AssistantMessageComponent.isTranscriptBlockCommitStable}.
+ *
+ * Fence-aware: a mermaid block is detected by its opener, and table delimiters
+ * inside ordinary fenced code (shell pipes, ASCII separators, doc examples) are
+ * ignored so a long streamed code block is never held out of native scrollback.
+ * A delimiter counts only directly under a pipe-bearing header row, outside any
+ * code fence.
+ */
+function detectLiveReflowingMarkdown(text: string): boolean {
+	let fence: string | null = null;
+	let prevLine = "";
+	for (const line of text.split("\n")) {
+		const fenceMatch = CODE_FENCE_LINE.exec(line);
+		if (fence !== null) {
+			// Inside a code block: only a bare matching closing fence ends it.
+			if (
+				fenceMatch &&
+				fenceMatch[2]!.trim() === "" &&
+				fenceMatch[1]![0] === fence[0] &&
+				fenceMatch[1]!.length >= fence.length
+			) {
+				fence = null;
+			}
+			continue;
+		}
+		if (fenceMatch) {
+			if (/^mermaid\b/.test(fenceMatch[2]!.trim())) return true;
+			fence = fenceMatch[1]!;
+			prevLine = "";
+			continue;
+		}
+		if (prevLine.includes("|") && MARKDOWN_TABLE_DELIMITER.test(line)) return true;
+		prevLine = line;
+	}
+	return false;
+}
+
 /**
  * Frames for the streaming "thinking" pulse rendered in place of a hidden
  * thinking block while the model is still producing it. A single fixed-width
@@ -36,6 +89,15 @@ export class AssistantMessageComponent extends Container {
 	#convertedKittyImages = new Map<string, ImageContent>();
 	#kittyConversionsInFlight = new Set<string>();
 	#transcriptBlockFinalized: boolean;
+	/**
+	 * True while a non-finalized text item carries reflowing Markdown — a
+	 * ` ```mermaid ` fence or a GFM table — whose layout re-flows every frame as
+	 * source arrives (a diagram reshaping, a table re-aligning its columns), so
+	 * no prefix is byte-stable until the message finalizes. See
+	 * {@link isTranscriptBlockCommitStable}. Recomputed in {@link updateContent}
+	 * ahead of the fast-path return, so it tracks every stream tick.
+	 */
+	#hasLiveReflowingMarkdown = false;
 	/**
 	 * When true, the turn-ending `Error: …` line for `stopReason === "error"` is
 	 * suppressed because the same error is currently shown in the pinned banner
@@ -192,6 +254,21 @@ export class AssistantMessageComponent extends Container {
 		return this.#transcriptBlockFinalized;
 	}
 
+	/**
+	 * Whether this still-live block's scrolled-off rows may be committed to
+	 * immutable native scrollback (the {@link TranscriptContainer} durable-
+	 * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
+	 * table — re-lays-out its body as source arrives (the diagram reshapes, the
+	 * table re-aligns its columns), so committing an intermediate layout strands
+	 * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
+	 * clear. While such content is still streaming the block therefore stays
+	 * wholly in the repaintable live region and commits once, at its final
+	 * layout, when the turn finalizes.
+	 */
+	isTranscriptBlockCommitStable(): boolean {
+		return this.#transcriptBlockFinalized || !this.#hasLiveReflowingMarkdown;
+	}
+
 	getTranscriptBlockVersion(): number {
 		return this.#blockVersion;
 	}
@@ -418,6 +495,15 @@ export class AssistantMessageComponent extends Container {
 		this.#lastMessage = message;
 		this.#lastUpdateTransient = opts?.transient === true;
 
+		// Streaming reflowing Markdown (a mermaid diagram reshaping, a GFM table
+		// re-aligning columns) re-lays-out its body each frame; see
+		// isTranscriptBlockCommitStable. Detect it from raw text — a Markdown
+		// parser only resolves these once the closing fence / delimiter row
+		// arrives, but the stale native-scrollback commits happen mid-stream.
+		this.#hasLiveReflowingMarkdown = message.content.some(
+			content => content.type === "text" && detectLiveReflowingMarkdown(content.text),
+		);
+
 		// Fast path: reuse Markdown children when shape is stable during streaming
 		if (this.#tryFastPathUpdate(message)) return;
 

package/src/modes/components/cache-invalidation-marker.ts

@@ -25,8 +25,13 @@ export interface CacheInvalidation {
  * request reads nothing from cache and re-pays for the whole prompt. We detect
  * that as: the previous turn cached a meaningful prefix, yet this turn's
  * `cacheRead` collapsed to zero while it still reprocessed a non-trivial prompt.
- * Returns `undefined` (no marker) for the first turn, tiny contexts, and turns
- * that reused any cache.
+ * Returns `undefined` (no marker) for the first turn, tiny contexts, turns
+ * that reused any cache, and — crucially — turns on providers with *implicit*
+ * best-effort caching. Only an explicit, prefix-controlled cache (Anthropic /
+ * Bedrock `cache_control`) re-creates the prefix on a cold turn (`cacheWrite >
+ * 0`); implicit caches (Google / OpenAI / Fireworks) report `cacheWrite: 0` and
+ * drop `cacheRead` to zero intermittently as routine propagation noise that
+ * self-heals the next turn, so flagging it would be a false positive.
  */
 export function detectCacheInvalidation(prev: Usage | undefined, current: Usage): CacheInvalidation | undefined {
 	if (!prev) return undefined;
@@ -34,6 +39,11 @@ export function detectCacheInvalidation(prev: Usage | undefined, current: Usage)
 	if (prevFootprint < MIN_CACHE_FOOTPRINT) return undefined;
 	// Any cache reuse this turn means the prefix survived (at least partly).
 	if (current.cacheRead > 0) return undefined;
+	// Only an explicit, prefix-controlled cache re-creates the prefix on a cold
+	// turn — Anthropic/Bedrock report that as `cacheWrite`. Implicit best-effort
+	// caches (Google/OpenAI/Fireworks) report `cacheWrite: 0` and drop `cacheRead`
+	// to zero intermittently as propagation noise, not a real invalidation.
+	if (current.cacheWrite <= 0) return undefined;
 	const reprocessedTokens = current.cacheWrite + current.input;
 	if (reprocessedTokens < MIN_CACHE_FOOTPRINT) return undefined;
 	return { reprocessedTokens };

package/src/modes/components/settings-defs.ts

@@ -76,6 +76,13 @@ export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef
 
 const CONDITIONS: Record<string, () => boolean> = {
 	hasImageProtocol: () => !!TERMINAL.imageProtocol,
+	advisorEnabled: () => {
+		try {
+			return Settings.instance.get("advisor.enabled") === true;
+		} catch {
+			return false;
+		}
+	},
 	hindsightActive: () => {
 		try {
 			return Settings.instance.get("memory.backend") === "hindsight";

package/src/modes/components/tips.txt

@@ -20,4 +20,5 @@ Press ctrl+r to search your prompt history and reuse a past message
 Pair up live: `/collab` shares your session through an end-to-end encrypted relay link — a teammate runs `/join <link>` to watch tool calls stream and prompt the agent from their own omp
 Press ← ← to drill into a running or finished agent and inspect its tool calls and transcript
 Hit a Codex rate limit? `/usage reset` spends a saved reset credit to immediately restore your quota
-No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
+No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
+Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice [NEW]

package/src/modes/components/welcome.ts

@@ -29,16 +29,73 @@ export const WELCOME_SESSION_SLOTS = 4;
  */
 export const WELCOME_LSP_SLOTS = 4;
 
-export function renderWelcomeTip(tip: string, boxWidth: number): string[] {
+/** Trailing marker that flags a tip as a "what's new" callout. Stripped before
+ *  wrapping (with any preceding whitespace) and replaced by {@link NEW_TAG_TEXT}
+ *  painted as a shimmering rainbow. Non-global so `.test` stays stateless. */
+const NEW_TIP_MARKER = /\s*\[NEW\]\s*$/;
+
+/** Visible text rendered in place of {@link NEW_TIP_MARKER}. */
+const NEW_TAG_TEXT = "NEW!";
+
+/** Milliseconds for one full hue rotation of the rainbow "NEW!" tag. */
+const NEW_GLOW_PERIOD_MS = 1500;
+
+/** Selection weight for "[NEW]" tips; ordinary tips weigh 1, so a freshly added
+ *  affordance surfaces this many times as often. */
+const NEW_TIP_WEIGHT = 4;
+
+/** Per-tip selection weights, parallel to {@link TIPS}. */
+const TIP_WEIGHTS: readonly number[] = TIPS.map(tip => (NEW_TIP_MARKER.test(tip) ? NEW_TIP_WEIGHT : 1));
+const TIP_WEIGHT_TOTAL = TIP_WEIGHTS.reduce((sum, weight) => sum + weight, 0);
+
+/** Pick a tip at random, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT}.
+ *  Returns "" when no tips are embedded. */
+function pickWeightedTip(): string {
+	if (TIPS.length === 0) return "";
+	let r = Math.random() * TIP_WEIGHT_TOTAL;
+	for (let i = 0; i < TIPS.length; i++) {
+		r -= TIP_WEIGHTS[i] ?? 1;
+		if (r < 0) return TIPS[i] ?? "";
+	}
+	return TIPS[TIPS.length - 1] ?? "";
+}
+
+type ColorEncoding = "ansi-16m" | "ansi-256";
+
+/** Paint each glyph of {@link NEW_TAG_TEXT} on a moving HSL rainbow. `phase`
+ *  rotates the hue offset cyclically; successive renders with increasing phase
+ *  shimmer, while a fixed phase yields a still rainbow. */
+function renderNewTag(phase: number, encoding: ColorEncoding): string {
+	const bold = "\x1b[1m";
+	const reset = "\x1b[0m";
+	const wrapped = ((phase % 1) + 1) % 1;
+	const chars = [...NEW_TAG_TEXT];
+	let out = bold;
+	let prev = "";
+	for (let i = 0; i < chars.length; i++) {
+		const hue = Math.round(((i / chars.length + wrapped) % 1) * 360);
+		const color = Bun.color(`hsl(${hue}, 95%, 60%)`, encoding) ?? "";
+		if (color !== prev) {
+			out += color;
+			prev = color;
+		}
+		out += chars[i];
+	}
+	return out + reset;
+}
+export function renderWelcomeTip(tip: string, boxWidth: number, phase = 0): string[] {
 	const label = "Tip: ";
 	const labelWidth = visibleWidth(label);
 	const bodyBudget = boxWidth - 1 - labelWidth; // 1 = leading indent
 	if (bodyBudget < 8) return [];
 
-	const wrappedBody = wrapTextWithAnsi(replaceTabs(tip), bodyBudget);
+	const isNew = NEW_TIP_MARKER.test(tip);
+	const body = isNew ? tip.replace(NEW_TIP_MARKER, "") : tip;
+
+	const wrappedBody = wrapTextWithAnsi(replaceTabs(body), bodyBudget);
 	if (wrappedBody.length === 0) return [];
 
-	const encoding = TERMINAL.trueColor ? "ansi-16m" : "ansi-256";
+	const encoding: ColorEncoding = TERMINAL.trueColor ? "ansi-16m" : "ansi-256";
 	const purple = Bun.color("#b48cff", encoding) ?? "";
 	const lightBlue = Bun.color("#9ccfff", encoding) ?? "";
 	const italic = "\x1b[3m";
@@ -46,11 +103,27 @@ export function renderWelcomeTip(tip: string, boxWidth: number): string[] {
 	const reset = "\x1b[0m";
 	const continuationIndent = padding(labelWidth);
 
-	return wrappedBody.map((body, index) =>
+	const lines = wrappedBody.map((line, index) =>
 		index === 0
-			? ` ${italic}${purple}${label}${dim}${lightBlue}${body}${reset}`
-			: ` ${italic}${continuationIndent}${dim}${lightBlue}${body}${reset}`,
+			? ` ${italic}${purple}${label}${dim}${lightBlue}${line}${reset}`
+			: ` ${italic}${continuationIndent}${dim}${lightBlue}${line}${reset}`,
 	);
+
+	if (isNew) {
+		// Append the rainbow tag to the final body line when it fits within the
+		// box; otherwise drop it onto its own indented continuation line so the
+		// styled glyphs never overflow or reflow the wrapped body.
+		const tag = renderNewTag(phase, encoding);
+		const tagWidth = 1 + visibleWidth(NEW_TAG_TEXT); // 1 = space separator
+		const lastLine = lines[lines.length - 1];
+		if (lastLine !== undefined && visibleWidth(lastLine) + tagWidth <= boxWidth) {
+			lines[lines.length - 1] = `${lastLine} ${tag}`;
+		} else {
+			lines.push(` ${continuationIndent}${tag}`);
+		}
+	}
+
+	return lines;
 }
 
 export interface RecentSession {
@@ -89,7 +162,7 @@ export class WelcomeComponent implements Component {
 			if (theme.getSymbolPreset() === "unicode" && Math.random() < 0.1) {
 				this.#selectedTip = "Please use nerdfont 😭.";
 			} else {
-				this.#selectedTip = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : "";
+				this.#selectedTip = pickWeightedTip();
 			}
 		}
 		return this.#selectedTip || undefined;
@@ -327,7 +400,12 @@ export class WelcomeComponent implements Component {
 	#renderTip(boxWidth: number): string[] {
 		const tip = this.tip;
 		if (!tip) return [];
-		return renderWelcomeTip(tip, boxWidth);
+		// A trailing "[NEW]" marker paints an animated rainbow "NEW!" tag. Derive
+		// its hue phase from wall-clock time so it shimmers across the welcome
+		// intro's re-render frames, then settles into a still rainbow once the box
+		// caches its resting frame. Non-"[NEW]" tips ignore the phase entirely.
+		const phase = NEW_TIP_MARKER.test(tip) ? performance.now() / NEW_GLOW_PERIOD_MS : 0;
+		return renderWelcomeTip(tip, boxWidth, phase);
 	}
 
 	/** Center text within a given width */

package/src/modes/controllers/event-controller.ts

@@ -186,7 +186,7 @@ export class EventController {
 	}
 	#updateWorkingMessageFromIntent(intent: unknown): void {
 		if (this.ctx.session.isAborting) return;
-		// Streamed JSON can deliver non-string `_i` (object, number, boolean) before
+		// Streamed JSON can deliver non-string `i` (object, number, boolean) before
 		// schema validation; `?.` only guards null/undefined, so guard the type too.
 		if (typeof intent !== "string") return;
 		const trimmed = intent.trim();

package/src/prompts/system/personalities/default.md

@@ -1,26 +1,18 @@
 You are a terse, evidence-first engineer: every sentence carries a fact, a decision, or a risk.
 
 # Tone
-- Use terse sentence fragments when clearer.
-- Skip ceremony, hedging, summaries, filler, motivational and marketing language, and generic explanation.
-- Do not narrate obvious steps or over-explain basics.
-- MUST assume the reader is technical.
-- Be concrete: mention exact files, symbols, APIs, state fields, edge cases, and verification.
-- Compress reasoning into facts, constraints, tradeoffs, decisions, and checks. Action-oriented and dense.
-- Do not hide uncertainty: state it briefly at the specific claim, name the tradeoff, and pick the boring/safe option.
+- Terse fragments when clearer. Skip ceremony, hedging, summaries, filler, and marketing language.
+- Don't narrate obvious steps or over-explain basics. Assume a technical reader.
+- Be concrete: exact files, symbols, APIs, state fields, edge cases, verification.
+- Compress reasoning into facts, constraints, tradeoffs, decisions, checks. Lead with the conclusion, then evidence.
+- Don't hide uncertainty: state it at the specific claim, name the tradeoff, pick the boring/safe option.
 - For code, focus on invariants, risks, and verification.
-- Lead with the conclusion, then concrete evidence: changed files and verification.
 
 # Reasoning Format
-- Problem: what is wrong.
-- Decision: what to do & why (concrete facts).
-- Check: what can break & how to verify result.
-- Next: the next concrete edit/action.
+- Problem: what's wrong. Decision: what to do & why. Check: what can break & how to verify. Next: the next concrete action.
 
 # Succinct Patterns
-- Y → Need update X.
-- This is safe: Z.
-- Could do A, but B avoids C.
+- Y → need update X. This is safe: Z. Could do A, but B avoids C.
 
 # Escalation
-Push back when the plan hides risk or a claim is wrong: name the risk, show the evidence, propose the alternative. Once overruled, execute the user's call without relitigating.
+Push back when the plan hides risk or a claim is wrong: name the risk, show evidence, propose the alternative. Once overruled, execute the user's call without relitigating.