dskcode 0.1.40 → 0.1.41

package/dist/index.js

@@ -1160,23 +1160,207 @@ function formatMoney(yuan) {
 
 // src/ui/ToolCallBlock.tsx
 import { Box as Box3, Text as Text4 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function formatArgsSummary(args) {
+
+// src/agent/tool-call-summary.ts
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "token",
+  "apikey",
+  "api_key",
+  "secret",
+  "authorization",
+  "auth",
+  "credential",
+  "credentials",
+  "private_key",
+  "privatekey"
+]);
+function templateToolCall(toolName, args) {
+  if (!isPlainObject(args)) {
+    return `${toolName}()`;
+  }
+  switch (toolName) {
+    case "read_file":
+      return `${toolName}(path=${shortStr(args.path)})`;
+    case "write_file":
+      return `${toolName}(path=${shortStr(args.path)})`;
+    case "edit_file":
+      return `${toolName}(path=${shortStr(args.path)}, old_text=${shortStr(args.old_text, 30)})`;
+    case "multi_edit": {
+      const edits = Array.isArray(args.edits) ? args.edits.length : 0;
+      return `${toolName}(path=${shortStr(args.path)}, edits=${edits})`;
+    }
+    case "delete_range": {
+      return `${toolName}(path=${shortStr(args.path)})`;
+    }
+    case "bash":
+      return `${toolName}(command=${shortStr(args.command, 60)})`;
+    case "ls":
+      return `${toolName}(path=${shortStr(args.path ?? ".")})`;
+    case "glob":
+      return `${toolName}(pattern=${shortStr(args.pattern)})`;
+    case "grep":
+      return `${toolName}(pattern=${shortStr(args.pattern)}, path=${shortStr(args.path ?? ".")})`;
+    case "fetch":
+      return `${toolName}(url=${shortStr(args.url, 60)})`;
+    default:
+      const keys = Object.keys(args);
+      if (keys.length === 0) return `${toolName}()`;
+      const preview = keys.slice(0, 4).map((k) => `${k}=\u2026`).join(", ");
+      const more = keys.length > 4 ? `, +${keys.length - 4}` : "";
+      return `${toolName}(${preview}${more})`;
+  }
+}
+function maskSensitive(args) {
+  return maskRecursive(args, /* @__PURE__ */ new WeakSet());
+}
+function maskRecursive(value, seen) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  const obj = value;
+  if (seen.has(obj)) return "****";
+  seen.add(obj);
+  if (Array.isArray(value)) {
+    return value.map((v) => maskRecursive(v, seen));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (SENSITIVE_KEYS.has(k.toLowerCase())) {
+      out[k] = "****";
+    } else {
+      out[k] = maskRecursive(v, seen);
+    }
+  }
+  return out;
+}
+function formatArgsForDisplay(args, opts = {}) {
+  const valueMaxLen = opts.valueMaxLen ?? 80;
+  const doMask = opts.maskSensitive !== false;
+  const maxKeys = opts.maxKeys ?? 6;
+  if (!isPlainObject(args)) {
+    const s = formatValue(args, valueMaxLen);
+    return s;
+  }
+  const masked = doMask ? maskSensitive(args) : args;
+  const entries = Object.entries(masked);
+  const shown = entries.slice(0, maxKeys);
+  const lines = shown.map(([k, v]) => `${k}: ${formatValue(v, valueMaxLen)}`);
+  if (entries.length > maxKeys) {
+    lines.push(`+${entries.length - maxKeys} more`);
+  }
+  return lines.join("\n");
+}
+function formatValue(v, maxLen = 80) {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (typeof v === "string") {
+    return v.length > maxLen ? v.slice(0, maxLen - 1) + "\u2026" : v;
+  }
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) {
+    if (v.length <= 3) return JSON.stringify(v);
+    return `[\u2026${v.length} items\u2026]`;
+  }
+  if (typeof v === "object") {
+    const obj = v;
+    const keys = Object.keys(obj);
+    if (keys.length <= 3) return JSON.stringify(obj);
+    return `{\u2026${keys.length} keys\u2026}`;
+  }
+  return JSON.stringify(v);
+}
+function shortStr(v, maxLen = 40) {
+  if (v === void 0 || v === null) return String(v);
+  if (typeof v !== "string") return formatValue(v, maxLen);
+  if (v.length === 0) return "(\u7A7A)";
+  if (v.length > maxLen) return v.slice(0, maxLen - 1) + "\u2026";
+  return v;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/agent/tool-call-parser.ts
+function parseToolCallArgs(raw) {
+  if (raw === "" || raw === void 0 || raw === null) {
+    return { ok: true, args: {}, fixed: "" };
+  }
   try {
-    const parsed = JSON.parse(args);
-    const lines = Object.entries(parsed).map(([key, value]) => {
-      const val = String(value);
-      const truncated = val.length > 80 ? val.slice(0, 77) + "..." : val;
-      return `     ${key}: ${truncated}`;
-    });
-    return lines.join("\n");
-  } catch {
-    const truncated = args.length > 120 ? args.slice(0, 117) + "..." : args;
-    return `     ${truncated}`;
+    const args = JSON.parse(raw);
+    return { ok: true, args, fixed: raw };
+  } catch (firstErr) {
+    const fixed = fixStreamedJson(raw);
+    try {
+      const args = JSON.parse(fixed);
+      return { ok: true, args, fixed };
+    } catch (secondErr) {
+      const firstMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
+      if (isLikelyPartialJson(firstMsg, raw)) {
+        return {
+          ok: false,
+          reason: "PARTIAL",
+          partial: raw,
+          hint: "\u53C2\u6570 JSON \u5C1A\u672A\u6536\u5168\uFF0C\u6D41\u5F0F\u62FC\u63A5\u4E2D\uFF1B\u53EF\u80FD\u662F\u7F51\u7EDC/\u5FC3\u8DF3\u5BFC\u81F4\u534A\u622A"
+        };
+      }
+      return {
+        ok: false,
+        reason: "INVALID_JSON",
+        raw,
+        error: firstMsg
+      };
+    }
+  }
+}
+function fixStreamedJson(partial) {
+  let end = partial.length;
+  let backslashes = 0;
+  for (let i = partial.length - 1; i >= 0; i--) {
+    if (partial[i] === "\\") backslashes++;
+    else break;
+  }
+  if (backslashes % 2 === 1) end--;
+  let json = partial.slice(0, end);
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < json.length; i++) {
+    const ch = json[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") stack.push("}");
+    else if (ch === "[") stack.push("]");
+    else if (ch === "}" || ch === "]") stack.pop();
   }
+  if (inString) json += '"';
+  while (stack.length > 0) json += stack.pop();
+  return json;
+}
+function isLikelyPartialJson(errMsg, raw) {
+  if (errMsg.includes("Unexpected end of JSON")) return true;
+  if (errMsg.includes("Unterminated string")) return true;
+  if (raw.length < 5) return true;
+  return false;
 }
-function ToolCallBlock({ call }) {
-  const argsDisplay = formatArgsSummary(call.arguments);
+
+// src/ui/ToolCallBlock.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ToolCallBlock({ call, parsedArgs, schemaIssues }) {
+  const resolvedArgs = parsedArgs ?? resolveArgsFromRaw(call.arguments);
+  const safeArgs = maskSensitive(resolvedArgs);
+  const summary = templateToolCall(call.name, safeArgs);
+  const argsDisplay = formatArgsForDisplay(safeArgs);
   return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: [
     /* @__PURE__ */ jsxs3(Box3, { children: [
       /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
@@ -1188,9 +1372,34 @@ function ToolCallBlock({ call }) {
         "\u2500".repeat(Math.max(1, 30 - call.name.length))
       ] })
     ] }),
-    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: argsDisplay }) })
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 2, children: [
+      /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: summary }),
+      /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: argsDisplay })
+    ] }),
+    schemaIssues && schemaIssues.length > 0 && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 2, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: "yellow", children: [
+        "\u26A0 schema \u95EE\u9898\uFF08",
+        schemaIssues.length,
+        "\uFF09"
+      ] }),
+      schemaIssues.slice(0, 3).map((issue, i) => /* @__PURE__ */ jsxs3(Text4, { color: "yellow", children: [
+        "  - ",
+        issue.message
+      ] }, i)),
+      schemaIssues.length > 3 && /* @__PURE__ */ jsxs3(Text4, { color: "yellow", children: [
+        "  ...\u8FD8\u6709 ",
+        schemaIssues.length - 3,
+        " \u6761"
+      ] })
+    ] })
   ] });
 }
+function resolveArgsFromRaw(raw) {
+  if (!raw) return {};
+  const parsed = parseToolCallArgs(raw);
+  if (parsed.ok) return parsed.args;
+  return {};
+}
 
 // src/ui/HighlightedText.tsx
 import { Box as Box4, Text as Text5 } from "ink";
@@ -2188,7 +2397,7 @@ function CompactionProgress({ state, contentWidth }) {
 // package.json
 var package_default = {
   name: "dskcode",
-  version: "0.1.40",
+  version: "0.1.41",
   repository: {
     type: "git",
     url: "git+https://github.com/Awu12277/deepseek-agent-cli/tree/main"
@@ -2224,9 +2433,8 @@ var package_default = {
     "lint:fix": "oxlint --fix src/ tests/",
     format: "prettier --write src/ tests/",
     "format:check": "prettier --check src/ tests/",
-    test: "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    test: "vitest run --exclude 'tests/checkpoint.test.ts' --exclude 'tests/session-rewind.test.ts'",
+    "test:checkpoint": "vitest run tests/checkpoint.test.ts tests/session-rewind.test.ts",
     prepublishOnly: "npm run build && npm run test"
   },
   dependencies: {
@@ -2237,7 +2445,8 @@ var package_default = {
     ink: "^7.1.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
-    react: "^19.2.7"
+    react: "^19.2.7",
+    zod: "^3.25.76"
   },
   devDependencies: {
     "@types/node": "^22.14.0",
@@ -2554,12 +2763,19 @@ function fallbackSummary(turns) {
       const preview = userMsg.content.slice(0, FALLBACK_USER_PREVIEW);
       lines.push(`\u56DE\u5408${i + 1} \u7528\u6237: ${preview}`);
     }
-    const toolNames = /* @__PURE__ */ new Set();
+    const toolCalls = [];
     for (const m of turn) {
-      if (m.toolCalls) for (const tc of m.toolCalls) toolNames.add(tc.name);
+      if (m.toolCalls) for (const tc of m.toolCalls) toolCalls.push({ name: tc.name, argsRaw: tc.arguments });
     }
-    if (toolNames.size > 0) {
-      lines.push(`  \u8C03\u7528\u5DE5\u5177: ${[...toolNames].join(", ")}`);
+    if (toolCalls.length > 0) {
+      const summaries = toolCalls.map((tc) => {
+        const parsed = parseToolCallArgs(tc.argsRaw);
+        if (!parsed.ok) {
+          return `${tc.name}(\u89E3\u6790\u5931\u8D25)`;
+        }
+        return templateToolCall(tc.name, maskSensitive(parsed.args));
+      });
+      lines.push(`  \u8C03\u7528\u5DE5\u5177: ${summaries.join("; ")}`);
     }
   }
   return lines.join("\n");
@@ -2870,6 +3086,326 @@ var ToolRegistry = class {
   }
 };
 
+// src/tool/zod-schema-validator.ts
+import { z } from "zod";
+function zodSafeValidate(args, schema) {
+  const result = schema.safeParse(args);
+  if (result.success) {
+    return { ok: true, issues: [] };
+  }
+  const issues = result.error.issues.map(
+    (zi) => zodIssueToValidationIssue(zi, args)
+  );
+  return { ok: issues.length === 0, issues };
+}
+function zodIssueToValidationIssue(zi, rootArgs) {
+  const path = formatPath(zi.path);
+  const expected = formatExpected(zi);
+  const received = describeReceived(rootArgs, zi.path);
+  const message = formatMessage(path, expected, received, zi);
+  return { path, expected, received, message };
+}
+function formatPath(path) {
+  if (path.length === 0) return "$";
+  let out = "$";
+  for (const seg of path) {
+    if (typeof seg === "number") {
+      out += `[${seg}]`;
+    } else if (typeof seg === "string") {
+      out += `.${seg}`;
+    } else {
+      out += "[]";
+    }
+  }
+  return out;
+}
+function formatExpected(zi) {
+  switch (zi.code) {
+    case "invalid_type": {
+      const exp = zi.expected;
+      return exp;
+    }
+    case "too_small": {
+      const t = zi.type;
+      const min = zi.minimum;
+      if (t === "string") return `length >= ${min}`;
+      if (t === "array") return `length >= ${min}`;
+      if (t === "number") return `>= ${min}`;
+      return `>= ${min}`;
+    }
+    case "too_big": {
+      const t = zi.type;
+      const max = zi.maximum;
+      if (t === "string") return `length <= ${max}`;
+      if (t === "array") return `length <= ${max}`;
+      if (t === "number") return `<= ${max}`;
+      return `<= ${max}`;
+    }
+    case "invalid_enum_value": {
+      const opts = zi.options;
+      return `enum[${opts.map((o) => JSON.stringify(o)).join(",")}]`;
+    }
+    case "invalid_string": {
+      const v = zi.validation;
+      return `string ${v}`;
+    }
+    case "unrecognized_keys": {
+      const keys = zi.keys;
+      return `\u672A\u5728 schema \u4E2D\u5B9A\u4E49: ${keys.join(",")}`;
+    }
+    case "invalid_literal": {
+      const exp = zi.expected;
+      return `literal[${JSON.stringify(exp)}]`;
+    }
+    default:
+      return zi.code;
+  }
+}
+function describeReceived(rootArgs, path) {
+  let cur = rootArgs;
+  for (const seg of path) {
+    if (cur === null || cur === void 0) return "undefined";
+    if (typeof cur !== "object") return "undefined";
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur)) return "undefined";
+      cur = cur[seg];
+    } else if (typeof seg === "string") {
+      cur = cur[seg];
+    } else {
+      return "undefined";
+    }
+  }
+  if (cur === null) return "null";
+  if (cur === void 0) return "undefined";
+  if (typeof cur === "string") {
+    return cur.length > 60 ? JSON.stringify(cur.slice(0, 57) + "...") : JSON.stringify(cur);
+  }
+  if (typeof cur === "number" || typeof cur === "boolean") return JSON.stringify(cur);
+  if (Array.isArray(cur)) return `array(len=${cur.length})`;
+  if (typeof cur === "object") {
+    const keys = Object.keys(cur);
+    return `object{keys=${keys.length}}`;
+  }
+  return typeof cur;
+}
+function formatMessage(path, expected, received, zi) {
+  if (zi.code === "invalid_type") {
+    return `${path} \u5E94\u4E3A ${expected}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+  }
+  if (zi.code === "too_small") {
+    const t = zi.type;
+    const min = zi.minimum;
+    if (t === "string") return `${path} \u957F\u5EA6\u5E94 >= ${min}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    if (t === "array") return `${path} \u957F\u5EA6\u5E94 >= ${min}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    if (t === "number") return `${path} \u5E94 >= ${min}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    return `${path} \u5E94 >= ${min}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+  }
+  if (zi.code === "too_big") {
+    const t = zi.type;
+    const max = zi.maximum;
+    if (t === "string") return `${path} \u957F\u5EA6\u5E94 <= ${max}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    if (t === "array") return `${path} \u957F\u5EA6\u5E94 <= ${max}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    if (t === "number") return `${path} \u5E94 <= ${max}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+    return `${path} \u5E94 <= ${max}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+  }
+  if (zi.code === "invalid_enum_value") {
+    return `${path} \u5E94\u4E3A enum \u503C\u4E4B\u4E00\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+  }
+  if (zi.code === "unrecognized_keys") {
+    const keys = zi.keys;
+    return `${path} \u4E0D\u5141\u8BB8\u952E: ${keys.join(", ")}`;
+  }
+  if (zi.code === "invalid_literal") {
+    return `${path} \u5E94\u4E3A ${expected}\uFF0C\u5B9E\u9645\u4E3A ${received}`;
+  }
+  if (zi.code === "invalid_string") {
+    return `${path} \u4E0D\u5339\u914D ${expected}`;
+  }
+  return `${path} ${zi.message}\uFF08\u671F\u671B ${expected}\uFF0C\u5B9E\u9645 ${received}\uFF09`;
+}
+
+// src/tool/schema-validator.ts
+function validateArgs(args, schema) {
+  if (isZodSchema(schema)) {
+    return zodSafeValidate(args, schema);
+  }
+  const issues = [];
+  if (!isPlainObject2(schema)) {
+    return { ok: true, issues };
+  }
+  if (schema.type !== void 0 && schema.type !== "object") {
+    return { ok: true, issues };
+  }
+  validateObject(args, schema, "$", issues);
+  return { ok: issues.length === 0, issues };
+}
+function isZodSchema(schema) {
+  if (schema === null || typeof schema !== "object") return false;
+  const obj = schema;
+  return "_def" in obj && typeof obj.parse === "function" && typeof obj.safeParse === "function";
+}
+function validateObject(value, schema, path, issues) {
+  if (!isPlainObject2(value)) {
+    issues.push({
+      path,
+      expected: "object",
+      received: describe(value),
+      message: `${path} \u5E94\u4E3A object\uFF0C\u5B9E\u9645\u4E3A ${describe(value)}`
+    });
+    return;
+  }
+  for (const key of schema.required ?? []) {
+    if (!(key in value)) {
+      issues.push({
+        path: `${path}.${key}`,
+        expected: "present",
+        received: "missing",
+        message: `${path}.${key} \u662F\u5FC5\u586B\u5B57\u6BB5`
+      });
+    }
+  }
+  const props = schema.properties ?? {};
+  const additional = schema.additionalProperties;
+  for (const [k, v] of Object.entries(value)) {
+    const propSchema = props[k];
+    if (propSchema === void 0) {
+      if (additional === false) {
+        issues.push({
+          path: `${path}.${k}`,
+          expected: "\u672A\u5728 schema \u4E2D\u5B9A\u4E49",
+          received: describe(v),
+          message: `${path}.${k} \u4E0D\u5728\u5141\u8BB8\u5B57\u6BB5\u4E2D`
+        });
+      }
+      continue;
+    }
+    validateProperty(v, propSchema, `${path}.${k}`, issues);
+  }
+}
+function validateProperty(value, schema, path, issues) {
+  if (schema.type !== void 0) {
+    const actual = jsonTypeOf(value);
+    if (!typeMatches(actual, schema.type)) {
+      issues.push({
+        path,
+        expected: schema.type,
+        received: describe(value),
+        message: `${path} \u5E94\u4E3A ${schema.type}\uFF0C\u5B9E\u9645\u4E3A ${actual}`
+      });
+      return;
+    }
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    if (!isScalar(value)) {
+      issues.push({
+        path,
+        expected: `enum[${schema.enum.map((e) => JSON.stringify(e)).join(",")}]`,
+        received: describe(value),
+        message: `${path} \u5E94\u4E3A enum \u503C\u4E4B\u4E00\uFF0C\u5B9E\u9645\u4E3A ${describe(value)}`
+      });
+    } else if (!schema.enum.includes(value)) {
+      issues.push({
+        path,
+        expected: `enum[${schema.enum.map((e) => JSON.stringify(e)).join(",")}]`,
+        received: describe(value),
+        message: `${path} \u5E94\u4E3A enum \u503C\u4E4B\u4E00\uFF0C\u5B9E\u9645\u4E3A ${JSON.stringify(value)}`
+      });
+    }
+  }
+  if (typeof value === "number") {
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      issues.push({
+        path,
+        expected: `>= ${schema.minimum}`,
+        received: String(value),
+        message: `${path} \u5E94 >= ${schema.minimum}\uFF0C\u5B9E\u9645\u4E3A ${value}`
+      });
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      issues.push({
+        path,
+        expected: `<= ${schema.maximum}`,
+        received: String(value),
+        message: `${path} \u5E94 <= ${schema.maximum}\uFF0C\u5B9E\u9645\u4E3A ${value}`
+      });
+    }
+  }
+  if (typeof value === "string") {
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      issues.push({
+        path,
+        expected: `length >= ${schema.minLength}`,
+        received: `length ${value.length}`,
+        message: `${path} \u957F\u5EA6\u5E94 >= ${schema.minLength}\uFF0C\u5B9E\u9645\u4E3A ${value.length}`
+      });
+    }
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+      issues.push({
+        path,
+        expected: `length <= ${schema.maxLength}`,
+        received: `length ${value.length}`,
+        message: `${path} \u957F\u5EA6\u5E94 <= ${schema.maxLength}\uFF0C\u5B9E\u9645\u4E3A ${value.length}`
+      });
+    }
+    if (schema.pattern !== void 0) {
+      try {
+        const re = new RegExp(schema.pattern);
+        if (!re.test(value)) {
+          issues.push({
+            path,
+            expected: `pattern ${schema.pattern}`,
+            received: describe(value),
+            message: `${path} \u4E0D\u5339\u914D pattern ${schema.pattern}`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  if (schema.properties !== void 0) {
+    validateObject(value, schema, path, issues);
+  }
+  if (schema.items !== void 0 && Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      validateProperty(value[i], schema.items, `${path}[${i}]`, issues);
+    }
+  }
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isScalar(v) {
+  return v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+}
+function jsonTypeOf(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  if (typeof v === "object") return "object";
+  if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
+  return typeof v;
+}
+function typeMatches(actual, expected) {
+  if (actual === expected) return true;
+  if (expected === "integer" && actual === "number") return true;
+  if (expected === "number" && actual === "integer") return true;
+  return false;
+}
+function describe(v) {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (typeof v === "string") {
+    const s = v.length > 60 ? v.slice(0, 57) + "..." : v;
+    return JSON.stringify(s);
+  }
+  if (typeof v === "number" || typeof v === "boolean") return JSON.stringify(v);
+  if (Array.isArray(v)) return `array(len=${v.length})`;
+  if (typeof v === "object") {
+    const keys = Object.keys(v);
+    return `object{keys=${keys.length}}`;
+  }
+  return typeof v;
+}
+
 // src/agent/tool-executor.ts
 var ToolExecutor = class {
   /** 工具注册表（只读引用） */
@@ -2996,11 +3532,38 @@ var ToolExecutor = class {
         record: { name: toolName, success: false, error: "TOOL_NOT_FOUND", timestamp }
       };
     }
-    let toolArgs;
-    try {
-      toolArgs = tc.arguments ? JSON.parse(tc.arguments) : {};
-    } catch {
-      toolArgs = {};
+    const parsed = parseToolCallArgs(tc.arguments ?? "");
+    if (!parsed.ok) {
+      if (parsed.reason === "PARTIAL") {
+        const errMsg2 = `\u5DE5\u5177 "${toolName}" \u53C2\u6570\u5C1A\u672A\u6536\u5168\uFF0C\u672C\u8F6E\u8DF3\u8FC7\uFF08\u6D41\u5F0F\u5206\u7247\u5BFC\u81F4\uFF09\uFF1A${parsed.hint}`;
+        return {
+          item: {
+            name: toolName,
+            callId: tc.id,
+            result: { success: false, data: errMsg2, error: "PARTIAL_JSON" }
+          },
+          record: { name: toolName, success: false, error: "PARTIAL_JSON", timestamp }
+        };
+      }
+      const errMsg = `\u5DE5\u5177 "${toolName}" \u53C2\u6570\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${parsed.error}
+\u539F\u6587: ${parsed.raw.slice(0, 200)}`;
+      return {
+        item: {
+          name: toolName,
+          callId: tc.id,
+          result: { success: false, data: errMsg, error: "INVALID_JSON" }
+        },
+        record: { name: toolName, success: false, error: "INVALID_JSON", timestamp }
+      };
+    }
+    const toolArgs = parsed.args;
+    let schemaIssues;
+    const schemaToCheck = tool.schema ?? tool.parameters;
+    if (schemaToCheck) {
+      const validation = validateArgs(toolArgs, schemaToCheck);
+      if (!validation.ok) {
+        schemaIssues = validation.issues;
+      }
     }
     const gateResult = await this.#gate.check(toolName, toolArgs);
     if (!gateResult) {
@@ -3020,10 +3583,29 @@ var ToolExecutor = class {
       }
     }
     try {
-      const result = await this.#invokeTool(tool, toolArgs);
+      let result = await this.#invokeTool(tool, toolArgs);
+      if (schemaIssues && schemaIssues.length > 0) {
+        const issuesText = schemaIssues.map((i) => `  - ${i.message}`).join("\n");
+        const tag = result.success ? "[schema \u8B66\u544A]" : "[schema \u95EE\u9898]";
+        result = {
+          ...result,
+          data: `${result.data}
+
+${tag} \u53C2\u6570\u4E0D\u7B26\u5408 schema\uFF1A
+${issuesText}`,
+          issues: schemaIssues
+        };
+      }
+      const record = {
+        name: toolName,
+        success: result.success,
+        error: result.error,
+        timestamp,
+        ...schemaIssues ? { issues: schemaIssues } : {}
+      };
       return {
         item: { name: toolName, callId: tc.id, result },
-        record: { name: toolName, success: result.success, error: result.error, timestamp }
+        record
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -3122,7 +3704,7 @@ var Reflector = class {
     const reflections = [];
     for (const item of items) {
       if (item.result.success) continue;
-      const r = this.#ruleRepeatedFailure(item) ?? this.#ruleFileNotFound(item) ?? this.#ruleTextNotFound(item) ?? this.#rulePermissionDenied(item) ?? this.#ruleOutOfWriteRoot(item, ctx.writeRoots);
+      const r = this.#ruleRepeatedFailure(item) ?? this.#ruleFileNotFound(item) ?? this.#ruleTextNotFound(item) ?? this.#rulePermissionDenied(item) ?? this.#ruleOutOfWriteRoot(item, ctx.writeRoots) ?? this.#ruleInvalidArgs(item);
       if (r) reflections.push(r);
       if (reflections.length >= this.#maxReflections) break;
     }
@@ -3264,6 +3846,25 @@ var Reflector = class {
     if (text.length <= this.#maxHintChars) return text;
     return text.slice(0, this.#maxHintChars - 3) + "...";
   }
+  /**
+   * R5 INVALID_ARGS：参数不符合工具的 JSON Schema。
+   *
+   * 阶段 2 新增：tool-executor 校验后会把 issues 放进 result.issues，
+   * 这里读取并生成反思。注意是 warn-only，不阻塞工具继续执行。
+   *
+   * @pure 仅读入参
+   */
+  #ruleInvalidArgs(item) {
+    const issues = item.result.issues;
+    if (!issues || issues.length === 0) return null;
+    const shown = issues.slice(0, 3).map((i) => i.message).join("; ");
+    const more = issues.length > 3 ? `\uFF08\u53E6\u6709 ${issues.length - 3} \u6761\uFF09` : "";
+    return {
+      category: "invalid_args",
+      toolName: item.name,
+      hint: `\`${item.name}\` \u53C2\u6570\u4E0D\u7B26\u5408 schema\uFF1A${shown}${more}\u3002\u8BF7\u68C0\u67E5\u5FC5\u586B\u5B57\u6BB5\u3001\u7C7B\u578B\u4E0E enum \u767D\u540D\u5355\u3002`
+    };
+  }
 };
 
 // src/agent/tool-definitions.ts
@@ -3779,7 +4380,12 @@ async function restoreToClean(cwd) {
 async function discardCheckpoint(checkpoint) {
   if (!checkpoint.isGitRepo || !checkpoint.stashSha) return;
   const { cwd, stashSha } = checkpoint;
-  const shas = await listStashShas(cwd);
+  let shas;
+  try {
+    shas = await listStashShas(cwd);
+  } catch {
+    return;
+  }
   const idx = shas.indexOf(stashSha);
   if (idx < 0) return;
   try {
@@ -3976,11 +4582,19 @@ var ConversationLogger = class _ConversationLogger {
     this.log({ ts: Date.now(), type: "reasoning", content, round });
   }
   /** 记录工具调用 */
-  logToolCall(name, callId, args, round) {
-    this.log({ ts: Date.now(), type: "tool_call", name, callId, arguments: args, round });
+  logToolCall(name, callId, args, round, parsedArgs) {
+    this.log({
+      ts: Date.now(),
+      type: "tool_call",
+      name,
+      callId,
+      arguments: args,
+      ...parsedArgs !== void 0 ? { parsedArgs } : {},
+      round
+    });
   }
   /** 记录工具结果 */
-  logToolResult(name, callId, success, data, error, elapsed, round) {
+  logToolResult(name, callId, success, data, error, elapsed, round, schemaIssues) {
     this.log({
       ts: Date.now(),
       type: "tool_result",
@@ -3990,6 +4604,7 @@ var ConversationLogger = class _ConversationLogger {
       data: truncate(data),
       ...error ? { error } : {},
       ...elapsed !== void 0 ? { elapsed } : {},
+      ...schemaIssues ? { schemaIssues } : {},
       round
     });
   }