pi-pier 0.1.3 → 0.1.4

package/src/core/todo.ts

@@ -7,19 +7,18 @@
  *  - `pi-herdr.todo-deps`：todos 服务（session 状态层，留在 index）+ options +
  *    mirrorTodos 回调 + appendEntry + state 槽（renderWidget 回填给 index 生命周期）。
  *
- * 本文件承接：todo_write 工具 + /todos /todo 命令 + TUI widget（widgetLines/
- * renderWidget/formatTodosMarkdown）+ 读钩（before_agent_start planTodoReadHook，
+ * 本文件承接：todo_write 工具 + /todos 命令（查看/编辑）+ TUI widget（widgetLines/
+ * renderWidget）+ 读钩（before_agent_start planTodoReadHook，
  * 轮次计数器内聚）。reconcile / 镜像 / reportAgent 仍在 index（session 状态层）。
  */
 import { Context } from '@deepseek-ai/cordis';
 import { Type } from 'typebox';
-import { join } from 'node:path';
-import { writeFileSync } from 'node:fs';
 import type { PiSurface } from '../pi-surface.ts';
 import type { TodosService } from '../todos-service.ts';
 import { planTodoReadHook } from '../todo-read-hook.ts';
 import { makeProgressUpdate } from '../subagent-core.ts';
 import { TODO_DETAILS_KEY, TODO_TOOL_NAME, formatTodoConfirmation, type TodoItem, type TodoStatus } from '../vocab.ts';
+import { formatAge, isArchived } from '../stale-core.ts';
 import {
   TODO_EDIT_CUSTOM_TYPE,
   completionTransitions,
@@ -89,29 +88,32 @@ function renderGroups(items: readonly TodoItem[]): string[] {
 }
 
 /**
- * widget 行（全局预算版，用户实证修复）：
- * 旧实现按分组插入序逐组渲染（每组预算 10），pi 头部截 10 行 → 老 phase 吃光窗口、
- * 最新任务组（in_progress 所在）整组不可见。新规则：
+ * widget 行（活动锚定窗口，用户实证二修）：
  *  - 全局预算 = WIDGET_MAX_LINES（含摘要行与 +N 行）；
- *  - 超额丢弃顺序 = 最老 completed → 最老 open（尾部/当前工作永远存活）；
+ *  - 窗口锚定第一条 in_progress：可见的条目是它前后的连续区段（正在做的
+ *    上下文——前因后果可见），不再是固定头部/尾部（旧实现超窗时只剩尾部，
+ *    正在执行的条目滚出视窗，01a03c0d 实证"显示最后几条，不管当前执行到哪"）；
+ *  - 无 in_progress → 锚定最后一条 open；全完成 → 尾部切片（刚完成的可见）；
  *  - +N 行指路 /todos（全量视图）。
  */
-export function widgetLines(items: readonly TodoItem[]): string[] {
+export function widgetLines(items: readonly TodoItem[], opts?: { archivedAgeMs?: number | null }): string[] {
   if (items.length === 0) return [];
   const c = countTodos(items);
-  const summary = `todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓`;
-
-  const kept = [...items];
-  while (
-    kept.length > 0
-    && 1 + renderGroups(kept).length + (items.length > kept.length ? 1 : 0) > WIDGET_MAX_LINES
-  ) {
-    const oldestCompleted = kept.findIndex((it) => it.status === 'completed');
-    kept.splice(oldestCompleted === -1 ? 0 : oldestCompleted, 1);
+  // 反冻结：归档列表不逐条渲染，两行说明 + 指路 /todos（死计划不再占满视窗）。
+  if (opts?.archivedAgeMs != null) {
+    return [
+      `todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓ · archived ${formatAge(opts.archivedAgeMs)}`,
+      '  archived — /todos 全量',
+    ];
   }
 
-  const hidden = items.filter((it) => !kept.includes(it));
-  const lines = [summary, ...renderGroups(kept)];
+  // 条目预算 = 总预算 - 摘要行 -（隐藏时的）+N 行。phase 头也占行——按渲染行数
+  // 迭代收缩：锚定窗口切片 → 超行则两端各收一格（保锚点），直到装得下。
+  const renderBudget = WIDGET_MAX_LINES - 1 - 1;
+  const [start, end] = anchorRange(items, renderBudget);
+  const kept = items.slice(start, end);
+  const hidden = items.filter((_, i) => i < start || i >= end);
+  const lines = [`todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓`, ...renderGroups(kept)];
   if (hidden.length > 0) {
     const hiddenCompleted = hidden.filter((it) => it.status === 'completed').length;
     lines.push(`   +${hidden.length} hidden (${hiddenCompleted}✓) · /todos 全量`);
@@ -119,30 +121,43 @@ export function widgetLines(items: readonly TodoItem[]): string[] {
   return lines;
 }
 
-/** D38：TODO.md 导出（分组 + 任务列表语法）。 */
-function formatTodosMarkdown(items: TodoItem[]): string {
-  const groups = new Map<string, TodoItem[]>();
-  for (const it of items) {
-    const key = it.phase ?? '默认';
-    const arr = groups.get(key) ?? [];
-    arr.push(it);
-    groups.set(key, arr);
+/**
+ * 活动锚定窗口：锚点 = 第一条 in_progress（无则最后一条 open；全完成 → 尾部）。
+ * 以渲染行数（含 phase 头）为预算，从锚点贪心扩张（尾部优先——后续工作先
+ * 可见），装不下即停；锚点条目永远在窗内。
+ */
+function anchorRange(items: readonly TodoItem[], renderBudget: number): [number, number] {
+  if (renderGroups(items).length <= renderBudget) return [0, items.length];
+  const anchor = items.findIndex((it) => it.status === 'in_progress');
+  const anchorIdx = anchor >= 0
+    ? anchor
+    : items.reduce((acc, it, i) => (it.status !== 'completed' ? i : acc), -1);
+  if (anchorIdx < 0) {
+    // 全完成：尾部切片（按行数从头收缩）
+    let end = items.length;
+    while (renderGroups(items.slice(0, end)).length > renderBudget && end > 1) end -= 1;
+    return [0, end];
   }
-  const lines = ['# TODO'];
-  for (const [phase, list] of groups) {
-    lines.push('', `## ${phase}`);
-    for (const it of list) {
-      const box = it.status === 'completed' ? 'x'
-        : it.status === 'in_progress' ? '/'
-        : it.status === 'blocked' ? '!'
-        : it.status === 'abandoned' ? '~'
-        : ' ';
-      const suffix = it.status === 'blocked' && it.blocker ? ` — blocker: ${it.blocker}` : '';
-      lines.push(`- [${box}] ${it.content}${suffix}`);
+  let start = anchorIdx;
+  let end = anchorIdx + 1;
+  const fits = () => renderGroups(items.slice(start, end)).length <= renderBudget;
+  let growTail = true;
+  while ((end < items.length || start > 0) && (end - start) < items.length) {
+    if (growTail && end < items.length) {
+      end += 1;
+      if (!fits()) { end -= 1; break; }
+    } else if (start > 0) {
+      start -= 1;
+      if (!fits()) { start += 1; break; }
+    } else if (end < items.length) {
+      end += 1;
+      if (!fits()) { end -= 1; break; }
+    } else {
+      break;
     }
+    growTail = !growTail; // 严格交替：锚点前因与后果均衡可见（用户实证诉求）
   }
-  lines.push('');
-  return lines.join('\n');
+  return [start, end];
 }
 
 export default function todoPlugin(ctx: Context): void {
@@ -151,12 +166,25 @@ export default function todoPlugin(ctx: Context): void {
     ctx.get('pi-herdr.todo-deps') as TodoDeps;
   const scoped = surface.forModule(import.meta.url);
 
+  /** 归档年龄（非归档 → null）；widget / /todos 共用。 */
+  function archivedAgeMs(now = Date.now()): number | null {
+    return todos.lastWriteAt != null && isArchived(todos.items, todos.lastWriteAt, now)
+      ? now - todos.lastWriteAt
+      : null;
+  }
+
+  /** 事件 ctx 里的 widget UI（有则 setWidget；守卫后具名使用，不做行内断言）。 */
+  function widgetUi(eventCtx: unknown): { setWidget?: (id: string, lines: string[]) => void } | undefined {
+    if (eventCtx === null || typeof eventCtx !== 'object' || !('ui' in eventCtx)) return undefined;
+    const ui = (eventCtx as { ui: unknown }).ui; // 'ui' in 已守卫
+    return ui !== null && typeof ui === 'object'
+      ? (ui as { setWidget?: (id: string, lines: string[]) => void })
+      : undefined;
+  }
+
   function renderWidget(eventCtx: unknown): void {
     try {
-      (eventCtx as { ui?: { setWidget?: (id: string, lines: string[]) => void } })?.ui?.setWidget?.(
-        'todos',
-        widgetLines(todos.items),
-      );
+      widgetUi(eventCtx)?.setWidget?.('todos', widgetLines(todos.items, { archivedAgeMs: archivedAgeMs() }));
     } catch {
       /* 无 widget 能力的 pi 版本静默降级 */
     }
@@ -165,18 +193,55 @@ export default function todoPlugin(ctx: Context): void {
   // 槽回填：index 的 session_start/session_tree 调用
   state.renderWidget = renderWidget;
 
-  /* ── 读钩（轮次计数器内聚；D39 提示注入） ── */
+  /* ── 读钩（轮次计数器内聚；D39 提示注入 + 反冻结 stale-core） ── */
   let todoReadTurn = 0;
   let lastEmptyGuardTurn: number | null = null;
-  scoped.on('before_agent_start', async () => {
+  // 反冻结状态：距上次写入轮数 / stale 警告计数与节奏 / 归档翻转检测
+  let lastWriteTurn: number | null = null;
+  let staleNotices = 0;
+  let lastStaleGuardTurn: number | null = null;
+  let lastArchivedMirror = false;
+
+  // 任何真实变更（todo_write / 人类编辑 / 对账 / 分支重建）都终结当前停滞期
+  todos.on('todo.updated', () => {
+    lastWriteTurn = todoReadTurn;
+    staleNotices = 0;
+  });
+
+  scoped.on('before_agent_start', async (eventCtx?: unknown) => {
     const plan = planTodoReadHook({
       items: todos.items,
       turn: todoReadTurn,
       lastEmptyGuardTurn,
+      lastWriteAt: todos.lastWriteAt,
+      turnsSinceWrite: lastWriteTurn == null ? null : todoReadTurn - lastWriteTurn,
+      now: Date.now(),
+      staleNotices,
+      lastStaleGuardTurn,
     });
+    if (plan.inject && plan.effect === 'stale-notice') {
+      staleNotices += 1;
+      lastStaleGuardTurn = todoReadTurn;
+    }
+    // 空守卫 / 归档通知 / R2 重写窗口共用注入节奏（archived=true 的 stale 窗口同享，
+    // 否则终态通知会在窗口后紧跟一拍挤掉宽限）。
+    if (plan.inject && (plan.effect === 'empty-guard' || plan.archived)) {
+      lastEmptyGuardTurn = todoReadTurn;
+    }
+    // R1：归档通知注入即清空——明细早已不再注入，保留死列表只会挡住空守卫的
+    // before-stopping 驱动（01a03c0d：归档后 2h 多步工作零跟踪）。rm 全量落
+    // JSONL，重启 rebuild 同样折叠得空表；历史明细仍在会话文件里。
+    if (plan.inject && plan.effect === 'archive-notice' && plan.clearArchived && todos.items.length > 0) {
+      const edits = todos.items.map((it) => ({ op: 'rm' as const, content: it.content }));
+      try {
+        appendEntry(TODO_EDIT_CUSTOM_TYPE, { version: 1, edits, ts: Date.now() });
+      } catch {
+        /* 尽力而为（内存清空照常） */
+      }
+      todos.replace([]);
+    }
     todoReadTurn += 1;
     if (!plan.inject) return;
-    if (todos.items.length === 0) lastEmptyGuardTurn = todoReadTurn - 1;
     return {
       message: {
         customType: plan.message.customType,
@@ -264,7 +329,7 @@ export default function todoPlugin(ctx: Context): void {
     },
   });
 
-  /* ── 命令：/todos（查看 + done/drop/rm 人类编辑，D38）+ /todo export ── */
+  /* ── 命令：/todos（查看 + done/drop/rm/unblock 人类编辑，D38）── */
   scoped.registerCommand('todos', {
     description: 'Show the todo list, or edit it: /todos done|drop|rm|unblock <fuzzy content match>',
     handler: async (args: unknown, eventCtx: unknown) => {
@@ -312,29 +377,18 @@ export default function todoPlugin(ctx: Context): void {
         ui?.notify?.(`"${content}" ${verb}`, 'info');
         return;
       }
-      // 全量视图（/todos 不受 widget 10 行预算限制——"看整个列表"的正式入口）
+      // 全量视图（/todos 不受 widget 行预算限制——"看整个列表"的正式入口）
       const body = renderGroups(todos.items);
       if (body.length === 0) {
         ui?.notify?.('todo list is empty', 'info');
         return;
       }
       const c = countTodos(todos.items);
-      ui?.notify?.([`todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓`, ...body].join('\n'), 'info');
-    },
-  });
-
-  scoped.registerCommand('todo', {
-    description: 'Export the current todo list to TODO.md in the working directory',
-    handler: async (_args: unknown, eventCtx: unknown) => {
-      const ui = (eventCtx as { ui?: { notify?: (text: string, level?: string) => void } }).ui;
-      const cwd = (eventCtx as { cwd?: string }).cwd ?? process.cwd();
-      try {
-        const target = join(cwd, 'TODO.md');
-        writeFileSync(target, formatTodosMarkdown(todos.items));
-        ui?.notify?.(`TODO.md written: ${target} (${todos.items.length} items)`, 'info');
-      } catch (err) {
-        ui?.notify?.(`failed to write TODO.md: ${(err as Error).message}`, 'error');
-      }
+      const age = archivedAgeMs();
+      const head = `todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓`
+        + (age != null ? ` · archived ${formatAge(age)}（不再注入）` : '');
+      ui?.notify?.([head, ...body].join('\n'), 'info');
     },
   });
 }
+

package/src/herdr-client.ts

@@ -77,7 +77,7 @@ export interface HerdrClientLike {
   readonly available: boolean;
   reportAgent(state: PaneAgentState, message: string | null): Promise<void>;
   reportAgentSession(sessionPath: string | null): Promise<void>;
-  reportMetadata(meta: { session: string; items: TodoItem[]; progressSuffix?: string | null }): Promise<void>;
+  reportMetadata(meta: { session: string; items: TodoItem[]; progressSuffix?: string | null; lastWriteAt?: number | null }): Promise<void>;
   /** M18：写锁 token 上报（键 lock-<hash>，值 paneId|path；null = 释放；≤16 键/批自动分批）。 */
   reportLockTokens(tokens: Record<string, string | null>): Promise<void>;
   /**
@@ -302,10 +302,13 @@ export class HerdrClient implements HerdrClientLike {
     }
   }
 
-  async reportMetadata(meta: { session: string; items: TodoItem[]; progressSuffix?: string | null }): Promise<void> {
+  async reportMetadata(meta: { session: string; items: TodoItem[]; progressSuffix?: string | null; lastWriteAt?: number | null }): Promise<void> {
     try {
       void meta.session;
-      const title = formatPaneTitle(meta.items, null, { progressSuffix: meta.progressSuffix });
+      const title = formatPaneTitle(meta.items, null, {
+        progressSuffix: meta.progressSuffix,
+        lastWriteAt: meta.lastWriteAt,
+      });
       const blocked = formatBlockedLabel(meta.items);
       // D96：stale 清理与日常上报分离——stale(16) + pi-todo(1) = 17 > herdr tokens max=16
       // → 整个请求被拒 → title/tokens 全丢（D93 回归根因）。stale 单独批次，成功后才置位。

package/src/history-store.ts

@@ -47,6 +47,16 @@ export interface HistoryEntry {
   closedAt?: number | null;
   /** 打回重做/复活时的前代 paneId。 */
   revivedFrom?: string | null;
+  /** B5：写手标记（spawn / poll-settle / poll-timeout / gc / zombie-sweep …）——
+   * 同秒多行可审计（01a03c0d 台账 row#23/24 双写实证）。 */
+  via?: string;
+}
+
+/** B5：closed 行 outcome 继承——patch 未显式指定 outcome 时沿用该 taskId 最近非空值，
+ * 「最新行即现状」语义下结算成果不因 GC 补记而丢失。 */
+export function inheritOutcome(lastOutcome: string | null | undefined, patchOutcome: string | null | undefined): string | null {
+  if (patchOutcome !== undefined) return patchOutcome;
+  return lastOutcome ?? null;
 }
 
 export function historyFilePath(agentRoot: string, cwd: string): string {

package/src/index.ts

@@ -24,9 +24,7 @@ import {
 import { collapseNotices } from './notice-buffer.ts';
 import {
   TODO_EDIT_CUSTOM_TYPE,
-  applyTodoEdits,
   currentActivity,
-  foldLatestTodos,
 } from './todo-core.ts';
 import { pipeNameFor, pipeRequest, startPipeServer } from './pipe-channel.ts';
 
@@ -55,9 +53,12 @@ import {
   releaseTokensFor,
   type LockAgentView,
 } from './lock-core.ts';
+import { ABORT_STOP_REASON, planSettleWake } from './settle-wake-core.ts';
 import { composeForRole } from './manifest-compose.ts';
 import { parseRuntimeManifest, planActiveTools, planToolGate, type RuntimeRoleManifest } from './tool-gate.ts';
 import { detectHerdrEnv } from './herdr-client.ts';
+import { formatPaneTitle } from './pane-title.ts';
+import { registerSlimFrame, updateSlimFrame } from './slim-frame.ts';
 
 /**
  * WS-D7：master pane 自应用 manifest——与 subagent 同一条强制链
@@ -156,7 +157,19 @@ export default async function (pi: ExtensionAPI) {
     const p = progressOf(todos.items);
     const eta = estimateEta({ completedAt: completedStamps, total: p.total, now: Date.now() });
     const suffix = formatProgressSuffix({ completed: p.completed, total: p.total, eta });
-    client.reportMetadata({ session: label, items: todos.items, progressSuffix: suffix }).catch(() => {});
+    // 反冻结：lastWriteAt 随行 → 标题侧 archived 判定（pane-title）
+    const title = formatPaneTitle(todos.items, null, {
+      progressSuffix: suffix,
+      lastWriteAt: todos.lastWriteAt,
+    });
+    // D97：窄格静帧与 pane 标题同参同源（thinking token 碰不到 → 静帧即冻结）
+    updateSlimFrame(title);
+    client.reportMetadata({
+      session: label,
+      items: todos.items,
+      progressSuffix: suffix,
+      lastWriteAt: todos.lastWriteAt,
+    }).catch(() => {});
   }
 
   /* ── M17：结算自动对账（纯规划器 + D38 权威路径；幂等，双路径双跑无害） ── */
@@ -323,6 +336,10 @@ export default async function (pi: ExtensionAPI) {
     // 此时再 setWidget 会破坏 TUI 的 '/' 命令面板输入路由（'/' 被当消息文本送给模型）。
     const reason = (event as { reason?: string } | undefined)?.reason;
     if (reason !== 'resume') todoUi.renderWidget(ctx);
+    // D97：窄格静帧 overlay（幂等注册；herdr pane 内才有意义——普通终端窄窗
+    // 盖住交互面是事故，且热力放大才提供退出路径。resume 也重注册：pi 会话
+    // 切换会 resetExtensionUI 拆掉 overlay）。
+    if (env) registerSlimFrame(ctx);
     mirrorTodos();
     reportSession(sessionId);
     // D93：侧边栏身份 = role 名（display_agent 优先于 agent 检测值，0.8.2 actions.rs:563）。
@@ -401,18 +418,47 @@ export default async function (pi: ExtensionAPI) {
   });
 
   let agentActive = false;
+  // D96 状态（settle-wake-core 去重/冷却的锚点）。
+  let d96NoticeKey: string | null = null;
+  let d96NoticeAt = 0;
+  // 反唤醒风暴（settle-wake-core）：追踪最后一次 assistant turn 的 stopReason，
+  // 'aborted' = 用户 ESC 显式叫停 → settled 时不得注入任何唤醒型消息。
+  let lastStopReason: string | null = null;
   pi.on('turn_start', async () => {
     agentActive = true;
     reportAgent('working', currentActivity(todos.items));
   });
+  pi.on('turn_end', async (event: unknown) => {
+    if (event === null || typeof event !== 'object' || !('message' in event)) return;
+    const msg = (event as { message: unknown }).message; // 'message' in 已守卫
+    if (msg === null || typeof msg !== 'object') return;
+    const { role, stopReason } = msg as { role?: unknown; stopReason?: unknown };
+    if (role === 'assistant' && typeof stopReason === 'string') {
+      lastStopReason = stopReason;
+    }
+  });
 
   pi.on('agent_settled', async () => {
     agentActive = false;
     reportAgent('idle', null);
+    const plan = planSettleWake({
+      lastStopReason,
+      running: subagentSlots.listRunningSubs?.() ?? [],
+      lastNoticeKey: d96NoticeKey,
+      lastNoticeAt: d96NoticeAt,
+      now: Date.now(),
+    });
+    d96NoticeKey = plan.noticeKey;
+    d96NoticeAt = plan.noticeAt;
+    if (!plan.wake) {
+      // 用户 abort 后静默：结算缓冲保留（pendingSettleNotices 不清空），
+      // 待下次自然 run 的 turn_end steer / 自然 settled 再投。
+      return;
+    }
     // D96：master settled（run 结束/想总结）时仍有后台 subagent running → 注入提醒。
     // worker 侧 subagentSlots.listRunningSubs 为 null（不注入）。
-    const running = subagentSlots.listRunningSubs?.() ?? [];
-    if (running.length > 0 && !isSubagent) {
+    if (plan.notice && !isSubagent) {
+      const running = subagentSlots.listRunningSubs?.() ?? [];
       const brief = running.map((s) => `${s.paneId} (${s.description})`).join('、');
       const notice = `注意：仍有 ${running.length} 个后台 subagent 在运行：${brief}。若你的任务依赖它们，请等待其结算（list_agents 查看状态）；若不等待，请说明放弃原因。`;
       void sendUserMessageIn(notice);
@@ -531,22 +577,32 @@ export default async function (pi: ExtensionAPI) {
    *   - agent_settled 兜底：run 真正结束后残余缓冲直投（触发新 run）。
    * 折叠规则（notice-buffer.ts）：≤3 条原文逐条，>3 条前 3 + 尾行计数/全量指引。 */
   const pendingSettleNotices: string[] = [];
-  const deliverNotice = async (content: string): Promise<void> => {
-    if (agentActive) {
+  /** B2：缓冲中尚未送达的结算通知所属 pane（GC 豁免判据——01a03c0d 实证：
+   * pD 结算 3s 后 pane 被 GC 关掉，通知 100s 后才经 turn 间隙送达，master 只好 revive）。 */
+  const pendingNoticePaneIds = new Set<string>();
+  const deliverNotice = async (content: string, paneId?: string): Promise<void> => {
+    // 反唤醒风暴：abort 后不直投（会触发新 run）——入缓冲，待下次自然 turn 投递。
+    // 结算内容本身持久在台账（list_agents / resume_subagent 可查），推送让位于用户意图。
+    if (content !== '' && paneId !== undefined) pendingNoticePaneIds.add(paneId);
+    if (agentActive || lastStopReason === ABORT_STOP_REASON) {
       pendingSettleNotices.push(content);
       return;
     }
     await sendUserMessageIn(content);
+    if (content !== '' && paneId !== undefined) pendingNoticePaneIds.delete(paneId);
   };
   const flushSettleNotices = async (mode: 'steer' | 'followUp'): Promise<void> => {
     if (pendingSettleNotices.length === 0) return;
     const collapsed = collapseNotices(pendingSettleNotices.splice(0));
+    pendingNoticePaneIds.clear(); // B2：折叠批次视为已送达（GC 恢复正常回收）
     if (collapsed) await sendUserMessageAs(collapsed, mode);
   };
   pi.on('turn_end', () => {
     void flushSettleNotices('steer');
   });
   pi.on('agent_settled', () => {
+    // abort 后不投缓冲（会触发新 run；缓冲保留待下次自然 turn）——见 settle-wake-core。
+    if (lastStopReason === ABORT_STOP_REASON) return;
     void flushSettleNotices('followUp');
   });
 
@@ -570,7 +626,12 @@ export default async function (pi: ExtensionAPI) {
             push: req.push === true,
             sinceTs: Date.now(),
           };
-          await sendUserMessageIn(req.text);
+          // B3：follow_up 带 steer → 以 steer 投递（pi 语义：当前 tool call 执行完、
+          // 下次 LLM 调用前到达）——长 run 中途的补充契约秒级生效，不再排队整个 run
+          // （01a03c0d：契约 20min 后才到，worker 按旧契约实现被迫返工）。
+          // 初始 prompt 不 steer：空闲 worker 上的 followUp 才触发新 run（D96 语义）。
+          if (req.steer === true) await sendUserMessageAs(req.text, 'steer');
+          else await sendUserMessageIn(req.text);
           return { type: 'ok', id: req.id };
         }
         if (req.type === 'interrupt') {
@@ -589,7 +650,7 @@ export default async function (pi: ExtensionAPI) {
             const body = (req.sessionFile ? `${head}\nSession: ${req.sessionFile}` : head)
               + (notes.length ? `\n${notes.join('\n')}` : '');
             // D92：经缓冲注入（忙时 turn_end 折叠 steer，闲时直投）
-            await deliverNotice(body);
+            await deliverNotice(body, req.paneId);
           }
           return { type: 'ok', id: req.id };
         }
@@ -700,7 +761,8 @@ export default async function (pi: ExtensionAPI) {
       env,
       extPath: fileURLToPath(import.meta.url),
       sessionRoot,
-      slots: subagentSlots,
+      deliverNotice,
+      noticePending: () => pendingNoticePaneIds,
       getSessionId: () => sessionId,
       getBlockedDepth: () => blockedDepth,
       reconcileOnSettlement,

package/src/pane-title.ts

@@ -5,6 +5,7 @@
  * herdr 把 title / state_label 截到 80 字符——本地先裁，避免半截 emoji。
  */
 import { countTodos, PI_HERDR_META_KEY, type TodoItem } from './vocab.ts';
+import { formatAge, isArchived } from './stale-core.ts';
 
 /** herdr 对 title / state_label 的字符上限（官方文档 + schema 实测）。 */
 export const TITLE_MAX = 80;
@@ -46,14 +47,23 @@ function clipTitle(s: string): string {
  * `▶i ○p ■b ✓c (N/M [~eta]) · <activity>`（D91 图标统一：黑白字符四件套）。
  * activity = 第一条 in_progress，否则 fallbackDescription，再否则只报计数。
  * 空列表 → null。progressSuffix（M16）= formatProgressSuffix 产物。
+ *
+ * 反冻结（stale-core D）：全完成 + 墙钟过期（archived）→ 死列表降权为
+ * `✓N done <age>`，不再以 ▶○■✓ 满权重视窗冒充当前状态；"在干嘛"由
+ * report_agent 的工具徽标/活动行承担，todo token 只报计划真实状态。
  */
 export function formatPaneTitle(
   items: readonly TodoItem[],
   fallbackDescription?: string | null,
-  opts?: { progressSuffix?: string | null },
+  opts?: { progressSuffix?: string | null; lastWriteAt?: number | null; now?: number },
 ): string | null {
   if (items.length === 0) return TITLE_EMPTY;
   const c = countTodos(items);
+  const now = opts?.now ?? Date.now();
+  if (isArchived(items, opts?.lastWriteAt ?? null, now)) {
+    const age = formatAge(now - (opts?.lastWriteAt as number));
+    return clipTitle(`✓${c.completed} done ${age}`);
+  }
   const activity =
     items.find((it) => it.status === 'in_progress')?.content
     ?? (fallbackDescription?.trim() ? fallbackDescription.trim() : null);

package/src/pipe-channel.ts

@@ -37,6 +37,9 @@ export type PipeRequest =
       from?: string | null;
       /** D50：结算时是否 push reply（后台 true、前台 false——前台由调用方同步取结果）。 */
       push?: boolean;
+      /** B3：follow_up 以 steer 投递（tool-call 间隙即达，秒级）。缺省/ false =
+       * followUp 队列语义（run 结束才投）——初始 prompt 保持队列语义，续作指令走 steer。 */
+      steer?: boolean;
     }
   | { type: 'interrupt'; id: string }
   | {

package/src/settle-wake-core.ts

@@ -0,0 +1,54 @@
+/**
+ * settled 唤醒决策纯核心（反唤醒风暴；session 01a03bf0 实证）。
+ *
+ * 实证链：ESC 中止 → agent_settled → D96「仍有后台 subagent」提醒
+ * sendUserMessage(followUp)（空闲时必触发新 run）→ master 重启 → 用户再 ESC → …
+ * 30 连 abort，ESC 永远打不断，Ctrl+C 杀进程才停。
+ * 且自然 settle 也有自激励环：settle → 提醒 → 新 run → settle → 提醒……
+ *
+ * 规则：
+ *  - abort 抑制：上次 assistant stopReason === 'aborted' → 本次 settled 不做任何
+ *    唤醒型注入（用户显式叫停；结算缓冲保留待下次自然 turn 投递）；
+ *  - D96 去重：同一组 running paneId 只提醒一次；集合变化（新 sub / 结算）重置；
+ *  - D96 冷却：同集合重提醒至少间隔 REPEAT_NOTICE_MS（集合没变却再提醒 = 噪音）。
+ */
+export const ABORT_STOP_REASON = 'aborted';
+
+/** D96：同一 running 集合的重提醒冷却。 */
+export const D96_REPEAT_NOTICE_MS = 10 * 60_000;
+
+export interface SettleWakeInput {
+  /** 本次 settled 前最后一次 assistant turn 的 stopReason（未知 = null，视作自然结束）。 */
+  lastStopReason: string | null;
+  /** 仍在 running 的后台 subagent（空数组 = 无）。 */
+  running: ReadonlyArray<{ paneId: string }>;
+  /** 上次 D96 提醒时的集合键（无 = null）。 */
+  lastNoticeKey: string | null;
+  /** 上次 D96 提醒时间（epoch ms）。 */
+  lastNoticeAt: number;
+  now: number;
+}
+
+export interface SettleWakePlan {
+  /** false = 本次 settled 静默：不投任何唤醒型消息。 */
+  wake: boolean;
+  /** 是否注入 D96「仍在运行」提醒。 */
+  notice: boolean;
+  /** 新的集合键（提醒时更新；running 空 → null）。 */
+  noticeKey: string | null;
+  noticeAt: number;
+}
+
+export function planSettleWake(input: SettleWakeInput): SettleWakePlan {
+  if (input.lastStopReason === ABORT_STOP_REASON) {
+    return { wake: false, notice: false, noticeKey: input.lastNoticeKey, noticeAt: input.lastNoticeAt };
+  }
+  const key = input.running.length === 0 ? null : input.running.map((s) => s.paneId).sort().join(',');
+  if (key === null) {
+    return { wake: true, notice: false, noticeKey: null, noticeAt: input.lastNoticeAt };
+  }
+  const newSet = key !== input.lastNoticeKey;
+  const cooled = input.now - input.lastNoticeAt >= D96_REPEAT_NOTICE_MS;
+  const notice = newSet || cooled;
+  return { wake: true, notice, noticeKey: key, noticeAt: notice ? input.now : input.lastNoticeAt };
+}