min-agent 0.3.0 → 0.4.0

package/dist/memory.js

@@ -1,9 +1,34 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from "fs";
+import { readFileSync, mkdirSync, existsSync, renameSync } from "fs";
 import path from "path";
-import { randomUUID } from "crypto";
-import { getConfigDir } from "./config.js";
+import { getConfigDir, getProjectConfigDir } from "./config.js";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
 import { tool, jsonSchema } from "ai";
-function getMemoryFile() {
+export function readMemoryScope(value) {
+    if (value === undefined || value === null || value === "")
+        return { ok: true, scope: undefined };
+    if (value === "global" || value === "project")
+        return { ok: true, scope: value };
+    return { ok: false };
+}
+export function takeScopeFlags(tokens) {
+    let scope;
+    const rest = [];
+    for (const t of tokens) {
+        if (t === "--project")
+            scope = "project";
+        else if (t === "--global")
+            scope = "global";
+        else
+            rest.push(t);
+    }
+    return { scope, rest };
+}
+export function defaultMemoryScope() {
+    return existsSync(getProjectConfigDir()) ? "project" : "global";
+}
+function getMemoryFile(scope) {
+    if (scope === "project")
+        return path.join(getProjectConfigDir(), "memory.json");
     return path.join(getConfigDir(), "memory.json");
 }
 /** Preserve corrupt data instead of letting it be overwritten and lost forever. */
@@ -15,8 +40,8 @@ function backupCorrupt(file) {
         // nothing else we can do with an unreadable file
     }
 }
-export function loadMemories() {
-    const file = getMemoryFile();
+export function loadMemories(scope = "global") {
+    const file = getMemoryFile(scope);
     if (!existsSync(file))
         return [];
     let data;
@@ -34,55 +59,40 @@ export function loadMemories() {
     return data.filter((m) => typeof m === "object" && m !== null && typeof m.content === "string");
 }
 /** Atomic replace via temp file + rename, so a crash never leaves a truncated memory.json. */
-function saveMemories(memories) {
-    const file = getMemoryFile();
+function saveMemories(memories, scope) {
+    const file = getMemoryFile(scope);
     mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.tmp-${randomUUID()}`;
-    try {
-        writeFileSync(tmp, JSON.stringify(memories, null, 2), "utf-8");
-        renameSync(tmp, file);
-    }
-    catch (err) {
-        try {
-            if (existsSync(tmp))
-                unlinkSync(tmp);
-        }
-        catch { }
-        throw err;
-    }
+    atomicWriteFileSync(file, JSON.stringify(memories, null, 2));
 }
 // read-modify-write runs fully synchronously, so concurrent tool calls in
 // this process cannot interleave between load and save.
-export function addMemory(content, tags = []) {
-    const memories = loadMemories();
+export function addMemory(content, tags = [], scope = "global") {
+    const memories = loadMemories(scope);
     const memory = {
         content,
         tags,
         created: new Date().toISOString(),
     };
     memories.push(memory);
-    saveMemories(memories);
+    saveMemories(memories, scope);
     return memory;
 }
-export function deleteMemory(index) {
-    const memories = loadMemories();
+export function deleteMemory(index, scope = "global") {
+    const memories = loadMemories(scope);
     if (index < 0 || index >= memories.length)
         return false;
     memories.splice(index, 1);
-    saveMemories(memories);
+    saveMemories(memories, scope);
     return true;
 }
-export function searchMemories(query) {
-    const memories = loadMemories();
+export function searchMemories(query, scope = "global") {
+    const memories = loadMemories(scope);
     const lower = query.toLowerCase();
     return memories
         .map((m, i) => ({ ...m, index: i }))
-        .filter((m) => m.content.toLowerCase().includes(lower) ||
-        m.tags.some((t) => t.toLowerCase().includes(lower)));
+        .filter((m) => m.content.toLowerCase().includes(lower) || m.tags.some((t) => t.toLowerCase().includes(lower)));
 }
-/** Build a system prompt section from stored memories (newest first, capped). */
-export function getMemorySystemPrompt() {
-    const memories = loadMemories();
+function formatMemoryBlock(memories, heading) {
     if (memories.length === 0)
         return "";
     const MAX_MEMORIES = 30;
@@ -98,19 +108,31 @@ export function getMemorySystemPrompt() {
     const capped = memories.length > MAX_MEMORIES
         ? `\n(${memories.length - MAX_MEMORIES} older memories not shown — use memory_search to find them.)`
         : "";
-    return [
+    return [heading, ...items, capped].filter(Boolean).join("\n");
+}
+/** Build a system prompt section from stored memories (newest first, capped). */
+export function getMemorySystemPrompt() {
+    const project = loadMemories("project");
+    const global = loadMemories("global");
+    if (project.length === 0 && global.length === 0)
+        return "";
+    const intro = [
         "## Memories",
         "The following are things you have remembered from previous conversations. Use them to provide better, personalized responses.",
         "You can save new memories with the memory_save tool when the user tells you something worth remembering (preferences, project details, conventions, etc).",
+        'Use scope "project" for repo-specific facts and "global" for preferences that apply everywhere.',
         "",
-        ...items,
-        capped,
-    ].join("\n");
+    ];
+    const sections = [
+        formatMemoryBlock(project, "### This project"),
+        formatMemoryBlock(global, project.length > 0 ? "### Global" : ""),
+    ].filter((s) => s.length > 0);
+    return [...intro, ...sections].join("\n");
 }
 /** Create the memory tools for the agent */
 export function getMemoryTools() {
     const memorySave = tool({
-        description: "Save a memory for future conversations. Use this when the user shares preferences, project conventions, important context, or asks you to remember something. Memories persist across sessions.",
+        description: "Save a memory for future conversations. Use this when the user shares preferences, project conventions, important context, or asks you to remember something. Memories persist across sessions. Use scope project for this repository, global for all projects.",
         inputSchema: jsonSchema({
             type: "object",
             properties: {
@@ -120,12 +142,18 @@ export function getMemoryTools() {
                     items: { type: "string" },
                     description: "Optional tags for categorization (e.g. 'preference', 'project', 'convention')",
                 },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Where to store the memory. Defaults to project when .min-agent exists, otherwise global.",
+                },
             },
             required: ["content"],
         }),
-        execute: async ({ content, tags }) => {
-            const memory = addMemory(content, tags ?? []);
-            return `Saved memory: "${content}" (tags: ${memory.tags.length > 0 ? memory.tags.join(", ") : "none"})`;
+        execute: async ({ content, tags, scope }) => {
+            const resolved = scope === "global" || scope === "project" ? scope : defaultMemoryScope();
+            const memory = addMemory(content, tags ?? [], resolved);
+            return `Saved ${resolved} memory: "${content}" (tags: ${memory.tags.length > 0 ? memory.tags.join(", ") : "none"})`;
         },
     });
     const memorySearch = tool({
@@ -134,35 +162,48 @@ export function getMemoryTools() {
             type: "object",
             properties: {
                 query: { type: "string", description: "Search keyword or phrase" },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Limit search to one store. Omit to search both.",
+                },
             },
             required: ["query"],
         }),
-        execute: async ({ query }) => {
-            const results = searchMemories(query);
-            if (results.length === 0)
+        execute: async ({ query, scope }) => {
+            const scopes = scope === "global" || scope === "project" ? [scope] : ["project", "global"];
+            const lines = [];
+            for (const s of scopes) {
+                for (const m of searchMemories(query, s)) {
+                    const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+                    lines.push(`${s} #${m.index + 1}: ${m.content}${tags} (${m.created.split("T")[0]})`);
+                }
+            }
+            if (lines.length === 0)
                 return `No memories found matching "${query}"`;
-            return results
-                .map((m) => {
-                const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-                return `#${m.index + 1}: ${m.content}${tags} (${m.created.split("T")[0]})`;
-            })
-                .join("\n");
+            return lines.join("\n");
         },
     });
     const memoryDelete = tool({
-        description: "Delete a memory by its number. Use memory_search or memory_list first to find the index.",
+        description: "Delete a memory by its number. Use memory_search first to find the index and scope.",
         inputSchema: jsonSchema({
             type: "object",
             properties: {
                 index: { type: "number", description: "The memory number to delete (1-based)" },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Which store the number belongs to. Defaults to project when .min-agent exists, otherwise global.",
+                },
             },
             required: ["index"],
         }),
-        execute: async ({ index }) => {
-            const success = deleteMemory(index - 1);
+        execute: async ({ index, scope }) => {
+            const resolved = scope === "global" || scope === "project" ? scope : defaultMemoryScope();
+            const success = deleteMemory(index - 1, resolved);
             if (success)
-                return `Memory #${index} deleted.`;
-            return `Memory #${index} not found.`;
+                return `${resolved} memory #${index} deleted.`;
+            return `${resolved} memory #${index} not found.`;
         },
     });
     return {

package/dist/output.js

@@ -30,7 +30,7 @@ const RESULT_PREVIEW_MAX_CHARS = 1200;
  * applied in one pass, so the "N more lines" count always matches what was
  * actually withheld.
  */
-export function printToolResult(name, result, isError = false) {
+export function printToolResult(_name, result, isError = false) {
     const text = toolResultText(result).replace(/\s+$/, "");
     const lines = text === "" ? [] : text.split("\n");
     const kept = [];
@@ -53,13 +53,14 @@ export function printToolResult(name, result, isError = false) {
     const body = kept.join(`\n${COLORS.dim}    `);
     console.log(`${marker} ${COLORS.dim}${body}${suffix}${COLORS.reset}\n`);
 }
-export function printDone(steps, usage, contextWindow) {
+export function printDone(steps, usage, contextWindow, contextTokens) {
     const input = usage?.inputTokens ?? 0;
     const output = usage?.outputTokens ?? 0;
     const total = input + output;
+    const occupied = contextTokens !== undefined ? contextTokens : input;
     let contextInfo = "";
-    if (input > 0 && contextWindow && contextWindow > 0) {
-        const pct = Math.round((input / contextWindow) * 100);
+    if (occupied > 0 && contextWindow && contextWindow > 0) {
+        const pct = Math.round((occupied / contextWindow) * 100);
         const bar = renderBar(pct);
         contextInfo = ` | Context: ${bar} ${pct}%`;
     }
@@ -67,7 +68,8 @@ export function printDone(steps, usage, contextWindow) {
 }
 function renderBar(pct) {
     const width = 10;
-    const filled = Math.round((pct / 100) * width);
+    const safePct = Math.max(0, Math.min(100, pct));
+    const filled = Math.round((safePct / 100) * width);
     const empty = width - filled;
     const color = pct >= 80 ? "\x1b[31m" : pct >= 50 ? "\x1b[33m" : "\x1b[32m";
     return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m\x1b[90m`;

package/dist/permission-cli.js

@@ -0,0 +1,43 @@
+import { takeScopeFlags } from "./memory.js";
+import { getPermissionSnapshot, parsePermissionMode, permissionModeLabel, setPermissionMode, } from "./config.js";
+import { getPermissionOverride, setPermissionOverride } from "./confirm.js";
+export const PERMISSION_CLI_USAGE = [
+    "Usage: min-agent permission [ask|accept-edits|allow-all] [--project|--global]",
+    "       min-agent --permission ask|accept-edits|allow-all [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
+}
+function scopeLabel(scope) {
+    return scope === "project" ? "project" : "global";
+}
+export function runPermissionCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [PERMISSION_CLI_USAGE] };
+    }
+    if (rest.length === 1) {
+        const parsed = parsePermissionMode(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [PERMISSION_CLI_USAGE] };
+        setPermissionMode(parsed, scope);
+        setPermissionOverride(parsed);
+        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(parsed)} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [PERMISSION_CLI_USAGE] };
+    if (input.flagMode) {
+        setPermissionMode(input.flagMode, scope);
+        setPermissionOverride(input.flagMode);
+        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(input.flagMode)} (${scopeLabel(scope)})`] };
+    }
+    const snap = getPermissionSnapshot();
+    const override = getPermissionOverride();
+    const mode = override ?? snap.permission;
+    const source = override ? "cli" : snap.source;
+    return {
+        ok: true,
+        lines: [`Current permission: ${permissionModeLabel(mode)} (${sourceLabel(source)})`, PERMISSION_CLI_USAGE],
+    };
+}

package/dist/plugins.js

@@ -3,11 +3,20 @@ import { existsSync, readdirSync, statSync } from "fs";
 import { pathToFileURL } from "url";
 import path from "path";
 import { getConfigDir } from "./config.js";
-const PLUGIN_DIRS = [
-    path.join(process.cwd(), ".min-agent", "tools"),
-    path.join(getConfigDir(), "tools"),
-];
+import { confirm, isAutoApprove } from "./confirm.js";
+const PLUGIN_DIRS = [path.join(process.cwd(), ".min-agent", "tools"), path.join(getConfigDir(), "tools")];
 let cachedPlugins = null;
+let pluginReadOnlyIds = new Set();
+export function pluginNeedsConfirm(def) {
+    if (def.readOnly === true)
+        return false;
+    if (def.dangerous === false)
+        return false;
+    return true;
+}
+export function getPluginReadOnlyIds() {
+    return pluginReadOnlyIds;
+}
 function pluginSignature(dirs) {
     return dirs
         .map((dir) => {
@@ -24,14 +33,17 @@ function pluginSignature(dirs) {
 export async function loadPluginTools(dirs) {
     const pluginDirs = dirs ?? PLUGIN_DIRS;
     const signature = pluginSignature(pluginDirs);
-    if (cachedPlugins && cachedPlugins.signature === signature)
+    if (cachedPlugins && cachedPlugins.signature === signature) {
+        pluginReadOnlyIds = cachedPlugins.readOnlyIds;
         return cachedPlugins.tools;
+    }
     const tools = await loadPluginToolsUncached(pluginDirs);
-    cachedPlugins = { signature, tools };
+    cachedPlugins = { signature, tools, readOnlyIds: pluginReadOnlyIds };
     return tools;
 }
 async function loadPluginToolsUncached(pluginDirs) {
     const tools = {};
+    const readOnlyIds = new Set();
     for (const dir of pluginDirs) {
         if (!existsSync(dir))
             continue;
@@ -52,9 +64,12 @@ async function loadPluginToolsUncached(pluginDirs) {
                     const properties = {};
                     const required = [];
                     for (const [key, param] of Object.entries(def.parameters)) {
-                        properties[key] = { type: param.type, description: param.description };
+                        const type = narrowJsonType(param.type);
+                        properties[key] = { type, ...(param.description ? { description: param.description } : {}) };
                         required.push(key);
                     }
+                    if (def.readOnly === true)
+                        readOnlyIds.add(toolId);
                     tools[toolId] = tool({
                         description: def.description,
                         inputSchema: jsonSchema({
@@ -63,9 +78,15 @@ async function loadPluginToolsUncached(pluginDirs) {
                             required,
                         }),
                         execute: async (args) => {
+                            if (pluginNeedsConfirm(def) && !isAutoApprove()) {
+                                const preview = summarizePluginArgs(args);
+                                const approved = await confirm(`运行自定义工具 ${toolId}${preview ? `\n${preview}` : ""}`);
+                                if (!approved)
+                                    return "自定义工具已被拒绝。";
+                            }
                             try {
                                 const result = await def.execute(args);
-                                return typeof result === "string" ? result : JSON.stringify(result) ?? "undefined";
+                                return typeof result === "string" ? result : (JSON.stringify(result) ?? "undefined");
                             }
                             catch (err) {
                                 return `Plugin error: ${String(err instanceof Error ? err.message : err)}`;
@@ -79,12 +100,29 @@ async function loadPluginToolsUncached(pluginDirs) {
             }
         }
     }
+    pluginReadOnlyIds = readOnlyIds;
     const count = Object.keys(tools).length;
     if (count > 0) {
         console.log(`\x1b[90m  Plugins loaded: ${count} tool(s)\x1b[0m`);
     }
     return tools;
 }
+function summarizePluginArgs(args) {
+    try {
+        const text = JSON.stringify(args);
+        if (!text || text === "{}")
+            return "";
+        return text.length > 400 ? `${text.slice(0, 400)}…` : text;
+    }
+    catch {
+        return "";
+    }
+}
+function narrowJsonType(type) {
+    if (type === "number" || type === "boolean" || type === "object" || type === "array")
+        return type;
+    return "string";
+}
 function isPluginTool(value) {
     if (!value || typeof value !== "object")
         return false;

package/dist/pricing.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, mkdirSync, existsSync } from "fs";
 import path from "path";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
 import { getConfigDir, loadConfig } from "./config.js";
 const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
 const memoryCache = new Map();
@@ -23,7 +24,7 @@ function loadDiskCache() {
 function saveCache(cache) {
     const file = cacheFile();
     mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(cache), "utf-8");
+    atomicWriteFileSync(file, JSON.stringify(cache));
 }
 function getCached(modelId) {
     const memory = memoryCache.get(modelId);
@@ -108,8 +109,7 @@ export async function getModelPrice(modelId) {
 export function estimateCost(usage, price) {
     if (!price)
         return null;
-    const cost = (usage.inputTokens / 1_000_000) * price.inputPerMillion +
-        (usage.outputTokens / 1_000_000) * price.outputPerMillion;
+    const cost = (usage.inputTokens / 1_000_000) * price.inputPerMillion + (usage.outputTokens / 1_000_000) * price.outputPerMillion;
     return cost > 0 ? cost : null;
 }
 export function formatCost(cost) {

package/dist/provider.js

@@ -1,5 +1,21 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { loadConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
+import { getEffectiveConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
+import { createTimeoutFetch, DEFAULT_FIRST_BYTE_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from "./fetch-timeout.js";
+function positiveMs(raw, fallback) {
+    const value = typeof raw === "string" ? Number(raw) : raw;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return fallback;
+    return value;
+}
+/** Timeout/trace-aware fetch shared by every provider client. */
+export function modelFetch() {
+    const cfg = getEffectiveConfig();
+    return createTimeoutFetch({
+        firstByteTimeoutMs: positiveMs(process.env.MIN_AGENT_REQUEST_TIMEOUT_MS ?? cfg.agent?.requestTimeoutMs, DEFAULT_FIRST_BYTE_TIMEOUT_MS),
+        idleTimeoutMs: positiveMs(process.env.MIN_AGENT_STREAM_IDLE_TIMEOUT_MS ?? cfg.agent?.streamIdleTimeoutMs, DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+        trace: process.env.MIN_AGENT_TRACE === "1" || process.env.MIN_AGENT_TRACE === "true",
+    });
+}
 export function resolveModelForProvider(provider, modelId) {
     if (!provider.baseURL || !provider.apiKey) {
         throw new Error("Not configured. Run: min-agent setup");
@@ -8,15 +24,17 @@ export function resolveModelForProvider(provider, modelId) {
     if (!id) {
         throw new Error("No model specified. Run: min-agent setup");
     }
+    const fetchImpl = modelFetch();
     switch (provider.type ?? "openai-compatible") {
         case "openai": {
-            const client = createOpenAI({ apiKey: provider.apiKey });
+            const client = createOpenAI({ apiKey: provider.apiKey, fetch: fetchImpl });
             return client.chat(id);
         }
         case "ollama": {
             const client = createOpenAI({
                 baseURL: normalizeOllamaBaseURL(provider.baseURL),
                 apiKey: provider.apiKey || "ollama",
+                fetch: fetchImpl,
             });
             return client.chat(id);
         }
@@ -24,6 +42,7 @@ export function resolveModelForProvider(provider, modelId) {
             const client = createOpenAI({
                 baseURL: provider.baseURL,
                 apiKey: provider.apiKey,
+                fetch: fetchImpl,
             });
             return client.chat(id);
         }
@@ -32,10 +51,8 @@ export function resolveModelForProvider(provider, modelId) {
     }
 }
 export function resolveModel(modelId, providerName) {
-    const config = loadConfig();
-    const provider = providerName
-        ? config.providers?.find((p) => p.name === providerName)
-        : getActiveProvider(config);
+    const config = getEffectiveConfig();
+    const provider = providerName ? config.providers?.find((p) => p.name === providerName) : getActiveProvider(config);
     if (!provider) {
         throw new Error(providerName ? `Provider "${providerName}" not found` : "Not configured. Run: min-agent setup");
     }

package/dist/question-format.js

@@ -0,0 +1,60 @@
+const OPTION_TEXT_KEYS = ["label", "description", "title", "text", "value", "content", "prompt"];
+function firstText(rec, keys) {
+    const parts = [];
+    const seen = new Set();
+    for (const key of keys) {
+        const v = rec[key];
+        if (typeof v !== "string")
+            continue;
+        const text = v.trim();
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        parts.push(text);
+    }
+    return parts;
+}
+/** Pull a user-visible label out of a model-supplied question option. */
+export function optionText(item) {
+    if (item == null)
+        return null;
+    if (typeof item === "string") {
+        const text = item.trim();
+        return text.length > 0 ? text : null;
+    }
+    if (typeof item === "number" || typeof item === "boolean")
+        return String(item);
+    if (typeof item !== "object" || Array.isArray(item))
+        return null;
+    const rec = item;
+    const parts = firstText(rec, OPTION_TEXT_KEYS);
+    if (parts.length > 0)
+        return parts.join(" — ");
+    const key = rec.key;
+    return typeof key === "string" && key.trim() ? key.trim() : null;
+}
+export function normalizeQuestionPrompt(question) {
+    if (typeof question === "string")
+        return question;
+    return optionText(question) ?? "";
+}
+/**
+ * Models often send `{label, description, key}` (Claude-style) instead of
+ * `string[]`. Normalize to display strings so the TUI never calls string
+ * methods on objects.
+ */
+export function normalizeQuestionOptions(options) {
+    if (options == null)
+        return [];
+    const list = Array.isArray(options) ? options : [options];
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        const text = optionText(item);
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        out.push(text);
+    }
+    return out;
+}

package/dist/sandbox-cli.js

@@ -0,0 +1,82 @@
+import { takeScopeFlags } from "./memory.js";
+import { getSandboxSnapshot, setSandboxConfig } from "./config.js";
+import { parseNetworkPolicy, parseSandboxMode, getEffectiveSandboxPolicy, sandboxEnforcementCaveat, sandboxModeLabel, sandboxStatusLabel, setSandboxOverride, } from "./sandbox.js";
+export const SANDBOX_CLI_USAGE = [
+    "Usage: min-agent sandbox [off|workspace|strict] [--project|--global]",
+    "       min-agent sandbox network allow|deny [--project|--global]",
+    "       min-agent --sandbox off|workspace|strict [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli"
+        ? "this run"
+        : source === "env"
+            ? "environment variable"
+            : source === "project"
+                ? "project"
+                : source === "global"
+                    ? "global"
+                    : "default";
+}
+function scopeLabel(scope) {
+    return scope === "project" ? "project" : "global";
+}
+export function runSandboxCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [SANDBOX_CLI_USAGE] };
+    }
+    if (rest[0] === "network") {
+        const parsed = parseNetworkPolicy(rest[1]);
+        if (!parsed || rest.length > 2)
+            return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+        setSandboxConfig({ network: parsed }, scope);
+        setSandboxOverride({ network: parsed });
+        return { ok: true, lines: [`✓ Network set to ${parsed === "deny" ? "denied" : "allowed"} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length === 1) {
+        const parsed = parseSandboxMode(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+        setSandboxConfig({ mode: parsed }, scope);
+        setSandboxOverride({ mode: parsed });
+        const caveat = sandboxEnforcementCaveat(parsed);
+        return {
+            ok: true,
+            lines: [`✓ Sandbox set to ${sandboxModeLabel(parsed)} (${scopeLabel(scope)})`, ...(caveat ? [caveat] : [])],
+        };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+    if (input.flagMode || input.flagNetwork) {
+        setSandboxConfig({
+            ...(input.flagMode ? { mode: input.flagMode } : {}),
+            ...(input.flagNetwork ? { network: input.flagNetwork } : {}),
+        }, scope);
+        setSandboxOverride({
+            ...(input.flagMode ? { mode: input.flagMode } : {}),
+            ...(input.flagNetwork ? { network: input.flagNetwork } : {}),
+        });
+        const parts = [
+            ...(input.flagMode ? [`sandbox set to ${sandboxModeLabel(input.flagMode)}`] : []),
+            ...(input.flagNetwork ? [`network set to ${input.flagNetwork === "deny" ? "denied" : "allowed"}`] : []),
+        ];
+        const caveat = input.flagMode ? sandboxEnforcementCaveat(input.flagMode) : null;
+        return { ok: true, lines: [`✓ ${parts.join(", ")} (${scopeLabel(scope)})`, ...(caveat ? [caveat] : [])] };
+    }
+    const snap = getSandboxSnapshot();
+    const extras = [
+        ...(snap.extraWriteRoots.length > 0 ? [`Extra writable dirs: ${snap.extraWriteRoots.join(", ")}`] : []),
+        ...(snap.extraReadRoots.length > 0 ? [`Extra readable dirs: ${snap.extraReadRoots.join(", ")}`] : []),
+    ];
+    const caveat = sandboxEnforcementCaveat(getEffectiveSandboxPolicy().mode);
+    return {
+        ok: true,
+        lines: [
+            `Current sandbox: ${sandboxStatusLabel()} (${sourceLabel(snap.source)})`,
+            ...extras,
+            ...(caveat ? [caveat] : []),
+            SANDBOX_CLI_USAGE,
+        ],
+    };
+}