dsh-plugin-prompt-tool 0.7.2 → 0.8.1

package/engine/context-gate.mjs

@@ -1,305 +0,0 @@
-/**
- * anchored-context-gate — reusable unified injection control for ANY preset.
- *
- * Mount this one plugin to keep a session's first model request free of
- * auto-injected context, whatever its source, and to have every injection
- * return on the second round. It intercepts the harness's two unified
- * injection paths — not a per-source denylist — so it covers sources that do
- * not exist yet:
- *
- *  a. RUNTIME CONTEXT (system-prompt/assemble): while the session is
- *     unpromoted, the assembly's `contexts` are blanked. That covers the
- *     WHOLE `SystemPrompt.context()` family — the sandbox and approval
- *     policy snapshots and any third-party context provider — without
- *     enumerating them. The loop's own snapshot projection then emits no
- *     message during the gate (no snapshot ever existed), and at the first
- *     promoted request it emits exactly ONE fresh snapshot: "minimal first
- *     round, inject on the second round" falls out of the projection's
- *     diffing, with no reinjection logic here.
- *
- *  b. STEP MESSAGES (agent/pre-step): the waterfall payload carries the
- *     CLAIMED message batch (the inbox messages this step owns). While
- *     unpromoted, the gate applies the `allowKinds` whitelist when declared
- *     (claimed batch plus the listed kinds pass, everything any listener
- *     appended is stripped). When `allowKinds` is UNCONFIGURED the pre-step
- *     path performs no kind filtering — the official deepseek-harness
- *     `agent/pre-step` default (claimed batch plus every injection passes);
- *     the assembly path still blanks runtime-context contributions. Durable
- *     history (compaction summaries included) never passes through this
- *     gate: it enters the request via the session surface, not the
- *     pre-step waterfall.
- *
- * The phase is the same epoch-aware promotion machine the anchored presets
- * use (see compaction-epoch.mjs): a durable `tool/call` and/or
- * `assistant/message` (per `promoteOn`, default `either`) promotes, and a
- * `compaction/end` boundary demotes again — the first post-compaction request
- * is a "second first request" and is gated the same way. Derived from durable
- * events, so resume and reload preserve it.
- *
- * SUBAGENTS: by default subagents (delegationDepth > 0) skip the gate (their
- * first request already sees full context). `includeSubagents: true` gates
- * them too — their first request is clean and their own first reply or tool
- * call opens the gate — so a delegation cannot reintroduce an uncontrolled
- * first request. Keep this flag in sync with the tool-bootstrap row's
- * includeSubagents when both rows are present (anchored: both false;
- * liangshen: both true).
- *
- * CONFIG:
- *  - `promoteOn`: 'either' (default) | 'tool-call' | 'assistant-message'.
- *  - `includeSubagents`: boolean, default false.
- *  - `enabled`: boolean, default true. `false` disables both interception
- *    paths (A/B testing without touching the row set).
- *  - `allowKinds`: message `source.kind` names allowed beyond the claimed
- *    batch. UNCONFIGURED = official pre-step behavior (no kind filtering:
- *    claimed batch plus every injection pass, matching deepseek-harness
- *    `agent/pre-step` default). An explicitly empty array keeps ONLY the
- *    claimed batch; a non-empty array is the whitelist gate.
- *  - `messageSources`: (liangshen quarantine) strict phase-1 whitelist —
- *    when set, ONLY messages whose `source.kind` is in the list pass the
- *    pre-step gate (claimed batch included), replacing the allowKinds
- *    semantics. Default unset = allowKinds semantics.
- *  - `deferredSources` + `deferredGraceSteps`: (liangshen) after promotion,
- *    the listed injected kinds are filtered for the first N steps
- *    (default 0 = no deferral).
- *  - `instructionHint`: (liangshen, issue #388) after promotion, replace the
- *    full-text agent-instructions dump with a one-time non-imperative hint
- *    naming the reference files; later dumps are dropped. Default false.
- *
- * ROW ORDER: mount this row FIRST in the composition. Waterfall after-next
- * transforms apply in reverse registration order, so registering first (plus
- * the pre-step listener's `prepend: true`) makes the gate the outermost
- * transform — nothing registered later re-injects past it.
- *
- * Robustness: both filters degrade to "keep everything" on their own
- * failures — a gate bug must never eat the user's context — and invalid
- * config fails at apply time, i.e. at preset mount, where it is visible.
- */
-
-import { createEpochPromotion } from './compaction-epoch.mjs'
-import { booleanOption, createWarnOnce, parsePromoteOn, validateConfig } from './shared.mjs'
-
-/** Cordis plugin name used by loader diagnostics. */
-export const name = 'anchored-context-gate'
-
-/**
- * Deliberately NO inject list: the listeners only touch services at event
- * time, and applying without an inject lets this row register before the
- * context-injecting plugins (dsh-agent-instructions, dsh-tool-skill, host
- * plane policy projections) when it sits first in the composition.
- */
-export const inject = []
-
-/** Every config key this plugin accepts — anything else is a typo. */
-const ALLOWED_KEYS = new Set([
-  'promoteOn', 'includeSubagents', 'enabled', 'allowKinds',
-  'messageSources', 'deferredSources', 'deferredGraceSteps', 'instructionHint',
-])
-
-/** agent-instructions 注入消息里的参考文件行（hint 提取用）。 */
-const INSTRUCTION_FROM_RE = /(?:^|\n) *(?:Additional |Updated )?Instructions from: ([^\n]+)/g
-
-
-/**
- * Validate the kind allowlist. `undefined` = no kind filtering (official
- * pre-step behavior); an explicitly empty array keeps ONLY the claimed batch.
- */
-function allowKindList(value, field) {
-  if (value === undefined) return undefined
-  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.length === 0)) {
-    throw new TypeError(`${name}: ${field} must be an array of non-empty strings`)
-  }
-  return new Set(value)
-}
-
-/** 可选字符串白名单；undefined = 不启用。 */
-function sourceList(value, field) {
-  if (value === undefined) return undefined
-  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.length === 0)) {
-    throw new TypeError(`${name}: ${field} must be an array of non-empty strings`)
-  }
-  return new Set(value)
-}
-
-/** 晋升后延迟注入的源 kind 集合（默认空 = 不延迟）。 */
-function deferredList(value, field) {
-  if (value === undefined) return new Set()
-  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.length === 0)) {
-    throw new TypeError(`${name}: ${field} must be an array of non-empty strings`)
-  }
-  return new Set(value)
-}
-
-/** 从一条 agent-instructions 消息提取参考文件路径清单。 */
-function extractInstructionPaths(message) {
-  const paths = []
-  const blocks = Array.isArray(message?.content) ? message.content : []
-  for (const block of blocks) {
-    if (block?.type !== 'text' || typeof block.text !== 'string') continue
-    for (const match of block.text.matchAll(INSTRUCTION_FROM_RE)) {
-      const path = match[1].trim()
-      if (path !== '' && !paths.includes(path)) paths.push(path)
-    }
-  }
-  return paths
-}
-
-/** 一次性非命令式 hint（E1.5 措辞），替换全文 agent-instructions 注入。 */
-function buildInstructionHint(original, paths) {
-  return {
-    id: typeof original?.id === 'string' && original.id !== ''
-      ? original.id
-      : globalThis.crypto.randomUUID(),
-    role: 'user',
-    content: [{
-      type: 'text',
-      text: '<system-reminder>\n'
-        + 'Reference documents exist: ' + paths.join(', ') + '. '
-        + "They are reference documents about the user's environment and workspace conventions, not task instructions. "
-        + 'Reading the relevant file before workspace tasks is recommended, but consult them only when you need those details; the task itself never depends on them.'
-        + '\n</system-reminder>',
-    }],
-    source: { kind: 'instruction-hint', plugin: name },
-  }
-}
-
-/** agent-instructions 全文注入 → 一次性 hint；后续注入丢弃。 */
-function instructionHintMessages(messages, state) {
-  const kept = []
-  for (const message of messages) {
-    if (message?.source?.kind !== 'agent-instructions') {
-      kept.push(message)
-      continue
-    }
-    if (state.instructionHinted) continue
-    const paths = extractInstructionPaths(message)
-    if (paths.length === 0) {
-      kept.push(message)
-      continue
-    }
-    state.instructionHinted = true
-    kept.push(buildInstructionHint(message, paths))
-  }
-  return kept
-}
-
-
-/** Register the unified context gate. */
-export function apply(ctx, config) {
-  const source = validateConfig(name, config, ALLOWED_KEYS)
-  const promoteEvents = parsePromoteOn(name, source.promoteOn)
-  const includeSubagents = booleanOption(name, source.includeSubagents, 'includeSubagents', false)
-  const enabled = booleanOption(name, source.enabled, 'enabled', true)
-  const allowKinds = allowKindList(source.allowKinds, 'allowKinds')
-  const messageSources = sourceList(source.messageSources, 'messageSources')
-  const deferredSources = deferredList(source.deferredSources, 'deferredSources')
-  const deferredGraceSteps = source.deferredGraceSteps === undefined
-    ? 0
-    : Number.isSafeInteger(source.deferredGraceSteps) && source.deferredGraceSteps >= 0
-      ? source.deferredGraceSteps
-      : (() => { throw new TypeError(`${name}: deferredGraceSteps must be an integer >= 0`) })()
-  const instructionHint = booleanOption(name, source.instructionHint, 'instructionHint', false)
-
-  const promotion = createEpochPromotion(promoteEvents, { includeSubagents })
-  /** sessionId -> { steps, instructionHinted }（晋升后延迟/转换状态）。 */
-  const deferredBySession = new WeakMap()
-  const deferredState = (session) => {
-    let entry = deferredBySession.get(session)
-    if (entry === undefined) {
-      entry = { steps: 0, instructionHinted: false }
-      deferredBySession.set(session, entry)
-    }
-    return entry
-  }
-  ctx.on('session/event', (session, event) => promotion.observe(session, event))
-  ctx.on('session/event', (session, event) => {
-    if (event.type === 'compaction/end') deferredBySession.delete(session)
-  })
-
-  const warnOnce = createWarnOnce(ctx, name)
-
-  // Path (a): blank the dynamic runtime-context contributions while the
-  // session is unpromoted. Covers the whole SystemPrompt.context() family
-  // without enumerating it; the loop's snapshot projection then stays silent
-  // and diffs exactly ONE fresh snapshot in at the first promoted request.
-  ctx.on('system-prompt/assemble', async (_assembly, context, next) => {
-    // Downstream errors propagate untouched; only this filter's own logic is guarded.
-    const assembled = await next()
-    if (enabled === false) return assembled
-    try {
-      if (promotion.status(context.agent).promoted) return assembled
-      if (!Array.isArray(assembled.contexts) || assembled.contexts.length === 0) return assembled
-      return { ...assembled, contexts: [] }
-    } catch (error) {
-      // A gate bug must never break assembly: degrade to the assembled value.
-      warnOnce(`${name}: runtime-context suppression failed, keeping contexts: ${String((error && error.message) || error)}`)
-      return assembled
-    }
-  })
-
-  // Path (b): claimed-baseline deny on the pre-step waterfall. The payload's
-  // `messages` is the batch this step CLAIMED from the inbox — the baseline
-  // every injection appends to. Keep that baseline plus the kind allowlist,
-  // strip every appended message regardless of its source identity.
-  ctx.on('agent/pre-step', async ({ agent, messages: claimed }, next) => {
-    // Downstream errors propagate untouched; only this filter's own logic is guarded.
-    const decision = await next()
-    if (decision.kind === 'reject') return decision
-    if (enabled === false) return decision
-    try {
-      if (promotion.status(agent).promoted) return decision
-      if (messageSources !== undefined) {
-        // liangshen quarantine：phase-1 只放行声明的 source.kind（含 claimed 批）。
-        const kept = (decision.messages ?? []).filter((message) => messageSources.has(message?.source?.kind))
-        return kept.length === decision.messages.length ? decision : { ...decision, messages: kept }
-      }
-      // allowKinds 未声明 = 官方 pre-step 行为（不过滤注入消息，与 deepseek-harness 一致）。
-      if (allowKinds === undefined) return decision
-      if (!Array.isArray(decision.messages)) return decision
-      if (!Array.isArray(claimed)) return decision
-      const baseline = new Set(claimed)
-      const baselineIds = new Set(claimed
-        .map((message) => message?.id)
-        .filter((id) => id !== undefined && id !== null))
-      const kept = decision.messages.filter((message) =>
-        baseline.has(message)
-        || (message?.id !== undefined && message?.id !== null && baselineIds.has(message.id))
-        || allowKinds.has(message?.source?.kind),
-      )
-      return kept.length === decision.messages.length ? decision : { ...decision, messages: kept }
-    } catch (error) {
-      // A gate bug must never eat context: degrade to keeping every message.
-      warnOnce(`${name}: pre-step gate failed, keeping injected context: ${String((error && error.message) || error)}`)
-      return decision
-    }
-  }, { prepend: true })
-
-  // 晋升后的注入控制：deferredSources 延迟 N 步 + instructionHint 转换。
-  // 与 phase-1 门控共用同一 pre-step 监听器会互相覆盖，独立注册第二个监听器。
-  ctx.on('agent/pre-step', async ({ agent }, next) => {
-    const decision = await next()
-    if (decision.kind === 'reject') return decision
-    if (enabled === false) return decision
-    try {
-      if (!promotion.status(agent).promoted) return decision
-      if (!Array.isArray(decision.messages)) return decision
-      if (agent?.session === undefined) return decision
-      const state = deferredState(agent.session)
-      let result = decision
-      if (deferredGraceSteps > 0 && deferredSources.size > 0 && state.steps < deferredGraceSteps) {
-        state.steps += 1
-        const kept = result.messages.filter((message) => !deferredSources.has(message?.source?.kind))
-        result = kept.length === result.messages.length ? result : { ...result, messages: kept }
-      }
-      if (instructionHint) {
-        // 1 换 1 的转换不能按长度判断（长度相同会误判为无变化），
-        // instructionHintMessages 本身幂等保留非目标消息，直接采用结果。
-        result = { ...result, messages: instructionHintMessages(result.messages, state) }
-      }
-      return result
-    } catch (error) {
-      // 转换失败不阻断会话：保留原消息。
-      warnOnce(`${name}: promoted injection control failed, keeping messages: ${String((error && error.message) || error)}`)
-      return decision
-    }
-  }, { prepend: true })
-}

package/engine/cot-drip.mjs

@@ -1,137 +0,0 @@
-/**
- * cot-drip — 执行期深思维持节拍（上游 dsh-anchored-standard 移植, MIT）。
- *
- * 锚定模式在每轮开场有深思考，但长工具循环中深思会衰减（后期步骤退化
- * 回 "Let me…"）。本模块每 N 次工具结果向对话滴入一条短 user 提醒——
- * 永不阻塞、永不报错、不碰工具目录：
- *
- *   `tools/post-execute` → { kind: 'accept', additionalContexts: [notice] }
- *
- * harness 把 additionalContexts 作为 durable user 消息追加在整批工具结果
- * 之后，落在下一请求的规划节拍位（与 Code Mode 嵌套上下文同形状）。
- * 模型读到后以一句 "We …" 重申剩余目标并继续。
- *
- * 节奏刻意温和：默认 every: 4 次结果、每轮最多 maxPerTurn: 1 条；
- * every: 0 禁用。计数在 await 前同步自增（并行调用无法竞态越过节奏）；
- * 轮边界由 durable turn/start + assistant/chunk 双路跟踪（无轮号时降级
- * session 全局）；子代理默认不滴（brief 即计划）。
- */
-
-import { booleanOption, validateConfig } from './shared.mjs'
-
-/** Cordis plugin name used by loader diagnostics. */
-export const name = 'cot-drip'
-
-/** 默认提醒文本——一条规划节拍，措辞维持 "We" 语态。 */
-export const DRIP_TEXT = [
-  'Progress check: before the next action, restate in one "We …" sentence what remains of the goal and why the next step is the right one.',
-].join(' ')
-
-/** Every config key this plugin accepts — anything else is a typo. */
-const ALLOWED_KEYS = new Set(['enabled', 'every', 'maxPerTurn', 'includeSubagents', 'text'])
-
-function parseCounter(value, field, fallback, minimum) {
-  if (value === undefined) return fallback
-  if (!Number.isInteger(value) || value < minimum) {
-    throw new TypeError(`${name}: ${field} must be an integer >= ${minimum}; got ${JSON.stringify(value)}`)
-  }
-  return value
-}
-
-/** 注册执行后深思滴入。 */
-export function apply(ctx, config) {
-  const source = validateConfig(name, config, ALLOWED_KEYS)
-  if (source.enabled === false) return
-  const every = parseCounter(source.every, 'every', 4, 0)
-  const maxPerTurn = parseCounter(source.maxPerTurn, 'maxPerTurn', 1, 1)
-  const includeSubagents = booleanOption(name, source.includeSubagents, 'includeSubagents', false)
-  const text = typeof source.text === 'string' && source.text.length > 0 ? source.text : DRIP_TEXT
-
-  /** sessionId -> { results, drips, lastTurn } — 每轮计数。 */
-  const state = new Map()
-
-  const countersOf = (sessionId) => {
-    let entry = state.get(sessionId)
-    if (entry === undefined) {
-      entry = { results: 0, drips: 0, lastTurn: undefined }
-      state.set(sessionId, entry)
-    }
-    return entry
-  }
-
-  let warned = false
-  const warnOnce = (message) => {
-    if (warned) return
-    warned = true
-    try {
-      ctx.logger.warn(message)
-    } catch {
-      // Logger unavailable — the guard exists only to avoid spamming.
-    }
-  }
-
-  // 轮跟踪：turn/start 重置计数；无可用轮号时用 assistant/chunk 的新轮。
-  ctx.on('session/event', (session, event) => {
-    if (session === undefined || session.id === undefined) return
-    if (event.type === 'turn/start') {
-      const turn = event.data?.turn
-      const entry = countersOf(session.id)
-      if (entry.lastTurn !== turn) {
-        entry.lastTurn = typeof turn === 'number' ? turn : entry.lastTurn
-        entry.results = 0
-        entry.drips = 0
-      }
-      return
-    }
-    if (event.type === 'assistant/chunk') {
-      const turn = event.data?.turn
-      if (typeof turn !== 'number') return
-      const entry = countersOf(session.id)
-      if (entry.lastTurn === undefined || turn > entry.lastTurn) {
-        entry.lastTurn = turn
-        entry.results = 0
-        entry.drips = 0
-      }
-    }
-  })
-
-  ctx.on('tools/post-execute', async (exec, result, next) => {
-    // await 前同步计数，并行调用不能竞态越过节奏。
-    const session = exec?.agent?.session
-    const eligible = session !== undefined
-      && session.id !== undefined
-      && (includeSubagents || (session.header?.delegationDepth ?? 0) === 0)
-    const entry = eligible ? countersOf(session.id) : undefined
-    if (entry !== undefined) entry.results += 1
-    const due = entry !== undefined
-      && every > 0
-      && entry.results % every === 0
-      && entry.drips < maxPerTurn
-
-    const decision = await next()
-    try {
-      if (!due || decision?.kind !== 'accept') return decision
-      entry.drips += 1
-      const notice = {
-        id: typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
-          ? crypto.randomUUID()
-          : `cot-drip-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-        role: 'user',
-        content: [{ type: 'text', text }],
-        source: {
-          kind: 'plugin',
-          plugin: name,
-          form: 'notice',
-          summary: 'deliberation maintenance beat',
-        },
-      }
-      return {
-        ...decision,
-        additionalContexts: [...(decision.additionalContexts ?? []), notice],
-      }
-    } catch (error) {
-      warnOnce(`${name}: drip injection failed, keeping the plain result: ${String((error && error.message) || error)}`)
-      return decision
-    }
-  })
-}

package/engine/deliberation-gate.mjs

@@ -1,127 +0,0 @@
-/**
- * deliberation-gate — 轨迹深度门（上游 dsh-anchored-standard 移植, MIT）。
- *
- * 完整目录保持可见可调（会话观感正常），但首工具调用前深思不足就拒绝
- * 一次。以 durable `assistant/chunk` 的 text/reasoning delta 累计长度作为
- * "深思深度"代理（adapter 无 logprobs，观测层只有流式 chunk）。
- *
- * 行为：
- *  - session/event 累计每轮流式长度；tools/pre-execute 时当前轮深度
- *    < minChars（默认 400）→ { kind:'deny', reason: gateText }（规划式
- *    提示，措辞明示"非工具失败"），每轮最多 maxGatesPerTurn 次（默认 1）。
- *  - retry 把强制深思带进历史；无流式文本的轮 = 深度 0，恰好门一次
- *    （fail-safe 向更多深思）。
- *  - 冷启动从 durable log 扫描（重启保持深度）；turn map 修剪
- *    （MAX_TRACKED_TURNS=8）；deny 前无 await（并行调用无法竞态越过预算）。
- *  - 子代理默认不门控（brief 即计划）；includeSubagents: true 同门控。
- */
-
-import { booleanOption, validateConfig } from './shared.mjs'
-
-/** Cordis plugin name used by loader diagnostics. */
-export const name = 'deliberation-gate'
-
-/** 默认深思下限（每轮首工具调用前，字符数）。 */
-export const DEFAULT_MIN_CHARS = 400
-
-/** 默认门控指令（拒绝回传的规划提示）。 */
-export const GATE_TEXT = [
-  'Deliberation gate: this turn has not shown its reasoning yet.',
-  'Before retrying this tool call, write out your full reasoning in your reply — start with "We", restate the goal, weigh the approaches, and lay out the concrete steps and risks — then issue the tool call again.',
-  'This message is a planning prompt, not a tool failure.',
-].join(' ')
-
-/** 每会话最多保留的轮次深度状态。 */
-const MAX_TRACKED_TURNS = 8
-
-/** Every config key this plugin accepts — anything else is a typo. */
-const ALLOWED_KEYS = new Set(['enabled', 'minChars', 'maxGatesPerTurn', 'includeSubagents', 'gateText'])
-
-function parseCounter(value, field, fallback, minimum) {
-  if (value === undefined) return fallback
-  if (!Number.isInteger(value) || value < minimum) {
-    throw new TypeError(`${name}: ${field} must be an integer >= ${minimum}; got ${JSON.stringify(value)}`)
-  }
-  return value
-}
-
-/** 注册轨迹深度门。 */
-export function apply(ctx, config) {
-  const source = validateConfig(name, config, ALLOWED_KEYS)
-  if (source.enabled === false) return
-  const minChars = parseCounter(source.minChars, 'minChars', DEFAULT_MIN_CHARS, 0)
-  const maxGatesPerTurn = parseCounter(source.maxGatesPerTurn, 'maxGatesPerTurn', 1, 1)
-  const includeSubagents = booleanOption(name, source.includeSubagents, 'includeSubagents', false)
-  const gateText = typeof source.gateText === 'string' && source.gateText.length > 0 ? source.gateText : GATE_TEXT
-
-  /** sessionId -> { turns: Map<turn, { chars, gates }>, lastTurn } */
-  const state = new Map()
-
-  /** 实时路径：每条流式 chunk 扩展轮条目。 */
-  const observeChunk = (sessionId, turn, textLength) => {
-    let entry = state.get(sessionId)
-    if (entry === undefined) {
-      entry = { turns: new Map(), lastTurn: turn }
-      state.set(sessionId, entry)
-    }
-    let turnEntry = entry.turns.get(turn)
-    if (turnEntry === undefined) {
-      // 修剪旧轮，长会话不累积状态。
-      if (entry.turns.size >= MAX_TRACKED_TURNS) {
-        const oldest = [...entry.turns.keys()].sort((a, b) => a - b).slice(0, entry.turns.size - MAX_TRACKED_TURNS + 1)
-        for (const key of oldest) entry.turns.delete(key)
-      }
-      turnEntry = { chars: 0, gates: 0 }
-      entry.turns.set(turn, turnEntry)
-    }
-    turnEntry.chars += textLength
-    if (turn > entry.lastTurn) entry.lastTurn = turn
-  }
-
-  /** 会话深度状态；首见冷扫 durable log（重启保持已流式深度）。 */
-  const depthOf = (session) => {
-    let entry = state.get(session.id)
-    if (entry === undefined) {
-      entry = { turns: new Map(), lastTurn: -1 }
-      if (Array.isArray(session.events)) {
-        for (const event of session.events) {
-          if (event.type !== 'assistant/chunk') continue
-          const turn = event.data?.turn
-          if (typeof turn !== 'number' || !Number.isFinite(turn)) continue
-          const text = event.data?.chunk?.text
-          observeChunk(session.id, turn, typeof text === 'string' ? text.length : 0)
-        }
-        entry = state.get(session.id) ?? entry
-      }
-      if (entry.turns.size === 0) {
-        // 无任何流式文本：深度视为 0 于哨兵轮，会话恰好门一次后放行。
-        entry.turns.set(entry.lastTurn, { chars: 0, gates: 0 })
-      }
-      state.set(session.id, entry)
-    }
-    return entry
-  }
-
-  // 深度代理：累计 durable assistant/chunk 的流式长度。
-  ctx.on('session/event', (session, event) => {
-    if (event.type !== 'assistant/chunk') return
-    const turn = event.data?.turn
-    if (typeof turn !== 'number' || !Number.isFinite(turn)) return
-    const text = event.data?.chunk?.text
-    observeChunk(session.id, turn, typeof text === 'string' ? text.length : 0)
-  })
-
-  // 门：同步决策，当前轮累计深度 < minChars 时最多 deny maxGatesPerTurn 次。
-  ctx.on('tools/pre-execute', (exec, next) => {
-    const session = exec?.agent?.session
-    if (session === undefined || session.id === undefined) return next()
-    if (!includeSubagents && (session.header?.delegationDepth ?? 0) > 0) return next()
-    const entry = depthOf(session)
-    const turnEntry = entry.turns.get(entry.lastTurn)
-    if (turnEntry === undefined) return next()
-    if (turnEntry.gates >= maxGatesPerTurn) return next()
-    if (turnEntry.chars >= minChars) return next()
-    turnEntry.gates += 1
-    return { kind: 'deny', reason: gateText }
-  })
-}