miii-agent 0.1.17 → 0.1.19

package/dist/cli.js

@@ -158,6 +158,30 @@ async function modelContext(entry, model) {
     throw err;
   }
 }
+async function paramCountB(entry, model) {
+  try {
+    const info = await makeClient(entry).show({ model });
+    const details = info.details;
+    if (details?.parameter_size) {
+      const m = details.parameter_size.match(/([\d.]+)\s*([BM])/i);
+      if (m) {
+        const n = parseFloat(m[1]);
+        if (!isNaN(n)) return m[2].toUpperCase() === "M" ? n / 1e3 : n;
+      }
+    }
+    const modelInfo = info.model_info;
+    if (modelInfo) {
+      const key = Object.keys(modelInfo).find((k) => k.endsWith("parameter_count"));
+      if (key) {
+        const val = Number(modelInfo[key]);
+        if (!isNaN(val) && val > 0) return val / 1e9;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function* chat(entry, model, messages, tools, opts) {
   if (opts?.signal?.aborted) return;
   const signal = opts?.signal;
@@ -177,15 +201,19 @@ async function* chat(entry, model, messages, tools, opts) {
       num_ctx: opts?.num_ctx ?? 8192
     };
     if (numPredict !== void 0 && numPredict > 0) options.num_predict = numPredict;
-    stream = await client.chat({
+    const req = {
       model,
       messages,
-      tools,
       stream: true,
       think: true,
       keep_alive: opts?.keep_alive ?? "10m",
       options
-    });
+    };
+    if (opts?.format) req.format = opts.format;
+    else if (tools) req.tools = tools;
+    stream = await client.chat(
+      req
+    );
   } catch (err) {
     if (signal?.aborted) return;
     if (isConnectionError(err)) {
@@ -452,6 +480,9 @@ var init_openai = __esm({
 function active() {
   return resolveProvider();
 }
+function providerName() {
+  return active().name;
+}
 function isAvailable3() {
   const { entry } = active();
   return entry.type === "ollama" ? isAvailable(entry) : isAvailable2(entry);
@@ -468,6 +499,16 @@ async function modelContext3(model) {
   const { entry } = active();
   return entry.type === "ollama" ? modelContext(entry, model) : modelContext2(entry, model);
 }
+async function modelParamCountB(model) {
+  const { entry } = active();
+  if (entry.type !== "ollama") return null;
+  const key = `${entry.baseUrl}:${model}`;
+  const cached = paramCountCache.get(key);
+  if (cached !== void 0) return cached;
+  const params = await paramCountB(entry, model);
+  paramCountCache.set(key, params);
+  return params;
+}
 async function* chat3(model, messages, tools, opts) {
   const { entry } = active();
   if (entry.type === "ollama") {
@@ -476,12 +517,70 @@ async function* chat3(model, messages, tools, opts) {
     yield* chat2(entry, model, messages, tools, opts);
   }
 }
+var paramCountCache;
 var init_client = __esm({
   "src/llm/client.ts"() {
     "use strict";
     init_config();
     init_ollama();
     init_openai();
+    paramCountCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/llm/grammar.ts
+function argProperties(props) {
+  const out = {};
+  for (const [key, spec] of Object.entries(props)) {
+    const node = { type: spec.type };
+    if (spec.enum && spec.enum.length) node.enum = spec.enum;
+    out[key] = node;
+  }
+  return out;
+}
+function toolBranch(tool) {
+  const args2 = {
+    type: "object",
+    additionalProperties: false,
+    properties: argProperties(tool.input_schema.properties)
+  };
+  if (tool.input_schema.required && tool.input_schema.required.length) {
+    args2.required = tool.input_schema.required;
+  }
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["name", "arguments"],
+    properties: {
+      name: { const: tool.name },
+      arguments: args2
+    }
+  };
+}
+function respondBranch() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["name", "arguments"],
+    properties: {
+      name: { const: RESPOND_ACTION },
+      arguments: {
+        type: "object",
+        additionalProperties: false,
+        required: ["message"],
+        properties: { message: { type: "string" } }
+      }
+    }
+  };
+}
+function buildToolGrammar(tools) {
+  return { oneOf: [...tools.map(toolBranch), respondBranch()] };
+}
+var RESPOND_ACTION;
+var init_grammar = __esm({
+  "src/llm/grammar.ts"() {
+    "use strict";
+    RESPOND_ACTION = "respond";
   }
 });
 
@@ -851,26 +950,45 @@ var init_run_bash = __esm({
 
 // src/tools/grep.ts
 import { execa as execa2 } from "execa";
-var grep;
+var bool, grep;
 var init_grep = __esm({
   "src/tools/grep.ts"() {
     "use strict";
     init_paths();
+    bool = (v) => v === true || String(v) === "true";
     grep = {
       name: "grep",
       description: "Search file contents for a regex pattern. Uses ripgrep if available, falls back to grep -R.",
       input_schema: {
         type: "object",
         properties: {
-          pattern: { type: "string", description: "Regex pattern" },
+          pattern: { type: "string", description: "Regex pattern (literal when fixed_strings)" },
           path: { type: "string", description: "Root path to search (default cwd)" },
           glob: { type: "string", description: 'File glob filter, e.g. "*.ts"' },
           case_insensitive: { type: "boolean", description: "Case-insensitive match" },
-          max_results: { type: "number", description: "Max matching lines (default 200)" }
+          max_results: { type: "number", description: "Max matching lines (default 200)" },
+          context: { type: "number", description: "Lines of context before & after each match" },
+          files_only: { type: "boolean", description: "List matching filenames only" },
+          type: { type: "string", description: 'ripgrep file type filter, e.g. "js" (ignored by grep fallback)' },
+          multiline: { type: "boolean", description: "Allow matches to span multiple lines" },
+          count: { type: "boolean", description: "Print count of matching lines per file" },
+          fixed_strings: { type: "boolean", description: "Treat pattern as literal string, not regex" }
         },
         required: ["pattern"]
       },
-      handler: async ({ pattern, path, glob: glob2, case_insensitive, max_results }) => {
+      handler: async ({
+        pattern,
+        path,
+        glob: glob2,
+        case_insensitive,
+        max_results,
+        context,
+        files_only,
+        type,
+        multiline,
+        count,
+        fixed_strings
+      }) => {
         let root;
         try {
           root = confinePath(path ?? ".");
@@ -878,21 +996,37 @@ var init_grep = __esm({
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
         const limit = max_results ?? 200;
-        const ci = case_insensitive === true || String(case_insensitive) === "true";
+        const ci = bool(case_insensitive);
+        const filesOnly = bool(files_only);
+        const ml = bool(multiline);
+        const cnt = bool(count);
+        const fixed = bool(fixed_strings);
+        const ctx = typeof context === "number" && context > 0 ? Math.floor(context) : 0;
         const tryRg = async () => {
           const args2 = ["--line-number", "--no-heading", "--color=never", "-m", String(limit)];
           if (ci) args2.push("-i");
+          if (fixed) args2.push("-F");
           if (glob2) args2.push("--glob", glob2);
+          if (type) args2.push("-t", type);
+          if (ctx) args2.push("-C", String(ctx));
+          if (ml) args2.push("-U", "--multiline-dotall");
+          if (filesOnly) args2.push("-l");
+          if (cnt) args2.push("-c");
           args2.push("--", pattern, root);
           return execa2("rg", args2, { reject: false, timeout: 2e4 });
         };
         const tryGrep = async () => {
           const args2 = ["-R", "-n", "--color=never"];
           if (ci) args2.push("-i");
+          if (fixed) args2.push("-F");
           if (glob2) args2.push("--include", glob2);
+          if (ctx) args2.push("-C", String(ctx));
+          if (filesOnly) args2.push("-l");
+          if (cnt) args2.push("-c");
           args2.push("--", pattern, root);
           return execa2("grep", args2, { reject: false, timeout: 2e4 });
         };
+        const missing = (err) => err?.code === "ENOENT" || err?.errno === "ENOENT";
         try {
           let res;
           try {
@@ -900,7 +1034,8 @@ var init_grep = __esm({
             if (res.exitCode === 127 || (res.stderr ?? "").includes("command not found")) {
               res = await tryGrep();
             }
-          } catch {
+          } catch (err) {
+            if (!missing(err)) throw err;
             res = await tryGrep();
           }
           const lines = (res.stdout ?? "").split("\n").slice(0, limit);
@@ -1113,8 +1248,15 @@ var init_context = __esm({
 });
 
 // src/prompt/system.ts
-function buildSystemPrompt(tools, cwd, project) {
+function buildSystemPrompt(tools, cwd, project, grammarMode = false) {
   const toolLines = tools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+  const actionProtocol = grammarMode ? `
+# Action protocol (strict)
+Every reply is exactly ONE JSON action object, nothing else \u2014 no prose outside it, no markdown, no fences. Decoding is grammar-constrained, so malformed output is impossible; your only job is to choose the right action.
+  To use a tool: {"name": "<tool_name>", "arguments": { ...that tool's args }}
+  To give your final answer to the user: {"name": "respond", "arguments": {"message": "<your full answer here>"}}
+Call tools until the GOAL is met, then emit a single "respond" action with the complete answer. The "respond" action is the ONLY way to end the turn and talk to the user \u2014 never put your final answer in a tool call.
+` : "";
   const projectSection = project && project.content.trim() ? `
 # ${CONTEXT_FILENAME} \u2014 project instructions (authoritative, read first)
 The user maintains ${CONTEXT_FILENAME} at ${project.source} to steer how you work in this project: conventions, commands, architecture, do's and don'ts. Treat it as direct instruction from the user, higher priority than your defaults. When it conflicts with a default rule below, ${CONTEXT_FILENAME} wins (except permissions and safety, which you never override).${project.truncated ? `
@@ -1139,6 +1281,17 @@ If GAPS is non-empty, ask the minimum questions needed to fill them \u2014 one m
 
 Re-read GOAL before every tool call. If a tool call does not move toward GOAL, skip it.
 
+# Plan summary before acting (conditional)
+Write a brief plan BEFORE the first tool call ONLY when the work is non-trivial:
+  - Multi-step, OR touches multiple files, OR is destructive/hard to reverse, OR mixes investigation + change.
+SKIP the plan for trivial work \u2014 a single read, one small edit, a quick search, a direct question. Just act.
+When you do write one:
+  - One or two plain-text sentences naming what you will do and in what order.
+  - State the intent (the bug/feature/fix and the steps), not a tool-by-tool narration.
+  - Keep it short \u2014 the user reads this to follow along, not a spec.
+Then begin immediately with the first tool call. Do not wait for approval unless GAPS was non-empty or the work is destructive.
+This summary is the ONE allowed preamble. It does not override the Tool calls rule below: after this plan, emit tool calls directly with no further narration between them.
+
 # Attention: re-attend to goal at each step
 After each tool result, answer silently: "Does this result move me toward GOAL?"
   YES \u2192 continue
@@ -1148,9 +1301,19 @@ This prevents drift. Each step attends to the original goal, not just the previo
 
 # Output format
 - Always reply in plain text. Never use Markdown syntax: no \`#\` headings, no \`**bold**\`, no \`-\` bullet lists, no fenced \`\`\` code blocks, no inline backticks.
+- This applies to your reasoning/thinking too. Write internal thoughts in plain text \u2014 no Markdown headings, bold, lists, or code fences there either.
 - Quote code, paths, and identifiers inline as plain text. Do not wrap them.
 - Keep prose terse.
 
+# Tone and voice
+- Sound like a calm, caring teammate who is genuinely invested in the user's goal. Warm, steady, reassuring \u2014 never cold or robotic.
+- Lead with empathy, especially when the user is stuck, frustrated, or facing a hard bug. Acknowledge the difficulty briefly before diving in: "That's a tricky one \u2014 let's work through it together."
+- Be encouraging about the goal. Treat it as something worth caring about, and convey quiet confidence that you'll reach it together.
+- Stay honest and direct. Empathy never means hedging, sugarcoating, or hiding bad news. Deliver hard truths kindly but plainly.
+- Keep warmth lightweight: a sentence or a few words, not gushing. One genuine, human touch beats a paragraph of pleasantries.
+- Mind the user's effort and context. If something will take a while or carry risk, say so gently and set expectations.
+- Celebrate progress in passing \u2014 a fixed bug, a passing test \u2014 without slowing the work down.
+
 # Engineering mindset
 - Treat every request as one of: bug, feature, or fix. Name which one before you start.
 - Apply first principles: decompose unclear tasks into smallest concrete sub-problems, solve each explicitly, compose the result.
@@ -1178,7 +1341,7 @@ Ask in a numbered list. One round of questions per turn. Then wait.
 # Tools
 You have access to the following tools. Call them via the function-calling interface.
 ${toolLines}
-
+${actionProtocol}
 # Loop semantics
 - When you need to act on the filesystem or run a command, emit a tool call.
 - After each tool result, decide: more tool calls, or a final plain-text answer.
@@ -1189,7 +1352,7 @@ ${toolLines}
 - Prefer editing existing files over creating new ones.
 - For edit_file, make old_str unique by including surrounding context, or set replace_all to change every occurrence.
 - Never invent file paths. Read, glob, or grep before editing.
-- No filler, no pleasantries, no apologies.
+- No empty filler or robotic boilerplate. A brief, genuine warm touch (see Tone and voice) is welcome; hollow pleasantries and reflexive apologies are not.
 
 # Context discipline
 - read_file returns line numbers and accepts offset/limit. For large files, grep or glob to the relevant region first, then read only that range with offset/limit. Do not read a whole large file when you need a few functions \u2014 it wastes the context window.
@@ -1243,6 +1406,17 @@ function subjectFor(toolName, input) {
   if (typeof obj.path === "string") return obj.path;
   return "";
 }
+function generalizeCommand(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || tokens[0] === "") return command;
+  const prog = tokens[0];
+  const prefixLen = WRAPPER_PROGRAMS.has(prog) && tokens.length > 1 ? 2 : 1;
+  const prefix = tokens.slice(0, prefixLen).join(" ");
+  return `${prefix} *`;
+}
+function patternToPersist(toolName, subject) {
+  return toolName === "run_bash" ? generalizeCommand(subject) : subject;
+}
 function globToRegExp(glob2) {
   const escaped = glob2.replace(/[.+^${}()|[\]\\]/g, "\\$&");
   const pattern = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
@@ -1263,15 +1437,28 @@ async function check(toolName, input, ctx) {
   if (rules.some((r) => matches(r, toolName, subject))) return "allow";
   const answer = await ctx.ask(toolName, input);
   if (answer === "no") return "deny";
-  if (answer === "always") addRule(toolName, subject);
+  if (answer === "always") addRule(toolName, patternToPersist(toolName, subject));
   return "allow";
 }
-var RULES_DIR, RULES_PATH, ALWAYS_ALLOW;
+var RULES_DIR, RULES_PATH, WRAPPER_PROGRAMS, ALWAYS_ALLOW;
 var init_policy = __esm({
   "src/permissions/policy.ts"() {
     "use strict";
     RULES_DIR = join7(homedir5(), ".miii");
     RULES_PATH = join7(RULES_DIR, "permissions.json");
+    WRAPPER_PROGRAMS = /* @__PURE__ */ new Set([
+      "npm",
+      "npx",
+      "pnpm",
+      "yarn",
+      "brew",
+      "pip",
+      "pip3",
+      "cargo",
+      "docker",
+      "kubectl",
+      "go"
+    ]);
     ALWAYS_ALLOW = /* @__PURE__ */ new Set(["read_file", "grep", "glob"]);
   }
 });
@@ -1384,6 +1571,75 @@ function extractFirstJsonObject(s) {
   }
   return null;
 }
+function parseGrammarAction(content, knownToolNames) {
+  if (!content) return null;
+  let raw = content.trim();
+  if (!raw.startsWith("{")) {
+    const found = extractFirstJsonObject(raw);
+    if (!found) return null;
+    raw = found.json;
+  }
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    const found = extractFirstJsonObject(raw);
+    if (!found) return null;
+    try {
+      obj = JSON.parse(found.json);
+    } catch {
+      return null;
+    }
+  }
+  const name = typeof obj.name === "string" ? obj.name : void 0;
+  const args2 = obj.arguments ?? {};
+  if (!name) return null;
+  if (name === "respond") {
+    const message = typeof args2.message === "string" ? args2.message : "";
+    return { kind: "respond", message };
+  }
+  if (!knownToolNames.includes(name)) return null;
+  return { kind: "tool", name, arguments: args2 };
+}
+function streamRespondMessage(text) {
+  if (!/"name"\s*:\s*"respond"/.test(text)) return null;
+  const m = text.match(/"message"\s*:\s*"/);
+  if (!m || m.index == null) return null;
+  const start = m.index + m[0].length;
+  const escapes = {
+    n: "\n",
+    t: "	",
+    r: "\r",
+    b: "\b",
+    f: "\f",
+    '"': '"',
+    "\\": "\\",
+    "/": "/"
+  };
+  let out = "";
+  let i = start;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') return { message: out, complete: true };
+    if (ch === "\\") {
+      const nx = text[i + 1];
+      if (nx === void 0) break;
+      if (nx === "u") {
+        const hex = text.slice(i + 2, i + 6);
+        if (hex.length < 4) break;
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 6;
+        continue;
+      }
+      out += escapes[nx] ?? nx;
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return { message: out, complete: false };
+}
 function blocksFromOllama(text, tool_calls, knownToolNames = []) {
   const blocks = [];
   let finalText = text;
@@ -1441,8 +1697,15 @@ function markSeen(name, input, seen) {
 async function* runAgent(opts) {
   const { model, cwd, permissions, hooks, signal, num_ctx } = opts;
   const startTime = Date.now();
-  const system = buildSystemPrompt(TOOLS, cwd, loadProjectContext(cwd));
+  let useGrammar = false;
+  if (providerName() === "ollama") {
+    const params = await modelParamCountB(model);
+    useGrammar = params == null || params <= GRAMMAR_MAX_PARAMS_B;
+  }
+  const system = buildSystemPrompt(TOOLS, cwd, loadProjectContext(cwd), useGrammar);
+  const grammar = useGrammar ? buildToolGrammar(TOOLS) : void 0;
   const ollamaTools = toOllamaTools(TOOLS);
+  const toolNames = TOOLS.map((t) => t.name);
   const effort = EFFORT_OPTIONS[loadConfig().effort ?? "medium"];
   const history = [
     ...opts.history,
@@ -1456,6 +1719,8 @@ async function* runAgent(opts) {
   for (let turn = 0; turn < MAX_TURNS; turn++) {
     let text = "";
     let tool_calls;
+    let respondEmitted = 0;
+    let streamedRespond = false;
     let lastTail = "";
     let tailRepeats = 0;
     let streamLooped = false;
@@ -1463,11 +1728,22 @@ async function* runAgent(opts) {
     const composedSignal = signal ? AbortSignal.any ? AbortSignal.any([signal, ac.signal]) : ac.signal : ac.signal;
     if (signal) signal.addEventListener("abort", () => ac.abort(), { once: true });
     try {
-      for await (const chunk of chat3(model, toOllamaMessages(history, system), ollamaTools, { signal: composedSignal, num_ctx, num_predict: effort.num_predict, temperature: effort.temperature })) {
+      for await (const chunk of chat3(model, toOllamaMessages(history, system), useGrammar ? void 0 : ollamaTools, { signal: composedSignal, num_ctx, num_predict: effort.num_predict, temperature: effort.temperature, format: grammar })) {
         if (signal?.aborted) break;
         if (chunk.content) {
           text += chunk.content;
-          yield { type: "text-delta", text: chunk.content };
+          if (!useGrammar) {
+            yield { type: "text-delta", text: chunk.content };
+          } else {
+            const r = streamRespondMessage(text);
+            if (r) {
+              streamedRespond = true;
+              if (r.message.length > respondEmitted) {
+                yield { type: "text-delta", text: r.message.slice(respondEmitted) };
+                respondEmitted = r.message.length;
+              }
+            }
+          }
           if (text.length >= REPEAT_TAIL) {
             const tail = text.slice(-REPEAT_TAIL);
             if (tail === lastTail) {
@@ -1515,7 +1791,19 @@ async function* runAgent(opts) {
       };
       return history;
     }
-    const blocks = blocksFromOllama(text, tool_calls, TOOLS.map((t) => t.name));
+    let blocks;
+    if (useGrammar) {
+      const action = parseGrammarAction(text, toolNames);
+      if (action?.kind === "tool") {
+        blocks = [{ type: "tool_use", id: mintToolUseId(), name: action.name, input: action.arguments }];
+      } else {
+        const message = action?.kind === "respond" ? action.message : text.trim();
+        if (message && !streamedRespond) yield { type: "text-delta", text: message };
+        blocks = message ? [{ type: "text", text: message }] : [];
+      }
+    } else {
+      blocks = blocksFromOllama(text, tool_calls, toolNames);
+    }
     const tool_uses = blocks.filter((b) => b.type === "tool_use");
     history.push({ role: "assistant", content: blocks });
     if (tool_uses.length === 0) {
@@ -1624,11 +1912,12 @@ async function* runAgent(opts) {
   yield { type: "done", prompt_tokens: promptTokens, eval_tokens: evalTokens };
   return history;
 }
-var MAX_TURNS, REPEAT_TAIL, REPEAT_KILL;
+var MAX_TURNS, REPEAT_TAIL, REPEAT_KILL, GRAMMAR_MAX_PARAMS_B;
 var init_loop = __esm({
   "src/agent/loop.ts"() {
     "use strict";
     init_client();
+    init_grammar();
     init_paths();
     init_registry();
     init_validate();
@@ -1640,6 +1929,7 @@ var init_loop = __esm({
     MAX_TURNS = 25;
     REPEAT_TAIL = 120;
     REPEAT_KILL = 4;
+    GRAMMAR_MAX_PARAMS_B = 14;
   }
 });
 
@@ -2615,10 +2905,11 @@ function ToolResultBlock({ result, toolName }) {
   const visible = expanded ? lines : lines.slice(0, COLLAPSED_LINES);
   const shown = visible.map((l) => truncate2(l, MAX_LINE_WIDTH));
   const extra = lines.length - shown.length;
+  const header = toolName === "grep" || toolName === "glob" ? summarizeResult(result, toolName) : `${lines.length} line${lines.length === 1 ? "" : "s"}`;
   return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
     /* @__PURE__ */ jsxs9(Text9, { color: result.is_error ? "red" : void 0, dimColor: !result.is_error, children: [
       "\u23BF  ",
-      summarizeResult(result, toolName)
+      header
     ] }),
     shown.map((ln, i) => /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsx9(Text9, { color: result.is_error ? "red" : void 0, dimColor: true, children: ln || " " }) }, i)),
     extra > 0 && /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
@@ -2809,7 +3100,7 @@ function useAgentRunner(model, activeCtx) {
     if (busyRef.current || !model) return;
     busyRef.current = true;
     setBusy(true);
-    setProcessingLabel("thinking\u2026");
+    setProcessingLabel("crunching\u2026");
     setError(null);
     setMessages((prev) => [...prev, { role: "user", content: text }]);
     setThinking(true);
@@ -2891,7 +3182,7 @@ function useAgentRunner(model, activeCtx) {
           case "thinking-delta": {
             thinkingAcc += ev.text;
             setThinking(true);
-            setProcessingLabel("thinking\u2026");
+            setProcessingLabel("crunching\u2026");
             flushThink();
             break;
           }
@@ -2908,7 +3199,7 @@ function useAgentRunner(model, activeCtx) {
               is_error: ev.block.is_error
             });
             setActiveToolResults([...turnResults]);
-            setProcessingLabel("thinking\u2026");
+            setProcessingLabel("crunching\u2026");
             break;
           }
           case "turn-end": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Terminal AI coding agent powered by Ollama",
   "type": "module",
   "bin": {