@cryer/star-cli 0.3.7 → 0.3.8

package/dist/{chunk-OOOW7FC4.js → chunk-OHLA2DP7.js}

@@ -75,6 +75,10 @@ var HookConfigSchema = z.object({
 });
 var ConfigSchema = z.object({
   defaultModel: z.string().default(""),
+  // Optional [[models]] name for cheap auxiliary LLM calls (compaction
+  // summaries, session titles, turn completion checks) — Claude Code routes
+  // these to a Haiku-class model. Unset = the active main model does them.
+  smallModel: z.string().optional(),
   permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
   providers: z.array(ProviderConfigSchema).default([]),
   models: z.array(ModelConfigSchema).default([]),
@@ -219,6 +223,16 @@ var SUMMARY_SYSTEM_PROMPT = [
   "- outstanding TODOs and next steps",
   "Output only the summary, no preamble."
 ].join("\n");
+var MAX_SUMMARY_INPUT_CHARS = 8e4;
+var SUMMARY_HEAD_CHARS = 24e3;
+function truncateSummaryInput(transcript) {
+  if (transcript.length <= MAX_SUMMARY_INPUT_CHARS) return transcript;
+  const tailChars = MAX_SUMMARY_INPUT_CHARS - SUMMARY_HEAD_CHARS;
+  const omitted = transcript.length - MAX_SUMMARY_INPUT_CHARS;
+  return `${transcript.slice(0, SUMMARY_HEAD_CHARS)}
+[... ${omitted} characters omitted ...]
+${transcript.slice(-tailChars)}`;
+}
 function serializeMessage(message) {
   if (typeof message.content === "string") {
     return `${message.role}: ${message.content}`;
@@ -234,7 +248,7 @@ function serializeMessage(message) {
   return `${message.role}: ${parts.join("\n")}`;
 }
 async function summarizeMessages(messages, model, signal, temperature) {
-  const transcript = messages.map(serializeMessage).join("\n");
+  const transcript = truncateSummaryInput(messages.map(serializeMessage).join("\n"));
   const { text } = await generateText({
     model,
     system: SUMMARY_SYSTEM_PROMPT,
@@ -710,6 +724,241 @@ async function runHooks(event, hooks2, ctx) {
   return result;
 }
 
+// src/llm/provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+// src/llm/activity.ts
+var trackers = /* @__PURE__ */ new WeakMap();
+function streamActivity(signal) {
+  return trackers.get(signal);
+}
+function wrapFetchWithActivity(baseFetch = fetch) {
+  return async (input, init) => {
+    const response = await baseFetch(input, init);
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : null);
+    if (!signal || !response.body) return response;
+    const tracker = { lastChunkAt: Date.now() };
+    trackers.set(signal, tracker);
+    const reader = response.body.getReader();
+    const body = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          tracker.lastChunkAt = Date.now();
+          controller.enqueue(value);
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+      cancel(reason) {
+        return reader.cancel(reason);
+      }
+    });
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
+
+// src/llm/registry.ts
+function listModels(config) {
+  return config.models;
+}
+function resolveModelConfig(config, modelName) {
+  const name = modelName ?? config.defaultModel;
+  const model = config.models.find((m) => m.name === name);
+  if (!model) {
+    const available = config.models.map((m) => m.name).join(", ") || "(none)";
+    throw new Error(`Model "${name}" not found. Available models: ${available}`);
+  }
+  return model;
+}
+
+// src/llm/sse-normalize.ts
+function splitJsonPrefix(text) {
+  if (!text.startsWith("{")) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return [text.slice(0, i + 1), text.slice(i + 1).trimStart()];
+    }
+  }
+  return null;
+}
+var SseNormalizeTransform = class extends TransformStream {
+  constructor() {
+    let buffer = "";
+    let pending = null;
+    const flushPending = (controller) => {
+      if (pending === null) return;
+      controller.enqueue(`data: ${pending}
+
+`);
+      pending = null;
+    };
+    const emitPayload = (payload, controller) => {
+      let rest = payload;
+      for (; ; ) {
+        const split = splitJsonPrefix(rest);
+        if (!split) {
+          pending = rest;
+          return;
+        }
+        const [json, tail] = split;
+        if (tail === "") {
+          pending = json;
+          return;
+        }
+        controller.enqueue(`data: ${json}
+
+`);
+        if (tail.startsWith("data:")) {
+          rest = tail.slice(5).replace(/^ /, "");
+          continue;
+        }
+        if (tail.startsWith("{")) {
+          rest = tail;
+          continue;
+        }
+        controller.enqueue(`${tail}
+`);
+        return;
+      }
+    };
+    const handleLine = (raw, controller) => {
+      const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+      if (line === "") {
+        flushPending(controller);
+        return;
+      }
+      if (line.startsWith("data:")) {
+        flushPending(controller);
+        emitPayload(line.slice(5).replace(/^ /, ""), controller);
+        return;
+      }
+      if (line.startsWith("{") && pending !== null) {
+        flushPending(controller);
+        emitPayload(line, controller);
+        return;
+      }
+      flushPending(controller);
+      controller.enqueue(`${line}
+`);
+    };
+    super({
+      transform(chunk, controller) {
+        buffer += chunk;
+        let index = buffer.indexOf("\n");
+        while (index !== -1) {
+          handleLine(buffer.slice(0, index), controller);
+          buffer = buffer.slice(index + 1);
+          index = buffer.indexOf("\n");
+        }
+      },
+      flush(controller) {
+        if (buffer.length > 0) handleLine(buffer, controller);
+        flushPending(controller);
+      }
+    });
+  }
+};
+function createSseNormalizingFetch(baseFetch = fetch) {
+  return async (input, init) => {
+    const response = await baseFetch(input, init);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.body || !contentType.includes("text/event-stream")) {
+      return response;
+    }
+    const body = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new SseNormalizeTransform()).pipeThrough(new TextEncoderStream());
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+
+// src/llm/provider.ts
+function resolveApiKey(provider) {
+  const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
+  const apiKey = fromEnv ?? provider.apiKey;
+  if (!apiKey) {
+    const hint = provider.apiKeyEnv ? `set ${provider.apiKeyEnv} or configure apiKey` : "configure apiKey";
+    throw new Error(`Missing API key for provider "${provider.name}": ${hint}`);
+  }
+  return apiKey;
+}
+function createModel(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider) {
+    const available = config.providers.map((p) => p.name).join(", ") || "(none)";
+    throw new Error(
+      `Provider "${modelConfig.provider}" for model "${modelConfig.name}" not found. Available providers: ${available}`
+    );
+  }
+  const apiKey = resolveApiKey(provider);
+  const trackedFetch = wrapFetchWithActivity();
+  switch (provider.protocol) {
+    case "anthropic":
+      return createAnthropic({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        fetch: trackedFetch
+      })(modelConfig.model);
+    case "openai-compatible":
+      return createOpenAICompatible({
+        name: provider.name,
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        fetch: trackedFetch
+      })(modelConfig.model, {}, { includeUsage: true });
+    case "openai-responses":
+      return createOpenAI({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        // Relays fronting the Responses API sometimes batch several JSON
+        // events into one SSE data payload, which the SDK's parser cannot
+        // read; normalize the wire format back to one event per data line.
+        fetch: createSseNormalizingFetch(trackedFetch)
+      }).responses(modelConfig.model);
+  }
+}
+function reasoningEffortMetadata(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  if (!modelConfig.reasoningEffort) return void 0;
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider || provider.protocol === "anthropic") return void 0;
+  const key = provider.protocol === "openai-responses" ? "openai" : provider.name;
+  return { [key]: { reasoningEffort: modelConfig.reasoningEffort } };
+}
+
 // src/llm/retry.ts
 var NON_RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
   "AI_NoSuchToolError",
@@ -788,45 +1037,6 @@ function summarizeStreamError(error) {
 // src/llm/stream.ts
 import { streamText } from "ai";
 
-// src/llm/activity.ts
-var trackers = /* @__PURE__ */ new WeakMap();
-function streamActivity(signal) {
-  return trackers.get(signal);
-}
-function wrapFetchWithActivity(baseFetch = fetch) {
-  return async (input, init) => {
-    const response = await baseFetch(input, init);
-    const signal = init?.signal ?? (input instanceof Request ? input.signal : null);
-    if (!signal || !response.body) return response;
-    const tracker = { lastChunkAt: Date.now() };
-    trackers.set(signal, tracker);
-    const reader = response.body.getReader();
-    const body = new ReadableStream({
-      async pull(controller) {
-        try {
-          const { done, value } = await reader.read();
-          if (done) {
-            controller.close();
-            return;
-          }
-          tracker.lastChunkAt = Date.now();
-          controller.enqueue(value);
-        } catch (error) {
-          controller.error(error);
-        }
-      },
-      cancel(reason) {
-        return reader.cancel(reason);
-      }
-    });
-    return new Response(body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  };
-}
-
 // src/llm/debug.ts
 import { appendFileSync } from "fs";
 import path2 from "path";
@@ -874,6 +1084,24 @@ var GENERATION_PART_TYPES = /* @__PURE__ */ new Set(["text-delta", "reasoning",
 var MAX_KEEPALIVE_SILENCE_MS = 10 * 6e4;
 var CACHE_READ_KEYS = ["cacheReadInputTokens", "cache_read_input_tokens"];
 var CACHED_PROMPT_KEYS = ["cachedPromptTokens", "cached_prompt_tokens", "cachedTokens"];
+function withAnthropicCacheBreakpoints(model, messages) {
+  if (!model.provider.startsWith("anthropic")) return messages;
+  const mark = (message) => ({
+    ...message,
+    experimental_providerMetadata: {
+      ...message.experimental_providerMetadata,
+      anthropic: {
+        ...message.experimental_providerMetadata?.anthropic,
+        cacheControl: { type: "ephemeral" }
+      }
+    }
+  });
+  const result = messages.slice();
+  if (result[0]?.role === "system") result[0] = mark(result[0]);
+  const last = result.length - 1;
+  if (last > 0 && result[last]) result[last] = mark(result[last]);
+  return result;
+}
 function extractCacheUsage(providerMetadata) {
   if (!providerMetadata || typeof providerMetadata !== "object") return {};
   for (const value of Object.values(providerMetadata)) {
@@ -898,7 +1126,7 @@ async function* streamChat(opts) {
   const { openai: openaiMetadata, ...otherMetadata } = opts.providerMetadata ?? {};
   const result = streamText({
     model: opts.model,
-    messages: opts.messages,
+    messages: withAnthropicCacheBreakpoints(opts.model, opts.messages),
     tools: opts.tools,
     abortSignal: controller.signal,
     maxTokens: opts.maxTokens,
@@ -2979,74 +3207,108 @@ var schema5 = z6.object({
   offset: z6.number().int().positive().optional().describe("1-based line number to start reading from"),
   limit: z6.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
 });
-var readFileTool = {
-  name: "read_file",
-  description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default.",
-  permission: "read",
-  parameters: schema5,
-  async execute(args, ctx) {
-    const filePath = path11.resolve(ctx.cwd, args.path);
-    const resolvedPath = await realpath2(filePath).catch(() => null);
-    if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
-      return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
-    }
-    const st = await stat5(filePath).catch(() => null);
-    if (!st) {
-      return { content: `File not found: ${args.path}`, isError: true };
-    }
-    if (st.isDirectory()) {
-      return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
-    }
-    const bytesToRead = Math.min(st.size, MAX_READ_BYTES);
-    const fileCapped = st.size > MAX_READ_BYTES;
-    const handle = await open(filePath, "r").catch(() => null);
-    if (!handle) {
-      return { content: `Failed to read ${args.path}`, isError: true };
-    }
-    let buf;
-    try {
-      const { bytesRead, buffer } = await handle.read(Buffer.alloc(bytesToRead), 0, bytesToRead, 0);
-      buf = buffer.subarray(0, bytesRead);
-    } finally {
-      await handle.close().catch(() => {
-      });
-    }
-    const decoded = decodeTextBuffer(buf);
-    if ("binary" in decoded) {
-      return { content: `Cannot read binary file: ${args.path}`, isError: true };
-    }
-    const lines = decoded.text.split("\n");
-    const totalDesc = fileCapped ? `at least ${lines.length}` : `${lines.length}`;
-    const start = args.offset ?? 1;
-    const limit = args.limit ?? DEFAULT_LIMIT;
-    if (start > lines.length) {
-      return { content: `(offset ${start} beyond end of file; file has ${totalDesc} lines)` };
-    }
-    const end = Math.min(lines.length, start - 1 + limit);
-    const out = [];
-    let size = 0;
-    let truncatedBySize = false;
-    for (let i = start - 1; i < end; i++) {
-      const line = (lines[i] ?? "").replace(/\r$/, "");
-      const numbered = `${i + 1}	${line}`;
-      if (size + numbered.length > MAX_CHARS) {
-        truncatedBySize = true;
-        break;
+var READ_CACHE_MAX_ENTRIES = 200;
+function createReadFileTool() {
+  const cache4 = /* @__PURE__ */ new Map();
+  return {
+    name: "read_file",
+    description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default. Re-reading an unchanged file range returns a short note instead of the content.",
+    permission: "read",
+    parameters: schema5,
+    reset: () => cache4.clear(),
+    async execute(args, ctx) {
+      const filePath = path11.resolve(ctx.cwd, args.path);
+      const resolvedPath = await realpath2(filePath).catch(() => null);
+      if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
+        return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
       }
-      out.push(numbered);
-      size += numbered.length;
-    }
-    const lastShown = start - 1 + out.length;
-    if (truncatedBySize) {
-      out.push(
-        `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${totalDesc})`
-      );
-    } else if (end < lines.length || fileCapped) {
-      out.push(`... (truncated: showing lines ${start}-${end} of ${totalDesc})`);
+      const st = await stat5(filePath).catch(() => null);
+      if (!st) {
+        return { content: `File not found: ${args.path}`, isError: true };
+      }
+      if (st.isDirectory()) {
+        return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
+      }
+      const start = args.offset ?? 1;
+      const limit = args.limit ?? DEFAULT_LIMIT;
+      const cacheKey = resolvedPath ?? filePath;
+      const hit = cache4.get(cacheKey);
+      if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+        const requestedEnd = Math.min(hit.totalLines, start - 1 + limit);
+        if (start >= hit.start && requestedEnd <= hit.end && start <= hit.totalLines) {
+          return {
+            content: `[unchanged since last read: ${args.path} \u2014 lines ${start}-${requestedEnd} of ${hit.totalLines} are already in context and the file has not changed]`
+          };
+        }
+      }
+      const bytesToRead = Math.min(st.size, MAX_READ_BYTES);
+      const fileCapped = st.size > MAX_READ_BYTES;
+      const handle = await open(filePath, "r").catch(() => null);
+      if (!handle) {
+        return { content: `Failed to read ${args.path}`, isError: true };
+      }
+      let buf;
+      try {
+        const { bytesRead, buffer } = await handle.read(
+          Buffer.alloc(bytesToRead),
+          0,
+          bytesToRead,
+          0
+        );
+        buf = buffer.subarray(0, bytesRead);
+      } finally {
+        await handle.close().catch(() => {
+        });
+      }
+      const decoded = decodeTextBuffer(buf);
+      if ("binary" in decoded) {
+        return { content: `Cannot read binary file: ${args.path}`, isError: true };
+      }
+      const lines = decoded.text.split("\n");
+      const totalDesc = fileCapped ? `at least ${lines.length}` : `${lines.length}`;
+      if (start > lines.length) {
+        return { content: `(offset ${start} beyond end of file; file has ${totalDesc} lines)` };
+      }
+      const end = Math.min(lines.length, start - 1 + limit);
+      const out = [];
+      let size = 0;
+      let truncatedBySize = false;
+      for (let i = start - 1; i < end; i++) {
+        const line = (lines[i] ?? "").replace(/\r$/, "");
+        const numbered = `${i + 1}	${line}`;
+        if (size + numbered.length > MAX_CHARS) {
+          truncatedBySize = true;
+          break;
+        }
+        out.push(numbered);
+        size += numbered.length;
+      }
+      const lastShown = start - 1 + out.length;
+      if (truncatedBySize) {
+        out.push(
+          `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${totalDesc})`
+        );
+      } else if (end < lines.length || fileCapped) {
+        out.push(`... (truncated: showing lines ${start}-${end} of ${totalDesc})`);
+      }
+      if (out.length > 0) {
+        if (cache4.size >= READ_CACHE_MAX_ENTRIES) cache4.clear();
+        const prev = hit?.mtimeMs === st.mtimeMs && hit.size === st.size ? hit : void 0;
+        cache4.set(cacheKey, {
+          mtimeMs: st.mtimeMs,
+          size: st.size,
+          totalLines: lines.length,
+          // Extend the remembered range when the new read overlaps or abuts
+          // the previous one; disjoint ranges replace it.
+          start: prev && start <= prev.end + 1 ? Math.min(prev.start, start) : start,
+          end: prev && lastShown >= prev.start - 1 ? Math.max(prev.end, lastShown) : lastShown
+        });
+      }
+      return { content: out.join("\n") };
     }
-    return { content: out.join("\n") };
-  }
-};
+  };
+}
+var readFileTool = createReadFileTool();
 
 // src/tools/fs/read-image.ts
 import { readFile as readFile5, realpath as realpath3, stat as stat6 } from "fs/promises";
@@ -3274,9 +3536,160 @@ var writeFileTool = {
   }
 };
 
-// src/tools/tasks.ts
+// src/tools/screenshot.ts
 import { z as z9 } from "zod";
 
+// src/core/screenshot.ts
+import { execFile as execFile3 } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile6, unlink as unlink2 } from "fs/promises";
+import os5 from "os";
+import path15 from "path";
+import { promisify as promisify2 } from "util";
+var SCREENSHOT_TIMEOUT_MS = 2e4;
+var execFileAsync2 = promisify2(execFile3);
+function windowsScreenshotScript(outputFile) {
+  const output = outputFile.replace(/'/g, "''");
+  return [
+    `try { Add-Type -MemberDefinition '[DllImport("user32.dll")] public static extern bool SetProcessDpiAwarenessContext(int v);' -Name Dpi -Namespace StarShot -ErrorAction Stop; [void][StarShot.Dpi]::SetProcessDpiAwarenessContext(-4) } catch { }`,
+    "Add-Type -AssemblyName System.Windows.Forms,System.Drawing",
+    "$b = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds",
+    "$bmp = New-Object System.Drawing.Bitmap($b.Width, $b.Height)",
+    "$g = [System.Drawing.Graphics]::FromImage($bmp)",
+    "$g.CopyFromScreen($b.Left, $b.Top, 0, 0, $bmp.Size)",
+    `$bmp.Save('${output}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "$g.Dispose(); $bmp.Dispose()"
+  ].join("; ");
+}
+function screenshotPlan(platform, outputFile, env = process.env, tools = {}) {
+  if (platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", windowsScreenshotScript(outputFile)]
+    };
+  }
+  if (platform === "darwin") {
+    return { command: "screencapture", args: ["-x", "-D", "1", outputFile] };
+  }
+  if (platform === "linux") {
+    if (env.WAYLAND_DISPLAY) {
+      if (tools.grim) return { command: "grim", args: [outputFile] };
+      if (tools["gnome-screenshot"]) {
+        return { command: "gnome-screenshot", args: ["-f", outputFile] };
+      }
+      if (tools.spectacle) {
+        return { command: "spectacle", args: ["-b", "-n", "-o", outputFile] };
+      }
+      return null;
+    }
+    if (env.DISPLAY) {
+      if (tools.import) return { command: "import", args: ["-window", "root", outputFile] };
+      if (tools.scrot) return { command: "scrot", args: ["--overwrite", outputFile] };
+      if (tools["gnome-screenshot"]) {
+        return { command: "gnome-screenshot", args: ["-f", outputFile] };
+      }
+      if (tools.spectacle) {
+        return { command: "spectacle", args: ["-b", "-n", "-o", outputFile] };
+      }
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function noScreenshotToolMessage(platform, env = process.env) {
+  if (platform === "linux") {
+    if (!env.WAYLAND_DISPLAY && !env.DISPLAY) {
+      return "no display server (neither DISPLAY nor WAYLAND_DISPLAY is set) \u2014 this session is headless (e.g. SSH), there is no screen to capture";
+    }
+    return "no screenshot tool found \u2014 install one of: grim or spectacle (Wayland), scrot or ImageMagick's import (X11), or gnome-screenshot";
+  }
+  return `screenshots are not supported on this platform (${platform})`;
+}
+async function commandExists2(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync2(checker, [command], { timeout: SCREENSHOT_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LINUX_TOOL_NAMES = ["grim", "gnome-screenshot", "spectacle", "import", "scrot"];
+async function captureScreenshot() {
+  const outputFile = path15.join(os5.tmpdir(), `star-screenshot-${randomUUID3()}.png`);
+  try {
+    const tools = {};
+    if (process.platform === "linux") {
+      const found = await Promise.all(LINUX_TOOL_NAMES.map(commandExists2));
+      for (const [i, name] of LINUX_TOOL_NAMES.entries()) {
+        tools[name] = found[i] ?? false;
+      }
+    }
+    const plan = screenshotPlan(process.platform, outputFile, process.env, tools);
+    if (!plan) {
+      return { ok: false, error: noScreenshotToolMessage(process.platform) };
+    }
+    try {
+      await execFileAsync2(plan.command, plan.args, { timeout: SCREENSHOT_TIMEOUT_MS });
+    } catch (err) {
+      const detail = err instanceof Error && err.message ? ` (${err.message})` : "";
+      return { ok: false, error: `${plan.command} failed to capture the screen${detail}` };
+    }
+    const buf = await readFile6(outputFile).catch(() => null);
+    if (!buf || buf.length === 0) {
+      return { ok: false, error: `${plan.command} produced no image file` };
+    }
+    if (!probeImageDimensions(buf)) {
+      return { ok: false, error: `${plan.command} produced an unrecognized image file` };
+    }
+    const downsampled = await downsampleImageIfNeeded({
+      path: "screen",
+      mimeType: "image/png",
+      data: buf.toString("base64")
+    });
+    if (downsampled.oversized && !downsampled.resized) {
+      return {
+        ok: false,
+        error: "screenshot exceeds 2000px and could not be downsampled on this platform"
+      };
+    }
+    return { ok: true, image: downsampled.image };
+  } finally {
+    await unlink2(outputFile).catch(() => {
+    });
+  }
+}
+
+// src/tools/screenshot.ts
+var schema8 = z9.object({});
+function createScreenshotTool(capture = captureScreenshot) {
+  return {
+    name: "screenshot",
+    description: "Capture a screenshot of the primary display and see it. Use this to check the actual visual result of a running program (web page, GUI) \u2014 e.g. after starting a dev server \u2014 instead of inferring from code. The capture shows exactly what is visible on screen, including overlapping windows: content hidden behind other windows cannot be seen, so if a specific window matters ask the user to bring it to the front first. Note the capture may include anything else currently on screen.",
+    permission: "read",
+    parameters: schema8,
+    async execute() {
+      const result = await capture();
+      if (!result.ok) {
+        return { content: `Screenshot failed: ${result.error}`, isError: true };
+      }
+      const image = result.image;
+      const dims = probeImageDimensions(Buffer.from(image.data, "base64"));
+      const sizeKB = Math.round(image.data.length / 1024);
+      const desc = dims ? `${dims.width}x${dims.height}` : "unknown dimensions";
+      return {
+        content: `Screenshot captured (${desc}, ~${sizeKB}KB). The image is attached below \u2014 look at it now.`,
+        images: [image]
+      };
+    }
+  };
+}
+var screenshotTool = createScreenshotTool();
+
+// src/tools/tasks.ts
+import { z as z10 } from "zod";
+
 // src/agent/agent-tasks.ts
 import { EventEmitter as EventEmitter2 } from "events";
 var MAX_FINISHED_RECORDS2 = 50;
@@ -3446,8 +3859,8 @@ function formatTaskFinished(task) {
 }
 
 // src/tools/tasks.ts
-var idSchema = z9.object({
-  id: z9.string().describe("Task id, e.g. task-1 or agent-1")
+var idSchema = z10.object({
+  id: z10.string().describe("Task id, e.g. task-1 or agent-1")
 });
 function truncateOutput(s) {
   if (s.length <= MAX_OUTPUT) return s;
@@ -3464,7 +3877,7 @@ var taskListTool = {
   name: "task_list",
   description: "List background tasks (shell commands and subagents) with status and runtime.",
   permission: "read",
-  parameters: z9.object({}),
+  parameters: z10.object({}),
   execute() {
     const shell = formatTaskList(defaultTaskManager.list());
     const agents = defaultAgentTasks.list();
@@ -3523,20 +3936,20 @@ var taskKillTool = {
 };
 
 // src/tools/todo.ts
-import { mkdir as mkdir4, readFile as readFile6, rename, writeFile as writeFile6 } from "fs/promises";
-import path15 from "path";
-import { z as z10 } from "zod";
-var todoItemSchema = z10.object({
-  id: z10.number().int(),
-  title: z10.string(),
-  status: z10.enum(["pending", "in_progress", "done"])
+import { mkdir as mkdir4, readFile as readFile7, rename, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import path16 from "path";
+import { z as z11 } from "zod";
+var todoItemSchema = z11.object({
+  id: z11.number().int(),
+  title: z11.string(),
+  status: z11.enum(["pending", "in_progress", "done"])
 });
-var writeSchema = z10.object({
-  todos: z10.array(todoItemSchema).describe("The full todo list, replacing the current one")
+var writeSchema = z11.object({
+  todos: z11.array(todoItemSchema).describe("The full todo list, replacing the current one")
 });
-var readSchema = z10.object({});
+var readSchema = z11.object({});
 function fileFor(cwd) {
-  return path15.join(cwd, ".star", "todos.json");
+  return path16.join(cwd, ".star", "todos.json");
 }
 var persistGuard = () => true;
 function setTodoPersistGuard(guard) {
@@ -3556,7 +3969,7 @@ var TodoStore = class {
   async load(cwd) {
     let raw;
     try {
-      raw = await readFile6(fileFor(cwd), "utf8");
+      raw = await readFile7(fileFor(cwd), "utf8");
     } catch {
       return;
     }
@@ -3569,15 +3982,22 @@ var TodoStore = class {
     }
   }
   // Atomic write (tmp + rename): a crash or failed save can never leave a
-  // truncated todos.json behind.
+  // truncated todos.json behind. An empty or fully completed list has no
+  // resume value — rehydrating it would only restore finished work — so the
+  // file is deleted instead of persisted.
   async save(cwd) {
     if (!persistGuard()) {
       return;
     }
-    await mkdir4(path15.join(cwd, ".star"), { recursive: true });
+    const items = this.list();
     const file = fileFor(cwd);
+    if (items.length === 0 || items.every((it) => it.status === "done")) {
+      await rm3(file, { force: true });
+      return;
+    }
+    await mkdir4(path16.join(cwd, ".star"), { recursive: true });
     const tmp = `${file}.tmp`;
-    await writeFile6(tmp, `${JSON.stringify(this.list(), null, 2)}
+    await writeFile6(tmp, `${JSON.stringify(items, null, 2)}
 `);
     await rename(tmp, file);
   }
@@ -3650,13 +4070,13 @@ function createTodoTools(store = defaultStore) {
 }
 
 // src/tools/web/fetch.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var DEFAULT_MAX_CHARS = 2e4;
 var MAX_BYTES = 2 * 1024 * 1024;
 var TIMEOUT_MS = 3e4;
-var schema8 = z11.object({
-  url: z11.string().describe("The http(s) URL to fetch"),
-  maxChars: z11.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+var schema9 = z12.object({
+  url: z12.string().describe("The http(s) URL to fetch"),
+  maxChars: z12.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
 });
 function safeCodePoint(n, raw) {
   if (!Number.isInteger(n) || n < 0 || n > 1114111) {
@@ -3727,7 +4147,7 @@ var webFetchTool = {
   name: "web_fetch",
   description: "Fetch a URL over http(s) and return its contents as readable text. HTML pages are converted to plain text (tags, scripts and styles removed). Output is truncated to maxChars (default 20000). Can reach internal/intranet addresses, so do not use it for untrusted URLs.",
   permission: "read",
-  parameters: schema8,
+  parameters: schema9,
   async execute(args, ctx) {
     let url;
     try {
@@ -3790,15 +4210,15 @@ var webFetchTool = {
 };
 
 // src/tools/web/search.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var TIMEOUT_MS2 = 15e3;
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS_LIMIT = 10;
 var SEARCH_URL = "https://html.duckduckgo.com/html/?q=";
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
-var schema9 = z12.object({
-  query: z12.string().min(1).describe("The search query"),
-  maxResults: z12.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+var schema10 = z13.object({
+  query: z13.string().min(1).describe("The search query"),
+  maxResults: z13.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
     `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
   )
 });
@@ -3849,7 +4269,7 @@ var webSearchTool = {
   name: "web_search",
   description: "Search the web using DuckDuckGo and return a numbered list of results with title, URL and snippet. No API key required. Use web_fetch to read a result's full page.",
   permission: "read",
-  parameters: schema9,
+  parameters: schema10,
   async execute(args, ctx) {
     const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
     const url = `${SEARCH_URL}${encodeURIComponent(args.query)}`;
@@ -3911,8 +4331,11 @@ var ToolRegistry = class {
   // their own instance so a child's todo_write cannot clobber the parent list.
   constructor(todoStore) {
     for (const tool of [
-      readFileTool,
+      // Fresh per registry (i.e. per agent loop): the unchanged-since-last-
+      // read cache must not leak across loops, whose contexts differ.
+      createReadFileTool(),
       readImageTool,
+      screenshotTool,
       writeFileTool,
       editFileTool,
       globTool,
@@ -3931,6 +4354,12 @@ var ToolRegistry = class {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  // Drops per-session volatile tool state after a wholesale history rewrite
+  // (compaction, /undo, resume): anything a tool remembers as "already sent
+  // to the model" may no longer be in the context.
+  resetVolatileState() {
+    for (const tool of this.tools.values()) tool.reset?.();
+  }
   get(name) {
     return this.tools.get(name);
   }
@@ -3944,12 +4373,12 @@ var ToolRegistry = class {
 
 // src/agent/project-memory.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import path16 from "path";
+import path17 from "path";
 var PROJECT_MEMORY_FILE = "AGENTS.md";
 var PROJECT_MEMORY_MAX_CHARS = 32 * 1024;
 var cache = /* @__PURE__ */ new Map();
 function readProjectMemory(cwd) {
-  const file = path16.join(cwd, PROJECT_MEMORY_FILE);
+  const file = path17.join(cwd, PROJECT_MEMORY_FILE);
   let mtimeMs;
   try {
     mtimeMs = statSync2(file).mtimeMs;
@@ -3979,8 +4408,8 @@ ${body}`;
 
 // src/agent/skills.ts
 import { readFileSync as readFileSync3, readdirSync, statSync as statSync3 } from "fs";
-import path17 from "path";
-import { z as z13 } from "zod";
+import path18 from "path";
+import { z as z14 } from "zod";
 var SKILL_FILE = "SKILL.md";
 var SKILL_MAX_CHARS = 32 * 1024;
 var NAME_PATTERN = /^[a-z0-9-]+$/;
@@ -4010,7 +4439,7 @@ function parseSkillFile(filePath, dirName, scope) {
     const name = parsed?.meta.name || dirName;
     const description = parsed?.meta.description;
     if (parsed && NAME_PATTERN.test(name) && description) {
-      skill = { name, description, filePath, dir: path17.dirname(filePath), scope };
+      skill = { name, description, filePath, dir: path18.dirname(filePath), scope };
     }
   } catch {
     skill = null;
@@ -4027,14 +4456,14 @@ function scanDir(base, scope, into) {
   }
   for (const entry of entries.sort()) {
     if (!NAME_PATTERN.test(entry)) continue;
-    const parsed = parseSkillFile(path17.join(base, entry, SKILL_FILE), entry, scope);
+    const parsed = parseSkillFile(path18.join(base, entry, SKILL_FILE), entry, scope);
     if (parsed) into.set(parsed.name, parsed);
   }
 }
 function discoverSkills(cwd, home = starHome()) {
   const byName = /* @__PURE__ */ new Map();
-  scanDir(path17.join(home, "skills"), "user", byName);
-  scanDir(path17.join(cwd, ".star", "skills"), "project", byName);
+  scanDir(path18.join(home, "skills"), "user", byName);
+  scanDir(path18.join(cwd, ".star", "skills"), "project", byName);
   return [...byName.values()];
 }
 function formatSkillsBlock(skills) {
@@ -4065,8 +4494,8 @@ function createSkillTool(deps) {
     name: "skill",
     description: "Load the full instructions of a skill by name. Available skills are listed in the system prompt when present; call this before starting work that matches one of them.",
     permission: "read",
-    parameters: z13.object({
-      name: z13.string().describe("Name of the skill to load, as listed in the system prompt.")
+    parameters: z14.object({
+      name: z14.string().describe("Name of the skill to load, as listed in the system prompt.")
     }),
     async execute(args) {
       const skills = discoverSkills(deps.cwd, deps.home);
@@ -4096,7 +4525,7 @@ function createSkillTool(deps) {
 }
 
 // src/agent/subagent.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/tools/index.ts
 function createDefaultRegistry(todoStore) {
@@ -4137,7 +4566,7 @@ function convertUsagePricing(usage, from, to, config) {
   return result;
 }
 async function runSubagent(deps, args, cwd, signal) {
-  const { AgentLoop: AgentLoop2 } = await import("./loop-DVVPIOS7.js");
+  const { AgentLoop: AgentLoop2 } = await import("./loop-2MOFLXTG.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -4208,10 +4637,10 @@ function createSubagentTool(deps) {
     name: "subagent",
     description: "Spawn a subagent with its own agent loop to handle a focused subtask (research, exploration, or an isolated change). The subagent has the same tools but cannot spawn further subagents. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation. Set run_in_background to start it without blocking: independent subtasks then run concurrently and their reports are delivered to you automatically when they finish (also inspectable via task_list/task_output/task_kill).",
     permission: "exec",
-    parameters: z14.object({
-      prompt: z14.string().describe("Complete, self-contained instructions for the subagent."),
-      description: z14.string().optional().describe("Short label for the subtask, shown in the result header."),
-      run_in_background: z14.boolean().optional().describe(
+    parameters: z15.object({
+      prompt: z15.string().describe("Complete, self-contained instructions for the subagent."),
+      description: z15.string().optional().describe("Short label for the subtask, shown in the result header."),
+      run_in_background: z15.boolean().optional().describe(
         "Run concurrently in the background and return a task id immediately (default false). Use for independent subtasks that can run in parallel."
       )
     }),
@@ -4238,13 +4667,13 @@ function createSubagentTool(deps) {
 
 // src/agent/user-memory.ts
 import { appendFileSync as appendFileSync2, mkdirSync, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import path18 from "path";
-import { z as z15 } from "zod";
+import path19 from "path";
+import { z as z16 } from "zod";
 var USER_MEMORY_MAX_CHARS = 32 * 1024;
 var REMEMBER_TEXT_MAX_CHARS = 500;
 var cache3 = /* @__PURE__ */ new Map();
 function readUserMemory(home = starHome()) {
-  const file = path18.join(home, "MEMORY.md");
+  const file = path19.join(home, "MEMORY.md");
   let mtimeMs;
   try {
     mtimeMs = statSync4(file).mtimeMs;
@@ -4276,7 +4705,7 @@ function readUserMemory(home = starHome()) {
 }
 function appendUserMemory(text, home = starHome()) {
   mkdirSync(home, { recursive: true });
-  appendFileSync2(path18.join(home, "MEMORY.md"), `- ${text}
+  appendFileSync2(path19.join(home, "MEMORY.md"), `- ${text}
 `, "utf8");
 }
 function createRememberTool(deps = {}) {
@@ -4284,8 +4713,8 @@ function createRememberTool(deps = {}) {
     name: "remember",
     description: `Save a note to the user's long-term memory (${userMemoryPath()}), injected into every future session. ONLY use when the user explicitly asks to remember or save something. Never use autonomously.`,
     permission: "write",
-    parameters: z15.object({
-      text: z15.string().max(REMEMBER_TEXT_MAX_CHARS).describe("The note to save, as a single concise sentence.")
+    parameters: z16.object({
+      text: z16.string().max(REMEMBER_TEXT_MAX_CHARS).describe("The note to save, as a single concise sentence.")
     }),
     async execute(args) {
       appendUserMemory(args.text, deps.home);
@@ -4310,6 +4739,24 @@ function finalNudgeWarning(autoContinues, maxAutoContinues) {
   return autoContinues >= maxAutoContinues ? " This is the final automatic continuation \u2014 if your next reply again has no tool calls, nudging stops and the turn is handed back to the user. Finish the work now or summarize what remains." : "";
 }
 var COMPLETION_CHECK_TIMEOUT_MS = 3e4;
+function attachTurnContext(messages, context) {
+  if (!context) return messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "user") continue;
+    const reminder = {
+      type: "text",
+      text: `<system-reminder>
+${context}
+</system-reminder>`
+    };
+    const content = typeof message.content === "string" ? message.content ? [reminder, { type: "text", text: message.content }] : [reminder] : [reminder, ...message.content];
+    const copy = messages.slice();
+    copy[i] = { ...message, content };
+    return copy;
+  }
+  return messages;
+}
 async function checkTaskComplete(model, request, finalReply, signal, temperature) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), COMPLETION_CHECK_TIMEOUT_MS);
@@ -4417,6 +4864,16 @@ var AgentLoop = class {
   activeTurnUserIndex = -1;
   titleScheduled = false;
   titleInput;
+  // Rendered git context for the in-flight turn (null when unavailable);
+  // snapshotted at turn start so every step of the turn sends the same block.
+  turnGitContext = null;
+  // Lazily resolved auxiliary model (config.smallModel) for cheap side calls
+  // — compaction summaries, session titles, completion checks. Undefined =
+  // use the main model; a resolution failure is surfaced once as a notice.
+  auxModelResolved = false;
+  auxModelValue;
+  auxTemperatureValue;
+  auxModelError = null;
   confirmHandler;
   // Hook failures never block the turn (except an explicit PreToolUse block);
   // their stderr surfaces through this callback (REPL system message / stderr
@@ -4462,6 +4919,29 @@ var AgentLoop = class {
   getMessages() {
     return this.messages;
   }
+  // Auxiliary model for cheap side calls: config.smallModel, resolved once.
+  // An unresolvable name/key degrades to the main model instead of breaking
+  // turns; the failure rides out once as a notice at the next turn start.
+  resolveAuxModel() {
+    if (this.auxModelResolved) return;
+    this.auxModelResolved = true;
+    const name = this.opts.config.smallModel;
+    if (!name) return;
+    try {
+      this.auxModelValue = createModel(this.opts.config, name);
+      this.auxTemperatureValue = resolveModelConfig(this.opts.config, name).temperature ?? this.opts.temperature;
+    } catch (error) {
+      this.auxModelError = `smallModel "${name}" could not be resolved (${error instanceof Error ? error.message : String(error)}); using the main model for auxiliary calls.`;
+    }
+  }
+  getAuxModel() {
+    this.resolveAuxModel();
+    return this.auxModelValue ?? this.opts.model;
+  }
+  getAuxTemperature() {
+    this.resolveAuxModel();
+    return this.auxModelValue ? this.auxTemperatureValue : this.opts.temperature;
+  }
   // Rebinds the per-call provider metadata (e.g. after the reasoning effort
   // for the current model changed via /model) without recreating the loop.
   setProviderMetadata(metadata) {
@@ -4502,6 +4982,7 @@ var AgentLoop = class {
     this.messages = reconcileToolCalls(messages);
     this.turnMarkers = [];
     this.redoStack = [];
+    this.opts.registry?.resetVolatileState();
   }
   // Read-only counterpart of retractLastTurn: how many messages /undo would
   // drop, which snapshot turn's file changes it would revert (undefined =
@@ -4533,6 +5014,7 @@ var AgentLoop = class {
     this.lastUndoneLabel = messageText(this.messages[userIndex]).slice(0, REDO_LABEL_MAX);
     this.messages = result.messages;
     await this.opts.sessionStore?.replaceMessages([...this.messages]);
+    this.opts.registry?.resetVolatileState();
     const last = this.turnMarkers[this.turnMarkers.length - 1];
     let turn;
     let tree;
@@ -4614,6 +5096,7 @@ var AgentLoop = class {
     if (removed === 0) return 0;
     this.messages = this.messages.slice(0, cut);
     await this.opts.sessionStore?.replaceMessages([...this.messages]);
+    this.opts.registry?.resetVolatileState();
     this.turnMarkers = this.turnMarkers.filter((m) => m.userIndex < cut);
     this.redoStack = [];
     return removed;
@@ -4649,7 +5132,7 @@ var AgentLoop = class {
     const input = this.titleInput;
     if (!input) return;
     this.titleScheduled = true;
-    scheduleSessionTitle(store, input, this.opts.model);
+    scheduleSessionTitle(store, input, this.getAuxModel());
   }
   // A user interrupt (Esc) ends the turn mid-stream, before the normal
   // assistant-message persistence runs. Whatever text and tool calls already
@@ -4694,6 +5177,13 @@ var AgentLoop = class {
   }
   async *stream(input, signal, opts) {
     this.syncSystemMessage();
+    const git = getGitSummaryCached(this.opts.cwd);
+    this.turnGitContext = git ? formatGitSummary(git) : null;
+    this.resolveAuxModel();
+    if (this.auxModelError) {
+      yield { type: "notice", message: this.auxModelError };
+      this.auxModelError = null;
+    }
     const inputText = typeof input === "string" ? input : input.text;
     const images = typeof input === "string" ? [] : input.images;
     if (this.titleInput === void 0 && inputText.trim().length > 0) {
@@ -4773,6 +5263,7 @@ ${finished.result}`
         this.messages = await this.applyCompactionSummary(compacted, signal);
         await this.opts.sessionStore?.replaceMessages([...this.messages]);
         this.turnMarkers = [];
+        this.opts.registry?.resetVolatileState();
       }
       const maxRetries = Math.max(0, config.streamMaxRetries);
       const baseDelay = this.opts.retryDelayMs ?? STREAM_RETRY_BASE_DELAY_MS;
@@ -4929,11 +5420,11 @@ ${finished.result}`
           )}. Complete them now with tool calls, or update the list with todo_write if they are no longer needed.`;
         } else if (usedToolsThisTurn && !signal.aborted) {
           const complete = await checkTaskComplete(
-            this.opts.model,
+            this.getAuxModel(),
             inputText,
             text,
             signal,
-            this.opts.temperature
+            this.getAuxTemperature()
           );
           if (complete === false) {
             reason = "completion check reports the task unfinished";
@@ -5061,14 +5552,11 @@ ${finished.result}`
   // The permission mode can change at runtime, so the system message is
   // recomputed at the start of every turn instead of being frozen by the
   // constructor. Also restores a system message after loadMessages() (resume,
-  // /model switch) replaced the history with one that has none. Git context
-  // (branch, dirty count, recent commits) is refreshed here too, so the model
-  // always sees the current repo state; any git failure is silently skipped.
-  // Project memory (AGENTS.md in the cwd) and user memory (~/.star-cli/
-  // MEMORY.md) are appended as delimited blocks; both cache by mtime, so this
-  // stays cheap per turn. The
-  // skills listing is refreshed here as well, so skills added mid-session
-  // show up in the next turn's system prompt.
+  // /model switch) replaced the history with one that has none. Everything in
+  // here is stable across turns (base prompt, plan-mode flag, memories, skills
+  // — the latter two cached by mtime), which keeps the prompt-cache prefix
+  // intact; volatile git state rides per-turn on the latest user message
+  // instead (attachTurnContext).
   syncSystemMessage() {
     const base = this.opts.system;
     const plan = this.opts.config.permissionMode === "plan";
@@ -5081,8 +5569,6 @@ ${finished.result}`
     if (userMemory) parts.push(userMemory);
     const skills = discoverSkills(this.opts.cwd);
     if (skills.length > 0) parts.push(formatSkillsBlock(skills));
-    const git = getGitSummaryCached(this.opts.cwd);
-    if (git) parts.push(formatGitSummary(git));
     if (parts.length === 0) return;
     const content = parts.join("\n\n");
     const head = this.messages[0];
@@ -5093,14 +5579,19 @@ ${finished.result}`
     }
   }
   async applyCompactionSummary(compacted, signal) {
-    const { config, model } = this.opts;
-    if (config.contextCompaction !== "summary" || !model) {
+    const { config } = this.opts;
+    if (config.contextCompaction !== "summary") {
       return compacted.messages;
     }
     const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
     const dropped = this.messages.slice(headCount, headCount + compacted.droppedCount);
     try {
-      const summary = await summarizeMessages(dropped, model, signal, this.opts.temperature);
+      const summary = await summarizeMessages(
+        dropped,
+        this.getAuxModel(),
+        signal,
+        this.getAuxTemperature()
+      );
       const messages = compacted.messages.slice();
       messages[headCount] = {
         role: "user",
@@ -5115,7 +5606,7 @@ ${summary}`
   async *streamOnce(aiTools, signal, timeoutScale = 1) {
     for await (const event of streamChat({
       model: this.opts.model,
-      messages: this.messages,
+      messages: attachTurnContext(this.messages, this.turnGitContext),
       tools: aiTools,
       abortSignal: signal,
       providerMetadata: this.opts.providerMetadata,
@@ -5311,7 +5802,10 @@ export {
   collectWorkingDiff,
   MAX_IMAGE_DIMENSION,
   reconcileToolCalls,
-  wrapFetchWithActivity,
+  listModels,
+  resolveModelConfig,
+  createModel,
+  reasoningEffortMetadata,
   starHome,
   globalConfigPath,
   sessionsDir,
@@ -5349,6 +5843,7 @@ export {
   createDefaultRegistry,
   appendUserMemory,
   PLAN_MODE_PROMPT,
+  attachTurnContext,
   AgentLoop
 };
-//# sourceMappingURL=chunk-OOOW7FC4.js.map
+//# sourceMappingURL=chunk-OHLA2DP7.js.map