pi-ui-extend 1.0.39 → 1.0.41

package/external/pi-tools-suite/src/dcp/progress-controller.ts

@@ -0,0 +1,244 @@
+export type DcpProgressPhase =
+  | "normal"
+  | "pressure"
+  | "awaiting_opportunity"
+  | "preparing"
+  | "committed"
+  | "cooldown"
+  | "blocked"
+  | "degraded";
+
+export type DcpBlockedReason =
+  | "live-head-only"
+  | "protected-budget-exceeded"
+  | "evidence-unknown"
+  | "summarizer-unavailable"
+  | "non-positive-gain"
+  | "missing-source"
+  | "budget-exhausted";
+
+export interface DcpBlockedReasonInput {
+  pressured: boolean;
+  candidateAvailable: boolean;
+  messageCandidateCount?: number;
+  requiredSavingsTokens?: number;
+  capacityExceeded?: boolean;
+  emergencyStats?: {
+    totalPairs: number;
+    eligiblePairs: number;
+    eligibleRecoverableTokens: number;
+    preservedRecentPairs: number;
+    preservedUnseenPairs: number;
+    preservedProtectedPairs: number;
+  };
+}
+
+/**
+ * Classify an exhausted E05 planning pass without guessing beyond the facts
+ * available from the emergency eligibility analysis. This is deliberately
+ * conservative: when a safe body candidate still exists, the controller is
+ * waiting for an opportunity rather than terminally blocked.
+ */
+export function inferDcpBlockedReason(input: DcpBlockedReasonInput): DcpBlockedReason | undefined {
+  if (!input.pressured || input.candidateAvailable || (input.messageCandidateCount ?? 0) > 0) return undefined;
+
+  const stats = input.emergencyStats;
+  if (!stats || stats.totalPairs === 0) return "live-head-only";
+
+  const requiredSavings = Math.max(0, Math.floor(input.requiredSavingsTokens ?? 0));
+  if (
+    stats.eligiblePairs > 0 &&
+    requiredSavings > 0 &&
+    stats.eligibleRecoverableTokens < requiredSavings
+  ) {
+    return "budget-exhausted";
+  }
+
+  if (stats.preservedUnseenPairs > 0 && stats.eligiblePairs === 0) return "evidence-unknown";
+  if (
+    stats.preservedProtectedPairs > 0 &&
+    (stats.eligiblePairs === 0 || input.capacityExceeded === true)
+  ) {
+    return "protected-budget-exceeded";
+  }
+  if (stats.preservedRecentPairs >= stats.totalPairs && stats.eligiblePairs === 0) return "live-head-only";
+  return "budget-exhausted";
+}
+
+export interface DcpProgressInput {
+  enabled: boolean;
+  autoEnabled: boolean;
+  pressure: boolean;
+  candidateAvailable: boolean;
+  ignoredOpportunities: number;
+  patience: number;
+  preparing?: boolean;
+  justCommitted?: boolean;
+  cooldown?: boolean;
+  blockedReason?: DcpBlockedReason;
+  degradedReason?: string;
+}
+
+export interface DcpProgressDecision {
+  phase: DcpProgressPhase;
+  shouldPrepare: boolean;
+  reason: string;
+  blockedReason?: DcpBlockedReason;
+}
+
+/**
+ * Pure E05 progress policy. Runtime hooks own opportunity accounting; this
+ * function only maps the current pressure/candidate/budget state to the next
+ * observable phase. In particular, context callback count is not an input.
+ */
+export function decideDcpProgress(input: DcpProgressInput): DcpProgressDecision {
+  if (!input.enabled) return { phase: "blocked", shouldPrepare: false, reason: "disabled" };
+  if (input.justCommitted) return { phase: "committed", shouldPrepare: false, reason: "committed" };
+  if (input.cooldown) return { phase: "cooldown", shouldPrepare: false, reason: "cooldown" };
+  if (input.degradedReason) return { phase: "degraded", shouldPrepare: false, reason: input.degradedReason };
+  if (input.blockedReason) {
+    return {
+      phase: "blocked",
+      shouldPrepare: false,
+      reason: input.blockedReason,
+      blockedReason: input.blockedReason,
+    };
+  }
+  if (!input.pressure) return { phase: "normal", shouldPrepare: false, reason: "below-pressure" };
+  if (input.preparing) return { phase: "preparing", shouldPrepare: false, reason: "already-preparing" };
+  if (!input.autoEnabled) return { phase: "pressure", shouldPrepare: false, reason: "auto-disabled" };
+  if (!input.candidateAvailable) {
+    return { phase: "awaiting_opportunity", shouldPrepare: false, reason: "no-candidate" };
+  }
+
+  const ignored = Math.max(0, Math.floor(input.ignoredOpportunities));
+  const patience = Math.max(0, Math.floor(input.patience));
+  if (ignored <= patience) {
+    return { phase: "awaiting_opportunity", shouldPrepare: false, reason: "below-patience" };
+  }
+  return { phase: "preparing", shouldPrepare: true, reason: "ignored-opportunities" };
+}
+
+export type DcpBudgetProjectionOrigin = "repo-fallback" | "provider-native" | "repo-over-provider";
+
+export interface DcpBudgetInput {
+  providerUsageTokens?: number | null;
+  repoProjectedTokens: number;
+  contextWindow: number;
+  reservedOutputTokens?: number;
+  reservedToolTokens?: number;
+  maxContextPercent: number;
+  hardContextPercent: number;
+  targetContextPercent?: number;
+  summaryBufferEnabled?: boolean;
+  activeSummaryTokens?: number;
+  summaryBufferMaxBonusRatio?: number;
+  estimatorMarginTokens?: number;
+}
+
+export interface DcpBudgetPlan {
+  projectedBeforeTokens: number;
+  projectionOrigin: DcpBudgetProjectionOrigin;
+  contextWindow: number;
+  reservedOutputTokens: number;
+  reservedToolTokens: number;
+  inputCapacityTokens: number;
+  summaryBufferTokensApplied: number;
+  softHeadroomTokens: number;
+  hardHeadroomTokens: number;
+  targetHeadroomTokens: number;
+  requiredSavingsTokens: number;
+  pressured: boolean;
+  hardPressure: boolean;
+  capacityExceeded: boolean;
+}
+
+function finiteNonNegative(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function clampFraction(value: number): number {
+  return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+
+/**
+ * Pure E05 budget planner. Provider-native usage is useful evidence but may be
+ * stale between completed requests, so the fresh repo projection is always a
+ * lower bound. Capacity is distinct from policy thresholds and explicitly
+ * reserves output/tool budget. `summaryBuffer` may relax the soft policy only
+ * inside that hard capacity.
+ */
+export function planDcpBudget(input: DcpBudgetInput): DcpBudgetPlan {
+  const contextWindow = Math.max(1, Math.floor(finiteNonNegative(input.contextWindow) ?? 1));
+  const repoProjectedTokens = Math.floor(finiteNonNegative(input.repoProjectedTokens) ?? 0);
+  const providerUsageTokens = finiteNonNegative(input.providerUsageTokens);
+  const projectedBeforeTokens = Math.max(repoProjectedTokens, Math.floor(providerUsageTokens ?? 0));
+  const projectionOrigin: DcpBudgetProjectionOrigin = providerUsageTokens === undefined
+    ? "repo-fallback"
+    : repoProjectedTokens > providerUsageTokens
+      ? "repo-over-provider"
+      : "provider-native";
+
+  const reservedOutputTokens = Math.min(
+    contextWindow,
+    Math.floor(finiteNonNegative(input.reservedOutputTokens) ?? 0),
+  );
+  const reservedToolTokens = Math.min(
+    Math.max(0, contextWindow - reservedOutputTokens),
+    Math.floor(finiteNonNegative(input.reservedToolTokens) ?? 0),
+  );
+  const inputCapacityTokens = Math.max(0, contextWindow - reservedOutputTokens - reservedToolTokens);
+
+  const baseSoftHeadroom = Math.min(
+    inputCapacityTokens,
+    Math.floor(clampFraction(input.maxContextPercent) * contextWindow),
+  );
+  const summaryBufferCap = Math.floor(
+    clampFraction(input.summaryBufferMaxBonusRatio ?? 0.05) * contextWindow,
+  );
+  const requestedSummaryBuffer = input.summaryBufferEnabled
+    ? Math.floor(finiteNonNegative(input.activeSummaryTokens) ?? 0)
+    : 0;
+  const summaryBufferTokensApplied = Math.min(
+    requestedSummaryBuffer,
+    summaryBufferCap,
+    Math.max(0, inputCapacityTokens - baseSoftHeadroom),
+  );
+  const softHeadroomTokens = baseSoftHeadroom + summaryBufferTokensApplied;
+  const hardHeadroomTokens = Math.min(
+    inputCapacityTokens,
+    Math.floor(clampFraction(input.hardContextPercent) * contextWindow),
+  );
+  const capacityExceeded = projectedBeforeTokens > inputCapacityTokens;
+  const hardPressure = capacityExceeded || projectedBeforeTokens > hardHeadroomTokens;
+  const pressured = hardPressure || projectedBeforeTokens > softHeadroomTokens;
+
+  const configuredTarget = clampFraction(input.targetContextPercent ?? input.maxContextPercent);
+  const recoveryHeadroom = Math.min(
+    inputCapacityTokens,
+    softHeadroomTokens,
+    Math.floor(configuredTarget * contextWindow),
+  );
+  const targetHeadroomTokens = hardPressure ? recoveryHeadroom : softHeadroomTokens;
+  const estimatorMarginTokens = Math.floor(finiteNonNegative(input.estimatorMarginTokens) ?? 0);
+  const requiredSavingsTokens = pressured
+    ? Math.max(0, projectedBeforeTokens - targetHeadroomTokens + estimatorMarginTokens)
+    : 0;
+
+  return {
+    projectedBeforeTokens,
+    projectionOrigin,
+    contextWindow,
+    reservedOutputTokens,
+    reservedToolTokens,
+    inputCapacityTokens,
+    summaryBufferTokensApplied,
+    softHeadroomTokens,
+    hardHeadroomTokens,
+    targetHeadroomTokens,
+    requiredSavingsTokens,
+    pressured,
+    hardPressure,
+    capacityExceeded,
+  };
+}

package/external/pi-tools-suite/src/dcp/prompts.ts

@@ -52,6 +52,9 @@ Passing check/test/lint/tsc logs are summary-only after you know the result. Pre
 DCP REMINDERS
 If a \`<dcp-system-reminder>\` is present in context, treat it as a signal to evaluate compression. Critical or high-context reminders should be handled promptly. Routine reminders should lead to compression only when a safe, closed, useful-to-summarize range exists; otherwise continue the next atomic step and re-check later.
 
+COMMITTED IS NOT NECESSARILY RECOVERED
+The tool rejects non-positive full-projection gain, including wrappers and preserved content. An unsuccessful call does not satisfy the reminder. Inspect \`netGain\`, \`pressureRelieved\`, and \`remainingRecoveryTokens\` in its result: a partial positive commit may still leave context pressure. Use freshly visible IDs for subsequent work; do not retry an unchanged rejected summary or discard required facts just to meet a token goal.
+
 THE SUMMARY
 Your summary must be COMPLETE FOR CONTINUATION, not a transcript rewrite. Preserve only information that will plausibly matter later: user intent, accepted constraints, decisions, files/symbols changed or inspected, exact errors that are still actionable, verification status, and next steps.
 
@@ -84,7 +87,9 @@ PROTECTED PROMPT CONTENT
 If selected user text contains \`<protect>...</protect>\` content, preserve that protected content verbatim in your summary. The tool may append protected text automatically, but you should still account for it semantically.
 
 COMPRESSED BLOCK PLACEHOLDERS
-When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
+When rolling up compressed blocks, summarize their continuation-relevant meaning instead of copying the full old summaries. Every block carries a protected-fragment ledger, and those fragments are preserved separately. A block missing that ledger is invalid and must not be rolled up.
+
+Only when the full previous summary is genuinely needed verbatim, use this exact placeholder format:
 
 - \`(bN)\`
 
@@ -96,11 +101,11 @@ Compressed block IDs always use the \`bN\` form (never \`mNNN\`) and are represe
 
 Rules:
 
-- Include every required block placeholder exactly once when you intentionally roll up older compressed blocks. If you omit one or duplicate one, the tool will try to recover by preserving the missing block summaries automatically, but do not rely on that recovery path.
+- Placeholders are optional, not required for every covered modern block. Each explicit placeholder expands the full old summary and may eliminate the intended savings. Include an intentionally preserved block at most once.
 - Do not invent placeholders for blocks outside the selected range.
 - Treat \`(bN)\` placeholders as RESERVED TOKENS. Do not emit \`(bN)\` text anywhere except intentional placeholders.
 - If you need to mention a block in prose, use plain text like \`compressed bN\` (not as a placeholder).
-- Preflight check before finalizing: the set of \`(bN)\` placeholders in your summary should match the required set, with no duplicates.
+- Preflight check before finalizing: each placeholder must refer to a known selected block whose full text you deliberately need to preserve. Otherwise write a concise factual summary in your own words.
 
 These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
 
@@ -125,10 +130,8 @@ Treat these reference lines as boundary metadata only, not as tool result conten
 
 Rules:
 
-- Pick \`startId\` and \`endId\` directly from injected IDs in context.
-- IDs must exist in the current conversation context.
-- \`startId\` must appear before \`endId\`.
-- Do not invent IDs. Use only IDs that are present in context.
+- Use only injected IDs in current context; \`startId\` must precede \`endId\`. Do not invent IDs.
+- For \`ranges\`, never split a tool group: include the calling assistant and all its tool results, including parallel calls.
 - If \`compress\` fails with \`Unknown message ID\`, treat those IDs as stale; retry at most once using only the error's listed current raw IDs or eligible \`bN\` blocks, or skip if no closed range is safe.
 
 BATCHING

package/external/pi-tools-suite/src/dcp/provider-tool-results.ts

@@ -84,3 +84,192 @@ export function providerPayloadIncludesToolResult(
   return typeof record.outputText === "string" &&
     evidence.anonymousSignatures.has(signature(record.toolName, record.outputText));
 }
+
+export function providerPayloadRevision(payload: unknown): string | undefined {
+  try {
+    const serialized = JSON.stringify(payload);
+    if (serialized === undefined) return undefined;
+    return createHash("sha256").update(serialized).digest("hex");
+  } catch {
+    return undefined;
+  }
+}
+
+/** Verify delivery of the exact trusted reminder, not just a context callback. */
+export function providerPayloadIncludesReminder(payload: unknown, reminder: string | undefined): boolean {
+  if (!reminder) return false;
+  try {
+    const serialized = JSON.stringify(payload);
+    return typeof serialized === "string" && serialized.includes(JSON.stringify(reminder).slice(1, -1));
+  } catch {
+    return false;
+  }
+}
+
+export interface ProviderEvidenceAttempt {
+  sessionEpoch: number;
+  provider?: string;
+  model?: string;
+  contentRevision?: string;
+  statePath?: string;
+  sessionId?: string;
+  toolIds: ReadonlySet<string>;
+  opportunityAvailable?: boolean;
+  opportunityKind?: "routine" | "emergency";
+}
+
+export interface ProviderEvidenceFinalMessage {
+  sessionEpoch: number;
+  provider?: string;
+  model?: string;
+  stopReason?: string;
+}
+
+export interface ProviderEvidencePendingSnapshot {
+  firstAttemptId: number;
+  lastAttemptId: number;
+  attempts: number;
+  sessionEpoch: number;
+  provider?: string;
+  model?: string;
+  contentRevision?: string;
+  statePath?: string;
+  sessionId?: string;
+  toolIds: Set<string>;
+  opportunityAvailable: boolean;
+  opportunityKind?: "routine" | "emergency";
+  ambiguous: boolean;
+}
+
+export type ProviderEvidenceCompletion =
+  | {
+      status: "promote";
+      firstAttemptId: number;
+      lastAttemptId: number;
+      attempts: number;
+      sessionEpoch: number;
+      statePath?: string;
+      sessionId?: string;
+      toolIds: Set<string>;
+      opportunityAvailable: boolean;
+      opportunityKind?: "routine" | "emergency";
+    }
+  | {
+      status: "refused";
+      reason:
+        | "no-pending"
+        | "terminal-failure"
+        | "ambiguous"
+        | "missing-identity"
+        | "stale-session"
+        | "identity-mismatch";
+      attempts: number;
+    };
+
+function sameStringSet(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean {
+  if (left.size !== right.size) return false;
+  for (const value of left) {
+    if (!right.has(value)) return false;
+  }
+  return true;
+}
+
+function attemptHasIdentity(attempt: ProviderEvidenceAttempt): boolean {
+  return Boolean(attempt.provider && attempt.model && attempt.contentRevision);
+}
+
+/**
+ * Correlates provider-input evidence with one finalized assistant message without
+ * inventing a request ID the extension API does not expose. Repeated identical
+ * attempts are treated as retries; any changed model/content/owner while an
+ * attempt is pending makes the evidence ambiguous and therefore non-promotable.
+ */
+export class ProviderEvidenceTracker {
+  private pending: ProviderEvidencePendingSnapshot | undefined;
+  private nextAttemptId = 1;
+
+  begin(attempt: ProviderEvidenceAttempt): ProviderEvidencePendingSnapshot {
+    const attemptId = this.nextAttemptId++;
+    const toolIds = new Set(attempt.toolIds);
+    if (!this.pending) {
+      this.pending = {
+        firstAttemptId: attemptId,
+        lastAttemptId: attemptId,
+        attempts: 1,
+        sessionEpoch: attempt.sessionEpoch,
+        provider: attempt.provider,
+        model: attempt.model,
+        contentRevision: attempt.contentRevision,
+        statePath: attempt.statePath,
+        sessionId: attempt.sessionId,
+        toolIds,
+        opportunityAvailable: Boolean(attempt.opportunityAvailable),
+        opportunityKind: attempt.opportunityKind,
+        ambiguous: !attemptHasIdentity(attempt),
+      };
+      return this.snapshot()!;
+    }
+
+    const pending = this.pending;
+    const sameAttemptShape =
+      pending.sessionEpoch === attempt.sessionEpoch &&
+      pending.provider === attempt.provider &&
+      pending.model === attempt.model &&
+      pending.contentRevision === attempt.contentRevision &&
+      pending.statePath === attempt.statePath &&
+      pending.sessionId === attempt.sessionId &&
+      pending.opportunityAvailable === Boolean(attempt.opportunityAvailable) &&
+      pending.opportunityKind === attempt.opportunityKind &&
+      sameStringSet(pending.toolIds, toolIds);
+
+    pending.lastAttemptId = attemptId;
+    pending.attempts++;
+    if (!sameAttemptShape || !attemptHasIdentity(attempt)) pending.ambiguous = true;
+    return this.snapshot()!;
+  }
+
+  complete(finalMessage: ProviderEvidenceFinalMessage): ProviderEvidenceCompletion {
+    const pending = this.pending;
+    this.pending = undefined;
+    if (!pending) return { status: "refused", reason: "no-pending", attempts: 0 };
+
+    const successfulStopReasons = new Set(["stop", "length", "toolUse", "deferred"]);
+    if (!finalMessage.stopReason || !successfulStopReasons.has(finalMessage.stopReason)) {
+      return { status: "refused", reason: "terminal-failure", attempts: pending.attempts };
+    }
+    if (pending.ambiguous) {
+      return { status: "refused", reason: "ambiguous", attempts: pending.attempts };
+    }
+    if (!pending.provider || !pending.model || !pending.contentRevision || !finalMessage.provider || !finalMessage.model) {
+      return { status: "refused", reason: "missing-identity", attempts: pending.attempts };
+    }
+    if (pending.sessionEpoch !== finalMessage.sessionEpoch) {
+      return { status: "refused", reason: "stale-session", attempts: pending.attempts };
+    }
+    if (pending.provider !== finalMessage.provider || pending.model !== finalMessage.model) {
+      return { status: "refused", reason: "identity-mismatch", attempts: pending.attempts };
+    }
+
+    return {
+      status: "promote",
+      firstAttemptId: pending.firstAttemptId,
+      lastAttemptId: pending.lastAttemptId,
+      attempts: pending.attempts,
+      sessionEpoch: pending.sessionEpoch,
+      statePath: pending.statePath,
+      sessionId: pending.sessionId,
+      toolIds: new Set(pending.toolIds),
+      opportunityAvailable: pending.opportunityAvailable,
+      opportunityKind: pending.opportunityKind,
+    };
+  }
+
+  snapshot(): ProviderEvidencePendingSnapshot | undefined {
+    if (!this.pending) return undefined;
+    return { ...this.pending, toolIds: new Set(this.pending.toolIds) };
+  }
+
+  reset(): void {
+    this.pending = undefined;
+  }
+}