pi-pier 0.4.1 → 0.4.3

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

@@ -10,6 +10,7 @@
  */
 import { isPlainObject } from './guards.ts';
 import { containsLikelySecret, FAILURE_SIGNAL } from './reducer-core.ts';
+import { completeLineExcerpt } from './observation-core.ts';
 
 /* ── Request/response shapes (closed set) ── */
 
@@ -153,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,
@@ -162,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 };
   }
@@ -262,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;
@@ -286,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');
@@ -308,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;
@@ -319,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/manifest-compose.ts

@@ -36,7 +36,7 @@ export function composeManifest(sources: ManifestSources): ComposedManifest {
   if (baseline.length === 0) {
     throw new ManifestError(
       'INVALID_ROLE_CONFIG',
-      'INVALID_ROLE_CONFIG: 基线工具不能为空，至少需包含 todo_write 和 ask_user_question',
+      'INVALID_ROLE_CONFIG: baseline tools must not be empty; todo_write and ask_user_question are required',
     );
   }
   const candidates = new Set<string>([
@@ -62,9 +62,9 @@ export function composeManifest(sources: ManifestSources): ComposedManifest {
   if (tools.length === 0) {
     throw new ManifestError(
       'EMPTY_MANIFEST',
-      `裁剪后 manifest 为空（deny-all trap？）。基线: ${baseline.join(', ') || '(空)'}；` +
-        `模型建议: ${sources.modelSuggested.join(', ') || '(无)'}；` +
-        `规则: ${JSON.stringify(rules)}`,
+      `Trimmed manifest is empty (deny-all trap?). Baseline: ${baseline.join(', ') || '(empty)'}; ` +
+        `model suggestions: ${sources.modelSuggested.join(', ') || '(none)'}; ` +
+        `rules: ${JSON.stringify(rules)}`,
     );
   }
 

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/pipe-channel.ts

@@ -58,14 +58,6 @@ export type PipeRequest =
       id: string;
       role: string;
     }
-  | {
-      /** Phase 2 (RFC rfc-delegation-identity §3.2): worker → master progress report. The master
-       * injects it as a display-less custom message (no turn, no visible chat noise). */
-      type: 'progress';
-      id: string;
-      paneId: string;
-      text: 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. */

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);
 }