shariq-pi-extensions 0.2.15 → 0.2.16

package/docs/EXTENSIONS.md

@@ -53,6 +53,8 @@ Replaces standard context compaction with a defensive, high-fidelity continuity
 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.

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/smart-compaction/README.md

@@ -18,11 +18,13 @@ When long-running agent sessions reach context thresholds, standard compaction f
 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 Engineering Ledger** — Programmatic `<read-files>`, `<touched-files>`, `<uncommitted-dirty-files>`, and bounded `<uncommitted-diff>` blocks. Historical touch state, current NUL-delimited porcelain status, and redacted patch data are persisted in versioned compaction details; sensitive paths are omitted.
+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**: 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).

package/extensions/smart-compaction/engine.ts

@@ -25,6 +25,7 @@ export interface GitEngineeringState {
   files: DirtyFileState[];
   patch: string;
   sensitiveFilesOmitted: number;
+  lockfilesAndGeneratedAssets: string[];
 }
 
 export interface SmartCompactionDetails {
@@ -41,6 +42,8 @@ export interface SmartCompactionDetails {
   dirtyStateAvailable: boolean;
   sensitiveDirtyFilesOmitted: number;
   sensitiveTouchedFilesOmitted: number;
+  activeBackgroundProcesses?: string[];
+  lockfilesAndGeneratedAssets?: string[];
   cycleCount: number;
   timestamp: number;
 }
@@ -124,6 +127,42 @@ export function extractPriorFileState(branchEntries?: any[]): {
   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;
@@ -170,7 +209,7 @@ async function readUntrackedPreviews(
   const sections: string[] = [];
   let remaining = DIRTY_PATCH_CHARS;
   for (const file of files) {
-    if (file.status !== "??" || isSensitivePath(file.path) || remaining <= 0) continue;
+    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;
@@ -201,19 +240,23 @@ async function readUntrackedPreviews(
 }
 
 export async function getGitEngineeringState(cwd?: string, signal?: AbortSignal): Promise<GitEngineeringState> {
-  if (!cwd) return { available: false, files: [], patch: "", sensitiveFilesOmitted: 0 };
+  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 trackedPaths = files.filter((file) => file.status !== "??").map((file) => file.path).slice(0, 250);
+
+    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 (trackedPaths.length > 0) {
-      stagedArgs.push("--", ...trackedPaths);
-      unstagedArgs.push("--", ...trackedPaths);
+    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)**");
@@ -222,7 +265,7 @@ export async function getGitEngineeringState(cwd?: string, signal?: AbortSignal)
     const [staged, unstaged, untracked] = await Promise.all([
       runGit(root, stagedArgs, signal),
       runGit(root, unstagedArgs, signal),
-      readUntrackedPreviews(root, files),
+      readUntrackedPreviews(root, codeFiles),
     ]);
     const sections = [
       staged ? `## Staged changes\n${staged}` : "",
@@ -234,10 +277,11 @@ export async function getGitEngineeringState(cwd?: string, signal?: AbortSignal)
       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 };
+    return { available: false, files: [], patch: "", sensitiveFilesOmitted: 0, lockfilesAndGeneratedAssets: [] };
   }
 }
 
@@ -519,6 +563,7 @@ export async function runSmartCompaction(
   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({
     readFiles: readFilesList,
@@ -527,6 +572,8 @@ export async function runSmartCompaction(
     dirtyPatch: gitState.patch,
     dirtyStateAvailable: gitState.available,
     sensitiveFilesOmitted: gitState.sensitiveFilesOmitted + sensitiveTouchedFilesOmitted,
+    activeBackgroundProcesses,
+    lockfilesAndGeneratedAssets: gitState.lockfilesAndGeneratedAssets,
   });
 
   const finalSummary = `${finalSummaryText}${fileOpsXml}`;
@@ -546,6 +593,8 @@ export async function runSmartCompaction(
     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(),
   };

package/extensions/smart-compaction/prompt.ts

@@ -229,15 +229,21 @@ export function formatFileOperationsXml(options?: {
   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) {
@@ -249,6 +255,12 @@ export function formatFileOperationsXml(options?: {
   if (dirty.length > 0) {
     sections.push(`<uncommitted-dirty-files>\n${dirty.map(escapeXml).join("\n")}\n</uncommitted-dirty-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>`);
   }

package/package.json

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