shariq-pi-extensions 0.2.14 → 0.2.16

package/docs/ARCHITECTURE.md

@@ -38,6 +38,8 @@ Installed package directories are treated as immutable. Extensions resolve writa
 
 - Cursor's authenticated Composer/Grok catalog cache: `<agent-dir>/cursor/models.json`
 - Factory key selection, Droid metadata, and throttled per-credential limit cache: `<agent-dir>/factory/`
+- Smart Compaction configuration and details ledgers: `<agent-dir>/smart-compaction.json`
+- Input mode configuration: `<agent-dir>/input-mode.json`
 - Pi Memory state: `<agent-dir>/pi-memory/`
 - Subagent configuration and catalog: paths derived from `getAgentDir()`
 - Orchestration settings and run ledgers: `<agent-dir>/orchestration/`

package/docs/DEVELOPMENT.md

@@ -45,9 +45,9 @@ Keep secrets out of examples and fixtures. Tests should inject temporary roots,
 
 ## Skills paired with extensions
 
-The root manifest declares `skills/background-terminals` and `skills/subagents`. Pi loads them directly from the managed Git package. Do not copy them into the agent directory from install scripts; that would create duplicates and leave stale files after removal.
+The root manifest declares `skills/background-terminals`, `skills/orchestration`, and `skills/subagents`. Pi loads them directly from the managed package. Do not copy them into the agent directory from install scripts; that would create duplicates and leave stale files after removal.
 
-When either skill changes, validate its structure and keep its behavior aligned with the corresponding extension tools.
+When any paired skill changes, validate its structure and keep its behavior aligned with the corresponding extension tools.
 
 ## Pi Memory
 

package/docs/EXTENSIONS.md

@@ -10,7 +10,7 @@ Registers the `antigravity` provider and `/login antigravity` flow for the lates
 
 ### [Cursor provider](../extensions/cursor-provider/README.md)
 
-Registers one `cursor` provider for Cursor-hosted Composer and Cursor Grok models through the native Cursor SDK. `/login cursor` supports browser-minted or existing user API keys, images and native Pi tool delegation are enabled, and `/cursor` shows Cursor's authoritative current-month total, Auto/Composer and named/API percentages, reset date, plan, and on-demand limits. It does not expose ACP, third-party models, or Factory-style 5-hour/weekly pools. The authenticated catalog cache belongs in `<agent-dir>/cursor/models.json`.
+Registers one `cursor` provider for Cursor-hosted Composer and Cursor Grok models through the native Cursor SDK with warm agent instance pooling (LRU pool with 10-minute idle TTL) and ambient settings suppression (`settingSources: []`) to eliminate per-turn startup latency. `/login cursor` supports browser-minted or existing user API keys, images and native Pi tool delegation are enabled, credential redaction automatically scrubs API keys and tokens from error logs, and `/cursor` shows Cursor's authoritative current-month total, Auto/Composer and named/API percentages, reset date, plan, and on-demand limits. It does not expose ACP, third-party models, or Factory-style 5-hour/weekly pools. The authenticated catalog cache belongs in `<agent-dir>/cursor/models.json`.
 
 ### [Factory provider](../extensions/factory-provider/README.md)
 
@@ -48,9 +48,17 @@ The model-facing `create_orchestration` tool starts planning only after an expli
 
 ### [Smart Compaction](../extensions/smart-compaction/README.md)
 
-Replaces standard context compaction with a high-fidelity continuity engine. It intercepts `session_before_compact` events and synthesizes multi-turn conversations into structured checkpoint summaries capturing primary goals and negative constraints, progress ledgers (`Done`/`In Progress`/`Blocked`), verbatim code snippets for active/uncommitted edits, exact error root causes, architectural decisions, resume anchors, and deterministic `<read-files>`/`<modified-files>` metadata.
-
-Successive compactions utilize an incremental Delta-Merge to eliminate context degradation over long sessions. `/compaction-model` selects any custom compaction model (e.g. `factory/gemini-3.7-flash`, `cursor/cursor-grok-4.5-fast`) or defaults to inheriting the active session model (`inherit`). `/smart-compaction` toggles or inspects compaction configuration stored in `<agent-dir>/smart-compaction.json`.
+Replaces standard context compaction with a defensive, high-fidelity continuity engine. It intercepts `session_before_compact` events and synthesizes multi-turn conversations into structured checkpoint summaries capturing primary goals and negative constraints, progress ledgers (`Done`/`In Progress`/`Blocked`), verbatim code snippets for active/uncommitted edits, exact error root causes, architectural decisions, resume anchors, and deterministic file/diff state.
+
+Key capabilities include:
+- **Fail-Closed Validation**: Strictly enforces `stopReason === "stop"`, rejects tool calls and length-truncated output, and requires all 6 section headings.
+- **Deterministic State Ledger (Schema v3)**: Machine-readable tracking of `touchedReadFiles`, `touchedModifiedFiles`, and asynchronous NUL-delimited Git worktree parsing capturing `activeDirtyFiles`, staged diffs, unstaged diffs, and untracked file previews in `CompactionEntry.details` and `<uncommitted-diff>` context.
+- **Lockfile & Bundle Diff Filtering**: Automatically isolates `package-lock.json`, `Cargo.lock`, `yarn.lock`, and minified assets from raw diffs to preserve token budgets for source code logic.
+- **Active Background Terminal Awareness**: Automatically identifies running background processes and records them under `<active-background-processes>` to prevent duplicate server launches.
+- **Hierarchical Delta-Merging**: Carries forward immutable goals and user constraints across 10+ compaction cycles while condensing older completed items to prevent summary bloat.
+- **Classified Retry Ladder**: Distinguishes non-retryable fatal auth/quota errors from transient reasoning/length limits (retrying with reasoning off) and falling back to the active session model.
+- **Two-Ended Truncation & Credential Redaction**: Retains both head and tail of tool outputs (ensuring final error traces and test results survive) while redacting secrets and sensitive paths.
+- **Custom Model Routing**: `/compaction-model` selects any custom compaction model (e.g. `factory/gemini-3.7-flash`, `cursor/cursor-grok-4.5-fast`) or defaults to inheriting the active session model (`inherit`). `/smart-compaction` manages settings stored in `<agent-dir>/smart-compaction.json`.
 
 ### [Background terminals](../extensions/background-terminals/README.md)
 

package/extensions/background-terminals/index.ts

@@ -48,6 +48,10 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
   const getManager = (): TerminalManager => {
     if (manager) return manager;
     manager = new TerminalManager();
+    (globalThis as any).__pi_get_active_terminals = () => {
+      if (!manager) return [];
+      return manager.list().filter((s) => s.status === "running").map((s) => `${s.id}: "${oneLine(s.title)}" (pid ${s.pid})`);
+    };
     manager.setOnSettled((snapshot) => {
       if (!modelOwned.delete(snapshot.id)) {
         ui?.notify(
@@ -393,4 +397,8 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
     description: "Open the background terminal control center",
     handler: async (_args, ctx) => openCommand(ctx),
   });
+
+  pi.on("session_shutdown", () => {
+    delete (globalThis as any).__pi_get_active_terminals;
+  });
 }

package/extensions/pi-memory/src/redaction.ts

@@ -1,42 +1,7 @@
 import path from "node:path";
+import { isSensitivePath, redactSecrets } from "../../shared/redaction.ts";
 
-const SENSITIVE_PATH_PARTS = new Set([
-  ".env",
-  "auth.json",
-  "credentials",
-  "credential",
-  "secrets",
-  "secret",
-  "keychain",
-  ".ssh",
-  ".aws",
-  ".gnupg",
-]);
-
-const CREDENTIAL_NAME = "(?:api[_-]?key|apiKey|access[_-]?token|accessToken|refresh[_-]?token|refreshToken|auth(?:orization)?|password|passwd|secret|cookie|session[_-]?token|sessionToken|aws[_-]?secret[_-]?access[_-]?key|aws[_-]?access[_-]?key[_-]?id|client[_-]?secret|clientSecret|private[_-]?key|privateKey|database[_-]?url|databaseUrl|connection[_-]?string|connectionString|dsn)";
-
-const REDACTIONS: Array<[RegExp, string]> = [
-  [/\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)[^\s/@]+@/gi, "$1<redacted>@"],
-  [/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, "Bearer <redacted>"],
-  [new RegExp(`(\\b${CREDENTIAL_NAME}\\b\\s*[:=]\\s*)(["'])(.*?)\\2`, "gi"), "$1$2<redacted>$2"],
-  [new RegExp(`(\\b${CREDENTIAL_NAME}\\b\\s*[:=]\\s*)[^\\r\\n,;]+`, "gi"), "$1<redacted>"],
-  [/\b(?:sk|pk|rk|ghp|github_pat|xox[baprs]|AIza)[-_A-Za-z0-9]{12,}\b/g, "<redacted-token>"],
-  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "<redacted-private-key>"],
-  [/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, "<redacted-opaque-value>"],
-];
-
-export function redactSecrets(value: string): string {
-  let result = value;
-  for (const [pattern, replacement] of REDACTIONS) result = result.replace(pattern, replacement);
-  return result;
-}
-
-export function isSensitivePath(value: string): boolean {
-  const normalized = value.toLowerCase().replaceAll("\\", "/");
-  return normalized.split("/").some((part) => SENSITIVE_PATH_PARTS.has(part))
-    || /(?:^|\/)\.env(?:\.|$)/.test(normalized)
-    || /(?:^|\/)(?:id_rsa|id_ed25519|known_hosts)(?:$|\/)/.test(normalized);
-}
+export { isSensitivePath, redactSecrets } from "../../shared/redaction.ts";
 
 export function hasSensitiveToolArguments(toolName: string, input: unknown): boolean {
   if (!["read", "write", "edit"].includes(toolName)) return false;

package/extensions/shared/redaction.ts

@@ -0,0 +1,55 @@
+const SENSITIVE_PATH_PARTS = new Set([
+  ".env",
+  "auth.json",
+  "credentials",
+  "credential",
+  "secrets",
+  "secret",
+  "keychain",
+  ".ssh",
+  ".aws",
+  ".gnupg",
+]);
+
+const CREDENTIAL_NAME = "(?:api[_-]?key|apiKey|access[_-]?token|accessToken|refresh[_-]?token|refreshToken|auth(?:orization)?|password|passwd|secret|cookie|session[_-]?token|sessionToken|aws[_-]?secret[_-]?access[_-]?key|aws[_-]?access[_-]?key[_-]?id|client[_-]?secret|clientSecret|private[_-]?key|privateKey|database[_-]?url|databaseUrl|connection[_-]?string|connectionString|dsn)";
+
+const REDACTIONS: Array<[RegExp, string]> = [
+  [/\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)[^\s/@]+@/gi, "$1<redacted>@"],
+  [/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, "Bearer <redacted>"],
+  [new RegExp(`(\\b${CREDENTIAL_NAME}\\b\\s*[:=]\\s*)(["'])(.*?)\\2`, "gi"), "$1$2<redacted>$2"],
+  [new RegExp(`(\\b${CREDENTIAL_NAME}\\b\\s*[:=]\\s*)[^\\r\\n,;]+`, "gi"), "$1<redacted>"],
+  [/\b(?:sk|pk|rk|ghp|github_pat|xox[baprs]|AIza)[-_A-Za-z0-9]{12,}\b/g, "<redacted-token>"],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "<redacted-private-key>"],
+  [/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, "<redacted-opaque-value>"],
+];
+
+export function redactSecrets(value: string): string {
+  let result = value;
+  for (const [pattern, replacement] of REDACTIONS) result = result.replace(pattern, replacement);
+  return result;
+}
+
+const CODE_SAFE_CREDENTIAL_NAME = "(?:api[_-]?key|apiKey|access[_-]?token|accessToken|refresh[_-]?token|refreshToken|auth(?:orization)?[_-]?token|password|passwd|secret|cookie|session[_-]?token|sessionToken|aws[_-]?secret[_-]?access[_-]?key|aws[_-]?access[_-]?key[_-]?id|client[_-]?secret|clientSecret|private[_-]?key|privateKey|database[_-]?url|databaseUrl|connection[_-]?string|connectionString|dsn)";
+
+const CODE_SAFE_REDACTIONS: Array<[RegExp, string]> = [
+  [/\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)[^\s/@]+@/gi, "$1<redacted>@"],
+  [/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, "Bearer <redacted>"],
+  [new RegExp(`(\\b${CODE_SAFE_CREDENTIAL_NAME}\\b\\s*[:=]\\s*)(["'])(.{8,}?)\\2`, "gi"), "$1$2<redacted>$2"],
+  [new RegExp(`(\\b${CODE_SAFE_CREDENTIAL_NAME}\\b\\s*[:=]\\s*)([^\\s,;]{8,})`, "gi"), "$1<redacted>"],
+  [/\b(?:sk|pk|rk|ghp|github_pat|xox[baprs]|AIza)[-_A-Za-z0-9]{12,}\b/g, "<redacted-token>"],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "<redacted-private-key>"],
+];
+
+/** Redact high-confidence secrets without treating ordinary code such as `auth = true` as sensitive. */
+export function redactLikelySecrets(value: string): string {
+  let result = value;
+  for (const [pattern, replacement] of CODE_SAFE_REDACTIONS) result = result.replace(pattern, replacement);
+  return result;
+}
+
+export function isSensitivePath(value: string): boolean {
+  const normalized = value.toLowerCase().replaceAll("\\", "/");
+  return normalized.split("/").some((part) => SENSITIVE_PATH_PARTS.has(part))
+    || /(?:^|\/)\.env(?:\.|$)/.test(normalized)
+    || /(?:^|\/)(?:id_rsa|id_ed25519|known_hosts)(?:$|\/)/.test(normalized);
+}

package/extensions/smart-compaction/README.md

@@ -14,22 +14,25 @@ When long-running agent sessions reach context thresholds, standard compaction f
 
 1. **🎯 Primary Goal & Nuanced Intent** — Retains full user objectives, styling preferences, scope boundaries, and explicit negative constraints.
 2. **📋 Progress Ledger** — Strict `[x] Done`, `[ ] In Progress`, and `[!] Blocked` tracking.
-3. **🛠️ Code Changes & In-Progress Snippets** — Captures verbatim code snippets of active work and recent edits so a successor agent resumes without re-reading or guessing.
+3. **🛠️ Code Changes & In-Progress Snippets** — Captures verbatim code snippets of active work and recent edits, supplemented by a bounded worktree patch so a successor can recover the current engineering state.
 4. **💥 Errors, Root Causes & Fixes** — Full error traces, root cause diagnostics, and verified solutions.
 5. **🧠 Key Decisions & Hypotheses** — Architectural choices, trade-offs, and discarded hypotheses.
 6. **📍 Resume Anchor & Immediate Next Action** — Verbatim quote or exact resume state with the single immediate next action.
-7. **📂 Deterministic File Ledger** — Programmatic `<read-files>` and `<modified-files>` XML blocks merged deterministically across cycles in `details.readFiles` and `details.modifiedFiles`.
+7. **📂 Deterministic Engineering Ledger** — Programmatic `<read-files>`, `<touched-files>`, `<uncommitted-dirty-files>`, `<modified-lockfiles-and-assets>`, `<active-background-processes>`, and bounded `<uncommitted-diff>` blocks. Lockfiles and minified bundles are automatically excluded from raw diffing to preserve token budgets for real source code, while active background terminals/daemons are recorded to prevent port conflicts.
 
 ## Defensive Reliability & Multi-Stage Retry Ladder
 
-- **Fail-Closed Validation**: Rejects `stopReason === "length"`, `stopReason === "error"`, accidental tool calls, or partial summaries missing required section headers.
+- **Fail-Closed Validation**: Accepts only `stopReason === "stop"` and rejects tool calls, empty output, or summaries missing required section headers.
+- **Lockfile & Bundle Diff Exclusion**: Automatically excludes `package-lock.json`, `Cargo.lock`, `yarn.lock`, `pnpm-lock.yaml`, and minified assets from raw diffs, recording their status under `<modified-lockfiles-and-assets>` to preserve 100% of diff token headroom for source code.
+- **Background Daemon & Terminal Awareness**: Automatically detects running background terminals/processes and injects their status into `<active-background-processes>` so the successor agent never launches duplicate services.
 - **Retry Ladder**: If an attempt encounters output limits or transient reasoning timeouts:
   1. Primary configured model with requested reasoning.
   2. Primary model with reasoning off (unblocks reasoning/token caps).
   3. Session model with reasoning off.
   4. Graceful fallback to Pi's default compactor if all stages fail.
 - **Two-Ended Head & Tail Truncation**: Preserves both the beginning (context) and end (stack traces, compiler errors, exit codes, test summaries) of tool results and command logs.
-- **Deterministic 10+ Cycle Stability**: Persists machine-readable file and cycle ledgers in `CompactionEntry.details` so file states survive indefinitely across successive compactions.
+- **Secret-Safe Persistence**: Redacts credential-shaped values and omits sensitive tool paths, results, dirty files, and patches before durable compaction state is created.
+- **Deterministic 10+ Cycle Stability**: Persists machine-readable touch, dirty-file, bounded-patch, and cycle ledgers in `CompactionEntry.details`; hierarchical delta merging keeps immutable constraints while condensing obsolete history.
 
 ## Model Selection
 

package/extensions/smart-compaction/engine.ts

@@ -1,6 +1,11 @@
+import { execFile } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
 import { uuidv7, type Api, type Context, type Model, type Usage, type AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionContext, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
 import type { SmartCompactionConfig } from "./config.ts";
+import { isSensitivePath, redactLikelySecrets } from "../shared/redaction.ts";
 import {
   formatFileOperationsXml,
   sanitizeTagContent,
@@ -10,27 +15,53 @@ import {
   serializeConversationForCompaction,
 } from "./prompt.ts";
 
+export interface DirtyFileState {
+  path: string;
+  status: string;
+}
+
+export interface GitEngineeringState {
+  available: boolean;
+  files: DirtyFileState[];
+  patch: string;
+  sensitiveFilesOmitted: number;
+  lockfilesAndGeneratedAssets: string[];
+}
+
 export interface SmartCompactionDetails {
-  schemaVersion: 2;
+  schemaVersion: 3;
   customCompactor: "smart-compaction";
-  model: string;
+  configuredModel: string;
+  resolvedModel: string;
   isInherited: boolean;
-  readFiles: string[];
-  modifiedFiles: string[];
+  touchedReadFiles: string[];
+  touchedModifiedFiles: string[];
+  activeDirtyFiles: string[];
+  activeDirtyFileStates: DirtyFileState[];
+  activeDirtyPatch: string;
+  dirtyStateAvailable: boolean;
+  sensitiveDirtyFilesOmitted: number;
+  sensitiveTouchedFilesOmitted: number;
+  activeBackgroundProcesses?: string[];
+  lockfilesAndGeneratedAssets?: string[];
   cycleCount: number;
   timestamp: number;
 }
 
+export function modelKey(model: Pick<Model<Api>, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
 export function resolveCompactionModel(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
   configuredModelString?: string,
-): { model: Model<Api>; isInherited: boolean } {
+): { model: Model<Api>; isInherited: boolean; isFallback: boolean; fallbackReason?: string } {
   const trimmed = configuredModelString?.trim();
   if (!trimmed || trimmed === "inherit") {
     if (!ctx.model) {
       throw new Error("No active session model available to inherit for compaction.");
     }
-    return { model: ctx.model, isInherited: true };
+    return { model: ctx.model, isInherited: true, isFallback: false };
   }
 
   // Parse "provider/model" or modelId
@@ -44,36 +75,48 @@ export function resolveCompactionModel(
   }
 
   if (candidate) {
-    return { model: candidate, isInherited: false };
+    return { model: candidate, isInherited: false, isFallback: false };
   }
 
   if (ctx.model) {
-    return { model: ctx.model, isInherited: true };
+    return {
+      model: ctx.model,
+      isInherited: true,
+      isFallback: true,
+      fallbackReason: `Configured compaction model "${trimmed}" is unavailable in model registry.`,
+    };
   }
 
   throw new Error(`Configured compaction model "${trimmed}" was not found in model registry.`);
 }
 
 export function extractPriorFileState(branchEntries?: any[]): {
-  readFiles: Set<string>;
-  modifiedFiles: Set<string>;
+  touchedReadFiles: Set<string>;
+  touchedModifiedFiles: Set<string>;
   cycleCount: number;
 } {
-  const readFiles = new Set<string>();
-  const modifiedFiles = new Set<string>();
+  const touchedReadFiles = new Set<string>();
+  const touchedModifiedFiles = new Set<string>();
   let cycleCount = 0;
 
-  if (!Array.isArray(branchEntries)) return { readFiles, modifiedFiles, cycleCount };
+  if (!Array.isArray(branchEntries)) return { touchedReadFiles, touchedModifiedFiles, cycleCount };
 
   for (let i = branchEntries.length - 1; i >= 0; i--) {
     const entry = branchEntries[i];
     if (entry?.type === "compaction" && entry.details) {
-      const details = entry.details as Partial<SmartCompactionDetails> & { readFiles?: string[]; modifiedFiles?: string[] };
-      if (Array.isArray(details.readFiles)) {
-        for (const file of details.readFiles) readFiles.add(file);
+      const details = entry.details as Partial<SmartCompactionDetails> & {
+        readFiles?: string[];
+        modifiedFiles?: string[];
+        touchedReadFiles?: string[];
+        touchedModifiedFiles?: string[];
+      };
+      const readList = details.touchedReadFiles ?? details.readFiles;
+      if (Array.isArray(readList)) {
+        for (const file of readList) touchedReadFiles.add(file);
       }
-      if (Array.isArray(details.modifiedFiles)) {
-        for (const file of details.modifiedFiles) modifiedFiles.add(file);
+      const modifiedList = details.touchedModifiedFiles ?? details.modifiedFiles;
+      if (Array.isArray(modifiedList)) {
+        for (const file of modifiedList) touchedModifiedFiles.add(file);
       }
       if (typeof details.cycleCount === "number") {
         cycleCount = Math.max(cycleCount, details.cycleCount);
@@ -81,7 +124,165 @@ export function extractPriorFileState(branchEntries?: any[]): {
     }
   }
 
-  return { readFiles, modifiedFiles, cycleCount };
+  return { touchedReadFiles, touchedModifiedFiles, cycleCount };
+}
+
+const GENERATED_OR_LOCKFILE_PATTERNS = [
+  /(?:^|\/)package-lock\.json$/i,
+  /(?:^|\/)pnpm-lock\.yaml$/i,
+  /(?:^|\/)yarn\.lock$/i,
+  /(?:^|\/)Cargo\.lock$/i,
+  /(?:^|\/)poetry\.lock$/i,
+  /(?:^|\/)bun\.lockb?$/i,
+  /(?:^|\/)composer\.lock$/i,
+  /(?:^|\/)flake\.lock$/i,
+  /(?:^|\/)mise\.lock$/i,
+  /\.min\.(?:js|css|mjs)$/i,
+  /\.map$/i,
+  /\.wasm$/i,
+  /(?:^|\/)(?:dist|build|out|\.next|\.nuxt|\.turbo|\.parcel-cache)\//i,
+];
+
+export function isGeneratedOrLockfile(filePath: string): boolean {
+  const normalized = filePath.replace(/\\/g, "/");
+  return GENERATED_OR_LOCKFILE_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+export function getActiveBackgroundProcesses(): string[] {
+  try {
+    const fn = (globalThis as any).__pi_get_active_terminals;
+    if (typeof fn === "function") {
+      const active = fn();
+      if (Array.isArray(active)) {
+        return active.filter((item): item is string => typeof item === "string" && Boolean(item.trim()));
+      }
+    }
+  } catch {
+    // Best-effort inspection.
+  }
+  return [];
+}
+
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 5_000;
+const GIT_OUTPUT_LIMIT = 2 * 1024 * 1024;
+const DIRTY_PATCH_CHARS = 16_000;
+const UNTRACKED_FILE_CHARS = 4_000;
+
+export function parseGitStatusPorcelainV1Z(output: string): DirtyFileState[] {
+  const records = output.split("\0");
+  const files: DirtyFileState[] = [];
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (!record || record.length < 4) continue;
+    const status = record.slice(0, 2);
+    const filePath = record.slice(3);
+    files.push({ path: filePath, status });
+    // In porcelain v1 -z output, rename/copy records are followed by the source path.
+    if (status.includes("R") || status.includes("C")) index++;
+  }
+  return [...new Map(files.map((file) => [file.path, file])).values()];
+}
+
+function truncatePatch(text: string): string {
+  if (text.length <= DIRTY_PATCH_CHARS) return text;
+  const half = Math.floor(DIRTY_PATCH_CHARS / 2);
+  const omitted = text.length - (half * 2);
+  return `${text.slice(0, half)}\n\n[... ${omitted} patch characters omitted ...]\n\n${text.slice(-half)}`;
+}
+
+async function runGit(cwd: string, args: string[], signal?: AbortSignal): Promise<string> {
+  const result = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_OUTPUT_LIMIT,
+    signal,
+  });
+  return result.stdout;
+}
+
+async function readUntrackedPreviews(
+  root: string,
+  files: DirtyFileState[],
+): Promise<string> {
+  const sections: string[] = [];
+  let remaining = DIRTY_PATCH_CHARS;
+  for (const file of files) {
+    if (file.status !== "??" || isSensitivePath(file.path) || isGeneratedOrLockfile(file.path) || remaining <= 0) continue;
+    const absolute = path.resolve(root, file.path);
+    const relative = path.relative(root, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) continue;
+    try {
+      const metadata = await stat(absolute);
+      if (!metadata.isFile()) continue;
+      const buffer = await readFile(absolute);
+      const header = `\n--- /dev/null\n+++ b/${file.path}\n`;
+      if (buffer.includes(0)) {
+        const binary = `${header}[binary untracked file: ${buffer.length} bytes]\n`;
+        sections.push(binary.slice(0, remaining));
+        remaining -= binary.length;
+        continue;
+      }
+      const text = buffer.toString("utf8");
+      const limit = Math.min(UNTRACKED_FILE_CHARS, remaining);
+      const preview = text.length <= limit
+        ? text
+        : `${text.slice(0, Math.floor(limit / 2))}\n[... untracked content truncated ...]\n${text.slice(-Math.floor(limit / 2))}`;
+      const section = `${header}${preview}\n`;
+      sections.push(section.slice(0, remaining));
+      remaining -= section.length;
+    } catch {
+      // A file can disappear between status and snapshot; its status remains useful.
+    }
+  }
+  return sections.join("");
+}
+
+export async function getGitEngineeringState(cwd?: string, signal?: AbortSignal): Promise<GitEngineeringState> {
+  if (!cwd) return { available: false, files: [], patch: "", sensitiveFilesOmitted: 0, lockfilesAndGeneratedAssets: [] };
+  try {
+    const root = (await runGit(cwd, ["rev-parse", "--show-toplevel"], signal)).trim();
+    const status = await runGit(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all"], signal);
+    const allFiles = parseGitStatusPorcelainV1Z(status);
+    const sensitiveFilesOmitted = allFiles.filter((file) => isSensitivePath(file.path)).length;
+    const files = allFiles.filter((file) => !isSensitivePath(file.path));
+
+    const codeFiles = files.filter((file) => !isGeneratedOrLockfile(file.path));
+    const lockOrGeneratedFiles = files.filter((file) => isGeneratedOrLockfile(file.path)).map((file) => file.path);
+
+    const trackedCodePaths = codeFiles.filter((file) => file.status !== "??").map((file) => file.path).slice(0, 250);
+    const stagedArgs = ["diff", "--cached", "--no-ext-diff", "--no-color", "--unified=2"];
+    const unstagedArgs = ["diff", "--no-ext-diff", "--no-color", "--unified=2"];
+    if (trackedCodePaths.length > 0) {
+      stagedArgs.push("--", ...trackedCodePaths);
+      unstagedArgs.push("--", ...trackedCodePaths);
+    } else {
+      // An unmatched pathspec avoids reading unrelated or sensitive tracked diffs.
+      stagedArgs.push("--", ":(exclude,top)**");
+      unstagedArgs.push("--", ":(exclude,top)**");
+    }
+    const [staged, unstaged, untracked] = await Promise.all([
+      runGit(root, stagedArgs, signal),
+      runGit(root, unstagedArgs, signal),
+      readUntrackedPreviews(root, codeFiles),
+    ]);
+    const sections = [
+      staged ? `## Staged changes\n${staged}` : "",
+      unstaged ? `## Unstaged changes\n${unstaged}` : "",
+      untracked ? `## Untracked files${untracked}` : "",
+    ].filter(Boolean);
+    return {
+      available: true,
+      files,
+      patch: truncatePatch(redactLikelySecrets(sections.join("\n\n"))),
+      sensitiveFilesOmitted,
+      lockfilesAndGeneratedAssets: lockOrGeneratedFiles,
+    };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return { available: false, files: [], patch: "", sensitiveFilesOmitted: 0, lockfilesAndGeneratedAssets: [] };
+  }
 }
 
 const REQUIRED_SECTION_PATTERNS = [
@@ -94,11 +295,8 @@ const REQUIRED_SECTION_PATTERNS = [
 ];
 
 export function validateSummaryOutput(response: AssistantMessage): string {
-  if (response.stopReason === "length") {
-    throw new Error("Compaction summary was truncated due to output length limit (stopReason=length).");
-  }
-  if (response.stopReason === "error") {
-    throw new Error("Compaction model reported stopReason=error.");
+  if (response.stopReason !== "stop") {
+    throw new Error(`Compaction model did not complete successfully (stopReason="${response.stopReason}").`);
   }
 
   // Reject accidental tool calls
@@ -136,15 +334,72 @@ export function computeCompactionTokenCeiling(
     ? config.maxSummaryTokens
     : 8192;
 
-  const reserveDerived = Math.max(4096, Math.floor(0.8 * reserveTokens));
+  if (!Number.isFinite(reserveTokens) || reserveTokens <= 0) {
+    throw new Error(`Compaction reserveTokens must be positive; received ${reserveTokens}.`);
+  }
+  const reserveDerived = Math.max(1, Math.floor(0.8 * reserveTokens));
   const modelLimit = model.maxTokens > 0 ? model.maxTokens : configuredMax;
 
   return Math.min(configuredMax, reserveDerived, modelLimit);
 }
 
+function errorStatus(err: unknown): number | undefined {
+  if (!err || typeof err !== "object") return undefined;
+  for (const key of ["status", "statusCode", "httpStatus"]) {
+    const value = (err as Record<string, unknown>)[key];
+    if (typeof value === "number") return value;
+  }
+  return undefined;
+}
+
+export function isFatalCompactionError(err: unknown): boolean {
+  if (!err) return false;
+  const status = errorStatus(err);
+  if (status === 401 || status === 402 || status === 403) return true;
+  const name = err instanceof Error ? err.name.toLowerCase() : "";
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return (
+    name === "aborterror" ||
+    msg.includes("cancelled") ||
+    msg.includes("canceled") ||
+    msg.includes("unauthorized") ||
+    msg.includes("invalid_api_key") ||
+    msg.includes("authentication failed") ||
+    msg.includes("forbidden") ||
+    msg.includes("insufficient_quota") ||
+    msg.includes("billing exhausted") ||
+    msg.includes("payment required")
+  );
+}
+
+export function combineCompactionUsage(first?: Usage, second?: Usage): Usage | undefined {
+  if (!first) return second;
+  if (!second) return first;
+  return {
+    input: first.input + second.input,
+    output: first.output + second.output,
+    cacheRead: first.cacheRead + second.cacheRead,
+    cacheWrite: first.cacheWrite + second.cacheWrite,
+    ...(first.cacheWrite1h !== undefined || second.cacheWrite1h !== undefined
+      ? { cacheWrite1h: (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) }
+      : {}),
+    ...(first.reasoning !== undefined || second.reasoning !== undefined
+      ? { reasoning: (first.reasoning ?? 0) + (second.reasoning ?? 0) }
+      : {}),
+    totalTokens: first.totalTokens + second.totalTokens,
+    cost: {
+      input: first.cost.input + second.cost.input,
+      output: first.cost.output + second.cost.output,
+      cacheRead: first.cost.cacheRead + second.cost.cacheRead,
+      cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
+      total: first.cost.total + second.cost.total,
+    },
+  };
+}
+
 export interface RunSmartCompactionOptions {
   event: SessionBeforeCompactEvent;
-  ctx: Pick<ExtensionContext, "model" | "modelRegistry" | "thinkingLevel">;
+  ctx: Pick<ExtensionContext, "model" | "modelRegistry" | "thinkingLevel" | "cwd">;
   config: SmartCompactionConfig;
 }
 
@@ -196,10 +451,6 @@ export async function runSmartCompaction(
     ],
   };
 
-  // Multi-Stage Retry Ladder:
-  // Stage 1: Primary configured model with requested reasoning
-  // Stage 2: Primary configured model with reasoning OFF
-  // Stage 3: Session model with reasoning OFF (if different)
   type AttemptPlan = {
     model: Model<Api>;
     reasoning?: "off" | "low" | "medium" | "high" | "max";
@@ -211,22 +462,27 @@ export async function runSmartCompaction(
     ? ctx.thinkingLevel
     : config.thinkingLevel;
 
+  const primaryReasoning = primaryModel.reasoning && desiredThinking && desiredThinking !== "off"
+    ? (desiredThinking as AttemptPlan["reasoning"])
+    : undefined;
   const plans: AttemptPlan[] = [
     {
       model: primaryModel,
-      reasoning: primaryModel.reasoning && desiredThinking && desiredThinking !== "off" ? (desiredThinking as any) : undefined,
+      reasoning: primaryReasoning,
       isInherited: primaryIsInherited,
-      stageLabel: "primary model with reasoning",
+      stageLabel: primaryReasoning ? "primary model with reasoning" : "primary model",
     },
-    {
+  ];
+  if (primaryReasoning) {
+    plans.push({
       model: primaryModel,
       reasoning: "off",
       isInherited: primaryIsInherited,
       stageLabel: "primary model without reasoning",
-    },
-  ];
+    });
+  }
 
-  if (sessionModel && sessionModel.id !== primaryModel.id) {
+  if (sessionModel && modelKey(sessionModel) !== modelKey(primaryModel)) {
     plans.push({
       model: sessionModel,
       reasoning: "off",
@@ -237,7 +493,7 @@ export async function runSmartCompaction(
 
   let lastError: Error | undefined;
   let finalSummaryText = "";
-  let finalUsage: Usage | undefined;
+  let accumulatedUsage: Usage | undefined;
   let activeModel = primaryModel;
   let activeIsInherited = primaryIsInherited;
 
@@ -263,12 +519,17 @@ export async function runSmartCompaction(
     try {
       const response = await ctx.modelRegistry.complete(plan.model, context, completeOptions as any);
       signal?.throwIfAborted();
+      if (response.usage) {
+        accumulatedUsage = combineCompactionUsage(accumulatedUsage, response.usage);
+      }
       finalSummaryText = validateSummaryOutput(response);
-      finalUsage = response.usage;
       lastError = undefined;
       break; // Success!
     } catch (err) {
       if (signal?.aborted) throw err;
+      if (isFatalCompactionError(err)) {
+        throw err instanceof Error ? err : new Error(String(err));
+      }
       lastError = err instanceof Error ? err : new Error(String(err));
       // Continue to next stage in retry ladder
     }
@@ -283,34 +544,57 @@ export async function runSmartCompaction(
   const currentOps = preparation.fileOps;
 
   const combinedModified = new Set([
-    ...prior.modifiedFiles,
+    ...prior.touchedModifiedFiles,
     ...(currentOps?.written ?? []),
     ...(currentOps?.edited ?? []),
   ]);
 
   const combinedRead = new Set([
-    ...prior.readFiles,
+    ...prior.touchedReadFiles,
     ...(currentOps?.read ?? []),
   ]);
 
-  const readFilesList = [...combinedRead].filter((f) => !combinedModified.has(f)).sort();
-  const modifiedFilesList = [...combinedModified].sort();
+  const allReadFiles = [...combinedRead].filter((file) => !combinedModified.has(file));
+  const allTouchedModifiedFiles = [...combinedModified];
+  const sensitiveTouchedFilesOmitted = new Set(
+    [...allReadFiles, ...allTouchedModifiedFiles].filter(isSensitivePath),
+  ).size;
+  const readFilesList = allReadFiles.filter((file) => !isSensitivePath(file)).sort();
+  const touchedModifiedFilesList = allTouchedModifiedFiles.filter((file) => !isSensitivePath(file)).sort();
+  const gitState = await getGitEngineeringState(ctx.cwd, signal);
+  const activeDirtyFilesList = gitState.files.map((file) => file.path);
+  const activeBackgroundProcesses = getActiveBackgroundProcesses();
 
   const fileOpsXml = formatFileOperationsXml({
-    read: readFilesList,
-    written: modifiedFilesList,
+    readFiles: readFilesList,
+    touchedModifiedFiles: touchedModifiedFilesList,
+    activeDirtyFiles: activeDirtyFilesList,
+    dirtyPatch: gitState.patch,
+    dirtyStateAvailable: gitState.available,
+    sensitiveFilesOmitted: gitState.sensitiveFilesOmitted + sensitiveTouchedFilesOmitted,
+    activeBackgroundProcesses,
+    lockfilesAndGeneratedAssets: gitState.lockfilesAndGeneratedAssets,
   });
 
   const finalSummary = `${finalSummaryText}${fileOpsXml}`;
   const cycleCount = prior.cycleCount + 1;
 
   const details: SmartCompactionDetails = {
-    schemaVersion: 2,
+    schemaVersion: 3,
     customCompactor: "smart-compaction",
-    model: `${activeModel.provider}/${activeModel.id}`,
+    configuredModel: config.model || "inherit",
+    resolvedModel: modelKey(activeModel),
     isInherited: activeIsInherited,
-    readFiles: readFilesList,
-    modifiedFiles: modifiedFilesList,
+    touchedReadFiles: readFilesList,
+    touchedModifiedFiles: touchedModifiedFilesList,
+    activeDirtyFiles: activeDirtyFilesList,
+    activeDirtyFileStates: gitState.files,
+    activeDirtyPatch: gitState.patch,
+    dirtyStateAvailable: gitState.available,
+    sensitiveDirtyFilesOmitted: gitState.sensitiveFilesOmitted,
+    sensitiveTouchedFilesOmitted,
+    activeBackgroundProcesses: activeBackgroundProcesses.length > 0 ? activeBackgroundProcesses : undefined,
+    lockfilesAndGeneratedAssets: gitState.lockfilesAndGeneratedAssets.length > 0 ? gitState.lockfilesAndGeneratedAssets : undefined,
     cycleCount,
     timestamp: Date.now(),
   };
@@ -319,7 +603,7 @@ export async function runSmartCompaction(
     summary: finalSummary,
     firstKeptEntryId: preparation.firstKeptEntryId,
     tokensBefore: preparation.tokensBefore,
-    usage: finalUsage,
+    usage: accumulatedUsage,
     details,
   };
 }

package/extensions/smart-compaction/index.ts

@@ -10,7 +10,7 @@ import {
   saveSmartCompactionConfig,
   type SmartCompactionConfig,
 } from "./config.ts";
-import { runSmartCompaction } from "./engine.ts";
+import { resolveCompactionModel, runSmartCompaction } from "./engine.ts";
 
 const STATUS_KEY = "smart-compaction";
 
@@ -64,7 +64,7 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
       if (event.fromExtension) {
         const details = event.compactionEntry.details as Record<string, unknown> | undefined;
         if (details?.customCompactor === "smart-compaction") {
-          const model = String(details.model ?? "session model");
+          const model = String(details.resolvedModel ?? details.model ?? "session model");
           ctx.ui?.notify(`Smart Compaction completed (${model})`, "info");
         }
       }
@@ -85,17 +85,21 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
             return;
           }
 
-          // Validate if model exists in registry
+          // Strict validation against available models in registry
           const available = cmdCtx.modelRegistry.getAvailable();
           const match = available.find(
             (m) => m.id === requested || `${m.provider}/${m.id}` === requested,
           );
 
           if (!match) {
-            cmdCtx.ui.notify(`Model "${requested}" not found in available models. Setting anyway.`, "warning");
+            cmdCtx.ui.notify(
+              `Model "${requested}" not found in available models. Run /compaction-model without arguments to select from active providers.`,
+              "error",
+            );
+            return;
           }
 
-          config.model = match ? `${match.provider}/${match.id}` : requested;
+          config.model = `${match.provider}/${match.id}`;
           saveSmartCompactionConfig(config, options.configFile);
           updateStatus();
           cmdCtx.ui.notify(`Compaction model set to: ${config.model}`, "info");
@@ -154,29 +158,29 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
           cmdCtx.ui.notify("Smart Compaction disabled (using default compactor).", "info");
           return;
         }
-        if (sub.startsWith("model ")) {
-          const target = args.trim().slice(6).trim();
-          config.model = target || "inherit";
-          saveSmartCompactionConfig(config, options.configFile);
-          updateStatus();
-          cmdCtx.ui.notify(`Smart Compaction model set to: ${config.model}`, "info");
-          return;
+
+        let resolvedInfo = "inherit";
+        try {
+          const { model, isFallback, fallbackReason } = resolveCompactionModel(cmdCtx, config.model);
+          resolvedInfo = `${model.provider}/${model.id}`;
+          if (isFallback) {
+            resolvedInfo += ` (FALLBACK: ${fallbackReason})`;
+          }
+        } catch {
+          resolvedInfo = "unresolved";
         }
 
-        // Default status
-        const currentModelDesc = config.model === "inherit"
-          ? `inherit (${cmdCtx.model ? `${cmdCtx.model.provider}/${cmdCtx.model.id}` : "active session model"})`
-          : config.model;
         const currentThinkingDesc = config.thinkingLevel === "inherit"
           ? `inherit (${cmdCtx.thinkingLevel ?? "session default"})`
           : (config.thinkingLevel ?? "inherit");
-        const maxTokensDesc = config.maxSummaryTokens ? `${config.maxSummaryTokens}` : "unlimited (full model output capacity)";
+        const maxTokensDesc = `${config.maxSummaryTokens ?? 8192} tokens`;
 
         const status = [
           `Smart Compaction: ${config.enabled ? "ENABLED" : "DISABLED"}`,
-          `Model: ${currentModelDesc}`,
+          `Configured Model: ${config.model}`,
+          `Resolved Model: ${resolvedInfo}`,
           `Thinking Level: ${currentThinkingDesc}`,
-          `Max Output Tokens: ${maxTokensDesc}`,
+          `Summary Token Ceiling: ${maxTokensDesc}`,
           "",
           "Commands:",
           "  /smart-compaction enable | disable",

package/extensions/smart-compaction/prompt.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { isSensitivePath, redactLikelySecrets } from "../shared/redaction.ts";
 
 export const SMART_COMPACTION_SYSTEM_PROMPT = `You are a high-fidelity context continuity synthesizer for an autonomous coding agent.
 Your task is to analyze the preceding conversation and produce a comprehensive, structured checkpoint summary.
@@ -93,7 +94,6 @@ Use this EXACT format with all 6 numbered section headings:
 
 const TOOL_RESULT_HEAD_CHARS = 1200;
 const TOOL_RESULT_TAIL_CHARS = 1200;
-const TOOL_RESULT_TOTAL_BUDGET = TOOL_RESULT_HEAD_CHARS + TOOL_RESULT_TAIL_CHARS;
 
 export function truncateHeadAndTail(text: string, headChars = TOOL_RESULT_HEAD_CHARS, tailChars = TOOL_RESULT_TAIL_CHARS): string {
   const maxTotal = headChars + tailChars;
@@ -105,6 +105,15 @@ export function truncateHeadAndTail(text: string, headChars = TOOL_RESULT_HEAD_C
   return `${head}\n\n[... ${omitted} characters omitted; showing beginning and end of output ...]\n\n${tail}`;
 }
 
+export function escapeXml(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
 export function sanitizeTagContent(text: string): string {
   return text
     .replace(/<\/conversation>/gi, "<\\/conversation>")
@@ -137,11 +146,13 @@ function extractTextContent(content: unknown): string {
 
 export function serializeConversationForCompaction(messages: AgentMessage[]): string {
   const parts: string[] = [];
+  const sensitiveToolCallIds = new Set<string>();
+  const safeTranscriptText = (text: string) => sanitizeTagContent(redactLikelySecrets(text));
 
   for (const msg of messages) {
     if (msg.role === "user") {
       const text = extractTextContent((msg as any).content);
-      if (text) parts.push(`[User]:\n${sanitizeTagContent(text)}`);
+      if (text) parts.push(`[User]:\n${safeTranscriptText(text)}`);
     } else if (msg.role === "assistant") {
       const content = (msg as any).content;
       const thinkingBlocks: string[] = [];
@@ -157,8 +168,17 @@ export function serializeConversationForCompaction(messages: AgentMessage[]): st
             textBlocks.push(block.text.trim());
           } else if (block.type === "toolCall") {
             const args = block.arguments as Record<string, unknown>;
+            const targetPath = typeof args?.path === "string" ? args.path : "";
+            const sensitive = ["read", "write", "edit"].includes(block.name)
+              && targetPath
+              && isSensitivePath(targetPath);
+            if (sensitive) {
+              if (typeof block.id === "string") sensitiveToolCallIds.add(block.id);
+              toolCallBlocks.push(`${block.name}([sensitive path and arguments omitted])`);
+              continue;
+            }
             const formattedArgs = Object.entries(args ?? {})
-              .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+              .map(([k, v]) => `${k}=${redactLikelySecrets(JSON.stringify(v))}`)
               .join(", ");
             toolCallBlocks.push(`${block.name}(${formattedArgs})`);
           }
@@ -169,49 +189,88 @@ export function serializeConversationForCompaction(messages: AgentMessage[]): st
 
       if (thinkingBlocks.length > 0) {
         const combinedThinking = thinkingBlocks.join("\n");
-        parts.push(`[Assistant Thinking]:\n${sanitizeTagContent(truncateHeadAndTail(combinedThinking, 800, 800))}`);
+        parts.push(`[Assistant Thinking]:\n${safeTranscriptText(truncateHeadAndTail(combinedThinking, 800, 800))}`);
       }
       if (textBlocks.length > 0) {
-        parts.push(`[Assistant]:\n${sanitizeTagContent(textBlocks.join("\n"))}`);
+        parts.push(`[Assistant]:\n${safeTranscriptText(textBlocks.join("\n"))}`);
       }
       if (toolCallBlocks.length > 0) {
-        parts.push(`[Assistant Tool Calls]:\n${sanitizeTagContent(toolCallBlocks.join("\n"))}`);
+        parts.push(`[Assistant Tool Calls]:\n${safeTranscriptText(toolCallBlocks.join("\n"))}`);
       }
     } else if (msg.role === "toolResult") {
+      if (sensitiveToolCallIds.has((msg as any).toolCallId)) {
+        parts.push("[Tool Result]:\n[sensitive tool result omitted]");
+        continue;
+      }
       const text = extractTextContent((msg as any).content);
       if (text) {
-        parts.push(`[Tool Result]:\n${sanitizeTagContent(truncateHeadAndTail(text, TOOL_RESULT_HEAD_CHARS, TOOL_RESULT_TAIL_CHARS))}`);
+        parts.push(`[Tool Result]:\n${safeTranscriptText(truncateHeadAndTail(text, TOOL_RESULT_HEAD_CHARS, TOOL_RESULT_TAIL_CHARS))}`);
       }
     } else if (msg.role === "custom") {
       const text = extractTextContent((msg as any).content);
-      if (text) parts.push(`[System Event]:\n${sanitizeTagContent(text)}`);
+      if (text) parts.push(`[System Event]:\n${safeTranscriptText(text)}`);
     } else if (msg.role === "bashExecution") {
       const cmd = (msg as any).command ?? "";
       const out = (msg as any).output ?? "";
-      parts.push(`[Command Executed]:\n$ ${cmd}\n${sanitizeTagContent(truncateHeadAndTail(out, 800, 800))}`);
+      parts.push(`[Command Executed]:\n$ ${safeTranscriptText(cmd)}\n${safeTranscriptText(truncateHeadAndTail(out, 800, 800))}`);
     } else if (msg.role === "compactionSummary" || msg.role === "branchSummary") {
       const summary = (msg as any).summary ?? "";
-      if (summary) parts.push(`[Prior Summary]:\n${sanitizeTagContent(summary)}`);
+      if (summary) parts.push(`[Prior Summary]:\n${safeTranscriptText(summary)}`);
     }
   }
 
   return parts.join("\n\n---\n\n");
 }
 
-export function formatFileOperationsXml(fileOps?: { read?: Iterable<string>; written?: Iterable<string>; edited?: Iterable<string> }): string {
-  if (!fileOps) return "";
-  const readSet = new Set(fileOps.read ?? []);
-  const modifiedSet = new Set([...(fileOps.written ?? []), ...(fileOps.edited ?? [])]);
-  const readOnly = [...readSet].filter((f) => !modifiedSet.has(f)).sort();
-  const modified = [...modifiedSet].sort();
+export function formatFileOperationsXml(options?: {
+  readFiles?: Iterable<string>;
+  touchedModifiedFiles?: Iterable<string>;
+  activeDirtyFiles?: Iterable<string>;
+  dirtyPatch?: string;
+  dirtyStateAvailable?: boolean;
+  sensitiveFilesOmitted?: number;
+  activeBackgroundProcesses?: Iterable<string>;
+  lockfilesAndGeneratedAssets?: Iterable<string>;
+}): string {
+  if (!options) return "";
+  const readSet = new Set(options.readFiles ?? []);
+  const touchedSet = new Set(options.touchedModifiedFiles ?? []);
+  const dirtySet = new Set(options.activeDirtyFiles ?? []);
+  const backgroundSet = new Set(options.activeBackgroundProcesses ?? []);
+  const lockfilesSet = new Set(options.lockfilesAndGeneratedAssets ?? []);
+
+  const readOnly = [...readSet].filter((f) => !touchedSet.has(f)).sort();
+  const touched = [...touchedSet].sort();
+  const dirty = [...dirtySet].sort();
+  const background = [...backgroundSet].sort();
+  const lockfiles = [...lockfilesSet].sort();
 
   const sections: string[] = [];
   if (readOnly.length > 0) {
-    sections.push(`<read-files>\n${readOnly.join("\n")}\n</read-files>`);
+    sections.push(`<read-files>\n${readOnly.map(escapeXml).join("\n")}\n</read-files>`);
+  }
+  if (touched.length > 0) {
+    sections.push(`<touched-files>\n${touched.map(escapeXml).join("\n")}\n</touched-files>`);
+  }
+  if (dirty.length > 0) {
+    sections.push(`<uncommitted-dirty-files>\n${dirty.map(escapeXml).join("\n")}\n</uncommitted-dirty-files>`);
   }
-  if (modified.length > 0) {
-    sections.push(`<modified-files>\n${modified.join("\n")}\n</modified-files>`);
+  if (lockfiles.length > 0) {
+    sections.push(`<modified-lockfiles-and-assets>\n${lockfiles.map(escapeXml).join("\n")}\n</modified-lockfiles-and-assets>`);
   }
+  if (background.length > 0) {
+    sections.push(`<active-background-processes>\n${background.map(escapeXml).join("\n")}\n</active-background-processes>`);
+  }
+  if (options.dirtyPatch) {
+    sections.push(`<uncommitted-diff>\n${escapeXml(options.dirtyPatch)}\n</uncommitted-diff>`);
+  }
+  if (options.dirtyStateAvailable === false) {
+    sections.push("<uncommitted-state-unavailable />");
+  }
+  if ((options.sensitiveFilesOmitted ?? 0) > 0) {
+    sections.push(`<sensitive-dirty-files-omitted count="${options.sensitiveFilesOmitted}" />`);
+  }
+
   if (sections.length === 0) return "";
   return `\n\n${sections.join("\n\n")}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shariq-pi-extensions",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Cross-platform extension suite for the Pi coding agent.",
   "license": "MIT",
   "author": "Shariq Riaz",