@cryer/star-cli 0.3.7 → 0.3.9

package/README.md

@@ -17,7 +17,7 @@ Multi-model LLM access · streaming terminal UI · tool calling · permission co
 
 </div>
 
-Features: streaming REPL with slash commands (+ autocomplete) · OpenAI / Anthropic / OpenAI-compatible providers with an interactive `/connect` onboarding wizard · built-in fs / bash / web tools with a permission gate · git integration (`/commit` drafts Conventional Commits messages, `/diff` shows a colored working-tree diff, repo status injected into the system prompt) · plan mode with read-only research and plan approval · thinking spinner with dim reasoning preview · diff preview on write/edit approval · `@file` mentions · `!cmd` shell passthrough · custom slash commands from Markdown files · conversation compaction (`/compact`) · session persistence and resume with auto-generated titles (`/resume`, `star -r`) · subagent delegation for focused subtasks · lifecycle hooks (`PreToolUse`/`PostToolUse`/`Stop` shell commands from config) · file-write snapshots with `/undo` and checkpoint rollback with `/rewind` · TODO task tracking · background shell tasks with status-bar visibility (`/tasks`) · terminal bell on long turns and background-task completion · Markdown session export (`/export`) · `/init` + `/doctor` project scaffolding and environment checks · cost estimation · update notifier · `--json` NDJSON output for scripting.
+Features: streaming REPL with slash commands (+ autocomplete) · OpenAI / Anthropic / OpenAI-compatible providers with an interactive `/connect` onboarding wizard · built-in fs / bash / web tools with a permission gate · git integration (`/commit` drafts Conventional Commits messages, `/diff` shows a colored working-tree diff, repo status sent as a per-turn request-scoped reminder so it never breaks the prompt cache) · prompt caching on Anthropic providers (cache breakpoints on the stable prefix and the history tail; OpenAI-style protocols cache server-side automatically) with a status-bar hit rate · token thrift: re-reading an unchanged file answers with a one-line note, and auxiliary calls (summaries, titles) can run on a cheaper `smallModel` · plan mode with read-only research and plan approval · thinking spinner with dim reasoning preview · diff preview on write/edit approval · `@file` mentions · `!cmd` shell passthrough · custom slash commands from Markdown files · conversation compaction (`/compact`) · session persistence and resume with auto-generated titles (`/resume`, `star -r`) · subagent delegation for focused subtasks · lifecycle hooks (`PreToolUse`/`PostToolUse`/`Stop` shell commands from config) · file-write snapshots with `/undo` and checkpoint rollback with `/rewind` · TODO task tracking · background shell tasks with status-bar visibility (`/tasks`) · terminal bell on long turns and background-task completion · Markdown session export (`/export`) · `/init` + `/doctor` project scaffolding and environment checks · cost estimation · update notifier · `--json` NDJSON output for scripting.
 
 ## Requirements
 
@@ -50,6 +50,9 @@ Config file: `~/.star-cli/config.toml` (set the `STAR_HOME` environment variable
 
 ```toml
 defaultModel = "gpt"              # name of the [[models]] block used by default
+# smallModel = "haiku"            # optional [[models]] block for cheap auxiliary calls
+                                  # (compaction summaries, session titles, completion checks);
+                                  # unset = the active main model does them
 permissionMode = "ask"            # ask | auto | readonly | yolo | plan
 contextMaxTokens = 100000         # context window in tokens (per-model override below)
 # compactThresholdTokens = 80000  # optional auto-compaction trigger in tokens; defaults to the
@@ -113,6 +116,11 @@ model = "gpt-4o"                  # model id sent to the API
                                   # provider (low/medium/high are common; some add minimal/max...).
                                   # Unset = server default. Ignored for anthropic. The /model
                                   # picker also offers these levels after a model pick.
+# vision = false                  # mark a text-only model: read_image/screenshot then decline with
+                                  # a text error instead of attaching images the endpoint would
+                                  # reject. Unset = images allowed. (Without it, a 4xx rejecting
+                                  # images outright still self-heals: the images are stripped from
+                                  # the history and the request retried once.)
 # streamIdleTimeoutSec = 60       # per-model overrides of the global stream watchdog timeouts
 # streamFirstChunkTimeoutSec = 600
 # optional per-model pricing in USD per 1M tokens — enables the $ estimate in /cost and /usage.
@@ -348,7 +356,7 @@ A `.starignore` file in the working directory hides paths from the agent: the `g
 
 ## Built-in tools
 
-`read_file`, `read_image` (attach an image file to the conversation mid-session — screenshots, mockups; png/jpg/gif/webp, auto-downsampled past 2000px), `write_file`, `edit_file`, `glob`, `grep`, `bash`, `web_fetch`, `web_search` (DuckDuckGo, no API key needed), `todo_read`, `todo_write`, `task_list`, `task_output`, `task_kill`, `subagent`, `skill`, `remember` — each declares a permission level (`read` / `write` / `exec`) enforced by the permission gate. Hard safety rules (dangerous shell commands, paths outside the working directory, secret files like `.env` / private keys) are denied in `ask` / `auto` / `readonly` and cannot be overridden by allow-rules.
+`read_file`, `read_image` (attach an image file to the conversation mid-session — screenshots, mockups; png/jpg/gif/webp, auto-downsampled past 2000px), `screenshot` (capture the primary display and see it — visual verification of a running program, e.g. a dev server's rendered page; platform-native capture with no dependencies, DPI-aware on Windows so scaled displays come out pixel-exact, headless sessions get a clear error), `write_file`, `edit_file`, `glob`, `grep`, `bash`, `web_fetch`, `web_search` (DuckDuckGo, no API key needed), `todo_read`, `todo_write`, `task_list`, `task_output`, `task_kill`, `subagent`, `skill`, `remember` — each declares a permission level (`read` / `write` / `exec`) enforced by the permission gate. Hard safety rules (dangerous shell commands, paths outside the working directory, secret files like `.env` / private keys) are denied in `ask` / `auto` / `readonly` and cannot be overridden by allow-rules.
 
 The `subagent` tool (`exec` level, so it is hidden in plan mode and denied in readonly) spawns a child agent loop with the same built-in tools to handle a focused, self-contained subtask — research, exploration, or an isolated change — and returns the child's final report as the tool result. Subagents run one level deep (a subagent cannot spawn further subagents), share the parent's permission mode and confirmation prompt, and their conversation is not persisted to the session.
 

package/README.zh-CN.md

@@ -17,7 +17,7 @@
 
 </div>
 
-功能特性：带斜杠命令（+ 自动补全）的流式 REPL · OpenAI / Anthropic / OpenAI 兼容服务商，配交互式 `/connect` 接入向导 · 内置 fs / bash / web 工具，带权限门禁 · git 集成（`/commit` 起草 Conventional Commits 提交信息，`/diff` 显示彩色工作区 diff，仓库状态注入系统提示词）· 计划模式：只读调研 + 计划批准 · 带暗色推理预览的思考动画 · 写入/编辑批准时的 diff 预览 · `@file` 引用 · `!cmd` shell 直通 · 用 Markdown 文件自定义斜杠命令 · 对话压缩（`/compact`）· 会话持久化与恢复，自动生成标题（`/resume`、`star -r`）· 子代理委派，处理专注的子任务 · 生命周期钩子（来自配置的 `PreToolUse`/`PostToolUse`/`Stop` shell 命令）· 文件写入快照 `/undo` 与检查点回滚 `/rewind` · TODO 任务跟踪 · 状态栏可见的后台 shell 任务（`/tasks`）· 长回合与后台任务完成时的终端响铃 · Markdown 会话导出（`/export`）· `/init` + `/doctor` 项目脚手架与环境检查 · 成本估算 · 更新提醒 · 便于脚本化的 `--json` NDJSON 输出。
+功能特性：带斜杠命令（+ 自动补全）的流式 REPL · OpenAI / Anthropic / OpenAI 兼容服务商，配交互式 `/connect` 接入向导 · 内置 fs / bash / web 工具，带权限门禁 · git 集成（`/commit` 起草 Conventional Commits 提交信息，`/diff` 显示彩色工作区 diff，仓库状态以每回合请求级 reminder 发送，不会破坏提示词缓存）· Anthropic 服务商的提示词缓存（在稳定前缀与历史尾部打缓存断点；OpenAI 系协议由服务端自动缓存），状态栏显示命中率 · token 节俭：重复读取未变化的文件只回一行说明，压缩摘要、标题等辅助调用可配置更便宜的 `smallModel` · 计划模式：只读调研 + 计划批准 · 带暗色推理预览的思考动画 · 写入/编辑批准时的 diff 预览 · `@file` 引用 · `!cmd` shell 直通 · 用 Markdown 文件自定义斜杠命令 · 对话压缩（`/compact`）· 会话持久化与恢复，自动生成标题（`/resume`、`star -r`）· 子代理委派，处理专注的子任务 · 生命周期钩子（来自配置的 `PreToolUse`/`PostToolUse`/`Stop` shell 命令）· 文件写入快照 `/undo` 与检查点回滚 `/rewind` · TODO 任务跟踪 · 状态栏可见的后台 shell 任务（`/tasks`）· 长回合与后台任务完成时的终端响铃 · Markdown 会话导出（`/export`）· `/init` + `/doctor` 项目脚手架与环境检查 · 成本估算 · 更新提醒 · 便于脚本化的 `--json` NDJSON 输出。
 
 ## 环境要求
 
@@ -50,6 +50,9 @@ star -p "hi"             # non-interactive print mode
 
 ```toml
 defaultModel = "gpt"              # 默认使用的 [[models]] 块名称
+# smallModel = "haiku"            # 可选的 [[models]] 块，用于低价的辅助调用
+                                  #（压缩摘要、会话标题、完成度检查）；
+                                  # 不设置 = 由当前主模型执行
 permissionMode = "ask"            # ask | auto | readonly | yolo | plan
 contextMaxTokens = 100000         # 上下文窗口（token 数，下方可按模型覆盖）
 # compactThresholdTokens = 80000  # 可选的自动压缩触发阈值（token 数）；默认为上下文窗口本身，
@@ -111,6 +114,10 @@ model = "gpt-4o"                  # 发送给 API 的模型 id
                                   # minimal/max 等），因此接受任意字符串，由服务端校验。
                                   # 不设置 = 服务端默认。anthropic 协议下忽略。
                                   # /model 选完模型后也会接着让你选择推理强度。
+# vision = false                  # 标记纯语言模型：read_image/screenshot 会直接返回文本错误，
+                                  # 不再把图片塞进历史导致端点报 4xx。不设置 = 允许图片。（即使
+                                  # 不设置，端点明确拒绝图片的 4xx 也会自愈：剥掉历史中的图片后
+                                  # 自动重试一次。）
 # streamIdleTimeoutSec = 60       # 按模型覆盖全局的流看门狗超时
 # streamFirstChunkTimeoutSec = 600
 # 可选的按模型定价（美元/1M token）——启用 /cost 和 /usage 中的美元估算。
@@ -344,7 +351,7 @@ star -p "what's wrong in this UI?" --image screenshot.png --image mockup.jpg
 
 ## 内置工具
 
-`read_file`、`read_image`（会话中把图片文件带给模型——截图、设计稿等；支持 png/jpg/gif/webp，超过 2000px 自动降采样）、`write_file`、`edit_file`、`glob`、`grep`、`bash`、`web_fetch`、`web_search`（DuckDuckGo，无需 API 密钥）、`todo_read`、`todo_write`、`task_list`、`task_output`、`task_kill`、`subagent`、`skill`、`remember`——每个都声明一个权限级别（`read` / `write` / `exec`），由权限门禁强制执行。硬性安全规则（危险 shell 命令、工作目录之外的路径、`.env` / 私钥等机密文件）在 `ask` / `auto` / `readonly` 下被拒绝，且无法被 allow 规则覆盖。
+`read_file`、`read_image`（会话中把图片文件带给模型——截图、设计稿等；支持 png/jpg/gif/webp，超过 2000px 自动降采样）、`screenshot`（截取主显示器画面给模型看——用于核对运行中程序的真实视觉效果，比如 dev server 渲染的页面；平台原生截图、零依赖，Windows 上 DPI 感知保证缩放下像素精确，无显示器的 headless 会话返回明确错误）、`write_file`、`edit_file`、`glob`、`grep`、`bash`、`web_fetch`、`web_search`（DuckDuckGo，无需 API 密钥）、`todo_read`、`todo_write`、`task_list`、`task_output`、`task_kill`、`subagent`、`skill`、`remember`——每个都声明一个权限级别（`read` / `write` / `exec`），由权限门禁强制执行。硬性安全规则（危险 shell 命令、工作目录之外的路径、`.env` / 私钥等机密文件）在 `ask` / `auto` / `readonly` 下被拒绝，且无法被 allow 规则覆盖。
 
 `subagent` 工具（`exec` 级别，因此在计划模式下隐藏，在 readonly 下被拒绝）派生一个带相同内置工具的子代理循环，处理专注、自包含的子任务——调研、探索或一处孤立的改动——并把子代理的最终报告作为工具结果返回。子代理只运行一层（子代理不能再派生子代理），共享父代理的权限模式与确认提示，其对话不持久化到会话。
 

package/dist/chunk-4IRY44TG.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// 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;
+}
+function resolveStartupModel(config, sessionModel) {
+  if (sessionModel) {
+    if (config.models.some((m) => m.name === sessionModel)) {
+      return { name: sessionModel, notice: null };
+    }
+    return {
+      name: config.defaultModel,
+      notice: `Session model "${sessionModel}" not found in config \u2014 using default model.`
+    };
+  }
+  return { name: config.defaultModel, notice: null };
+}
+
+export {
+  listModels,
+  resolveModelConfig,
+  resolveStartupModel
+};
+//# sourceMappingURL=chunk-4IRY44TG.js.map

package/dist/chunk-4IRY44TG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/llm/registry.ts"],"sourcesContent":["import type { ModelConfig, StarConfig } from \"../config/schema\";\n\nexport function listModels(config: StarConfig): ModelConfig[] {\n  return config.models;\n}\n\nexport function resolveModelConfig(config: StarConfig, modelName?: string): ModelConfig {\n  const name = modelName ?? config.defaultModel;\n  const model = config.models.find((m) => m.name === name);\n  if (!model) {\n    const available = config.models.map((m) => m.name).join(\", \") || \"(none)\";\n    throw new Error(`Model \"${name}\" not found. Available models: ${available}`);\n  }\n  return model;\n}\n\n// Pick the model at startup. An explicit --model already sits in\n// config.defaultModel (loader override), so it wins naturally; otherwise a\n// resumed session's recorded model is restored when it still exists in the\n// config. A stale recorded model falls back to the default with a notice.\nexport function resolveStartupModel(\n  config: StarConfig,\n  sessionModel?: string | null,\n): { name: string | undefined; notice: string | null } {\n  if (sessionModel) {\n    if (config.models.some((m) => m.name === sessionModel)) {\n      return { name: sessionModel, notice: null };\n    }\n    return {\n      name: config.defaultModel,\n      notice: `Session model \"${sessionModel}\" not found in config — using default model.`,\n    };\n  }\n  return { name: config.defaultModel, notice: null };\n}\n"],"mappings":";;;AAEO,SAAS,WAAW,QAAmC;AAC5D,SAAO,OAAO;AAChB;AAEO,SAAS,mBAAmB,QAAoB,WAAiC;AACtF,QAAM,OAAO,aAAa,OAAO;AACjC,QAAM,QAAQ,OAAO,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,IAAI;AACvD,MAAI,CAAC,OAAO;AACV,UAAM,YAAY,OAAO,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,IAAI,KAAK;AACjE,UAAM,IAAI,MAAM,UAAU,IAAI,kCAAkC,SAAS,EAAE;AAAA,EAC7E;AACA,SAAO;AACT;AAMO,SAAS,oBACd,QACA,cACqD;AACrD,MAAI,cAAc;AAChB,QAAI,OAAO,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,YAAY,GAAG;AACtD,aAAO,EAAE,MAAM,cAAc,QAAQ,KAAK;AAAA,IAC5C;AACA,WAAO;AAAA,MACL,MAAM,OAAO;AAAA,MACb,QAAQ,kBAAkB,YAAY;AAAA,IACxC;AAAA,EACF;AACA,SAAO,EAAE,MAAM,OAAO,cAAc,QAAQ,KAAK;AACnD;","names":[]}

package/dist/chunk-56ZIA57D.js

@@ -0,0 +1,493 @@
+#!/usr/bin/env node
+import {
+  gitTreesDir,
+  isSensitivePath
+} from "./chunk-A5PXPWHB.js";
+
+// src/core/messages.ts
+function toStarMessage(message) {
+  return "role" in message ? { message } : message;
+}
+function toCoreMessages(messages) {
+  return messages.map((star) => star.message);
+}
+function isSyntheticUserMessage(star) {
+  return star.message.role === "user" && star.meta?.synthetic !== void 0;
+}
+function coreMessageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+  }
+  return "";
+}
+var MISSING_TOOL_RESULT_TEXT = "tool result missing (session was interrupted)";
+var INTERRUPTED_TOOL_RESULT_TEXT = "Tool execution interrupted by user.";
+var UNFINISHED_TOOL_RESULT_TEXT = "Tool execution interrupted before a result was produced.";
+function reconcileStarMessages(messages) {
+  const result = [];
+  let pending = [];
+  const flushPending = () => {
+    for (const call of pending) {
+      result.push({
+        message: {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              result: MISSING_TOOL_RESULT_TEXT
+            }
+          ]
+        }
+      });
+    }
+    pending = [];
+  };
+  for (const star of messages) {
+    const message = star.message;
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      flushPending();
+      pending = message.content.filter((part) => part.type === "tool-call").map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName }));
+    } else if (message.role === "tool" && Array.isArray(message.content) && pending.length > 0) {
+      const answered = new Set(message.content.map((part) => part.toolCallId));
+      pending = pending.filter((call) => !answered.has(call.toolCallId));
+    } else {
+      flushPending();
+    }
+    result.push(star);
+  }
+  flushPending();
+  return result;
+}
+function retractLastTurn(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const star = messages[i];
+    if (star && star.message.role === "user" && !isSyntheticUserMessage(star)) {
+      return { messages: messages.slice(0, i), removed: messages.length - i };
+    }
+  }
+  return { messages, removed: 0 };
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  // openai-responses talks to the Responses API (/responses) instead of chat
+  // completions — the wire format codex uses, and the native API of
+  // reasoning-model relays that otherwise hide reasoning behind empty chat
+  // completions. streamChat sends strictSchemas:false + store:false with it.
+  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z.string(),
+  apiKeyEnv: z.string().optional(),
+  apiKey: z.string().optional(),
+  headers: z.record(z.string()).optional()
+});
+var ModelConfigSchema = z.object({
+  name: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  maxTokens: z.number().int().positive().optional(),
+  // Per-model context window; overrides the top-level contextMaxTokens for
+  // compaction and the status bar when set.
+  contextMaxTokens: z.number().int().positive().optional(),
+  // Reasoning intensity for thinking models, forwarded verbatim as
+  // OpenAI-style reasoning_effort on every request (llm/provider.ts
+  // reasoningEffortMetadata) — level naming varies by model/provider
+  // (low|medium|high are common; some add minimal/max/xhigh/none), so any
+  // non-empty string is accepted and the server validates it. Unset = the
+  // request carries no effort field and the server-side default applies.
+  // Anthropic maps effort to a thinking budget instead — ignored there.
+  reasoningEffort: z.string().min(1).optional(),
+  // Sampling temperature forwarded on every request. Unset = the AI SDK's
+  // own default applies (ai@4 sends 0 — it does NOT omit the field). Some
+  // endpoints reject anything but one explicit value (e.g. kimi-for-coding:
+  // "invalid temperature: only 1 is allowed") — set it here. No upper
+  // bound: ranges vary by provider and the server validates.
+  temperature: z.number().min(0).optional(),
+  // Per-model overrides of the top-level stream watchdog timeouts (unset =
+  // the global values apply). Raise streamIdleTimeoutSec for relays that
+  // buffer long generations and stall mid-stream between flushes.
+  streamIdleTimeoutSec: z.number().positive().optional(),
+  streamFirstChunkTimeoutSec: z.number().positive().optional(),
+  // Text-only models: set false so image-producing tools (read_image,
+  // screenshot) decline with a text error instead of attaching images the
+  // endpoint would reject with an unrecoverable 4xx. Unset = images allowed.
+  vision: z.boolean().optional(),
+  // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
+  // the model is treated as unpriced.
+  promptPrice: z.number().nonnegative().optional(),
+  completionPrice: z.number().nonnegative().optional(),
+  // Optional price (USD per 1M tokens) for cache-read prompt tokens. When
+  // unset, OpenAI-style cached tokens bill at promptPrice and Anthropic-style
+  // cache reads are not billed — set this for accurate cache pricing.
+  cacheReadPrice: z.number().nonnegative().optional()
+});
+var PermissionsConfigSchema = z.object({
+  allow: z.array(z.string()).default([]),
+  deny: z.array(z.string()).default([]),
+  // Rules that force a confirmation prompt in auto mode (same tool(glob)
+  // syntax as allow/deny) — e.g. ask = ["bash(git push *)"]. Priority:
+  // deny > ask > allow > mode default. Only meaningful in auto mode (ask
+  // mode already prompts; readonly/plan are unaffected; yolo bypasses all).
+  ask: z.array(z.string()).default([]),
+  // Extra likely-secret file globs extending core/sensitive.ts's hardcoded
+  // list (same single-* glob semantics as rules, matched case-insensitively
+  // against the basename and the full normalized path). Global config only —
+  // the project-config sandbox drops the whole [permissions] table.
+  sensitive: z.array(z.string()).default([])
+});
+var HookConfigSchema = z.object({
+  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
+  matcher: z.string().refine(
+    (pattern) => {
+      try {
+        new RegExp(pattern);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "invalid regular expression" }
+  ).optional(),
+  command: z.string().min(1),
+  timeoutSec: z.number().positive().default(30)
+});
+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([]),
+  // Cap on model round-trips ("steps") per turn between progress checkpoints.
+  // One step is a streamed reply plus every tool call it asked for — stream
+  // retries and auto-continue nudges do not consume steps. Reaching the cap
+  // while tools still execute resets the budget with a notice; the turn stops
+  // only when no tool ran since the last checkpoint (the doom-loop
+  // signature). 0 disables the cap entirely (opencode/codex have none).
+  maxSteps: z.number().int().min(0).default(100),
+  contextMaxTokens: z.number().int().positive().default(1e5),
+  // Token threshold at which the agent loop auto-compacts the history.
+  // Defaults to the effective context window (compact only when full); set a
+  // lower value to compact earlier and keep headroom. Manual /compact ignores
+  // this — it always compacts.
+  compactThresholdTokens: z.number().int().positive().optional(),
+  // Seconds without any stream part before a stalled response is ended
+  // gracefully (some relays never send the terminal chunks). Applies once
+  // content has started streaming; the wait for the first content part gets
+  // a longer allowance (control/metadata parts don't count as content).
+  streamIdleTimeoutSec: z.number().positive().default(20),
+  // Seconds to wait for the very first content part before giving up; slow
+  // thinking-model endpoints can stay silent for minutes after accepting
+  // the request.
+  streamFirstChunkTimeoutSec: z.number().positive().default(300),
+  // Extra attempts per model request when a stream fails transiently
+  // (network error, 429/5xx, idle watchdog cutoff) or comes back empty, so a
+  // relay hiccup does not silently end a half-finished turn. 0 disables.
+  // The wait between attempts honors Retry-After headers and otherwise backs
+  // off exponentially with jitter (llm/retry.ts); retries after a
+  // timeout/empty failure also scale both stream timeouts up (attempt number
+  // ×, capped at 3x) since the relay is likely overloaded. Default 5 matches
+  // opencode/Codex retry budgets and rides out flaky relays (中转站) better
+  // than a minimal budget.
+  streamMaxRetries: z.number().int().min(0).default(5),
+  // How many consecutive unproductive replies may be nudged before the turn
+  // is handed back: a text-only reply that announces pending work ("我将…",
+  // "I will…") or answers a nudge with more words, or an empty reply that
+  // survived the stream retry budget (steered with a nudge — a changed
+  // request — since identical resends already failed). Tool calls reset the
+  // count, so a productive task keeps going; exhaustion surfaces a notice
+  // instead of stopping silently. Never fires in plan mode. 0 disables.
+  maxAutoContinues: z.number().int().min(0).default(2),
+  contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
+  // Optional per-session dollar budget; when set, the REPL stops the session
+  // once the estimated cost for the session reaches this amount.
+  sessionBudgetUsd: z.number().positive().optional(),
+  // Terminal bell (REPL only): ring when a turn takes longer than
+  // notifyBellThresholdSec, and when a background task finishes.
+  // STAR_NO_NOTIFY=1 disables without touching the config.
+  notifyBell: z.boolean().default(true),
+  notifyBellThresholdSec: z.number().positive().default(10),
+  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
+  hooks: z.array(HookConfigSchema).default([]),
+  // Consecutive identical tool calls (same tool + same arguments) allowed
+  // before the loop refuses to execute the repeat and tells the model to
+  // change approach — a guard against agents stuck retrying a failing call
+  // (opencode's doom_loop). 0 disables.
+  doomLoopThreshold: z.number().int().min(0).default(3),
+  // Track the whole working tree with an internal git repo (outside the
+  // user's .git) at every turn boundary, so /undo and /redo can restore
+  // changes made by ANY tool (bash included), not just write_file/edit_file.
+  // Falls back silently to per-file snapshots when git is unavailable.
+  gitSnapshots: z.boolean().default(true),
+  // web_fetch SSRF guard escape hatch: by default target hosts are resolved
+  // before connecting and private/reserved ranges are refused (loopback,
+  // RFC1918, link-local incl. the cloud metadata address 169.254.169.254,
+  // ULA, and localhost/.local/.internal names; redirect hops re-checked).
+  // true disables the guard for intranet use. Global config only — not in
+  // the project-config sandbox whitelist.
+  webFetchAllowPrivateHosts: z.boolean().default(false)
+});
+function contextWindowTokens(config, modelName) {
+  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
+}
+function resolveCompactThreshold(config, windowTokens) {
+  return Math.min(config.compactThresholdTokens ?? windowTokens, windowTokens);
+}
+
+// src/snapshot/git-tree.ts
+import { execFile } from "child_process";
+import { randomBytes } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readdir, rm, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+var GC_TIMEOUT_MS = 6e4;
+var GIT_MAX_BUFFER = 8 * 1024 * 1024;
+var GC_INTERVAL = 50;
+var TRACK_FAILURE_TTL_MS = 5 * 60 * 1e3;
+var MAX_PINNED_REFS = 50;
+var PINNED_REF_PREFIX = "refs/star/";
+var SENSITIVE_EXCLUDE_PATTERNS = [
+  ".env",
+  ".env.*",
+  "!.env.example",
+  "!.env.sample",
+  "!.env.template",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  ".npmrc",
+  ".netrc",
+  ".pgpass",
+  "*.pem",
+  "*.key",
+  "*.p12",
+  "*.pfx",
+  "**/.aws/credentials",
+  "**/.kube/config"
+];
+var GIT_CONFIG_ARGS = [
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.eol=native",
+  "-c",
+  "filter.lfs.process=",
+  "-c",
+  "filter.lfs.smudge=",
+  "-c",
+  "filter.lfs.clean="
+];
+function gitEnv() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && !key.toUpperCase().startsWith("GIT_")) env[key] = value;
+  }
+  return env;
+}
+function runGit(args, timeoutMs = GIT_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      [...GIT_CONFIG_ARGS, ...args],
+      { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER, encoding: "utf8", env: gitEnv() },
+      (error, stdout) => {
+        resolve(error ? null : stdout.trim());
+      }
+    );
+  });
+}
+var gitAvailable = null;
+var trackFailureUntil = /* @__PURE__ */ new Map();
+var trackCounts = /* @__PURE__ */ new Map();
+var scrubbedRepos = /* @__PURE__ */ new Set();
+async function isGitAvailable() {
+  if (gitAvailable === null) {
+    gitAvailable = await runGit(["--version"]) !== null;
+  }
+  return gitAvailable;
+}
+function treeRepoDir(cwd) {
+  const key = Buffer.from(path.resolve(cwd), "utf8").toString("base64url");
+  return path.join(gitTreesDir(), key);
+}
+async function removeTreeRepo(cwd) {
+  const dir = treeRepoDir(cwd);
+  trackFailureUntil.delete(path.resolve(cwd));
+  trackCounts.delete(dir);
+  scrubbedRepos.delete(dir);
+  await rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+}
+async function pruneTreeReposExcept(remainingCwds) {
+  let entries;
+  try {
+    entries = await readdir(gitTreesDir());
+  } catch {
+    return;
+  }
+  const keep = /* @__PURE__ */ new Set();
+  for (const cwd of remainingCwds) keep.add(path.basename(treeRepoDir(cwd)));
+  await Promise.all(
+    entries.filter((entry) => !keep.has(entry)).map(
+      (entry) => rm(path.join(gitTreesDir(), entry), { recursive: true, force: true }).catch(() => {
+      })
+    )
+  );
+}
+function isGuardedDir(cwd) {
+  const resolved = path.resolve(cwd);
+  const home = path.resolve(os.homedir());
+  const same = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  return same(resolved, home) || same(resolved, path.parse(resolved).root);
+}
+async function ensureTreeRepo(cwd) {
+  const dir = treeRepoDir(cwd);
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    if (!existsSync(path.join(dir, "HEAD"))) {
+      const out = await runGit(["init", "--bare", dir]);
+      if (out === null) return null;
+      await runGit([`--git-dir=${dir}`, "config", "core.autocrlf", "false"]);
+    }
+    await mkdir(path.join(dir, "info"), { recursive: true });
+    await writeFile(
+      path.join(dir, "info", "exclude"),
+      `${SENSITIVE_EXCLUDE_PATTERNS.join("\n")}
+`,
+      "utf8"
+    );
+  } catch {
+    return null;
+  }
+  return dir;
+}
+function repoArgs(dir, cwd) {
+  return [`--git-dir=${dir}`, `--work-tree=${cwd}`];
+}
+async function untrackExcluded(dir, cwd) {
+  const base = repoArgs(dir, cwd);
+  const listed = await runGit([...base, "ls-files", "-z", "-c", "-i", "--exclude-standard"]);
+  if (listed === null) return false;
+  const files = listed.split("\0").filter(Boolean);
+  if (files.length === 0) return true;
+  const removed = await runGit([
+    ...base,
+    "rm",
+    "--cached",
+    "--ignore-unmatch",
+    "-q",
+    "--",
+    ...files.map((file) => `:(literal)${file}`)
+  ]);
+  return removed !== null;
+}
+function trackTree(cwd) {
+  const key = path.resolve(cwd);
+  const next = (trackChains.get(key) ?? Promise.resolve(null)).then(() => trackTreeGuarded(cwd));
+  trackChains.set(key, next);
+  return next;
+}
+var trackChains = /* @__PURE__ */ new Map();
+async function trackTreeGuarded(cwd) {
+  if (isGuardedDir(cwd)) return null;
+  const key = path.resolve(cwd);
+  const failedUntil = trackFailureUntil.get(key);
+  if (failedUntil !== void 0 && Date.now() < failedUntil) return null;
+  const tree = await trackTreeUncached(cwd);
+  if (tree === null) {
+    trackFailureUntil.set(key, Date.now() + TRACK_FAILURE_TTL_MS);
+    return null;
+  }
+  trackFailureUntil.delete(key);
+  return tree;
+}
+async function pinTree(base, tree) {
+  const ref = `${PINNED_REF_PREFIX}${Date.now()}-${randomBytes(4).toString("hex")}`;
+  if (await runGit([...base, "update-ref", ref, tree]) === null) return;
+  const listed = await runGit([...base, "for-each-ref", "--format=%(refname)", PINNED_REF_PREFIX]);
+  if (listed === null) return;
+  const refs = listed.split("\n").filter(Boolean);
+  const stale = refs.slice(0, Math.max(0, refs.length - MAX_PINNED_REFS));
+  await Promise.all(stale.map((name) => runGit([...base, "update-ref", "-d", name])));
+}
+async function trackTreeUncached(cwd) {
+  if (!await isGitAvailable()) return null;
+  const dir = await ensureTreeRepo(cwd);
+  if (!dir) return null;
+  const base = repoArgs(dir, cwd);
+  if (!scrubbedRepos.has(dir)) {
+    if (!await untrackExcluded(dir, cwd)) return null;
+    scrubbedRepos.add(dir);
+  }
+  if (await runGit([...base, "add", "-A"]) === null) return null;
+  const tree = await runGit([...base, "write-tree"]);
+  if (tree === null) return null;
+  await pinTree(base, tree);
+  const count = (trackCounts.get(dir) ?? 0) + 1;
+  trackCounts.set(dir, count);
+  if (count % GC_INTERVAL === 0) {
+    await runGit([`--git-dir=${dir}`, "gc", "--auto"], GC_TIMEOUT_MS);
+  }
+  return tree;
+}
+async function restoreTree(cwd, hash) {
+  if (isGuardedDir(cwd)) return false;
+  if (!await isGitAvailable()) return false;
+  const dir = await ensureTreeRepo(cwd);
+  if (!dir) return false;
+  const base = repoArgs(dir, cwd);
+  if (await runGit([...base, "read-tree", hash]) === null) return false;
+  if (!await untrackExcluded(dir, cwd)) return false;
+  if (await runGit([...base, "checkout-index", "-f", "-a"]) === null) return false;
+  if (await runGit([...base, "clean", "-fd"]) === null) return false;
+  return true;
+}
+async function diffTreeNames(cwd, hash) {
+  if (!await isGitAvailable()) return null;
+  const dir = treeRepoDir(cwd);
+  if (!existsSync(path.join(dir, "HEAD"))) return null;
+  const base = repoArgs(dir, cwd);
+  const changed = await runGit([...base, "diff", "--name-only", hash]);
+  const untracked = await runGit([...base, "ls-files", "--others", "--exclude-standard"]);
+  if (changed === null || untracked === null) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const line of [...changed.split("\n"), ...untracked.split("\n")]) {
+    if (line !== "" && !isSensitivePath(line)) names.add(line);
+  }
+  return [...names];
+}
+
+export {
+  toStarMessage,
+  toCoreMessages,
+  isSyntheticUserMessage,
+  coreMessageText,
+  INTERRUPTED_TOOL_RESULT_TEXT,
+  UNFINISHED_TOOL_RESULT_TEXT,
+  reconcileStarMessages,
+  retractLastTurn,
+  ProviderConfigSchema,
+  ModelConfigSchema,
+  PermissionsConfigSchema,
+  HookConfigSchema,
+  ConfigSchema,
+  contextWindowTokens,
+  resolveCompactThreshold,
+  removeTreeRepo,
+  pruneTreeReposExcept,
+  trackTree,
+  restoreTree,
+  diffTreeNames
+};
+//# sourceMappingURL=chunk-56ZIA57D.js.map