gsd-pi 2.37.1-dev.d3ace49 → 2.38.0-dev.63ad7e5

package/src/resources/extensions/gsd/tests/worktree.test.ts

@@ -11,6 +11,7 @@ import {
   getMainBranch,
   getSliceBranchName,
   parseSliceBranch,
+  resolveProjectRoot,
   setActiveMilestoneId,
   SLICE_BRANCH_RE,
 } from "../worktree.ts";
@@ -165,6 +166,52 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ── detectWorktreeName: symlink-resolved paths ───────────────────────────
+  console.log("\n=== detectWorktreeName (symlink-resolved paths) ===");
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
+    "M001",
+    "detects milestone in symlink-resolved path",
+  );
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/abc123/worktrees/M002/subdir"),
+    "M002",
+    "detects milestone with trailing subdir in symlink-resolved path",
+  );
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/abc123"),
+    null,
+    "returns null for project root without worktrees segment",
+  );
+  assertEq(
+    detectWorktreeName("/foo/.gsd/worktrees/M001"),
+    "M001",
+    "still detects direct layout path",
+  );
+
+  // ── resolveProjectRoot: symlink-resolved paths ──────────────────────────
+  console.log("\n=== resolveProjectRoot (symlink-resolved paths) ===");
+  assertEq(
+    resolveProjectRoot("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
+    "/Users/fran",
+    "resolves to user home for symlink-resolved path",
+  );
+  assertEq(
+    resolveProjectRoot("/foo/.gsd/worktrees/M001"),
+    "/foo",
+    "still resolves direct layout path",
+  );
+  assertEq(
+    resolveProjectRoot("/some/repo"),
+    "/some/repo",
+    "returns unchanged for non-worktree path",
+  );
+  assertEq(
+    resolveProjectRoot("/data/.gsd/projects/deadbeef/worktrees/M003/nested"),
+    "/data",
+    "resolves correctly with nested subdirs after worktree name",
+  );
+
   rmSync(base, { recursive: true, force: true });
   report();
 }

package/src/resources/extensions/gsd/types.ts

@@ -423,7 +423,6 @@ export interface Requirement {
 
 // ─── Parallel Orchestration Types ────────────────────────────────────────
 
-export type CompressionStrategy = "truncate" | "compress";
 export type ContextSelectionMode = "full" | "smart";
 
 export type MergeStrategy = "per-slice" | "per-milestone";

package/src/resources/extensions/gsd/visualizer-data.ts

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { deriveState } from './state.js';
 import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
-import { findMilestoneIds } from './guided-flow.js';
+import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile } from './paths.js';
 import {
   getLedger,

package/src/resources/extensions/gsd/worktree.ts

@@ -67,40 +67,60 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string,
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
 
+/**
+ * Find the worktrees segment in a path, supporting both direct
+ * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
+ * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
+ * paths contain the intermediate `projects/<hash>/` segment that the old
+ * single-marker check missed.
+ */
+function findWorktreeSegment(normalizedPath: string): { gsdIdx: number; afterWorktrees: number } | null {
+  // Direct layout: /.gsd/worktrees/<name>
+  const directMarker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(directMarker);
+  if (idx !== -1) {
+    return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
+  }
+  // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
+  const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
+  const match = normalizedPath.match(symlinkRe);
+  if (match && match.index !== undefined) {
+    return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
+  }
+  return null;
+}
+
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath: string): string | null {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return null;
-  const afterMarker = normalizedPath.slice(idx + marker.length);
+  const seg = findWorktreeSegment(normalizedPath);
+  if (!seg) return null;
+  const afterMarker = normalizedPath.slice(seg.afterWorktrees);
   const name = afterMarker.split("/")[0];
   return name || null;
 }
 
 /**
  * Resolve the project root from a path that may be inside a worktree.
- * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
- * before `/.gsd/`. Otherwise returns the input unchanged.
+ * If the path contains a worktrees segment, returns the portion before
+ * `/.gsd/`. Otherwise returns the input unchanged.
  *
  * Use this in commands that call `process.cwd()` to ensure they always
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath: string): string {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return basePath;
-  // Return the original path up to the .gsd/ marker (un-normalized)
-  // Account for potential OS-specific separators
+  const seg = findWorktreeSegment(normalizedPath);
+  if (!seg) return basePath;
+  // Return the original path up to the /.gsd/ boundary
   const sep = basePath.includes("\\") ? "\\" : "/";
-  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
-  const idxOs = basePath.indexOf(markerOs);
-  if (idxOs !== -1) return basePath.slice(0, idxOs);
-  return basePath.slice(0, idx);
+  const gsdMarker = `${sep}.gsd${sep}`;
+  const gsdIdx = basePath.indexOf(gsdMarker);
+  if (gsdIdx !== -1) return basePath.slice(0, gsdIdx);
+  return basePath.slice(0, seg.gsdIdx);
 }
 
 /**

package/src/resources/extensions/remote-questions/status.ts

@@ -7,6 +7,8 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { readPromptRecord } from "./store.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 export interface LatestPromptSummary {
   id: string;
   status: string;
@@ -14,7 +16,7 @@ export interface LatestPromptSummary {
 }
 
 export function getLatestPromptSummary(): LatestPromptSummary | null {
-  const runtimeDir = join(homedir(), ".gsd", "runtime", "remote-questions");
+  const runtimeDir = join(gsdHome, "runtime", "remote-questions");
   if (!existsSync(runtimeDir)) return null;
   const files = readdirSync(runtimeDir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) return null;

package/src/resources/extensions/remote-questions/store.ts

@@ -7,8 +7,10 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 function runtimeDir(): string {
-  return join(homedir(), ".gsd", "runtime", "remote-questions");
+  return join(gsdHome, "runtime", "remote-questions");
 }
 
 function recordPath(id: string): string {

package/src/resources/extensions/search-the-web/provider.ts

@@ -17,7 +17,8 @@ import { resolveSearchProviderFromPreferences } from '../gsd/preferences.js'
 // Compute authFilePath locally instead of importing from app-paths.ts,
 // because extensions are copied to ~/.gsd/agent/extensions/ at runtime
 // where the relative import '../../../app-paths.ts' doesn't resolve.
-const authFilePath = join(homedir(), '.gsd', 'agent', 'auth.json')
+const gsdHome = process.env.GSD_HOME || join(homedir(), '.gsd')
+const authFilePath = join(gsdHome, 'agent', 'auth.json')
 
 export type SearchProvider = 'tavily' | 'brave' | 'ollama'
 export type SearchProviderPreference = SearchProvider | 'auto'

package/src/resources/extensions/subagent/index.ts

@@ -452,7 +452,7 @@ async function runSingleAgent(
 
 async function runSingleAgentInCmuxSplit(
 	cmuxClient: CmuxClient,
-	direction: "right" | "down",
+	directionOrSurfaceId: "right" | "down" | string,
 	defaultCwd: string,
 	agents: AgentConfig[],
 	agentName: string,
@@ -503,7 +503,12 @@ async function runSingleAgentInCmuxSplit(
 		const stdoutPath = path.join(tmpOutputDir, "stdout.jsonl");
 		const stderrPath = path.join(tmpOutputDir, "stderr.log");
 		const exitPath = path.join(tmpOutputDir, "exit.code");
-		const cmuxSurfaceId = await cmuxClient.createSplit(direction);
+		// Accept either a pre-created surface ID or a direction to create a new split
+		const isDirection = directionOrSurfaceId === "right" || directionOrSurfaceId === "down"
+			|| directionOrSurfaceId === "left" || directionOrSurfaceId === "up";
+		const cmuxSurfaceId = isDirection
+			? await cmuxClient.createSplit(directionOrSurfaceId as "right" | "down" | "left" | "up")
+			: directionOrSurfaceId;
 		if (!cmuxSurfaceId) {
 			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
 		}
@@ -806,12 +811,16 @@ export default function (pi: ExtensionAPI) {
 				const MAX_RETRIES = 1; // Retry failed tasks once
 				const batchId = crypto.randomUUID();
 				const batchSize = params.tasks.length;
+				// Pre-create a grid layout for cmux splits so agents get a clean tiled arrangement
+				const gridSurfaces = cmuxSplitsEnabled
+					? await cmuxClient.createGridLayout(Math.min(batchSize, MAX_CONCURRENCY))
+					: [];
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					const runTask = () => cmuxSplitsEnabled
 						? runSingleAgentInCmuxSplit(
 							cmuxClient,
-							index % 2 === 0 ? "right" : "down",
+							gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"),
 							ctx.cwd,
 							agents,
 							t.agent,

package/src/resources/extensions/subagent/isolation.ts

@@ -57,8 +57,10 @@ function encodeCwd(cwd: string): string {
 	return cwd.replace(/\//g, "--");
 }
 
+const gsdHome = process.env.GSD_HOME || path.join(os.homedir(), ".gsd");
+
 function getIsolationBaseDir(cwd: string, taskId: string): string {
-	return path.join(os.homedir(), ".gsd", "wt", encodeCwd(cwd), taskId);
+	return path.join(gsdHome, "wt", encodeCwd(cwd), taskId);
 }
 
 // Track active isolation dirs for cleanup on exit

package/src/resources/extensions/ttsr/rule-loader.ts

@@ -8,6 +8,8 @@
 import { readdirSync, readFileSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
+
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import type { Rule } from "./ttsr-manager.js";
 import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
 
@@ -59,7 +61,7 @@ function scanDir(dir: string): Rule[] {
  * Project rules override global rules with the same name.
  */
 export function loadRules(cwd: string): Rule[] {
-	const globalDir = join(homedir(), ".gsd", "agent", "rules");
+	const globalDir = join(gsdHome, "agent", "rules");
 	const projectDir = join(cwd, ".gsd", "rules");
 
 	const globalRules = scanDir(globalDir);

package/dist/resources/extensions/gsd/prompt-compressor.js

@@ -1,393 +0,0 @@
-/**
- * Prompt Compressor — deterministic text compression for context reduction.
- *
- * Applies a series of lossless and near-lossless transformations to reduce
- * token count while preserving semantic meaning. No LLM calls, no external
- * dependencies. Sub-millisecond for typical prompt sizes.
- *
- * Compression techniques (applied in order):
- * 1. Redundant whitespace normalization
- * 2. Markdown formatting reduction (collapse verbose tables, lists)
- * 3. Common phrase abbreviation
- * 4. Repeated pattern deduplication
- * 5. Low-information content removal (empty sections, boilerplate)
- */
-// ─── Phrase Abbreviation Map ────────────────────────────────────────────────
-/**
- * Build a regex that matches a verbose phrase even when split across lines.
- * Whitespace between words is matched with \s+ to handle line wrapping.
- */
-function phraseRegex(phrase) {
-    const words = phrase.split(/\s+/);
-    const pattern = `\\b${words.join("\\s+")}\\b`;
-    return new RegExp(pattern, "gi");
-}
-const VERBOSE_PHRASES = [
-    [phraseRegex("In order to"), "To"],
-    [phraseRegex("It is important to note that"), "Note:"],
-    [phraseRegex("As mentioned previously"), "(see above)"],
-    [phraseRegex("The following"), "These"],
-    [phraseRegex("In addition to"), "Also,"],
-    [phraseRegex("Due to the fact that"), "Because"],
-    [phraseRegex("At this point in time"), "Now"],
-    [phraseRegex("For the purpose of"), "For"],
-    [phraseRegex("In the event that"), "If"],
-    [phraseRegex("With regard to"), "Re:"],
-    [phraseRegex("Prior to"), "Before"],
-    [phraseRegex("Subsequent to"), "After"],
-    [phraseRegex("In accordance with"), "Per"],
-    [phraseRegex("A number of"), "Several"],
-    [phraseRegex("In the case of"), "For"],
-    [phraseRegex("On the basis of"), "Based on"],
-];
-function extractCodeBlocks(content) {
-    const blocks = new Map();
-    let counter = 0;
-    const text = content.replace(/```[\s\S]*?```/g, (match) => {
-        const placeholder = `\x00CODEBLOCK_${counter++}\x00`;
-        blocks.set(placeholder, match);
-        return placeholder;
-    });
-    return { text, blocks };
-}
-function restoreCodeBlocks(text, blocks) {
-    let result = text;
-    for (const [placeholder, block] of blocks) {
-        result = result.replace(placeholder, block);
-    }
-    return result;
-}
-// ─── Light Transformations ──────────────────────────────────────────────────
-function normalizeWhitespace(content) {
-    // Collapse 3+ consecutive blank lines to 2
-    let result = content.replace(/(\n\s*){3,}\n/g, "\n\n");
-    // Trim trailing whitespace on every line
-    result = result.replace(/[ \t]+$/gm, "");
-    return result;
-}
-function removeMarkdownComments(content) {
-    return content.replace(/<!--[\s\S]*?-->/g, "");
-}
-function removeHorizontalRules(content) {
-    // Remove horizontal rules (---, ***, ___) that stand alone on a line
-    return content.replace(/^\s*[-*_]{3,}\s*$/gm, "");
-}
-function collapseEmptyListItems(content) {
-    // Collapse repeated empty list items (- \n- \n- \n) into one
-    return content.replace(/(^[ \t]*[-*+]\s*$\n){2,}/gm, "$1");
-}
-function applyLightTransformations(content) {
-    let count = 0;
-    let result = content;
-    const after1 = normalizeWhitespace(result);
-    if (after1 !== result)
-        count++;
-    result = after1;
-    const after2 = removeMarkdownComments(result);
-    if (after2 !== result)
-        count++;
-    result = after2;
-    const after3 = removeHorizontalRules(result);
-    if (after3 !== result)
-        count++;
-    result = after3;
-    const after4 = collapseEmptyListItems(result);
-    if (after4 !== result)
-        count++;
-    result = after4;
-    return { content: result, count };
-}
-// ─── Moderate Transformations ───────────────────────────────────────────────
-function abbreviateVerbosePhrases(content) {
-    let count = 0;
-    let result = content;
-    for (const [pattern, replacement] of VERBOSE_PHRASES) {
-        const after = result.replace(pattern, replacement);
-        if (after !== result)
-            count++;
-        result = after;
-    }
-    return { content: result, count };
-}
-function removeBoilerplateLines(content) {
-    const lines = content.split("\n");
-    const filtered = lines.filter((line) => {
-        const trimmed = line.trim();
-        // Remove lines that are just N/A, (none), (empty), (not applicable)
-        if (/^(?:N\/A|\(none\)|\(empty\)|\(not applicable\))$/i.test(trimmed)) {
-            return false;
-        }
-        return true;
-    });
-    return filtered.join("\n");
-}
-function deduplicateConsecutiveLines(content) {
-    const lines = content.split("\n");
-    const result = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (i === 0 || lines[i] !== lines[i - 1] || lines[i].trim() === "") {
-            result.push(lines[i]);
-        }
-    }
-    return result.join("\n");
-}
-function collapseTableFormatting(content) {
-    // Remove excessive padding in markdown table cells
-    // Matches table rows like |  cell  |  cell  | and collapses to | cell | cell |
-    return content.replace(/\|[ \t]{2,}([^|\n]*?)[ \t]{2,}\|/g, (_, cellContent) => {
-        return `| ${cellContent.trim()} |`;
-    });
-}
-function applyModerateTransformations(content) {
-    let count = 0;
-    let result = content;
-    const phraseResult = abbreviateVerbosePhrases(result);
-    count += phraseResult.count;
-    result = phraseResult.content;
-    const after1 = removeBoilerplateLines(result);
-    if (after1 !== result)
-        count++;
-    result = after1;
-    const after2 = deduplicateConsecutiveLines(result);
-    if (after2 !== result)
-        count++;
-    result = after2;
-    const after3 = collapseTableFormatting(result);
-    if (after3 !== result)
-        count++;
-    result = after3;
-    return { content: result, count };
-}
-// ─── Aggressive Transformations ─────────────────────────────────────────────
-function removeMarkdownEmphasis(content) {
-    // Bold: **text** or __text__
-    let result = content.replace(/\*\*(.+?)\*\*/g, "$1");
-    result = result.replace(/__(.+?)__/g, "$1");
-    // Italic: *text* or _text_ (single, not inside words)
-    result = result.replace(/(?<!\w)\*([^*\n]+?)\*(?!\w)/g, "$1");
-    result = result.replace(/(?<!\w)_([^_\n]+?)_(?!\w)/g, "$1");
-    return result;
-}
-function removeMarkdownLinks(content) {
-    // [text](url) → text
-    return content.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-}
-function truncateLongLines(content) {
-    const lines = content.split("\n");
-    const result = lines.map((line) => {
-        if (line.length <= 300)
-            return line;
-        // Find a sentence boundary (. ! ?) near the 300 char mark
-        const truncateZone = line.slice(0, 300);
-        const lastSentenceEnd = Math.max(truncateZone.lastIndexOf(". "), truncateZone.lastIndexOf("! "), truncateZone.lastIndexOf("? "));
-        if (lastSentenceEnd > 150) {
-            return line.slice(0, lastSentenceEnd + 1);
-        }
-        // Fallback: cut at last space before 300
-        const lastSpace = truncateZone.lastIndexOf(" ");
-        if (lastSpace > 150) {
-            return line.slice(0, lastSpace);
-        }
-        return truncateZone;
-    });
-    return result.join("\n");
-}
-function removeBulletMarkers(content) {
-    // Remove bullet markers: - , * , + , numbered (1. 2. etc)
-    return content.replace(/^[ \t]*(?:[-*+]|\d+\.)\s+/gm, "");
-}
-function removeBlockquoteMarkers(content) {
-    return content.replace(/^[ \t]*>+\s?/gm, "");
-}
-function deduplicateStructuralPatterns(content) {
-    // Deduplicate consecutive lines that match the same "Key: value" pattern
-    const lines = content.split("\n");
-    const result = [];
-    const seen = new Set();
-    let lastWasStructural = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Detect structural patterns: "Key: value"
-        const structMatch = trimmed.match(/^(\w[\w\s]*?):\s+(.+)$/);
-        if (structMatch) {
-            if (seen.has(trimmed)) {
-                lastWasStructural = true;
-                continue;
-            }
-            seen.add(trimmed);
-            lastWasStructural = true;
-        }
-        else {
-            // Reset seen set when structural block ends
-            if (!lastWasStructural || trimmed === "") {
-                seen.clear();
-            }
-            lastWasStructural = false;
-        }
-        result.push(line);
-    }
-    return result.join("\n");
-}
-function applyAggressiveTransformations(content, preserveHeadings) {
-    let count = 0;
-    let result = content;
-    const after1 = removeMarkdownEmphasis(result);
-    if (after1 !== result)
-        count++;
-    result = after1;
-    const after2 = removeMarkdownLinks(result);
-    if (after2 !== result)
-        count++;
-    result = after2;
-    const after3 = truncateLongLines(result);
-    if (after3 !== result)
-        count++;
-    result = after3;
-    const after4 = removeBulletMarkers(result);
-    if (after4 !== result)
-        count++;
-    result = after4;
-    const after5 = removeBlockquoteMarkers(result);
-    if (after5 !== result)
-        count++;
-    result = after5;
-    const after6 = deduplicateStructuralPatterns(result);
-    if (after6 !== result)
-        count++;
-    result = after6;
-    return { content: result, count };
-}
-function extractHeadings(content) {
-    const headings = new Map();
-    let counter = 0;
-    const text = content.replace(/^(#{1,6}\s.+)$/gm, (match) => {
-        const placeholder = `\x00HEADING_${counter++}\x00`;
-        headings.set(placeholder, match);
-        return placeholder;
-    });
-    return { text, headings };
-}
-function restoreHeadings(text, headings) {
-    let result = text;
-    for (const [placeholder, heading] of headings) {
-        result = result.replace(placeholder, heading);
-    }
-    return result;
-}
-// ─── Public API ─────────────────────────────────────────────────────────────
-/**
- * Compress prompt content using deterministic text transformations.
- */
-export function compressPrompt(content, options) {
-    const level = options?.level ?? "moderate";
-    const preserveHeadings = options?.preserveHeadings ?? true;
-    const preserveCodeBlocks = options?.preserveCodeBlocks ?? true;
-    if (content === "") {
-        return {
-            content: "",
-            originalChars: 0,
-            compressedChars: 0,
-            savingsPercent: 0,
-            level,
-            transformationsApplied: 0,
-        };
-    }
-    const originalChars = content.length;
-    let working = content;
-    let totalTransformations = 0;
-    // Extract code blocks if preserving
-    let codeBlocks = null;
-    if (preserveCodeBlocks) {
-        const extracted = extractCodeBlocks(working);
-        working = extracted.text;
-        codeBlocks = extracted.blocks;
-    }
-    // Extract headings if preserving
-    let headings = null;
-    if (preserveHeadings) {
-        const extracted = extractHeadings(working);
-        working = extracted.text;
-        headings = extracted.headings;
-    }
-    // Apply light transformations (always)
-    const lightResult = applyLightTransformations(working);
-    working = lightResult.content;
-    totalTransformations += lightResult.count;
-    // Check target
-    if (options?.targetChars && getRestoredLength(working, codeBlocks, headings) <= options.targetChars) {
-        return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
-    }
-    // Apply moderate transformations
-    if (level === "moderate" || level === "aggressive") {
-        const modResult = applyModerateTransformations(working);
-        working = modResult.content;
-        totalTransformations += modResult.count;
-        if (options?.targetChars && getRestoredLength(working, codeBlocks, headings) <= options.targetChars) {
-            return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
-        }
-    }
-    // Apply aggressive transformations
-    if (level === "aggressive") {
-        const aggResult = applyAggressiveTransformations(working, preserveHeadings);
-        working = aggResult.content;
-        totalTransformations += aggResult.count;
-    }
-    return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
-}
-/**
- * Compress with a target size — applies progressively more aggressive
- * compression until the target is reached or all transformations exhausted.
- */
-export function compressToTarget(content, targetChars) {
-    if (content.length <= targetChars) {
-        return {
-            content,
-            originalChars: content.length,
-            compressedChars: content.length,
-            savingsPercent: 0,
-            level: "light",
-            transformationsApplied: 0,
-        };
-    }
-    const levels = ["light", "moderate", "aggressive"];
-    for (const level of levels) {
-        const result = compressPrompt(content, { level, targetChars });
-        if (result.compressedChars <= targetChars) {
-            return result;
-        }
-        // If aggressive and still over target, return best effort
-        if (level === "aggressive") {
-            return result;
-        }
-    }
-    // Unreachable, but satisfy TypeScript
-    return compressPrompt(content, { level: "aggressive" });
-}
-// ─── Helpers ────────────────────────────────────────────────────────────────
-function getRestoredLength(text, codeBlocks, headings) {
-    let result = text;
-    if (headings)
-        result = restoreHeadings(result, headings);
-    if (codeBlocks)
-        result = restoreCodeBlocks(result, codeBlocks);
-    return result.length;
-}
-function buildResult(working, originalChars, level, transformationsApplied, codeBlocks, headings) {
-    let content = working;
-    if (headings)
-        content = restoreHeadings(content, headings);
-    if (codeBlocks)
-        content = restoreCodeBlocks(content, codeBlocks);
-    const compressedChars = content.length;
-    const savingsPercent = originalChars > 0
-        ? Math.round(((originalChars - compressedChars) / originalChars) * 10000) / 100
-        : 0;
-    return {
-        content,
-        originalChars,
-        compressedChars,
-        savingsPercent,
-        level,
-        transformationsApplied,
-    };
-}