pi-pier 0.3.1 → 0.4.2

package/src/jev-client.ts

@@ -12,6 +12,10 @@ import { parseJevAnswers, type JevAnswer, type JevQuestion, type JevUsage } from
 import type { JevConfig } from './efficiency-config-core.ts';
 
 const JEV_DEFAULT_BASE_URL = 'https://api.typesafe.ai';
+/** Consecutive transport failures (timeout / network / 5xx) that open the breaker. */
+export const JEV_BREAKER_FAILURES = 2;
+/** While open, asks fail open locally without a request or a telemetry row; the tripping row says so. */
+export const JEV_BREAKER_OPEN_MS = 60_000;
 
 export interface JevAskMeta {
   /** Stable question-set id for telemetry rows (e.g. 'epr-diagnostic-gate'). */
@@ -23,7 +27,7 @@ export interface JevAskMeta {
   extra?: Record<string, unknown>;
   /**
    * Post-answer decision fields for telemetry (choices/scores/final verdicts — what threshold tuning
-   * needs; still never request bodies). Called exactly once per ask.
+   * needs; still never request bodies). Called exactly once per ask, with null answers on failure.
    */
   enrich?: (outcome: { ok: boolean; answers: Record<string, JevAnswer> | null }) => Record<string, unknown>;
 }
@@ -49,11 +53,14 @@ export interface JevRuntime {
 export function createJevRuntime(getConfig: () => JevConfig, deps: JevRuntimeDeps = {}): JevRuntime {
   const doFetch = deps.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
   const now = deps.now ?? Date.now;
-
+  // A run of 12 back-to-back network failures and 2.5s timeout stalls showed every site paying
+  // the full budget during an outage; the breaker makes an outage cost one tripping ask.
+  let transportFailures = 0;
+  let breakerOpenUntil = 0;
   async function logAsk(
     config: JevConfig,
     meta: JevAskMeta,
-    outcome: { ok: true; model: string; usage: JevUsage } | { ok: false; reason: string },
+    outcome: { ok: true; model: string; usage: JevUsage } | { ok: false; reason: string; extra?: Record<string, unknown> },
     latencyMs: number,
     state: unknown,
     enriched: Record<string, unknown>,
@@ -77,6 +84,7 @@ export function createJevRuntime(getConfig: () => JevConfig, deps: JevRuntimeDep
       stateHash: sha256Hex(serialized),
       ...(outcome.ok ? { usage: { input_tokens: outcome.usage.inputTokens, output_tokens: outcome.usage.outputTokens } } : {}),
       ...(meta.extra ?? {}),
+      ...(outcome.ok ? {} : outcome.extra ?? {}),
       ...enriched,
     };
     try {
@@ -95,14 +103,25 @@ export function createJevRuntime(getConfig: () => JevConfig, deps: JevRuntimeDep
     async ask(request, meta): Promise<JevAskResult> {
       const startedAt = now();
       const config = getConfig();
-      const fail = async (reason: string): Promise<JevAskResult> => {
+      const fail = async (reason: string, extra?: Record<string, unknown>): Promise<JevAskResult> => {
         const latencyMs = now() - startedAt;
         const enriched = meta.enrich?.({ ok: false, answers: null }) ?? {};
-        await logAsk(config, meta, { ok: false, reason }, latencyMs, request.state, enriched);
+        await logAsk(config, meta, { ok: false, reason, extra }, latencyMs, request.state, enriched);
         return { ok: false, reason, latencyMs };
       };
+      const transportFail = (reason: string, extra: Record<string, unknown> = {}): Promise<JevAskResult> => {
+        transportFailures += 1;
+        if (transportFailures < JEV_BREAKER_FAILURES) return fail(reason, extra);
+        transportFailures = 0;
+        breakerOpenUntil = now() + JEV_BREAKER_OPEN_MS;
+        return fail(reason, { ...extra, breakerOpenedMs: JEV_BREAKER_OPEN_MS });
+      };
       if (!config.enabled) return fail('disabled');
       if (!config.apiKey) return fail('no-api-key');
+      if (now() < breakerOpenUntil) {
+        meta.enrich?.({ ok: false, answers: null });
+        return { ok: false, reason: 'breaker-open', latencyMs: 0 };
+      }
 
       const timeoutMs = meta.timeoutMs ?? config.timeoutMs;
       const controller = new AbortController();
@@ -121,8 +140,11 @@ export function createJevRuntime(getConfig: () => JevConfig, deps: JevRuntimeDep
         if (!response.ok) {
           // 429 (and everything else) fails open immediately: limits are
           // dynamically adjusted upstream and every pier call is droppable.
+          if (response.status >= 500) return transportFail(`http-${response.status}`);
+          transportFailures = 0;
           return fail(response.status === 429 ? 'rate-limited' : `http-${response.status}`);
         }
+        transportFailures = 0;
         const raw: unknown = await response.json();
         const parsed = parseJevAnswers(raw, Object.keys(request.questions));
         if (!parsed.ok) return fail(parsed.reason);
@@ -131,8 +153,11 @@ export function createJevRuntime(getConfig: () => JevConfig, deps: JevRuntimeDep
         await logAsk(config, meta, { ok: true, model: parsed.model, usage: parsed.usage }, latencyMs, request.state, enriched);
         return { ok: true, answers: parsed.answers, model: parsed.model, usage: parsed.usage, latencyMs };
       } catch (error) {
-        const aborted = error instanceof Error && error.name === 'AbortError';
-        return fail(aborted ? 'timeout' : 'network-error');
+        if (error instanceof Error && error.name === 'AbortError') return transportFail('timeout');
+        // fetch wraps the socket error in `cause`; its code (ECONNRESET, ENOTFOUND, ...) is the diagnosis.
+        const source = error instanceof Error && error.cause instanceof Error ? error.cause : error;
+        const code = source instanceof Error && 'code' in source && typeof source.code === 'string' ? source.code : undefined;
+        return transportFail('network-error', code ? { errorCode: code } : {});
       } finally {
         clearTimeout(timer);
       }

package/src/jev-core.ts

@@ -8,7 +8,9 @@
  * question needs; instructions are English (CJK is weaker, hence the stricter P0-2 gate); and any
  * answer below its confidence gate counts as unanswered so callers fail open.
  */
+import { isPlainObject } from './guards.ts';
 import { containsLikelySecret, FAILURE_SIGNAL } from './reducer-core.ts';
+import { completeLineExcerpt } from './observation-core.ts';
 
 /* ── Request/response shapes (closed set) ── */
 
@@ -36,9 +38,6 @@ export type JevParsed =
   | { readonly ok: true; readonly answers: Record<string, JevAnswer>; readonly model: string; readonly usage: JevUsage }
   | { readonly ok: false; readonly reason: string };
 
-function isPlainObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === 'object' && v !== null && !Array.isArray(v);
-}
 
 function finiteNumber(v: unknown): number | undefined {
   return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
@@ -155,6 +154,8 @@ export interface DiagnosticGateVerdict {
   readonly choice: string | null;
   readonly noul: number | null;
 }
+/** Confidence is checked before the choice: an unconfident rejection is not authoritative, so the
+ *  caller's regex list must decide (same fail-open path as a typed `low-confidence` answer). */
 export function evaluateDiagnosticGate(
   answers: Record<string, JevAnswer>,
   minConfidence: number,
@@ -164,12 +165,12 @@ export function evaluateDiagnosticGate(
   if (kind === undefined || output === undefined) {
     return { hit: false, reason: 'missing-answer', confidence: null, choice: null, noul: null };
   }
-  if (kind.choice !== 'build_test_run') {
-    return { hit: false, reason: `not-build-test:${kind.choice}`, confidence: kind.confidence, choice: kind.choice, noul: output.noul };
-  }
   if (kind.confidence < minConfidence) {
     return { hit: false, reason: 'low-confidence', confidence: kind.confidence, choice: kind.choice, noul: output.noul };
   }
+  if (kind.choice !== 'build_test_run') {
+    return { hit: false, reason: `not-build-test:${kind.choice}`, confidence: kind.confidence, choice: kind.choice, noul: output.noul };
+  }
   if (output.noul < DIAGNOSTIC_OUTPUT_MIN_NOUL) {
     return { hit: false, reason: 'non-diagnostic-output', confidence: kind.confidence, choice: kind.choice, noul: output.noul };
   }
@@ -264,9 +265,12 @@ export interface ExcerptWindow {
   readonly id: ExcerptWindowId;
   readonly label: string;
   readonly text: string;
+  /** 0-based first line of the window in the packed output (telemetry joins picks to objects). */
+  readonly startLine: number;
 }
 
 interface LineWindow {
+  readonly start: number;
   readonly text: string;
   readonly bytes: number;
   readonly signalCount: number;
@@ -288,12 +292,12 @@ function buildLineWindow(lines: readonly string[], start: number, budgetBytes: n
     if (signalLines.has(i)) signalCount++;
   }
   if (selected.length === 0) return null;
-  return { text: selected.join('\n'), bytes, signalCount };
+  return { start, text: selected.join('\n'), bytes, signalCount };
 }
 
 /** Code-owned middle-window candidates for a packed observation: failure-signal windows (first hit,
- * densest cluster) when present, plus a plain mid-output window ALWAYS offered, so jev judges every
- * packed output — including logs whose failure lines the English FAILURE_SIGNAL regex cannot see. */
+ * densest cluster) when present, plus a plain mid-output window. The picker asks jev only when a
+ * signal window exists; a mid-only set kept head/tail or failed in 8 of 10 asks (D123). */
 export function buildExcerptWindows(text: string, halfBudgetBytes: number): ExcerptWindow[] {
   if (halfBudgetBytes <= 0) return [];
   const lines = text.split('\n');
@@ -310,7 +314,7 @@ export function buildExcerptWindows(text: string, halfBudgetBytes: number): Exce
     const firstWindow = buildLineWindow(lines, Math.max(0, first - 2), halfBudgetBytes, signalLines);
     if (firstWindow !== null && !seen.has(firstWindow.text)) {
       seen.add(firstWindow.text);
-      out.push({ id: 'first_signal', label: 'first failure-signal region', text: firstWindow.text });
+      out.push({ id: 'first_signal', label: 'first failure-signal region', text: firstWindow.text, startLine: firstWindow.start });
     }
 
     let best: LineWindow | null = null;
@@ -321,49 +325,80 @@ export function buildExcerptWindows(text: string, halfBudgetBytes: number): Exce
     }
     if (best !== null && !seen.has(best.text)) {
       seen.add(best.text);
-      out.push({ id: 'densest', label: 'densest failure-signal region', text: best.text });
+      out.push({ id: 'densest', label: 'densest failure-signal region', text: best.text, startLine: best.start });
     }
   }
 
   const midAnchor = Math.min(Math.floor(lines.length / 2), Math.max(0, lines.length - 1));
   const midWindow = buildLineWindow(lines, midAnchor, halfBudgetBytes, signalLines);
   if (midWindow !== null && !seen.has(midWindow.text)) {
-    out.push({ id: 'mid', label: 'middle region of the output', text: midWindow.text });
+    out.push({ id: 'mid', label: 'middle region of the output', text: midWindow.text, startLine: midWindow.start });
   }
   return out;
 }
 
-export function excerptPickRequest(
-  middleWindows: readonly ExcerptWindow[],
-  headExcerpt: string,
-  tailExcerpt: string,
-): JevRequest | null {
-  if (middleWindows.length === 0) return null;
-  const criteria: Record<string, string> = {
-    keep_head_tail: 'The existing head and tail excerpts are already the most informative; keep them',
-  };
-  const excerpts: Record<string, string> = { head_excerpt: headExcerpt, tail_excerpt: tailExcerpt };
-  for (const window of middleWindows) {
-    criteria[window.id] = `${window.label}: excerpt from the middle of the output`;
-    excerpts[window.id] = window.text;
+/**
+ * Which packed outputs are worth an excerpt ask, keeping each item's index into `items`. Skipped:
+ * outputs without a failure-signal window (only `mid` competes with head/tail; that lost in 8 of 10
+ * asks, D123) and outputs whose excerpts carry a credential shape (§8 privacy boundary).
+ */
+export function planExcerptAsks(
+  items: ReadonlyArray<{ obsId: string; text: string }>,
+  excerptBudgetBytes: number,
+): Array<{ index: number; obsId: string } & ExcerptPickItem> {
+  const halfBudget = Math.floor(excerptBudgetBytes / 2);
+  const asks: Array<{ index: number; obsId: string } & ExcerptPickItem> = [];
+  for (let index = 0; index < items.length; index++) {
+    const { obsId, text } = items[index]!;
+    const windows = buildExcerptWindows(text, halfBudget);
+    if (!windows.some((w) => w.id !== 'mid')) continue;
+    const headExcerpt = completeLineExcerpt(text, halfBudget, false);
+    const tailExcerpt = completeLineExcerpt(text, excerptBudgetBytes - halfBudget, true);
+    if (!excerptAskIsSafe(windows, headExcerpt, tailExcerpt)) continue;
+    asks.push({ index, obsId, windows, headExcerpt, tailExcerpt });
   }
-  return {
-    state: { excerpts },
-    questions: {
-      window: {
-        type: 'choice',
-        instructions: 'A large tool output was replaced by a placeholder keeping two short excerpts. Which excerpt set would most help a coding agent locate the problem without recalling the full text?',
-        criteria,
-      },
-    },
-  };
+  return asks;
+}
+
+export interface ExcerptPickItem {
+  readonly windows: readonly ExcerptWindow[];
+  readonly headExcerpt: string;
+  readonly tailExcerpt: string;
+}
+
+/** One request for every packed output (a compaction batch packs up to 20): one round trip instead of
+ *  a 20-way burst. `outputs[i]` carries item i's excerpts; its question is `excerpt_${i}_window`. */
+export function excerptPickRequest(items: readonly ExcerptPickItem[]): JevRequest | null {
+  if (items.length === 0) return null;
+  const questions: Record<string, JevQuestion> = {};
+  const outputs: Array<Record<string, string>> = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]!;
+    const criteria: Record<string, string> = {
+      keep_head_tail: 'The existing head and tail excerpts are already the most informative; keep them',
+    };
+    const excerpts: Record<string, string> = { head_excerpt: item.headExcerpt, tail_excerpt: item.tailExcerpt };
+    for (const window of item.windows) {
+      criteria[window.id] = `${window.label}: excerpt from the middle of the output`;
+      excerpts[window.id] = window.text;
+    }
+    outputs.push(excerpts);
+    // Question keys are NOT sent to the model, so the instruction names its output index.
+    questions[`excerpt_${i}_window`] = {
+      type: 'choice',
+      instructions: `A large tool output (outputs[${i}]) was replaced by a placeholder keeping two short excerpts. Which excerpt set would most help a coding agent locate the problem without recalling the full text?`,
+      criteria,
+    };
+  }
+  return { state: { outputs }, questions };
 }
 
 export function evaluateExcerptPick(
   answers: Record<string, JevAnswer>,
+  index: number,
   minConfidence: number,
 ): ExcerptWindowId | null {
-  const picked = answerOf(answers, 'window', 'choice');
+  const picked = answerOf(answers, `excerpt_${index}_window`, 'choice');
   if (picked === undefined) return null;
   if (picked.confidence < minConfidence) return null;
   return picked.choice === 'first_signal' || picked.choice === 'densest' || picked.choice === 'mid'

package/src/observation-core.ts

@@ -138,6 +138,8 @@ export interface RecallSliceResult {
   text: string;
   bytes: number;
   lines: number;
+  /** Byte offset the returned text actually starts at (after line-start alignment). */
+  offset: number;
   nextOffset: number;
   eof: boolean;
 }
@@ -157,7 +159,7 @@ export function sliceBufferChunk(
   limits: { maxBytes: number; maxLines: number },
 ): RecallSliceResult {
   if (offset >= buf.length) {
-    return { text: '', bytes: 0, lines: 0, nextOffset: buf.length, eof: true };
+    return { text: '', bytes: 0, lines: 0, offset, nextOffset: buf.length, eof: true };
   }
 
   let end = Math.min(buf.length - offset, limits.maxBytes);
@@ -169,6 +171,15 @@ export function sliceBufferChunk(
     }
   }
 
+  // A byte-cap cut mid-line would make the next page (and its aligned next_offset) skip the rest of
+  // that line; end this page at the previous line boundary instead. A line longer than maxBytes has
+  // no boundary to snap to and stays byte-sliced.
+  const cappedAt = offset + end;
+  if (cappedAt < buf.length && buf[cappedAt - 1] !== 0x0a) {
+    const lastNewline = buf.lastIndexOf(0x0a, cappedAt - 1);
+    if (lastNewline >= offset) end = lastNewline + 1 - offset;
+  }
+
   const chunkBuf = buf.subarray(offset, offset + trimUtf8End(buf.subarray(offset), end));
   const text = chunkBuf.toString('utf8');
   const nextOffset = offset + chunkBuf.length;
@@ -176,6 +187,7 @@ export function sliceBufferChunk(
     text,
     bytes: chunkBuf.length,
     lines: countLines(text),
+    offset,
     nextOffset,
     eof: nextOffset >= buf.length,
   };

package/src/panel-open.ts

@@ -0,0 +1,47 @@
+/** Shared Pier panel opening: `/dashboard` and `/pier-tree` both render through one popup entrypoint.
+ *
+ * Herdr popups are a singleton session resource (`popup.close` has no id) and are session-modal, so
+ * the human cannot invoke another slash command while one is open. The command therefore chooses
+ * the initial tab via env; tabs are switched inside the panel (`1`/`2`/`Tab`). A `ui_busy` result is
+ * surfaced instead of silently retrying as a tab. */
+import type { HerdrClientLike, HerdrEnv } from './herdr-client.ts';
+
+export type PierPanel = 'dashboard' | 'tree';
+export type PierPanelOpenResult = 'popup' | 'busy' | 'tab' | 'unavailable';
+
+export interface PierPanelOpenDeps {
+  client: HerdrClientLike;
+  env: HerdrEnv | null;
+}
+
+/**
+ * Open the shared popup on the requested tab. `busy` means another popup/modal owns the session;
+ * the caller should tell the human to close it.
+ */
+export async function openPierPanel(
+  deps: PierPanelOpenDeps,
+  opts: { panel: PierPanel; treeFile?: string | null },
+): Promise<PierPanelOpenResult> {
+  const { client, env } = deps;
+  if (!client.available || !env) return 'unavailable';
+
+  try {
+    const res = await client.openPluginPane({
+      pluginId: 'pier.workbench',
+      entrypoint: 'panel',
+      placement: 'popup',
+      width: '90%',
+      height: '80%',
+      focus: true,
+      env: {
+        PIER_PANEL: opts.panel,
+        ...(opts.treeFile ? { PIER_TREE_FILE: opts.treeFile } : {}),
+      },
+    });
+    if (res.mode === 'fallback_tab') return 'tab';
+    if (res.mode === 'busy') return 'busy';
+    return 'popup';
+  } catch {
+    return 'unavailable';
+  }
+}

package/src/pier-options.ts

@@ -47,11 +47,10 @@ export const PIER_OPTIONS: readonly OptionSpec[] = [
   { name: 'PIER_SETTLEMENT_WINDOW_MS', legacy: 'PI_HERDR_SETTLEMENT_WINDOW_MS', fallback: '60000', min: 0, policy: 'settlementWindowMs', description: 'settlement notice window / machine-inject grace / takeover idle' },
   { name: 'PIER_FOREGROUND_PATIENCE_MS', legacy: 'PI_HERDR_FOREGROUND_PATIENCE_MS', fallback: '300000', min: 0, policy: 'foregroundPatienceMs', description: 'foreground patience before demoting a subagent to background' },
   { name: 'PIER_SESSION_TTL_SECONDS', legacy: 'PI_HERDR_SESSION_TTL_SECONDS', fallback: '600', min: 0, policy: 'sessionTtlSeconds', description: 'session retention after a subagent exits, before GC' },
-  { name: 'PIER_FOCUS_POLL_MS', fallback: '1500', min: 0, description: 'pane-focus sampling cadence for the heat layout (0 disables; event-first on herdr 0.9.1+)' },
   { name: 'PIER_TERMINAL_PROMPT', legacy: 'PI_HERDR_TERMINAL_PROMPT', fallback: '(auto from $SHELL)', description: 'prompt strategy for terminal readiness: bash|zsh|powershell|pwsh' },
   { name: 'PIER_SLIM_FRAME', legacy: 'PI_HERDR_SLIM_FRAME', fallback: '1', description: 'mutation frame around todo-tool cards (0 disables)' },
   { name: 'PIER_TRACE', legacy: 'PI_HERDR_TRACE', fallback: '', description: 'write diagnostics (renderers, swallowed errors) to stderr (or to this file when it is a path)' },
-  { name: 'PIER_TERM_IDLE_MS', legacy: 'PI_HERDR_TERM_IDLE_MS', fallback: '1800000', min: 1, description: 'idle time before pier nudges about an open terminal (0/NaN falls back to the default)' },
+  { name: 'PIER_TERM_IDLE_MS', legacy: 'PI_HERDR_TERM_IDLE_MS', fallback: '300000', min: 1, description: 'idle time before the second cleanup nudge for an open terminal (per-terminal max 2; 0/NaN falls back to the default)' },
   { name: 'PIER_TERM_GRACE_MS', legacy: 'PI_HERDR_TERM_GRACE_MS', fallback: '30000', min: 1, description: 'settle grace before the terminal idle nudge (0/NaN falls back to the default)' },
   { name: 'PIER_TERM_READ_MAX', legacy: 'PI_HERDR_TERM_READ_MAX', fallback: '8000', min: 1, description: 'characters returned per terminal read (0/NaN falls back to the default)' },
   { name: 'PIER_TODO_GRACE_MS', legacy: 'PI_HERDR_TODO_GRACE_MS', fallback: '30000', min: 1, description: 'settle grace before the unfinished-todo reminder (0/NaN falls back to the default)' },

package/src/pipe-channel.ts

@@ -58,6 +58,15 @@ export type PipeRequest =
       id: string;
       role: string;
     }
+  | {
+      /** D113 (RFC rfc-unified-widget): worker → master full todo push on every todo_write, so the
+       * master's resident widget and /pier-tree render live worker state without polling herdr. */
+      type: 'todo_sync';
+      id: string;
+      paneId: string;
+      items: Array<{ content: string; status: string; blocker?: string }>;
+      summary: string;
+    }
   | {
       /** D50: fast-path settlement reply from child to requester, with summary and session path for progressive disclosure. */
       type: 'reply';

package/src/plugins/heat-plan.ts

@@ -10,6 +10,7 @@ import { type ShapeNode } from './grid-shape.ts';
 
 export const SPAWN_PLACEHOLDER_ID = '__pier_new__';
 const RATIO_FLOOR = 0.10;
+const NON_AGENT_RATIO_FLOOR = 0.25;
 const FOCUS_SHARE = 0.72;
 const FOCUS_SHARE_BLOCKED = 0.60;
 const MAX_AUTO_LAYOUT_PANES = 10;
@@ -57,6 +58,19 @@ function clampRatio(r: number): number {
   return Math.min(1 - RATIO_FLOOR, Math.max(RATIO_FLOOR, r));
 }
 
+/** Agent-less panes (plain shells report no status or `unknown`) keep NON_AGENT_RATIO_FLOOR in mixed splits. */
+function hasAgentPanes(node: LayoutNode, statuses: AgentStatusMap): boolean {
+  return flattenPanes(node).some((id) => statuses[id] !== undefined && statuses[id] !== 'unknown');
+}
+
+function splitRatio(node: SplitNode, ratio: number, statuses: AgentStatusMap): number {
+  const firstAgent = hasAgentPanes(node.first, statuses);
+  const secondAgent = hasAgentPanes(node.second, statuses);
+  if (firstAgent && !secondAgent) ratio = Math.min(ratio, 1 - NON_AGENT_RATIO_FLOOR);
+  else if (!firstAgent && secondAgent) ratio = Math.max(ratio, NON_AGENT_RATIO_FLOOR);
+  return clampRatio(ratio);
+}
+
 function tierWeight(status: string | undefined, isAsk = false, slim = false): number {
   if (status === 'blocked') return isAsk ? ASK_WEIGHT : BLOCKED_WEIGHT;
   if (status === 'working') return slim ? WORKING_WEIGHT * SLIM_FACTOR : WORKING_WEIGHT;
@@ -129,7 +143,8 @@ export function planSpawnSplitRatio(opts: {
   if (paneCount <= 1 || paneCount > MAX_AUTO_LAYOUT_PANES) return null;
   if (!containsPane(simulated, opts.focusPaneId) || !containsPane(simulated, newId)) return null;
 
-  const statuses = opts.statuses ?? {};
+  // The new pane is an agent pane; `idle` weighs the same as a missing status.
+  const statuses: AgentStatusMap = { [newId]: 'idle', ...opts.statuses };
   const askFlags = opts.askFlags ?? {};
   const slim = paneCount - 1 >= SLIM_THRESHOLD;
   const focusSteps = findPath(simulated, opts.focusPaneId);
@@ -148,11 +163,11 @@ export function planSpawnSplitRatio(opts: {
     const r = clampRatio(target ** (1 / focusSteps.length));
     const at = focusSteps.find((s) => s.node === newSplit);
     if (!at) return null;
-    return at.side === 'first' ? r : 1 - r;
+    return splitRatio(newSplit, at.side === 'first' ? r : 1 - r, statuses);
   }
 
   const wFirst = weightOf(newSplit.first, statuses, askFlags, slim);
   const wSecond = weightOf(newSplit.second, statuses, askFlags, slim);
   if (wFirst + wSecond <= 0) return null;
-  return clampRatio(wFirst / (wFirst + wSecond));
+  return splitRatio(newSplit, wFirst / (wFirst + wSecond), statuses);
 }