sentinelayer-cli 0.34.6 → 0.35.0

package/src/session/listener-process.js

@@ -0,0 +1,259 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { execFile } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { promisify } from "node:util";
+
+import { isProcessAlive } from "./daemon-spawn.js";
+import { resolveSessionPaths } from "./paths.js";
+
+const LISTENER_DIR_NAME = "listeners";
+const execFileAsync = promisify(execFile);
+
+function normalizeString(value) {
+  return String(value || "").trim();
+}
+
+export function normalizeListenerProcessKey(agentId = "") {
+  return (
+    normalizeString(agentId)
+      .toLowerCase()
+      .replace(/[^a-z0-9._-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "agent"
+  );
+}
+
+function normalizeCommandLine(value) {
+  return normalizeString(value).toLowerCase();
+}
+
+function listenerCommandLineMatches(commandLine, { sessionId = "", agentId = "" } = {}) {
+  const normalized = normalizeCommandLine(commandLine);
+  if (!normalized) return false;
+  const normalizedSessionId = normalizeString(sessionId).toLowerCase();
+  const normalizedAgentId = normalizeString(agentId).toLowerCase();
+  const hasCliEntry =
+    normalized.includes("sentinelayer-cli") ||
+    /[\\/](?:sl|sentinelayer-cli)\.js\b/.test(normalized);
+  return (
+    hasCliEntry &&
+    normalized.includes("session") &&
+    normalized.includes("listen") &&
+    (!normalizedSessionId || normalized.includes(normalizedSessionId)) &&
+    (!normalizedAgentId || normalized.includes(normalizedAgentId))
+  );
+}
+
+async function readWindowsCommandLine(pid) {
+  const command = [
+    "$ErrorActionPreference = 'Stop';",
+    `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${Number(pid)}";`,
+    "if ($p) { $p.CommandLine }",
+  ].join(" ");
+  const { stdout } = await execFileAsync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", command],
+    { windowsHide: true, timeout: 2000 },
+  );
+  return normalizeString(stdout);
+}
+
+async function readPosixCommandLine(pid) {
+  if (process.platform === "linux") {
+    try {
+      const raw = await fsp.readFile(`/proc/${Number(pid)}/cmdline`);
+      return normalizeString(raw.toString("utf8").replace(/\0/g, " "));
+    } catch {
+      // Fall through to ps(1), which also covers restricted /proc mounts.
+    }
+  }
+  const { stdout } = await execFileAsync("ps", ["-p", String(Number(pid)), "-o", "command="], {
+    timeout: 2000,
+  });
+  return normalizeString(stdout);
+}
+
+export async function readProcessCommandLine(pid) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return "";
+  try {
+    return process.platform === "win32"
+      ? await readWindowsCommandLine(numericPid)
+      : await readPosixCommandLine(numericPid);
+  } catch {
+    return "";
+  }
+}
+
+export function resolveListenerPidPath(
+  sessionId,
+  agentId,
+  { targetPath = process.cwd() } = {},
+) {
+  const paths = resolveSessionPaths(sessionId, { targetPath });
+  return path.join(
+    paths.sessionDir,
+    LISTENER_DIR_NAME,
+    `${normalizeListenerProcessKey(agentId)}.json`,
+  );
+}
+
+export async function readListenerPidRecord(
+  sessionId,
+  agentId,
+  { targetPath = process.cwd() } = {},
+) {
+  const pidPath = resolveListenerPidPath(sessionId, agentId, { targetPath });
+  try {
+    const raw = await fsp.readFile(pidPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeListenerPidRecord(
+  sessionId,
+  agentId,
+  {
+    targetPath = process.cwd(),
+    pid = process.pid,
+    listenerId = "",
+    transport = "",
+    intervalSeconds = null,
+    activeIntervalSeconds = null,
+    presenceIntervalSeconds = null,
+    logFile = "",
+  } = {},
+) {
+  const pidPath = resolveListenerPidPath(sessionId, agentId, { targetPath });
+  const record = {
+    pid: Number(pid),
+    sessionId: normalizeString(sessionId),
+    agentId: normalizeString(agentId),
+    listenerKey: normalizeListenerProcessKey(agentId),
+    listenerId: normalizeString(listenerId),
+    targetPath: path.resolve(String(targetPath || ".")),
+    transport: normalizeString(transport) || undefined,
+    intervalSeconds: Number(intervalSeconds) || undefined,
+    activeIntervalSeconds: Number(activeIntervalSeconds) || undefined,
+    presenceIntervalSeconds: Number(presenceIntervalSeconds) || undefined,
+    logFile: normalizeString(logFile) || undefined,
+    startedAt: new Date().toISOString(),
+  };
+  await fsp.mkdir(path.dirname(pidPath), { recursive: true });
+  await fsp.writeFile(pidPath, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+  return record;
+}
+
+export async function removeListenerPidRecord(
+  sessionId,
+  agentId,
+  { targetPath = process.cwd(), onlyForPid = null } = {},
+) {
+  const pidPath = resolveListenerPidPath(sessionId, agentId, { targetPath });
+  if (onlyForPid != null) {
+    const existing = await readListenerPidRecord(sessionId, agentId, { targetPath });
+    if (existing && Number(existing.pid) !== Number(onlyForPid)) {
+      return false;
+    }
+  }
+  try {
+    await fsp.unlink(pidPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getListenerProcessStatus(
+  sessionId,
+  agentId,
+  { targetPath = process.cwd(), _readProcessCommandLine = readProcessCommandLine } = {},
+) {
+  const record = await readListenerPidRecord(sessionId, agentId, { targetPath });
+  if (!record) {
+    return {
+      running: false,
+      pid: null,
+      stale: false,
+      record: null,
+      listenerKey: normalizeListenerProcessKey(agentId),
+    };
+  }
+  const alive = isProcessAlive(record.pid);
+  if (!alive) {
+    return {
+      running: false,
+      pid: null,
+      stale: true,
+      record,
+      listenerKey: normalizeListenerProcessKey(agentId),
+    };
+  }
+  const commandLine = await _readProcessCommandLine(record.pid);
+  if (!listenerCommandLineMatches(commandLine, { sessionId, agentId })) {
+    return {
+      running: false,
+      pid: null,
+      stale: true,
+      reused: Boolean(commandLine),
+      unverified: !commandLine,
+      record,
+      listenerKey: normalizeListenerProcessKey(agentId),
+      commandLine,
+    };
+  }
+  return {
+    running: true,
+    pid: Number(record.pid),
+    stale: false,
+    record,
+    listenerKey: normalizeListenerProcessKey(agentId),
+    commandLine,
+  };
+}
+
+export async function requestListenerProcessStop(
+  pid,
+  { signal = "SIGTERM", timeoutMs = 3000, pollIntervalMs = 100 } = {},
+) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) {
+    return { requested: false, stopped: true, reason: "invalid_pid" };
+  }
+  if (numericPid === process.pid) {
+    return { requested: false, stopped: false, reason: "self" };
+  }
+  if (!isProcessAlive(numericPid)) {
+    return { requested: false, stopped: true, reason: "not_running" };
+  }
+
+  try {
+    process.kill(numericPid, signal);
+  } catch (error) {
+    if (error?.code === "ESRCH") {
+      return { requested: false, stopped: true, reason: "not_running" };
+    }
+    return {
+      requested: false,
+      stopped: false,
+      reason: normalizeString(error?.code) || "signal_failed",
+    };
+  }
+
+  const deadlineMs = Date.now() + Math.max(1, Number(timeoutMs) || 3000);
+  const sleepMs = Math.max(10, Number(pollIntervalMs) || 100);
+  while (Date.now() < deadlineMs) {
+    if (!isProcessAlive(numericPid)) {
+      return { requested: true, stopped: true, reason: "stopped" };
+    }
+    await sleep(sleepMs);
+  }
+  return { requested: true, stopped: false, reason: "timeout" };
+}

package/src/session/listener.js

@@ -305,6 +305,8 @@ export async function listenSessionEvents({
   const activeWindowMs =
     Math.max(1, normalizePositiveInteger(activeWindowSeconds, DEFAULT_ACTIVE_WINDOW_SECONDS)) *
     1000;
+  const autoStreamIdleTimeoutMs =
+    normalizedTransport === "auto" ? Math.max(5_000, Math.min(idleSleepMs, 30_000)) : 0;
 
   if (fromNow) {
     const latest = await _pollLatest(normalizedSessionId, {
@@ -507,9 +509,6 @@ export async function listenSessionEvents({
         streamHeartbeatInFlight = false;
       }
     }, streamHeartbeatMs);
-    if (streamHeartbeatTimer && typeof streamHeartbeatTimer.unref === "function") {
-      streamHeartbeatTimer.unref();
-    }
   }
 
   await notifyLifecycle(
@@ -527,6 +526,7 @@ export async function listenSessionEvents({
       const streamResult = await _stream(normalizedSessionId, {
         targetPath,
         since: cursor,
+        idleTimeoutMs: autoStreamIdleTimeoutMs,
         signal,
         onEvent: async (event) => {
           await processEventBatch([event], normalizeString(event?.cursor) || cursor);

package/src/session/listeners.js

@@ -147,9 +147,15 @@ export function summarizeListeners(events = [], { nowMs = Date.now(), staleAfter
  */
 export async function fetchSessionListeners(
   sessionId,
-  { targetPath = process.cwd(), limit = 200, nowMs = Date.now, poll = pollSessionEventsBefore } = {}
+  {
+    targetPath = process.cwd(),
+    limit = 200,
+    nowMs = Date.now,
+    forceCircuitProbe = true,
+    poll = pollSessionEventsBefore,
+  } = {}
 ) {
-  const result = await poll(sessionId, { targetPath, limit });
+  const result = await poll(sessionId, { targetPath, limit, forceCircuitProbe });
   if (!result?.ok) {
     return { ok: false, reason: normalizeString(result?.reason) || "fetch_failed", listeners: [] };
   }

package/src/session/pricing-ledger.js

@@ -4,10 +4,12 @@ import {
   DEFAULT_PRICE_BOOK_VERSION,
   estimateModelCost,
 } from "../cost/tracker.js";
+import { estimateTokens } from "../cost/tokenizer.js";
 
 const SESSION_USAGE_EVENT = "session_usage";
 export const BILLING_SESSION_USAGE_SCHEMA = "billing/v1";
 export const LOCAL_SESSION_USAGE_SCHEMA = "session_usage/local-v1";
+export const ESTIMATED_MESSAGE_USAGE_SCHEMA = "session_usage/estimated-message-v1";
 const LEGACY_SESSION_USAGE_SCHEMAS = new Set(["", "session_usage/v0"]);
 const SUPPORTED_SESSION_USAGE_SCHEMAS = new Set([
   BILLING_SESSION_USAGE_SCHEMA,
@@ -38,6 +40,19 @@ const USAGE_HINT_KEYS = [
   "cost_usd",
   "cost",
 ];
+const ESTIMATED_MESSAGE_EVENT_KINDS = new Set([
+  "agent_response",
+  "session_message",
+  "session_say",
+]);
+const HUMAN_AGENT_IDS = new Set([
+  "cli-user",
+  "human",
+  "user",
+  "you",
+]);
+const DEFAULT_ESTIMATED_MESSAGE_USAGE_DEDUPE_WINDOW_MS = 5 * 60 * 1000;
+const DEFAULT_ESTIMATED_MESSAGE_USAGE_DEDUPE_SEQUENCE_WINDOW = 3;
 
 function n(value) {
   return String(value == null ? "" : value).trim();
@@ -94,6 +109,12 @@ function roundUsd(value) {
   return Math.round(Number(value || 0) * 1_000_000) / 1_000_000;
 }
 
+function positiveInteger(value, fallbackValue) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallbackValue;
+  return Math.floor(parsed);
+}
+
 export function createSessionUsageLedgerId({
   sessionId = "",
   agentId = "",
@@ -116,6 +137,52 @@ function fallbackIdempotencyKey({ sessionId, event, agentId, action, model, tota
   return `event:${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
 }
 
+function messageEstimateIdempotencyKey({ sessionId, event, agentId, model, text }) {
+  const payload = object(event?.payload);
+  const explicit =
+    n(payload.clientMessageId || payload.client_message_id) ||
+    n(event?.eventId || event?.event_id) ||
+    n(event?.idempotencyToken || event?.idempotency_token) ||
+    n(event?.cursor);
+  if (explicit) return `estimated-message:${explicit}`;
+  const sequence = n(event?.sequenceId ?? event?.sequence_id);
+  if (sequence) return `estimated-message:seq:${sequence}`;
+  const timestamp = n(event?.ts || event?.timestamp);
+  const source = [sessionId, timestamp, agentId, model, text].join("\x1f");
+  return `estimated-message:${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
+}
+
+function isLikelyHumanAgent({ agentId = "", role = "", model = "" } = {}) {
+  const id = n(agentId).toLowerCase();
+  const normalizedRole = n(role).toLowerCase();
+  const normalizedModel = n(model).toLowerCase();
+  if (!id && !normalizedModel) return true;
+  if (HUMAN_AGENT_IDS.has(id)) return true;
+  if (id.startsWith("human-") || id.startsWith("user-")) return true;
+  if (normalizedModel === "human") return true;
+  const agentLikeRole = ["coder", "reviewer", "tester", "observer", "orchestrator"].includes(normalizedRole);
+  const agentLikeId = /(codex|claude|gpt|gemini|grok|senti|kai-chen|agent|bot|warden|architect|builder)/i.test(id);
+  const agentLikeModel = /(gpt|claude|gemini|grok|codex|sonnet|opus|haiku)/i.test(normalizedModel);
+  if (normalizedRole === "human") return true;
+  if (normalizedRole === "participant" && !agentLikeId && !agentLikeModel) return true;
+  if (!agentLikeRole && !agentLikeId && !agentLikeModel && (!normalizedModel || normalizedModel === "unknown")) {
+    return true;
+  }
+  return false;
+}
+
+function responseText(payload = {}) {
+  if (payload.response && typeof payload.response === "object" && !Array.isArray(payload.response)) {
+    return n(payload.response.text);
+  }
+  return n(payload.response);
+}
+
+function messageText(event = {}) {
+  const payload = object(event?.payload);
+  return n(payload.message) || responseText(payload) || n(payload.text);
+}
+
 function providerCostFromPriceBook({ model, inputTokens, outputTokens, explicitProviderCost }) {
   if (explicitProviderCost != null) {
     return { providerCostUsd: explicitProviderCost, unpriced: false };
@@ -217,9 +284,139 @@ export function buildUsageLedgerEntry(
     unpriced,
     timestamp: n(event?.ts || event?.timestamp),
     sequenceId: nonNegativeInt(event?.sequenceId ?? event?.sequence_id),
+    estimated: false,
+  };
+}
+
+export function buildEstimatedMessageLedgerEntry(
+  event,
+  {
+    sessionId = "",
+    priceBookVersion = DEFAULT_PRICE_BOOK_VERSION,
+    billingTier = "estimated",
+    includeHumanMessages = false,
+    action = "estimated_agent_message",
+  } = {},
+) {
+  const kind = n(event?.event || event?.type);
+  if (!ESTIMATED_MESSAGE_EVENT_KINDS.has(kind)) return null;
+
+  const payload = object(event?.payload);
+  if (hasUsageHints(payload) || hasUsageHints(payload.usage)) return null;
+
+  const text = messageText(event);
+  if (!text) return null;
+
+  const agent = object(event?.agent);
+  const agentId = n(agent.id || event?.agentId) || "unknown";
+  const model = n(agent.model || event?.agentModel || payload.model) || "unknown";
+  const role = n(agent.role || payload.role);
+  const lowerAgentId = agentId.toLowerCase();
+  if (lowerAgentId === "senti" || lowerAgentId === "kai-chen") {
+    return null;
+  }
+  if (!includeHumanMessages && isLikelyHumanAgent({ agentId, role, model })) {
+    return null;
+  }
+
+  const outputTokens = estimateTokens(text, {
+    model,
+    provider: n(agent.provider || payload.provider),
+  });
+  if (outputTokens <= 0) return null;
+
+  const actionName = n(action) || "estimated_agent_message";
+  const idempotencyKey = messageEstimateIdempotencyKey({
+    sessionId,
+    event,
+    agentId,
+    model,
+    text,
+  });
+  const ledgerEntryId = createSessionUsageLedgerId({
+    sessionId,
+    agentId,
+    action: actionName,
+    idempotencyKey,
+  });
+  const { providerCostUsd, unpriced } = providerCostFromPriceBook({
+    model,
+    inputTokens: 0,
+    outputTokens,
+    explicitProviderCost: null,
+  });
+
+  return {
+    ledgerEntryId,
+    idempotencyKey,
+    schema: ESTIMATED_MESSAGE_USAGE_SCHEMA,
+    sessionId: n(sessionId),
+    agentId,
+    action: actionName,
+    model,
+    priceBookVersion: n(priceBookVersion) || DEFAULT_PRICE_BOOK_VERSION,
+    billingTier: n(billingTier) || "estimated",
+    provider: n(agent.provider || payload.provider),
+    inputTokens: 0,
+    outputTokens,
+    totalTokens: outputTokens,
+    providerCostUsd: roundUsd(providerCostUsd),
+    customerCostUsd: null,
+    unpriced,
+    timestamp: n(event?.ts || event?.timestamp),
+    sequenceId: nonNegativeInt(event?.sequenceId ?? event?.sequence_id),
+    estimated: true,
   };
 }
 
+function collectRealUsageAnchors(events = [], options = {}) {
+  const anchors = new Map();
+  for (const event of events) {
+    const entry = buildUsageLedgerEntry(event, options);
+    if (!entry || entry.estimated) continue;
+    if (!anchors.has(entry.agentId)) anchors.set(entry.agentId, []);
+    anchors.get(entry.agentId).push({
+      timestampMs: Date.parse(n(entry.timestamp)),
+      sequenceId: Number.isFinite(entry.sequenceId) ? entry.sequenceId : null,
+    });
+  }
+  return anchors;
+}
+
+function hasNearbyRealUsageAnchor(entry, anchors, options = {}) {
+  if (!entry || !entry.estimated || !anchors || anchors.size === 0) return false;
+  const agentAnchors = anchors.get(entry.agentId);
+  if (!agentAnchors || agentAnchors.length === 0) return false;
+  const windowMs = positiveInteger(
+    options.estimatedMessageUsageDedupeWindowMs,
+    DEFAULT_ESTIMATED_MESSAGE_USAGE_DEDUPE_WINDOW_MS,
+  );
+  const sequenceWindow = positiveInteger(
+    options.estimatedMessageUsageDedupeSequenceWindow,
+    DEFAULT_ESTIMATED_MESSAGE_USAGE_DEDUPE_SEQUENCE_WINDOW,
+  );
+  const entryTimestampMs = Date.parse(n(entry.timestamp));
+  const hasEntryTimestamp = Number.isFinite(entryTimestampMs);
+  const entrySequenceId = Number.isFinite(entry.sequenceId) ? entry.sequenceId : null;
+  return agentAnchors.some((anchor) => {
+    if (
+      entrySequenceId !== null &&
+      Number.isFinite(anchor.sequenceId) &&
+      Math.abs(entrySequenceId - anchor.sequenceId) <= sequenceWindow
+    ) {
+      return true;
+    }
+    if (
+      hasEntryTimestamp &&
+      Number.isFinite(anchor.timestampMs) &&
+      Math.abs(entryTimestampMs - anchor.timestampMs) <= windowMs
+    ) {
+      return true;
+    }
+    return false;
+  });
+}
+
 function newRollup(label) {
   return {
     label,
@@ -231,6 +428,7 @@ function newRollup(label) {
     customerCostUsd: 0,
     hasCustomerCost: false,
     unpriced: 0,
+    estimatedEntries: 0,
   };
 }
 
@@ -245,6 +443,7 @@ function addToRollup(rollup, entry) {
     rollup.hasCustomerCost = true;
   }
   if (entry.unpriced) rollup.unpriced += 1;
+  if (entry.estimated) rollup.estimatedEntries += 1;
 }
 
 function finalizeRollup(rollup) {
@@ -257,6 +456,9 @@ export function buildSessionUsageLedger(events = [], options = {}) {
   if (!Array.isArray(events)) {
     throw new Error("events must be an array.");
   }
+  const realUsageAnchors = options.includeEstimatedMessages
+    ? collectRealUsageAnchors(events, options)
+    : new Map();
   const entries = [];
   const totals = newRollup("session");
   const perAgent = new Map();
@@ -266,8 +468,13 @@ export function buildSessionUsageLedger(events = [], options = {}) {
   let duplicatesSkipped = 0;
 
   for (const event of events) {
-    const entry = buildUsageLedgerEntry(event, options);
+    const entry =
+      buildUsageLedgerEntry(event, options) ||
+      (options.includeEstimatedMessages
+        ? buildEstimatedMessageLedgerEntry(event, options)
+        : null);
     if (!entry) continue;
+    if (hasNearbyRealUsageAnchor(entry, realUsageAnchors, options)) continue;
     const dedupeKeys = [
       entry.idempotencyKey ? `idem:${entry.idempotencyKey}` : "",
       entry.ledgerEntryId ? `ledger:${entry.ledgerEntryId}` : "",

package/src/session/recap.js

@@ -22,6 +22,23 @@ const DEFAULT_TASK_SUMMARY_LIMIT = 3;
 const DEFAULT_WORK_PLAN_SUMMARY_LIMIT = 5;
 const MAX_WORK_PLAN_BYTES = 128_000;
 const WORK_PLAN_RELATIVE_PATH = "tasks/todo.md";
+const HISTORICAL_WORK_PLAN_MIN_COMPLETED = 25;
+const HISTORICAL_WORK_PLAN_MIN_TOTAL = 50;
+const HISTORICAL_WORK_PLAN_COMPLETED_RATIO = 0.75;
+const GENERIC_WORK_PLAN_SECTIONS = new Set([
+  "plan",
+  "plans",
+  "todo",
+  "todos",
+  "to do",
+  "tasks",
+  "work items",
+  "workitems",
+  "workstream",
+  "workstreams",
+  "backlog",
+  "next",
+]);
 const RECAP_SOURCE_IGNORED_EVENTS = new Set([
   "agent_heartbeat",
   "agent_join",
@@ -458,6 +475,41 @@ function shortWorkPlanText(value) {
   return `${text.slice(0, 97)}...`;
 }
 
+function normalizedWorkPlanSection(value = "") {
+  return normalizeString(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function isGenericWorkPlanSection(value = "") {
+  const normalized = normalizedWorkPlanSection(value);
+  if (!normalized) {
+    return false;
+  }
+  if (GENERIC_WORK_PLAN_SECTIONS.has(normalized)) {
+    return true;
+  }
+  return /^(active\s+)?(plan|todo|tasks|backlog)(\s+\d+)?$/.test(normalized);
+}
+
+function shouldSuppressHistoricalWorkPlanDetails(summary = emptyWorkPlanSummary()) {
+  const total = Number(summary.total || 0);
+  const open = Number(summary.open || 0);
+  const completed = Number(summary.completed || 0);
+  if (summary.truncated || open <= 0 || completed < HISTORICAL_WORK_PLAN_MIN_COMPLETED) {
+    return false;
+  }
+  if (total < HISTORICAL_WORK_PLAN_MIN_TOTAL) {
+    return false;
+  }
+  if (!isGenericWorkPlanSection(summary.currentSection)) {
+    return false;
+  }
+  return completed / Math.max(1, total) >= HISTORICAL_WORK_PLAN_COMPLETED_RATIO;
+}
+
 function summarizeWorkPlanMarkdown(
   raw = "",
   { limit = DEFAULT_WORK_PLAN_SUMMARY_LIMIT, truncated = false, sourceContext = {} } = {}
@@ -507,6 +559,10 @@ function summarizeWorkPlanMarkdown(
     .filter((record) => record.status === "open")
     .slice(-normalizedLimit);
   summary.recent = records.slice(-normalizedLimit);
+  if (!summary.detailSuppressed && shouldSuppressHistoricalWorkPlanDetails(summary)) {
+    summary.detailSuppressed = true;
+    summary.detailSuppressionReason = "historical_generic_plan_section";
+  }
   if (summary.detailSuppressed) {
     summary.currentSection = "";
     summary.recentOpen = [];
@@ -785,7 +841,15 @@ function buildWorkPlanText(workPlan = emptyWorkPlanSummary()) {
   const sourceReason = normalizeString(workPlan.sourceReason);
   const sourceReasonText = sourceReason ? ` (${sourceReason})` : "";
   if (workPlan.detailSuppressed || workPlan.truncated) {
-    return `Plan: ${open} open / ${completed} done in recent ${sourceText} window${sourceReasonText}. Current/next items suppressed because the plan file is large.`;
+    const suppressionReason = normalizeString(workPlan.detailSuppressionReason);
+    const sourceWindowText = workPlan.truncated
+      ? `recent ${sourceText} window`
+      : sourceText;
+    const suppressionText =
+      suppressionReason === "historical_generic_plan_section"
+        ? "Current/next items suppressed because this generic plan is mostly historical completed work."
+        : "Current/next items suppressed because the plan file is large.";
+    return `Plan: ${open} open / ${completed} done in ${sourceWindowText}${sourceReasonText}. ${suppressionText}`;
   }
   const currentSection = normalizeString(workPlan.currentSection);
   const currentText = currentSection ? ` Current: ${currentSection}.` : "";
@@ -814,7 +878,7 @@ function roundCurrency(value) {
 }
 
 function normalizeUsageSummary(events = []) {
-  const aggregate = aggregateSessionUsage(events);
+  const aggregate = aggregateSessionUsage(events, { includeEstimatedMessages: true });
   const totals = {
     totalTokens: Number(aggregate.totals.totalTokens || 0),
     inputTokens: Number(aggregate.totals.inputTokens || 0),