dsh-context-compression-improved 0.5.1 → 0.5.3

package/packages/selector/src/client/ReviewOverlay.tsx

@@ -1,320 +0,0 @@
-/**
- * TokenPilot-inspired R4: the review floating window.
- *
- * Mounted on the host `shell.overlay` slot (dsh-tidychat precedent: the layer
- * is click-through by default and only the card opts back in), showing a
- * bottom-right badge while any session has pending proposals and a card with
- * the four-state summary row plus one row per proposal. Every 10s it polls the
- * review-queue route; when the queue is empty or review mode is off the
- * component renders null, so it never disturbs the session.
- *
- * Styles carry the `dsh-cc-review-` prefix and ride a one-shot style tag.
- */
-import { useEffect, useState } from 'react'
-import type { ReactElement } from 'react'
-import type { SettingsScopeLike } from './review-scope.ts'
-
-const QUEUE_ROUTES = [
-  '/api/dsh-context-compression-improved/review-queue',
-  '/endpoint/dsh-context-compression-improved/review-queue',
-] as const
-const DECIDE_ROUTES = [
-  '/api/dsh-context-compression-improved/review-decide',
-  '/endpoint/dsh-context-compression-improved/review-decide',
-] as const
-
-export interface PendingProposal {
-  readonly sessionId: string
-  readonly id: string
-  readonly kind: string
-  readonly items: readonly { readonly seq: number, readonly tokensBefore: number, readonly tokensAfter: number }[]
-  readonly benefit: {
-    readonly recoveredTokens: number
-    readonly paybackTurns?: number
-    readonly expectedSaving?: number
-  }
-}
-
-export interface ReviewSummary {
-  readonly autoApplied: number
-  readonly reviewApplied: number
-  readonly expired: number
-  readonly voided: number
-}
-
-interface ReviewOverlayProps {
-  /** Bound settings scope; supplies the reviewMode switch. */
-  scope: SettingsScopeLike
-  t: (key: string) => string
-}
-
-const CSS = `
-.dsh-cc-review-badge {
-  position: fixed;
-  right: 20px;
-  bottom: 20px;
-  z-index: 70;
-  pointer-events: auto;
-  box-sizing: border-box;
-  min-width: 34px;
-  height: 34px;
-  padding: 0 10px;
-  border-radius: 17px;
-  border: 1px solid var(--dsw-alias-border-l2, rgba(128,128,128,0.4));
-  background: var(--dsw-alias-bg-layer-3, #fff);
-  color: var(--dsw-alias-label-primary, #222);
-  font-size: 13px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 6px;
-  cursor: pointer;
-  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.14);
-}
-.dsh-cc-review-card {
-  position: fixed;
-  right: 20px;
-  bottom: 62px;
-  z-index: 70;
-  pointer-events: auto;
-  box-sizing: border-box;
-  width: min(420px, calc(100vw - 40px));
-  max-height: min(60vh, 520px);
-  overflow: auto;
-  background: var(--dsw-alias-bg-layer-3, #fff);
-  border: 1px solid var(--dsw-alias-border-l2, rgba(128,128,128,0.4));
-  border-radius: 12px;
-  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.18);
-  padding: 12px 14px;
-  color: var(--dsw-alias-label-primary, #222);
-  font-size: 13px;
-}
-.dsh-cc-review-title {
-  font-weight: 600;
-  margin: 0 0 6px;
-  font-size: 13px;
-}
-.dsh-cc-review-summary {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 4px 12px;
-  color: var(--dsw-alias-label-tertiary, #888);
-  font-size: 12px;
-  margin-bottom: 8px;
-}
-.dsh-cc-review-row {
-  border-top: 1px solid var(--dsw-alias-border-l2, rgba(128,128,128,0.25));
-  padding: 8px 0;
-}
-.dsh-cc-review-row-meta {
-  color: var(--dsw-alias-label-tertiary, #888);
-  font-size: 12px;
-  margin-bottom: 4px;
-}
-.dsh-cc-review-actions {
-  display: flex;
-  gap: 8px;
-}
-.dsh-cc-review-btn {
-  appearance: none;
-  border: 1px solid var(--dsw-alias-border-l2, rgba(128,128,128,0.4));
-  background: transparent;
-  color: inherit;
-  border-radius: 6px;
-  padding: 3px 10px;
-  font-size: 12px;
-  cursor: pointer;
-}
-.dsh-cc-review-btn-primary {
-  background: var(--dsw-alias-state-business-primary, #3b82f6);
-  border-color: transparent;
-  color: #fff;
-}
-`
-
-function injectOnce(): () => void {
-  const tag = document.createElement('style')
-  tag.setAttribute('data-plugin-css', 'dsh-context-compression-improved-review')
-  tag.textContent = CSS
-  document.head.appendChild(tag)
-  return () => { tag.remove() }
-}
-
-async function fetchJson(route: string, init?: RequestInit): Promise<unknown> {
-  const response = await fetch(route, { headers: { 'cache-control': 'no-cache' }, ...init })
-  if (!response.ok) return undefined
-  return response.json()
-}
-
-async function pollQueue(): Promise<{ pending: PendingProposal[], summary?: ReviewSummary | undefined } | undefined> {
-  for (const route of QUEUE_ROUTES) {
-    const body = await fetchJson(route) as {
-      ok?: boolean
-      total?: number
-      pending?: PendingProposal[]
-      summary?: ReviewSummary
-    } | undefined
-    if (body?.ok === true) {
-      return { pending: body.pending ?? [], summary: body.summary }
-    }
-  }
-  return undefined
-}
-
-async function postDecide(proposal: PendingProposal, decision: string): Promise<boolean> {
-  for (const route of DECIDE_ROUTES) {
-    try {
-      const response = await fetch(route, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ sessionId: proposal.sessionId, proposalId: proposal.id, decision }),
-      })
-      if (response.status !== 404) return response.ok
-    } catch {
-      // Try the next prefix.
-    }
-  }
-  return false
-}
-
-/**
- * Slot factory helper: the client entry is a .ts file and cannot carry JSX,
- * so the element construction lives here.
- */
-export function renderReviewOverlay(
-  scope: SettingsScopeLike,
-  t: (key: string) => string,
-): ReactElement {
-  return <ReviewOverlay scope={scope} t={t} />
-}
-
-/**
- * The floating window itself: renders null (and stays silent) while review
- * mode is off or nothing is pending.
- */
-export function ReviewOverlay({ scope, t }: ReviewOverlayProps) {
-  const [reviewMode, setReviewMode] = useState(false)
-  const [pending, setPending] = useState<PendingProposal[]>([])
-  const [summary, setSummary] = useState<ReviewSummary | undefined>()
-  const [expanded, setExpanded] = useState(false)
-  const [busy, setBusy] = useState(false)
-
-  useEffect(injectOnce, [])
-  useEffect(() => {
-    const pull = (): void => {
-      try {
-        const snapshot = scope.getSnapshot()
-        setReviewMode(snapshot.status === 'ready' && snapshot.value?.presetOptions?.reviewMode === true)
-      } catch {
-        setReviewMode(false)
-      }
-    }
-    pull()
-    let unsubscribe: () => void
-    try {
-      unsubscribe = scope.subscribe(pull)
-    } catch {
-      unsubscribe = (): void => {}
-    }
-    return unsubscribe
-  }, [scope])
-
-  useEffect(() => {
-    if (!reviewMode) return
-    let alive = true
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const tick = (): void => {
-      void pollQueue().then((result) => {
-        if (!alive) return
-        setPending(result?.pending ?? [])
-        setSummary(result?.summary)
-        timer = setTimeout(tick, 10_000)
-      })
-    }
-    tick()
-    return () => {
-      alive = false
-      if (timer !== undefined) clearTimeout(timer)
-    }
-  }, [reviewMode])
-
-  if (!reviewMode || pending.length === 0) return null
-
-  const decide = (proposal: PendingProposal, decision: string): void => {
-    setBusy(true)
-    void postDecide(proposal, decision).then(() => {
-      return pollQueue().then((result) => {
-        setPending(result?.pending ?? [])
-        setSummary(result?.summary)
-        setBusy(false)
-      })
-    }).catch(() => { setBusy(false) })
-  }
-
-  const seqRange = (proposal: PendingProposal): string => {
-    const seqs = proposal.items.map(item => item.seq)
-    const min = Math.min(...seqs)
-    const max = Math.max(...seqs)
-    return min === max ? `#${String(min)}` : `#${String(min)}–#${String(max)}`
-  }
-
-  return (
-    <>
-      {expanded ? (
-        <div className="dsh-cc-review-card">
-          <p className="dsh-cc-review-title">{t('review.title')}</p>
-          {summary !== undefined ? (
-            <div className="dsh-cc-review-summary">
-              <span>{t('review.summary.autoApplied')}: {String(summary.autoApplied)}</span>
-              <span>{t('review.summary.reviewApplied')}: {String(summary.reviewApplied)}</span>
-              <span>{t('review.summary.expired')}: {String(summary.expired)}</span>
-              <span>{t('review.summary.voided')}: {String(summary.voided)}</span>
-            </div>
-          ) : null}
-          {pending.map(proposal => (
-            <div className="dsh-cc-review-row" key={proposal.id}>
-              <div className="dsh-cc-review-row-meta">
-                {proposal.kind} · {seqRange(proposal)} · R ≈ {String(proposal.benefit.recoveredTokens)}
-                {proposal.benefit.paybackTurns !== undefined
-                  ? ` · ${t('review.row.payback')}: ${String(Math.round(proposal.benefit.paybackTurns * 100) / 100)}`
-                  : ''}
-                {proposal.benefit.expectedSaving !== undefined
-                  ? ` · ${t('review.row.expectedSaving')}: ${String(Math.round(proposal.benefit.expectedSaving))} (${t('review.row.estimated')})`
-                  : ''}
-              </div>
-              <div className="dsh-cc-review-actions">
-                <button
-                  type="button" className="dsh-cc-review-btn dsh-cc-review-btn-primary"
-                  disabled={busy}
-                  onClick={() => { decide(proposal, 'approved') }}
-                >
-                  {t('review.action.approve')}
-                </button>
-                <button
-                  type="button" className="dsh-cc-review-btn"
-                  disabled={busy}
-                  onClick={() => { decide(proposal, 'rejected') }}
-                >
-                  {t('review.action.reject')}
-                </button>
-                <button
-                  type="button" className="dsh-cc-review-btn"
-                  disabled={busy}
-                  onClick={() => { decide(proposal, 'ignored') }}
-                >
-                  {t('review.action.ignore')}
-                </button>
-              </div>
-            </div>
-          ))}
-        </div>
-      ) : null}
-      <button
-        type="button" className="dsh-cc-review-badge"
-        onClick={() => { setExpanded(value => !value) }}
-      >
-        {t('review.badge')} {String(pending.length)}
-      </button>
-    </>
-  )
-}

package/packages/selector/src/client/review-scope.ts

@@ -1,16 +0,0 @@
-/**
- * The minimal face of the bound settings scope the review overlay consumes —
- * structural, so tests can stub it without the settings transport.
- */
-
-export interface SettingsScopeLike {
-  getSnapshot(): {
-    status: string
-    value?: {
-      presetOptions?: {
-        reviewMode?: boolean | undefined
-      } | undefined
-    } | undefined
-  }
-  subscribe(listener: () => void): () => void
-}

package/packages/selector/src/runtime/tokenpilot/proposal.ts

@@ -1,267 +0,0 @@
-/**
- * TokenPilot-inspired R4: benefit model for the human-gated review pipeline.
- *
- * Pure functions only: the classifier needs no I/O, no session state, and no
- * host services, so every decision is unit-testable and audit-replayable.
- *
- * The cost model follows the TokenPilot paper's cache-accounting view: one
- * merged mutation pays a one-time tail KV-cache refill penalty of
- * `(1−α)·tailTokens`, and every later turn recovers the reclaimed tokens at
- * the cache-hit discount `α`:
- *
- * ```
- * R              = Σ(tokensBefore − tokensAfter)   // net reclaimed tokens
- * paybackTurns   = (1−α)·tailTokens / (α·R)        // one-time refill / per-turn saving
- * expectedSaving = α·R·max(0, Ŝ − paybackTurns)    // Ŝ = estimated remaining turns
- * ```
- *
- * The refill penalty only models mutations of already-cached context. A
- * fresh-stage batch (shaped before its first request) is exempt via
- * `refillPenaltyExempt`: payback is 0 and every reclaimed token saves from
- * the very first turn.
- *
- * `expectedSaving` is only produced when Ŝ is known (the estimator answered
- * with `expectedRemainingTurns`); it is never fabricated from a guess.
- */
-import { createHash } from 'node:crypto'
-import type { ContentBlock } from '@deepseek-ai/dsh-llm'
-import { dedupeHash, flattenPlainText } from './dedup.ts'
-
-/** The minimal per-candidate face the benefit model consumes. */
-export interface BenefitCandidate {
-  readonly sourceSeq: number
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-}
-
-export interface BenefitInput {
-  /** Cache-hit discount rate α ∈ (0,1); validated upstream by config parsing. */
-  readonly alpha: number
-  /** Token mass of the protected tail that must be refilled after a mutation. */
-  readonly tailTokens: number
-  /** Estimated remaining turns Ŝ; `undefined` keeps expectedSaving out of the result. */
-  readonly remainingTurns?: number | undefined
-  /** True for fresh-stage batches: their content was never served, so it is
-   *  not in the KV cache and shaping it causes no cache break — no refill
-   *  penalty applies and the whole discounted recovery is pure gain. */
-  readonly refillPenaltyExempt?: boolean | undefined
-}
-
-export interface BenefitEstimate {
-  /** Net reclaimed tokens across the batch; may be ≤ 0 when a batch is not worth it. */
-  readonly recoveredTokens: number
-  /** The one-time cache-refill penalty the merged mutation pays: (1−α)·tailTokens. */
-  readonly penaltyTokens: number
-  /** Turns of discounted recovery needed to recoup the penalty; `undefined` when α·R ≤ 0. */
-  readonly paybackTurns?: number
-  /** Discounted net benefit over the remaining session; omitted when Ŝ is unknown. */
-  readonly expectedSaving?: number
-}
-
-/**
- * Aggregate the batch-level benefit of a set of reduction candidates.
- *
- * Individual candidates whose replacement would grow the context contribute
- * zero recovery (they never make a batch look better than dropping them).
- */
-export function computeBenefit(candidates: readonly BenefitCandidate[], input: BenefitInput): BenefitEstimate {
-  const { alpha, tailTokens, remainingTurns } = input
-  let recoveredTokens = 0
-  for (const candidate of candidates) {
-    recoveredTokens += Math.max(0, candidate.tokensBefore - candidate.tokensAfter)
-  }
-  const penaltyTokens = input.refillPenaltyExempt === true ? 0 : (1 - alpha) * tailTokens
-  const perTurnSaving = alpha * recoveredTokens
-  if (perTurnSaving <= 0) {
-    return remainingTurns === undefined
-      ? { recoveredTokens, penaltyTokens }
-      : { recoveredTokens, penaltyTokens, expectedSaving: -penaltyTokens }
-  }
-  const paybackTurns = penaltyTokens / perTurnSaving
-  if (remainingTurns === undefined) {
-    return { recoveredTokens, penaltyTokens, paybackTurns }
-  }
-  return {
-    recoveredTokens,
-    penaltyTokens,
-    paybackTurns,
-    expectedSaving: perTurnSaving * Math.max(0, remainingTurns - paybackTurns),
-  }
-}
-
-/**
- * Stable proposal identity: the sha-256 of the serialized item digests, cut to
- * 12 hex chars. Stable across re-enqueues of the same content so a repeated
- * classification cannot duplicate a pending proposal.
- */
-export function proposalId(itemDigests: readonly string[]): string {
-  const hash = createHash('sha256')
-  for (const digest of itemDigests) hash.update(digest)
-  hash.update(String(itemDigests.length))
-  return hash.digest('hex').slice(0, 12)
-}
-
-/** Human-facing reduction kind carried by every review proposal. */
-export type ProposalKind = 'estimator' | 'dedup' | 'read-state'
-
-/** The minimal candidate face the triage classifier consumes. */
-export interface ClassifiableCandidate {
-  readonly sourceSeq: number
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-  /** Compression primitive that planned this replacement. */
-  readonly component: string
-  /** Reducer id (`dedupe-pointer`, `superseded-read-whole-result`, …). */
-  readonly reducer: string
-  /** Content to freeze into the proposal digest. */
-  readonly content: readonly ContentBlock[]
-}
-
-export interface TriageInput {
-  /** Cache-hit discount rate α ∈ (0,1); validated upstream by config parsing. */
-  readonly alpha: number
-  /** Token mass of the protected tail that must be refilled after a mutation. */
-  readonly tailTokens: number
-  /** Candidates at or above this token impact skip triage and always enter review. */
-  readonly reviewHighImpactTokens: number
-  /** Estimated remaining turns Ŝ; `undefined` keeps the edge band closed. */
-  readonly remainingTurns?: number | undefined
-  /** Seqs whose reduction came from the estimator channel; overrides the kind. */
-  readonly estimatorSeqs?: ReadonlySet<number> | undefined
-  /** Landing stage of the batch: `'fresh'` batches are priced without the
-   *  tail-refill penalty (first-exposure shaping causes no cache break);
-   *  `'history'` batches — already-served content — pay it in full. */
-  readonly stage?: 'fresh' | 'history' | undefined
-}
-
-/** One frozen item inside a review proposal: metadata and digest, never content. */
-export interface ProposalItem {
-  readonly seq: number
-  readonly component: string
-  readonly kind: ProposalKind
-  readonly tokensBefore: number
-  readonly tokensAfter: number
-  /** Content sha-256 frozen at enqueue time and re-checked at the apply point. */
-  readonly digest: string
-}
-
-/** Proposal fields derivable at classification time; queue fields attach at enqueue. */
-export interface ProposalSkeleton {
-  readonly id: string
-  readonly kind: ProposalKind
-  readonly items: readonly ProposalItem[]
-  readonly benefit: BenefitEstimate
-}
-
-export interface ClassificationResult {
-  /** Clearly profitable candidates that keep the existing automatic path. */
-  readonly auto: readonly ClassifiableCandidate[]
-  /** Edge-band or high-impact candidates folded into review proposal skeletons. */
-  readonly review: readonly ProposalSkeleton[]
-  /** Negative-benefit candidates the pipeline keeps discarding. */
-  readonly drop: readonly ClassifiableCandidate[]
-}
-
-/**
- * Canonical content digest reused from the dedup hash: plain-text results hash
- * through the dedupe canonicalization; rich blocks fall back to canonical JSON
- * so every candidate is freezable.
- */
-export function contentDigest(content: readonly ContentBlock[]): string {
-  const text = flattenPlainText(content)
-  return dedupeHash(text ?? JSON.stringify(content), 'trim-eol')
-}
-
-function proposalKindFor(candidate: ClassifiableCandidate, estimatorSeqs: ReadonlySet<number> | undefined): ProposalKind {
-  if (estimatorSeqs?.has(candidate.sourceSeq) === true) return 'estimator'
-  if (candidate.reducer === 'dedupe-pointer') return 'dedup'
-  return 'read-state'
-}
-
-/**
- * Triage planned replacements into the three review-mode buckets, pricing the
- * pass as ONE merged mutation (R1): the tail KV-cache refill penalty is a
- * property of the landing event, not of any single candidate, so it must be
- * paid exactly once per batch. Pricing per candidate overstates the payback
- * N-fold and starves every real batch out of the auto path.
- *
- * Pipeline: zero/negative-recovery candidates are priced out first (they never
- * make a batch look better), the surviving batch is priced once through
- * `computeBenefit`, the verdict is a batch decision, and any high-impact
- * candidate (`tokensBefore ≥ reviewHighImpactTokens`) covers the whole batch
- * into review — splitting the batch would pay a second cache break that the
- * accounting does not model. Review skeletons are grouped one proposal per
- * kind; a proposal id covers every item digest.
- *
- * Batch verdict bands (identical thresholds to the per-candidate model):
- * - any high-impact candidate, or α too small to price a payback → review;
- * - `paybackTurns ≤ 1`, or Ŝ known and `paybackTurns ≤ 0.25·Ŝ` → auto;
- * - Ŝ known and `paybackTurns ∈ (1, 3]` → review;
- * - everything else (Ŝ unknown with a slow payback) → drop.
- *
- * Stage asymmetry: a `'fresh'` batch is exempt from the tail-refill penalty
- * (`refillPenaltyExempt`) — its content was never served, so compressing it
- * breaks no cache and payback is 0 — while a `'history'` batch mutates
- * already-cached context and pays `(1−α)·tailTokens` in full. Without this
- * exemption every realistic fresh batch prices into the drop band and the
- * auto bucket stays structurally unreachable.
- */
-export function classifyCandidates(
-  candidates: readonly ClassifiableCandidate[],
-  input: TriageInput,
-): ClassificationResult {
-  const drop: ClassifiableCandidate[] = []
-  const usable: ClassifiableCandidate[] = []
-  for (const candidate of candidates) {
-    if (Math.max(0, candidate.tokensBefore - candidate.tokensAfter) <= 0) {
-      drop.push(candidate)
-      continue
-    }
-    usable.push(candidate)
-  }
-  if (usable.length === 0) return { auto: [], review: [], drop }
-
-  const benefit = computeBenefit(usable, {
-    alpha: input.alpha,
-    tailTokens: input.tailTokens,
-    ...input.remainingTurns !== undefined ? { remainingTurns: input.remainingTurns } : {},
-    refillPenaltyExempt: input.stage === 'fresh',
-  })
-  const payback = benefit.paybackTurns
-  const highImpact = usable.some(candidate => candidate.tokensBefore >= input.reviewHighImpactTokens)
-  let verdict: 'auto' | 'review' | 'drop'
-  if (highImpact || payback === undefined) {
-    // High impact covers the whole batch; α too small to price a payback has
-    // no discounted recovery to argue from, so a human decides.
-    verdict = 'review'
-  } else if (payback <= 1
-    || (input.remainingTurns !== undefined && payback <= 0.25 * input.remainingTurns)) {
-    verdict = 'auto'
-  } else if (input.remainingTurns !== undefined && payback <= 3) {
-    verdict = 'review'
-  } else {
-    verdict = 'drop'
-  }
-  if (verdict === 'auto') return { auto: usable, review: [], drop }
-  if (verdict === 'drop') return { auto: [], review: [], drop: [...drop, ...usable] }
-
-  const itemsByKind = new Map<ProposalKind, ProposalItem[]>()
-  for (const candidate of usable) {
-    const item: ProposalItem = {
-      seq: candidate.sourceSeq,
-      component: candidate.component,
-      kind: proposalKindFor(candidate, input.estimatorSeqs),
-      tokensBefore: candidate.tokensBefore,
-      tokensAfter: candidate.tokensAfter,
-      digest: contentDigest(candidate.content),
-    }
-    const bucket = itemsByKind.get(item.kind) ?? []
-    bucket.push(item)
-    itemsByKind.set(item.kind, bucket)
-  }
-  const review: ProposalSkeleton[] = []
-  for (const [kind, items] of itemsByKind) {
-    review.push({ id: proposalId(items.map(item => item.digest)), kind, items, benefit })
-  }
-  return { auto: [], review, drop }
-}