@pikaa-ai/pikaa 0.3.19 → 0.3.21

package/dist/index.js

@@ -1347,12 +1347,15 @@ class DefaultModelClientSession {
       };
       return;
     }
-    const messages = [
-      {
-        role: "system",
-        content: params.systemPrompt
-      }
-    ];
+    const enablePromptCache = params.enablePromptCache ?? this.config.enablePromptCache ?? true;
+    const systemMessage = {
+      role: "system",
+      content: params.systemPrompt
+    };
+    if (enablePromptCache) {
+      systemMessage.cache_control = { type: "ephemeral" };
+    }
+    const messages = [systemMessage];
     for (let i = 0;i < params.history.length; i++) {
       const item = params.history[i];
       if (item.type === "user_message") {
@@ -1436,14 +1439,27 @@ class DefaultModelClientSession {
       temperature: params.temperature ?? 0.2
     };
     if (toolsPayload && toolsPayload.length > 0) {
-      body.tools = toolsPayload;
+      if (enablePromptCache && toolsPayload.length > 0) {
+        const clonedTools = [...toolsPayload];
+        const lastIdx = clonedTools.length - 1;
+        if (clonedTools[lastIdx] && typeof clonedTools[lastIdx] === "object") {
+          clonedTools[lastIdx] = {
+            ...clonedTools[lastIdx],
+            cache_control: { type: "ephemeral" }
+          };
+        }
+        body.tools = clonedTools;
+      } else {
+        body.tools = toolsPayload;
+      }
       body.tool_choice = "auto";
     }
     const maxRetries = params.maxRetries ?? this.config.maxRetries ?? 10;
     let attempt = 0;
     let response = null;
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "anthropic-beta": "prompt-caching-2024-07-25"
     };
     if (apiKey) {
       headers["Authorization"] = `Bearer ${apiKey}`;
@@ -1553,7 +1569,8 @@ class DefaultModelClientSession {
               type: "done",
               inputTokens: usageMetrics.inputTokens,
               outputTokens: usageMetrics.outputTokens,
-              totalTokens: usageMetrics.totalTokens
+              totalTokens: usageMetrics.totalTokens,
+              cachedTokens: usageMetrics.cachedTokens
             };
             return;
           }
@@ -1564,10 +1581,12 @@ class DefaultModelClientSession {
             continue;
           }
           if (parsed.usage) {
+            const cached = parsed.usage.prompt_tokens_details?.cached_tokens ?? parsed.usage.cache_read_input_tokens ?? parsed.usage.cached_content_token_count ?? 0;
             usageMetrics = {
               inputTokens: parsed.usage.prompt_tokens,
               outputTokens: parsed.usage.completion_tokens,
-              totalTokens: parsed.usage.total_tokens
+              totalTokens: parsed.usage.total_tokens,
+              cachedTokens: cached > 0 ? cached : undefined
             };
           }
           const choice = parsed.choices?.[0];
@@ -1772,24 +1791,30 @@ var applyPatchTool = {
     const replacementContent = String(args.replacementContent ?? "");
     if (ctx.execPolicy) {
       const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
-      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
-        return {
-          output: "Error: Cannot mutate files while in Plan Mode. Please present the implementation plan first.",
-          isError: true
-        };
-      }
       if (evalResult.prompt && ctx.requestApproval) {
-        const approval = await ctx.requestApproval(`Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
+        const approval = await ctx.requestApproval(evalResult.reason || `Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
         const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
         if (!allowed) {
-          return { output: `Action rejected by user: apply_patch '${rawPath}'`, isError: true };
+          return {
+            output: `[Plan Mode Gate]: File modification declined by user for '${rawPath}'. Please refine your implementation plan or ask the user for guidance.`,
+            isError: true
+          };
         }
+      } else if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: `[Plan Mode Gate]: Cannot mutate '${rawPath}' while in Plan Mode without user approval. Please present your implementation plan first.`,
+          isError: true
+        };
       }
     }
     if (!existsSync3(filePath)) {
       if (targetContent) {
         return {
-          output: `Error: Target file '${rawPath}' does not exist, but targetContent was provided.`,
+          output: `Error: Target file '${rawPath}' does not exist, but targetContent was provided.
+[Systematic Error Recovery Checklist]:
+1. Root Cause: Trying to patch a non-existent file with targetContent.
+2. Fix: For creating new files, leave 'targetContent' empty and provide full contents in 'replacementContent'.
+3. Alternatively, check if the file path '${rawPath}' was mistyped.`,
           isError: true
         };
       }
@@ -1799,7 +1824,7 @@ var applyPatchTool = {
         return { output: `Successfully created new file '${rawPath}'` };
       } catch (err) {
         return {
-          output: `Failed to create file: ${err instanceof Error ? err.message : String(err)}`,
+          output: `Failed to create file '${rawPath}': ${err instanceof Error ? err.message : String(err)}`,
           isError: true
         };
       }
@@ -1808,21 +1833,33 @@ var applyPatchTool = {
       const originalFileContent = readFileSync2(filePath, "utf8");
       if (!targetContent) {
         return {
-          output: `Error: File '${rawPath}' already exists. Specify targetContent to replace specific lines or use overwrite.`,
+          output: `Error: File '${rawPath}' already exists, but targetContent was empty.
+[Systematic Error Recovery Checklist]:
+1. Root Cause: An existing file requires targetContent to specify which lines to replace.
+2. Fix: Call 'read_file' on '${rawPath}', extract the exact target lines, and provide them in 'targetContent'.
+3. To overwrite the whole file, use the 'write_file' tool instead.`,
           isError: true
         };
       }
       const firstIndex = originalFileContent.indexOf(targetContent);
       if (firstIndex === -1) {
         return {
-          output: `Error: targetContent was not found in '${rawPath}'. Please verify file contents before editing.`,
+          output: `Error: targetContent was not found in '${rawPath}'.
+[Systematic Error Recovery Checklist]:
+1. Root Cause: The snippet in targetContent does not match the actual file content (differences in whitespace, indentation, line endings, or prior edits).
+2. Action: Call 'read_file' on '${rawPath}' to inspect current exact lines and indentation.
+3. Fix: Provide the exact matching lines (including leading spaces) or wider context, then retry 'apply_patch'.`,
           isError: true
         };
       }
       const secondIndex = originalFileContent.indexOf(targetContent, firstIndex + 1);
       if (secondIndex !== -1) {
         return {
-          output: `Error: targetContent matched multiple locations in '${rawPath}'. Provide more surrounding context lines to ensure uniqueness.`,
+          output: `Error: targetContent matched multiple locations in '${rawPath}'.
+[Systematic Error Recovery Checklist]:
+1. Root Cause: targetContent is ambiguous and occurs multiple times in the file.
+2. Action: Include 2-3 additional surrounding lines (before or after the target block) to make the target snippet uniquely identifiable.
+3. Fix: Re-run 'apply_patch' with the extended unique block.`,
           isError: true
         };
       }
@@ -1833,7 +1870,7 @@ var applyPatchTool = {
       };
     } catch (err) {
       return {
-        output: `Failed to apply patch: ${err instanceof Error ? err.message : String(err)}`,
+        output: `Failed to apply patch to '${rawPath}': ${err instanceof Error ? err.message : String(err)}`,
         isError: true
       };
     }
@@ -1867,9 +1904,9 @@ class ExecPolicy {
   shouldPromptFileEdit(filePath) {
     if (this.mode === "plan") {
       return {
-        prompt: false,
+        prompt: true,
         isPlanBlocked: true,
-        reason: "Plan Mode is active. Mutating files is not allowed while planning."
+        reason: `[Plan Mode Gate] Approval required to mutate '${filePath || "file"}' and proceed with implementation.`
       };
     }
     if (this.mode === "manual") {
@@ -1883,11 +1920,14 @@ class ExecPolicy {
   evaluate(command) {
     const trimmed = command.trim();
     if (this.mode === "plan") {
-      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show|rev-parse)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
       if (isReadOnly) {
         return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
       }
-      return { decision: "deny", reason: "Cannot execute mutating shell commands in Plan mode" };
+      return {
+        decision: "prompt",
+        reason: `[Plan Mode Gate] Approval required to execute shell command '${trimmed}' in Plan Mode`
+      };
     }
     if (this.mode === "manual") {
       return {
@@ -2283,6 +2323,73 @@ class PrefixRulesStore {
 }
 var globalPrefixRulesStore = new PrefixRulesStore;
 
+// src/workspace/ephemeral.ts
+import { mkdirSync as mkdirSync5, rmSync, existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+
+class EphemeralWorkspaceManager {
+  activeScratchpads = new Set;
+  createScratchpad(turnId) {
+    const uniqueId = `groupy_scratch_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const baseDir = join2(tmpdir(), "groupy-ephemeral", turnId ? `turn_${turnId}` : "general");
+    const scratchPath = join2(baseDir, uniqueId);
+    mkdirSync5(scratchPath, { recursive: true });
+    this.activeScratchpads.add(scratchPath);
+    return scratchPath;
+  }
+  cleanup(scratchPath) {
+    if (!scratchPath || !this.activeScratchpads.has(scratchPath))
+      return;
+    try {
+      if (existsSync7(scratchPath)) {
+        rmSync(scratchPath, { recursive: true, force: true });
+      }
+    } catch {} finally {
+      this.activeScratchpads.delete(scratchPath);
+    }
+  }
+  cleanupTurn(turnId) {
+    const turnDir = join2(tmpdir(), "groupy-ephemeral", `turn_${turnId}`);
+    try {
+      if (existsSync7(turnDir)) {
+        rmSync(turnDir, { recursive: true, force: true });
+      }
+    } catch {}
+  }
+  cleanRootResidue(cwd) {
+    const cleaned = [];
+    try {
+      const files = readdirSync2(cwd);
+      const tempPatterns = [
+        /^tmp_/i,
+        /^draft_/i,
+        /^scratch_/i,
+        /^temp_/i,
+        /^preview_.*\.html$/i,
+        /\.tmp$/i,
+        /\.bak$/i,
+        /~$/i
+      ];
+      for (const file of files) {
+        if (tempPatterns.some((p) => p.test(file))) {
+          const fullPath = join2(cwd, file);
+          const stat = statSync2(fullPath);
+          if (stat.isFile()) {
+            rmSync(fullPath, { force: true });
+            cleaned.push(file);
+          } else if (stat.isDirectory() && (file.startsWith("tmp_") || file.startsWith("scratch_") || file.startsWith("temp_"))) {
+            rmSync(fullPath, { recursive: true, force: true });
+            cleaned.push(file);
+          }
+        }
+      }
+    } catch {}
+    return cleaned;
+  }
+}
+var globalEphemeralWorkspace = new EphemeralWorkspaceManager;
+
 // src/tools/handlers/shell.ts
 function createShellTool(policy = new ExecPolicy) {
   return {
@@ -2368,6 +2475,7 @@ function createShellTool(policy = new ExecPolicy) {
       const timeoutMs = typeof args.timeoutMs === "number" ? args.timeoutMs : 30000;
       const isWindows = process.platform === "win32";
       const baseCmd = isWindows ? ["cmd.exe", "/d", "/s", "/c", command] : ["/bin/sh", "-c", command];
+      const ephemeralScratchpad = globalEphemeralWorkspace.createScratchpad(ctx.turnId);
       const sandboxProfile = globalKernelSandbox.buildDefaultProfile(ctx.cwd);
       if (isEscalated) {
         sandboxProfile.allowNetwork = true;
@@ -2378,6 +2486,10 @@ function createShellTool(policy = new ExecPolicy) {
           cwd: ctx.cwd,
           env: {
             ...process.env,
+            TMPDIR: ephemeralScratchpad,
+            TEMP: ephemeralScratchpad,
+            TMP: ephemeralScratchpad,
+            GROUPY_SCRATCH_DIR: ephemeralScratchpad,
             ...ctx.proxyEnv
           },
           stdout: "pipe",
@@ -2414,9 +2526,14 @@ function createShellTool(policy = new ExecPolicy) {
         if (result.stderr)
           outputParts.push(`STDERR:
 ${result.stderr.trim()}`);
-        if (result.code !== 0)
+        if (result.code !== 0) {
           outputParts.push(`
-[Process exited with code ${result.code}]`);
+[Process exited with non-zero code ${result.code}]`);
+          outputParts.push(`[Systematic Error Recovery Checklist]:
+1. Inspect STDERR above to pinpoint syntax errors, failed test assertions, or missing dependencies.
+2. If this is a test failure, trace the failure in source code and fix the root cause before re-running.
+3. If this is a missing command/module, install or configure the prerequisite.`);
+        }
         const output = outputParts.join(`
 `) || "[Command completed with no output]";
         return {
@@ -2425,16 +2542,21 @@ ${result.stderr.trim()}`);
         };
       } catch (err) {
         return {
-          output: `Execution error: ${err instanceof Error ? err.message : String(err)}`,
+          output: `Execution error: ${err instanceof Error ? err.message : String(err)}
+[Systematic Error Recovery Checklist]:
+1. Verify command syntax, arguments, and executable availability in PATH.
+2. Check if the current working directory ('${ctx.cwd}') is valid.`,
           isError: true
         };
+      } finally {
+        globalEphemeralWorkspace.cleanup(ephemeralScratchpad);
       }
     }
   };
 }
 var shellTool = createShellTool();
 // src/tools/handlers/file-ops.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync7, statSync as statSync2, mkdirSync as mkdirSync5 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync as statSync3, mkdirSync as mkdirSync6 } from "fs";
 import { resolve as resolve6, dirname as dirname4 } from "path";
 var readFileTool = {
   name: "read_file",
@@ -2448,7 +2570,7 @@ var readFileTool = {
   },
   async execute(args, ctx) {
     const filePath = resolve6(ctx.cwd, String(args.path || ""));
-    if (!existsSync7(filePath)) {
+    if (!existsSync8(filePath)) {
       return { output: `Error: File not found: '${args.path}'`, isError: true };
     }
     try {
@@ -2470,14 +2592,14 @@ var listDirTool = {
   },
   async execute(args, ctx) {
     const dirPath = resolve6(ctx.cwd, String(args.path || "."));
-    if (!existsSync7(dirPath)) {
+    if (!existsSync8(dirPath)) {
       return { output: `Error: Directory not found: '${args.path}'`, isError: true };
     }
     try {
-      const entries = readdirSync2(dirPath);
+      const entries = readdirSync3(dirPath);
       const formatted = entries.map((entry) => {
         const full = resolve6(dirPath, entry);
-        const isDir = statSync2(full).isDirectory();
+        const isDir = statSync3(full).isDirectory();
         return `${isDir ? "[DIR]" : "[FILE]"} ${entry}`;
       });
       return { output: formatted.join(`
@@ -2503,26 +2625,35 @@ var writeFileTool = {
     const filePath = resolve6(ctx.cwd, rawPath);
     if (ctx.execPolicy) {
       const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
-      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
-        return {
-          output: "Error: Cannot write or mutate files while in Plan Mode. Please present the implementation plan first.",
-          isError: true
-        };
-      }
       if (evalResult.prompt && ctx.requestApproval) {
-        const approval = await ctx.requestApproval(`Write file: ${rawPath}`, `write_file ${rawPath}`);
+        const approval = await ctx.requestApproval(evalResult.reason || `Write file: ${rawPath}`, `write_file ${rawPath}`);
         const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
         if (!allowed) {
-          return { output: `Action rejected by user: write_file '${rawPath}'`, isError: true };
+          return {
+            output: `[Plan Mode Gate]: File creation declined by user for '${rawPath}'. Please refine your implementation plan or ask the user for guidance.`,
+            isError: true
+          };
         }
+      } else if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: `[Plan Mode Gate]: Cannot write or mutate '${rawPath}' while in Plan Mode without user approval. Please present your implementation plan first.`,
+          isError: true
+        };
       }
     }
     try {
-      mkdirSync5(dirname4(filePath), { recursive: true });
+      mkdirSync6(dirname4(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
       return { output: `Successfully wrote to '${args.path}'` };
     } catch (err) {
-      return { output: `Failed to write file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+      return {
+        output: `Failed to write file '${rawPath}': ${err instanceof Error ? err.message : String(err)}
+[Systematic Error Recovery Checklist]:
+1. Check directory permissions and ensure the path is valid within the workspace.
+2. If the path contains non-existent nested folders, they should be auto-created.
+3. Verify that the file is not locked by another active process.`,
+        isError: true
+      };
     }
   }
 };
@@ -2641,8 +2772,8 @@ var updatePlanTool = {
   }
 };
 // src/search/engine.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3, existsSync as existsSync8 } from "fs";
-import { resolve as resolve7, relative, join as join2, extname } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4, existsSync as existsSync9 } from "fs";
+import { resolve as resolve7, relative, join as join3, extname } from "path";
 var DEFAULT_IGNORE_DIRS = new Set([
   ".git",
   "node_modules",
@@ -2688,7 +2819,7 @@ var BINARY_EXTENSIONS = new Set([
 class FileSearchEngine {
   grep(cwd, options) {
     const searchRoot = resolve7(cwd, options.path || ".");
-    if (!existsSync8(searchRoot)) {
+    if (!existsSync9(searchRoot)) {
       return { matches: [], totalMatches: 0, truncated: false };
     }
     const maxResults = options.maxResults || 50;
@@ -2738,7 +2869,7 @@ class FileSearchEngine {
   }
   findFiles(cwd, options) {
     const searchRoot = resolve7(cwd, options.path || ".");
-    if (!existsSync8(searchRoot))
+    if (!existsSync9(searchRoot))
       return [];
     const maxResults = options.maxResults || 100;
     const gitignoreRules = this.loadGitignoreRules(searchRoot);
@@ -2777,8 +2908,8 @@ class FileSearchEngine {
   }
   loadGitignoreRules(root) {
     const rules = new Set;
-    const gitignorePath = join2(root, ".gitignore");
-    if (existsSync8(gitignorePath)) {
+    const gitignorePath = join3(root, ".gitignore");
+    if (existsSync9(gitignorePath)) {
       try {
         const lines = readFileSync4(gitignorePath, "utf8").split(`
 `);
@@ -2795,7 +2926,7 @@ class FileSearchEngine {
   collectFiles(dir, root, gitignoreRules, includePattern) {
     const results = [];
     try {
-      const stat = statSync3(dir);
+      const stat = statSync4(dir);
       if (!stat.isDirectory()) {
         if (!this.isBinary(dir)) {
           results.push(dir);
@@ -2809,9 +2940,9 @@ class FileSearchEngine {
     while (queue.length > 0) {
       const currentDir = queue.shift();
       try {
-        const entries = readdirSync3(currentDir, { withFileTypes: true });
+        const entries = readdirSync4(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join2(currentDir, entry.name);
+          const fullPath = join3(currentDir, entry.name);
           const relToRoot = relative(root, fullPath).replace(/\\/g, "/");
           if (this.isIgnored(entry.name, relToRoot, gitignoreRules)) {
             continue;
@@ -3531,8 +3662,8 @@ class PathSandbox {
   }
 }
 // src/security/scanner.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { join as join3, relative as relative3, resolve as resolve9 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { join as join4, relative as relative3, resolve as resolve9 } from "path";
 var SECURITY_RULES = [
   {
     id: "SEC-001",
@@ -3670,21 +3801,21 @@ async function runSecurityScan(targetDir, options = {}) {
   const findings = [];
   let scannedCount = 0;
   function walk(current) {
-    if (scannedCount >= maxFiles || !existsSync9(current))
+    if (scannedCount >= maxFiles || !existsSync10(current))
       return;
     let entries;
     try {
-      entries = readdirSync4(current);
+      entries = readdirSync5(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join3(current, entry);
+      const fullPath = join4(current, entry);
       let stat;
       try {
-        stat = statSync4(fullPath);
+        stat = statSync5(fullPath);
       } catch {
         continue;
       }
@@ -3807,13 +3938,13 @@ function formatWorldStatePrompt(state) {
 `);
 }
 // src/prompts/loader.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve10, join as join4 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve10, join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 class PromptTemplateLoader {
   builtInTemplatesDir;
   constructor(builtInDir) {
-    this.builtInTemplatesDir = builtInDir || resolve10(join4(import.meta.dir, "..", "..", "templates"));
+    this.builtInTemplatesDir = builtInDir || resolve10(join5(import.meta.dir, "..", "..", "templates"));
   }
   loadTemplate(relativePath, variables = {}, cwd) {
     const rawContent = this.resolveTemplateContent(relativePath, cwd);
@@ -3822,27 +3953,27 @@ class PromptTemplateLoader {
   resolveTemplateContent(relativePath, cwd) {
     const normalizedRel = relativePath.replace(/^\/+/, "");
     if (cwd) {
-      const workspacePath = join4(cwd, ".agents", "templates", normalizedRel);
-      if (existsSync10(workspacePath)) {
+      const workspacePath = join5(cwd, ".agents", "templates", normalizedRel);
+      if (existsSync11(workspacePath)) {
         try {
           return readFileSync6(workspacePath, "utf-8");
         } catch {}
       }
     }
-    const globalPath = join4(getGlobalTemplatesDir(), normalizedRel);
-    if (existsSync10(globalPath)) {
+    const globalPath = join5(getGlobalTemplatesDir(), normalizedRel);
+    if (existsSync11(globalPath)) {
       try {
         return readFileSync6(globalPath, "utf-8");
       } catch {}
     }
-    const legacyGlobalPath = join4(homedir2(), ".groupy", "templates", normalizedRel);
-    if (existsSync10(legacyGlobalPath)) {
+    const legacyGlobalPath = join5(homedir2(), ".groupy", "templates", normalizedRel);
+    if (existsSync11(legacyGlobalPath)) {
       try {
         return readFileSync6(legacyGlobalPath, "utf-8");
       } catch {}
     }
-    const builtInPath = join4(this.builtInTemplatesDir, normalizedRel);
-    if (existsSync10(builtInPath)) {
+    const builtInPath = join5(this.builtInTemplatesDir, normalizedRel);
+    if (existsSync11(builtInPath)) {
       try {
         return readFileSync6(builtInPath, "utf-8");
       } catch {}
@@ -3859,8 +3990,8 @@ class PromptTemplateLoader {
 var globalPromptLoader = new PromptTemplateLoader;
 
 // src/prompts/agents-md.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve11, join as join5, dirname as dirname5 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve11, join as join6, dirname as dirname5 } from "path";
 var DEFAULT_AGENTS_MD_FILENAMES = [
   "AGENTS.override.md",
   "AGENTS.md",
@@ -3877,7 +4008,7 @@ class AgentsMdLoader {
   findProjectRoot(startDir) {
     let current = resolve11(startDir);
     while (true) {
-      if (existsSync11(join5(current, ".git"))) {
+      if (existsSync12(join6(current, ".git"))) {
         return current;
       }
       const parent = dirname5(current);
@@ -3911,8 +4042,8 @@ class AgentsMdLoader {
     const sourcePaths = [];
     for (const dir of dirHierarchy) {
       for (const filename of fallbackFilenames) {
-        const filePath = join5(dir, filename);
-        if (existsSync11(filePath)) {
+        const filePath = join6(dir, filename);
+        if (existsSync12(filePath)) {
           try {
             const content = readFileSync7(filePath, "utf-8").trim();
             if (content) {
@@ -3936,81 +4067,141 @@ class AgentsMdLoader {
 var globalAgentsMdLoader = new AgentsMdLoader;
 
 // src/context/instructions.ts
-function buildSystemPrompt(params) {
-  const sections = [];
+function wrapXmlTag(tag, content, attrs = {}) {
+  const attrStr = Object.entries(attrs).filter(([_, v]) => Boolean(v)).map(([k, v]) => ` ${k}="${v}"`).join("");
+  return `<${tag}${attrStr}>
+${content.trim()}
+</${tag}>`;
+}
+function buildStructuredSystemPrompt(params) {
   const cwd = params.cwd || process.cwd();
   const mode = params.collaborationMode || "default";
-  if (params.basePrompt) {
-    sections.push(params.basePrompt);
-  } else {
+  const blocks = [];
+  let baseContent = params.basePrompt;
+  if (!baseContent) {
     const templateName = params.basePromptTemplate || "base/groupy_prompt.md";
-    const baseContent = globalPromptLoader.loadTemplate(templateName, {}, cwd);
-    if (baseContent) {
-      sections.push(baseContent.trim());
-    } else {
-      sections.push("You are Groupy, an expert autonomous AI coding assistant. You think step-by-step, act surgically, and write clean, correct code.");
-    }
+    baseContent = globalPromptLoader.loadTemplate(templateName, {}, cwd) || "You are Groupy, an expert autonomous AI coding assistant. You think step-by-step, act surgically, and write clean, correct code.";
   }
+  blocks.push({
+    tag: "system_identity",
+    content: wrapXmlTag("system_identity", baseContent),
+    cacheable: true
+  });
   if (params.personality) {
     const personalityContent = globalPromptLoader.loadTemplate(`personalities/${params.personality}.md`, {}, cwd);
     if (personalityContent) {
-      sections.push(personalityContent.trim());
+      blocks.push({
+        tag: "personality",
+        content: wrapXmlTag("personality", personalityContent, { kind: params.personality }),
+        cacheable: true
+      });
     }
   }
   if (params.isOrchestrator) {
     const orchestratorContent = globalPromptLoader.loadTemplate("agents/orchestrator.md", {}, cwd);
     if (orchestratorContent) {
-      sections.push(orchestratorContent.trim());
+      blocks.push({
+        tag: "orchestrator_guidelines",
+        content: wrapXmlTag("orchestrator_guidelines", orchestratorContent),
+        cacheable: true
+      });
     }
   }
-  const modeTemplate = globalPromptLoader.loadTemplate(`modes/${mode}.md`, {
-    KNOWN_MODE_NAMES: "default, plan, review"
-  }, cwd);
+  const modeTemplate = globalPromptLoader.loadTemplate(`modes/${mode}.md`, { KNOWN_MODE_NAMES: "default, plan, review" }, cwd);
   if (modeTemplate) {
-    sections.push(modeTemplate.trim());
+    blocks.push({
+      tag: "collaboration_mode",
+      content: wrapXmlTag("collaboration_mode", modeTemplate, { name: mode }),
+      cacheable: true
+    });
   }
   if (params.sandboxMode) {
-    const sandboxTemplate = globalPromptLoader.loadTemplate(`permissions/sandbox_mode/${params.sandboxMode}.md`, {
-      network_access: params.networkAccess ? "enabled" : "disabled"
-    }, cwd);
+    const sandboxTemplate = globalPromptLoader.loadTemplate(`permissions/sandbox_mode/${params.sandboxMode}.md`, { network_access: params.networkAccess ? "enabled" : "disabled" }, cwd);
     if (sandboxTemplate) {
-      sections.push(sandboxTemplate.trim());
+      blocks.push({
+        tag: "sandbox_policy",
+        content: wrapXmlTag("sandbox_policy", sandboxTemplate, { mode: params.sandboxMode }),
+        cacheable: true
+      });
     }
   }
   if (params.approvalPolicy) {
     const approvalTemplate = globalPromptLoader.loadTemplate(`permissions/approval_policy/${params.approvalPolicy}.md`, {}, cwd);
     if (approvalTemplate) {
-      sections.push(approvalTemplate.trim());
+      blocks.push({
+        tag: "approval_policy",
+        content: wrapXmlTag("approval_policy", approvalTemplate, { policy: params.approvalPolicy }),
+        cacheable: true
+      });
     }
   }
   const projectInstructions = globalAgentsMdLoader.loadProjectInstructions(cwd);
   if (projectInstructions) {
-    sections.push(`## Project Instructions (AGENTS.md)
-
-${projectInstructions.content.trim()}`);
+    blocks.push({
+      tag: "project_instructions",
+      content: wrapXmlTag("project_instructions", projectInstructions.content, { source: "AGENTS.md" }),
+      cacheable: true
+    });
   }
   if (params.memoriesPrompt) {
-    sections.push(params.memoriesPrompt.trim());
+    blocks.push({
+      tag: "persistent_memories",
+      content: wrapXmlTag("persistent_memories", params.memoriesPrompt),
+      cacheable: true
+    });
   }
   if (params.skillsPrompt) {
-    sections.push(params.skillsPrompt.trim());
+    blocks.push({
+      tag: "domain_skills",
+      content: wrapXmlTag("domain_skills", params.skillsPrompt),
+      cacheable: true
+    });
   }
   if (params.mcpPrompt) {
-    sections.push(params.mcpPrompt.trim());
+    blocks.push({
+      tag: "mcp_servers",
+      content: wrapXmlTag("mcp_servers", params.mcpPrompt),
+      cacheable: true
+    });
   }
   if (params.developerInstructions) {
-    sections.push(`## Developer Instructions
-${params.developerInstructions}`);
+    blocks.push({
+      tag: "developer_instructions",
+      content: wrapXmlTag("developer_instructions", params.developerInstructions),
+      cacheable: true
+    });
   }
+  const dynamicBlocks = [];
   if (params.worldStatePrompt) {
-    sections.push(`## Environment Context
-${params.worldStatePrompt}`);
+    dynamicBlocks.push({
+      tag: "runtime_environment",
+      content: wrapXmlTag("runtime_environment", params.worldStatePrompt),
+      cacheable: false
+    });
   }
-  return sections.join(`
+  const staticPrefix = blocks.map((b) => b.content).join(`
+
+`);
+  const dynamicSuffix = dynamicBlocks.map((b) => b.content).join(`
 
 `);
+  const allBlocks = [...blocks, ...dynamicBlocks];
+  const text = allBlocks.map((b) => b.content).join(`
+
+`);
+  return {
+    text,
+    staticPrefix,
+    dynamicSuffix,
+    blocks: allBlocks
+  };
+}
+function buildSystemPrompt(params) {
+  return buildStructuredSystemPrompt(params).text;
 }
 // src/context/compactor.ts
+var DEFAULT_MAX_CONTEXT_TOKENS = 256000;
+var DEFAULT_AUTO_COMPACT_THRESHOLD_TOKENS = 180000;
 function estimateItemTokens(item) {
   const text = item.type === "user_message" ? item.content : item.type === "agent_message" ? item.content : item.type === "reasoning" ? item.content : item.type === "function_call" ? JSON.stringify(item.arguments) : item.type === "function_call_output" ? item.output : "";
   return Math.ceil(text.length / 4) + 4;
@@ -4078,7 +4269,7 @@ async function runTurn(session, turnContext, input) {
   });
   const currentHistory = session.getHistory();
   const estimatedTokens = estimateTotalTokens(currentHistory);
-  const maxTokenLimit = 80000;
+  const maxTokenLimit = DEFAULT_AUTO_COMPACT_THRESHOLD_TOKENS;
   if (estimatedTokens > maxTokenLimit) {
     const compacted = compactHistory(currentHistory);
     session.setHistory(compacted);
@@ -4117,6 +4308,7 @@ async function runTurn(session, turnContext, input) {
   let iteration = 0;
   let accumulatedInputTokens = 0;
   let accumulatedOutputTokens = 0;
+  let accumulatedCachedTokens = 0;
   const clientSession = session.modelClient.newSession();
   try {
     while (iteration < turnContext.maxIterations) {
@@ -4133,7 +4325,8 @@ async function runTurn(session, turnContext, input) {
         systemPrompt: effectiveSystemPrompt,
         history: session.getHistory(),
         tools: turnContext.tools,
-        signal
+        signal,
+        enablePromptCache: true
       });
       for await (const chunk of stream) {
         if (signal.aborted) {
@@ -4159,6 +4352,8 @@ async function runTurn(session, turnContext, input) {
             iterInputTokens = chunk.inputTokens;
           if (chunk.outputTokens !== undefined)
             iterOutputTokens = chunk.outputTokens;
+          if (chunk.cachedTokens !== undefined)
+            accumulatedCachedTokens += chunk.cachedTokens;
         } else if (chunk.type === "error") {
           throw chunk.error;
         }
@@ -4270,7 +4465,10 @@ async function runTurn(session, turnContext, input) {
           session.addHistoryItem({
             id: `msg_nudge_${Date.now()}`,
             type: "user_message",
-            content: "Please proceed with executing the task. Provide your complete analysis or call the required tools now.",
+            content: `[Systematic ReAct Nudge]: No tool actions or answers were produced in this iteration.
+1. Review the user's objective and determine the immediate next action.
+2. If more context is required, invoke an exploration tool ('read_file', 'list_dir', 'grep_search', 'find_files').
+3. If ready to answer or implement, call the required mutating tool or deliver your full, concrete response now.`,
             createdAt: Date.now()
           });
           continue;
@@ -4279,13 +4477,14 @@ async function runTurn(session, turnContext, input) {
       break;
     }
     const totalContextTokens = estimateTotalTokens(session.getHistory()) + Math.ceil(effectiveSystemPrompt.length / 4);
-    const maxContextTokens = 128000;
+    const maxContextTokens = DEFAULT_MAX_CONTEXT_TOKENS;
     session.emitEvent({
       type: "TurnCompleted",
       turnId,
       inputTokens: accumulatedInputTokens,
       outputTokens: accumulatedOutputTokens,
       totalTokens: accumulatedInputTokens + accumulatedOutputTokens,
+      cachedTokens: accumulatedCachedTokens > 0 ? accumulatedCachedTokens : undefined,
       contextTokens: totalContextTokens,
       maxContextTokens
     });
@@ -4300,6 +4499,8 @@ async function runTurn(session, turnContext, input) {
     });
   } finally {
     session.clearActiveTurn(turnId);
+    globalEphemeralWorkspace.cleanupTurn(turnId);
+    globalEphemeralWorkspace.cleanRootResidue(turnContext.environment.cwd);
   }
 }
 
@@ -5240,8 +5441,8 @@ class McpClient {
   }
 }
 // src/mcp/manager.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve12, dirname as dirname6, join as join6 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve12, dirname as dirname6, join as join7 } from "path";
 class McpManager {
   clients = new Map;
   serverConfigs = new Map;
@@ -5276,7 +5477,7 @@ class McpManager {
   }
   async loadConfigFile(filePath) {
     const fullPath = resolve12(filePath);
-    if (!existsSync12(fullPath))
+    if (!existsSync13(fullPath))
       return;
     this.loadedConfigFiles.add(fullPath);
     try {
@@ -5531,11 +5732,11 @@ class McpManager {
   saveServerToConfigFile(filePath, name, config) {
     const fullPath = resolve12(filePath);
     const dir = dirname6(fullPath);
-    if (!existsSync12(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync13(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
     let existing = { mcpServers: {} };
-    if (existsSync12(fullPath)) {
+    if (existsSync13(fullPath)) {
       try {
         const content = readFileSync8(fullPath, "utf8");
         existing = JSON.parse(content);
@@ -5550,7 +5751,7 @@ class McpManager {
   }
   removeServerFromConfigFile(filePath, name) {
     const fullPath = resolve12(filePath);
-    if (!existsSync12(fullPath))
+    if (!existsSync13(fullPath))
       return false;
     try {
       const content = readFileSync8(fullPath, "utf8");
@@ -5580,11 +5781,11 @@ class McpManager {
     }
   }
   getDefaultConfigFile(cwd = process.cwd()) {
-    const workspaceConfig = join6(cwd, ".mcp.json");
-    if (existsSync12(workspaceConfig))
+    const workspaceConfig = join7(cwd, ".mcp.json");
+    if (existsSync13(workspaceConfig))
       return workspaceConfig;
-    const altConfig = join6(cwd, "mcp_config.json");
-    if (existsSync12(altConfig))
+    const altConfig = join7(cwd, "mcp_config.json");
+    if (existsSync13(altConfig))
       return altConfig;
     return workspaceConfig;
   }
@@ -5606,30 +5807,30 @@ class McpManager {
 import { resolve as resolve14 } from "path";
 
 // src/mcp/servers/chrome-devtools/launcher.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, rmSync } from "fs";
-import { join as join7 } from "path";
-import { tmpdir } from "os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
+import { join as join8 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 class BrowserLauncher {
   proc = null;
   tempUserDataDir = null;
   wsDebuggerUrl = null;
   port = 0;
   static findBrowserExecutable() {
-    if (process.env.CHROME_PATH && existsSync13(process.env.CHROME_PATH)) {
+    if (process.env.CHROME_PATH && existsSync14(process.env.CHROME_PATH)) {
       return process.env.CHROME_PATH;
     }
     if (process.platform === "win32") {
       const candidates = [
         "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
         "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-        join7(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
+        join8(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
         "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-        join7(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
+        join8(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
       ];
       for (const path of candidates) {
-        if (path && existsSync13(path))
+        if (path && existsSync14(path))
           return path;
       }
     } else if (process.platform === "darwin") {
@@ -5640,7 +5841,7 @@ class BrowserLauncher {
         "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
       ];
       for (const path of candidates) {
-        if (existsSync13(path))
+        if (existsSync14(path))
           return path;
       }
     } else {
@@ -5653,7 +5854,7 @@ class BrowserLauncher {
         "/usr/bin/microsoft-edge"
       ];
       for (const path of candidates) {
-        if (existsSync13(path))
+        if (existsSync14(path))
           return path;
       }
     }
@@ -5665,8 +5866,8 @@ class BrowserLauncher {
       throw new Error("No supported browser (Google Chrome, Chromium, MS Edge, Brave) found on this machine. Please install Chrome or specify CHROME_PATH.");
     }
     this.port = options.port || 9200 + Math.floor(Math.random() * 500);
-    this.tempUserDataDir = options.userDataDir || join7(tmpdir(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
-    mkdirSync7(this.tempUserDataDir, { recursive: true });
+    this.tempUserDataDir = options.userDataDir || join8(tmpdir2(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    mkdirSync8(this.tempUserDataDir, { recursive: true });
     const isHeadless = options.headless ?? true;
     const launchArgs = [
       executable,
@@ -5743,9 +5944,9 @@ class BrowserLauncher {
       }
       this.proc = null;
     }
-    if (this.tempUserDataDir && existsSync13(this.tempUserDataDir)) {
+    if (this.tempUserDataDir && existsSync14(this.tempUserDataDir)) {
       try {
-        rmSync(this.tempUserDataDir, { recursive: true, force: true });
+        rmSync2(this.tempUserDataDir, { recursive: true, force: true });
       } catch {}
       this.tempUserDataDir = null;
     }
@@ -6104,7 +6305,7 @@ class DomSnapshotEngine {
   }
 }
 // src/mcp/servers/chrome-devtools/controller.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync9 } from "fs";
 import { dirname as dirname7, resolve as resolve13 } from "path";
 class ChromeDevToolsController {
   launcher = new BrowserLauncher;
@@ -6255,7 +6456,7 @@ class ChromeDevToolsController {
     const snapshot = await DomSnapshotEngine.captureSnapshot(cdp, params.verbose);
     if (params.filePath) {
       const fullPath = resolve13(params.filePath);
-      mkdirSync8(dirname7(fullPath), { recursive: true });
+      mkdirSync9(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, snapshot.textSnapshot, "utf8");
       return `Snapshot saved to ${params.filePath} (${snapshot.elementsCount} indexed elements)`;
     }
@@ -6284,7 +6485,7 @@ class ChromeDevToolsController {
     const base64Data = res.data;
     if (params.filePath) {
       const fullPath = resolve13(params.filePath);
-      mkdirSync8(dirname7(fullPath), { recursive: true });
+      mkdirSync9(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, Buffer.from(base64Data, "base64"));
       return { format, filePath: params.filePath };
     }
@@ -6429,7 +6630,7 @@ class ChromeDevToolsController {
     const value = res.result?.value;
     if (params.filePath) {
       const fullPath = resolve13(params.filePath);
-      mkdirSync8(dirname7(fullPath), { recursive: true });
+      mkdirSync9(dirname7(fullPath), { recursive: true });
       writeFileSync5(fullPath, JSON.stringify(value, null, 2), "utf8");
       return `Script output saved to ${params.filePath}`;
     }
@@ -7583,7 +7784,7 @@ import { resolve as resolve17 } from "path";
 // src/mcp/servers/sqlite/db-engine.ts
 import { Database as Database2 } from "bun:sqlite";
 import { resolve as resolve16, isAbsolute } from "path";
-import { readdirSync as readdirSync5 } from "fs";
+import { readdirSync as readdirSync6 } from "fs";
 
 class SqliteEngine {
   connections = new Map;
@@ -7613,7 +7814,7 @@ class SqliteEngine {
   }
   autoDiscoverDatabase() {
     try {
-      const files = readdirSync5(process.cwd());
+      const files = readdirSync6(process.cwd());
       const dbFile = files.find((f) => f.endsWith(".sqlite") || f.endsWith(".sqlite3") || f.endsWith(".db"));
       return dbFile ? resolve16(process.cwd(), dbFile) : null;
     } catch {
@@ -8117,8 +8318,8 @@ function verifyTaskAction(assertion, payload) {
   }
 }
 // src/agents/roles.ts
-import { existsSync as existsSync15, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve18, join as join8 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve18, join as join9 } from "path";
 
 class AgentRoleRegistry {
   roles = new Map;
@@ -8203,13 +8404,13 @@ class AgentRoleRegistry {
   }
   loadRolesFromDir(dirPath) {
     const fullPath = resolve18(dirPath);
-    if (!existsSync15(fullPath))
+    if (!existsSync16(fullPath))
       return;
-    const entries = readdirSync6(fullPath);
+    const entries = readdirSync7(fullPath);
     for (const entry of entries) {
       if (entry.endsWith(".json")) {
         try {
-          const content = readFileSync9(join8(fullPath, entry), "utf8");
+          const content = readFileSync9(join9(fullPath, entry), "utf8");
           const parsed = JSON.parse(content);
           if (parsed.name && parsed.systemPrompt) {
             this.registerRole(parsed);
@@ -8239,7 +8440,7 @@ class AgentRoleRegistry {
 // src/agents/graph-store.ts
 import { Database as Database3 } from "bun:sqlite";
 import { resolve as resolve19 } from "path";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10 } from "fs";
 class AgentGraphStore {
   db;
   constructor(dbPathOrDb) {
@@ -8249,8 +8450,8 @@ class AgentGraphStore {
       const dbPath = dbPathOrDb || getAgentGraphDbPath();
       if (dbPath !== ":memory:") {
         const dir = resolve19(dbPath, "..");
-        if (!existsSync16(dir)) {
-          mkdirSync9(dir, { recursive: true });
+        if (!existsSync17(dir)) {
+          mkdirSync10(dir, { recursive: true });
         }
       }
       this.db = new Database3(dbPath);
@@ -8672,7 +8873,7 @@ function registerMultiAgentTools(router2, spawner) {
 }
 // src/storage/sqlite-store.ts
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync17, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
 import { dirname as dirname8 } from "path";
 class SqliteThreadStore {
   db;
@@ -8680,8 +8881,8 @@ class SqliteThreadStore {
     const effectivePath = dbPath || this.getDefaultDbPath();
     if (effectivePath !== ":memory:") {
       const dir = dirname8(effectivePath);
-      if (!existsSync17(dir)) {
-        mkdirSync10(dir, { recursive: true });
+      if (!existsSync18(dir)) {
+        mkdirSync11(dir, { recursive: true });
       }
     }
     this.db = new Database4(effectivePath);
@@ -8913,8 +9114,8 @@ class SessionPersistenceManager {
   }
 }
 // src/skills/loader.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve20, join as join9 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve20, join as join10 } from "path";
 import { homedir as homedir3 } from "os";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
@@ -8985,7 +9186,7 @@ class SkillsLoader {
         resolve20(cwd, "skills")
       ];
       for (const cand of candidates) {
-        if (existsSync18(cand) && !roots.includes(cand)) {
+        if (existsSync19(cand) && !roots.includes(cand)) {
           roots.push(cand);
         }
       }
@@ -8994,7 +9195,7 @@ class SkillsLoader {
       roots.push(getGlobalSkillsDir(), resolve20(homedir3(), ".gemini", "config", "skills"));
     }
     roots.push(...this.customRoots.map((r) => resolve20(r)));
-    return roots.filter((r) => existsSync18(r));
+    return roots.filter((r) => existsSync19(r));
   }
   discoverSkills(cwd, options) {
     return this.listSkills(cwd, options);
@@ -9010,12 +9211,12 @@ class SkillsLoader {
     const discovered = new Map;
     for (const root of roots) {
       try {
-        const entries = readdirSync7(root, { withFileTypes: true });
+        const entries = readdirSync8(root, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const skillDir = join9(root, entry.name);
-            const skillFilePath = join9(skillDir, "SKILL.md");
-            if (existsSync18(skillFilePath)) {
+            const skillDir = join10(root, entry.name);
+            const skillFilePath = join10(skillDir, "SKILL.md");
+            if (existsSync19(skillFilePath)) {
               const meta = this.parseSkillFrontmatter(skillFilePath, entry.name, root, cwd);
               if (meta && !discovered.has(meta.name)) {
                 meta.enabled = !this.isSkillDisabled(meta.name);
@@ -9028,7 +9229,7 @@ class SkillsLoader {
         }
       } catch {}
     }
-    const result = Array.from(discovered.values());
+    const result = Array.from(discovered.values()).sort((a, b) => a.name.localeCompare(b.name));
     this.skillsCache.set(cacheKey, { timestamp: now, skills: result });
     return result;
   }
@@ -9117,10 +9318,10 @@ class SkillsLoader {
     const skills = this.listSkills(cwd, { includeDisabled: false });
     if (skills.length === 0)
       return "";
-    const workspaceSkills = skills.filter((s) => s.scope === "workspace");
-    const builtInSkills = skills.filter((s) => s.scope === "built-in");
-    const otherSkills = skills.filter((s) => s.scope !== "workspace" && s.scope !== "built-in");
-    const selectedSkills = [...workspaceSkills, ...builtInSkills, ...otherSkills].slice(0, 150);
+    const workspaceSkills = skills.filter((s) => s.scope === "workspace").sort((a, b) => a.name.localeCompare(b.name));
+    const builtInSkills = skills.filter((s) => s.scope === "built-in").sort((a, b) => a.name.localeCompare(b.name));
+    const otherSkills = skills.filter((s) => s.scope !== "workspace" && s.scope !== "built-in").sort((a, b) => a.name.localeCompare(b.name));
+    const selectedSkills = [...workspaceSkills, ...builtInSkills, ...otherSkills].slice(0, 300);
     const lines = selectedSkills.map((s) => {
       const desc = s.shortDescription || s.description;
       return `- **${s.name}**: ${desc}`;
@@ -9137,8 +9338,8 @@ When tackling complex specialized tasks that match any of these skills, autonomo
   }
 }
 // src/memories/store.ts
-import { existsSync as existsSync19, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11, readdirSync as readdirSync8 } from "fs";
-import { resolve as resolve21, join as join10, basename, dirname as dirname9 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync12, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve21, join as join11, basename, dirname as dirname9 } from "path";
 import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
@@ -9150,7 +9351,7 @@ class MemoryStore {
   findProjectRoot(cwd) {
     let current = resolve21(cwd);
     while (true) {
-      if (existsSync19(join10(current, ".git"))) {
+      if (existsSync20(join11(current, ".git"))) {
         return current;
       }
       const parent = dirname9(current);
@@ -9169,24 +9370,24 @@ class MemoryStore {
   getProjectMemoryDir(cwd) {
     if (this.customWorkspacePath) {
       const dir2 = resolve21(this.customWorkspacePath);
-      if (!existsSync19(dir2)) {
+      if (!existsSync20(dir2)) {
         try {
-          mkdirSync11(dir2, { recursive: true });
+          mkdirSync12(dir2, { recursive: true });
         } catch {}
       }
       return dir2;
     }
     const slug = this.getProjectSlug(cwd);
-    const dir = join10(getProjectsDir(), slug, "memory");
-    if (!existsSync19(dir)) {
+    const dir = join11(getProjectsDir(), slug, "memory");
+    if (!existsSync20(dir)) {
       try {
-        mkdirSync11(dir, { recursive: true });
+        mkdirSync12(dir, { recursive: true });
       } catch {}
     }
     return dir;
   }
   getMemoryIndexPath(cwd) {
-    return join10(this.getProjectMemoryDir(cwd), "MEMORY.md");
+    return join11(this.getProjectMemoryDir(cwd), "MEMORY.md");
   }
   normalizeCategory(raw) {
     const cat = raw.toLowerCase().trim();
@@ -9205,7 +9406,7 @@ class MemoryStore {
     const sanitizedName = params.name.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `note_${Date.now()}`;
     const memoryDir = this.getProjectMemoryDir(params.cwd);
     const fileName = `${type}_${sanitizedName}.md`;
-    const filePath = join10(memoryDir, fileName);
+    const filePath = join11(memoryDir, fileName);
     const nowIso = new Date().toISOString();
     const cleanContent = params.content.trim();
     const desc = (params.description || cleanContent.split(`
@@ -9240,17 +9441,17 @@ class MemoryStore {
   }
   readTopicMemory(topicNameOrFile, cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    let targetPath = join10(memoryDir, topicNameOrFile);
-    if (!existsSync19(targetPath)) {
+    let targetPath = join11(memoryDir, topicNameOrFile);
+    if (!existsSync20(targetPath)) {
       if (!topicNameOrFile.endsWith(".md")) {
-        targetPath = join10(memoryDir, `${topicNameOrFile}.md`);
+        targetPath = join11(memoryDir, `${topicNameOrFile}.md`);
       }
     }
-    if (!existsSync19(targetPath)) {
-      const files = readdirSync8(memoryDir);
+    if (!existsSync20(targetPath)) {
+      const files = readdirSync9(memoryDir);
       const match = files.find((f) => f.includes(topicNameOrFile));
       if (match) {
-        targetPath = join10(memoryDir, match);
+        targetPath = join11(memoryDir, match);
       } else {
         return null;
       }
@@ -9311,12 +9512,12 @@ class MemoryStore {
   }
   syncMemoryIndex(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    const indexPath = join10(memoryDir, "MEMORY.md");
-    const files = existsSync19(memoryDir) ? readdirSync8(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const indexPath = join11(memoryDir, "MEMORY.md");
+    const files = existsSync20(memoryDir) ? readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
     const items2 = [];
     for (const f of files) {
       try {
-        const full = join10(memoryDir, f);
+        const full = join11(memoryDir, f);
         const parsed = this.parseTopicFile(readFileSync11(full, "utf8"), full);
         items2.push({
           type: parsed.type,
@@ -9343,7 +9544,7 @@ class MemoryStore {
   }
   loadMemoryIndex(cwd) {
     const indexPath = this.getMemoryIndexPath(cwd);
-    if (!existsSync19(indexPath))
+    if (!existsSync20(indexPath))
       return "";
     try {
       const raw = readFileSync11(indexPath, "utf8");
@@ -9359,13 +9560,13 @@ class MemoryStore {
   }
   listProjectMemories(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    if (!existsSync19(memoryDir))
+    if (!existsSync20(memoryDir))
       return [];
-    const files = readdirSync8(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const files = readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
     const list = [];
     for (const f of files) {
       try {
-        const full = join10(memoryDir, f);
+        const full = join11(memoryDir, f);
         list.push(this.parseTopicFile(readFileSync11(full, "utf8"), full));
       } catch {}
     }
@@ -9543,8 +9744,8 @@ async function removeWorktreeGit(repoRoot, worktreePath, deleteBranch = false) {
   return { success: true };
 }
 // src/worktree/manager.ts
-import { resolve as resolve23, join as join11 } from "path";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve23, join as join12 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
 var DEFAULT_WORKTREE_KEEP_COUNT = 15;
 
 class WorktreeManager {
@@ -9568,15 +9769,15 @@ class WorktreeManager {
     const branchName = options.branch || `groupy/${taskId}`;
     const targetDir = options.worktreePath || (this.baseStorageDir ? resolve23(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve23(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
     const worktreeParent = resolve23(targetDir, "..");
-    if (!existsSync20(worktreeParent)) {
-      mkdirSync12(worktreeParent, { recursive: true });
+    if (!existsSync21(worktreeParent)) {
+      mkdirSync13(worktreeParent, { recursive: true });
     }
     const baseBranch = options.baseBranch || await getCurrentBranch(repoRoot);
     const result = await createWorktreeGit(repoRoot, targetDir, branchName, baseBranch);
     if (!result.success) {
       throw new Error(`Failed to create git worktree: ${result.error}`);
     }
-    const metaPath = join11(targetDir, "groupy-thread.json");
+    const metaPath = join12(targetDir, "groupy-thread.json");
     try {
       writeFileSync7(metaPath, JSON.stringify({
         version: 1,
@@ -9602,8 +9803,8 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join11(wt.path, "groupy-thread.json");
-      if (existsSync20(metaPath)) {
+      const metaPath = join12(wt.path, "groupy-thread.json");
+      if (existsSync21(metaPath)) {
         try {
           const raw = JSON.parse(readFileSync12(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
@@ -11333,6 +11534,8 @@ export {
   CodeModeRuntime,
   ContextWindowExceededError,
   CredentialsStore,
+  DEFAULT_AUTO_COMPACT_THRESHOLD_TOKENS,
+  DEFAULT_MAX_CONTEXT_TOKENS,
   DEFAULT_WORKTREE_KEEP_COUNT,
   DefaultModelClientSession,
   DomSnapshotEngine,
@@ -11380,6 +11583,7 @@ export {
   WorktreeManager,
   applyPatchTool,
   askQuestionTool,
+  buildStructuredSystemPrompt,
   buildSystemPrompt,
   captureWorldState,
   compactHistory,