zelari-code 2.12.0 → 2.13.0

package/dist/cli/main.bundled.js

@@ -18235,15 +18235,66 @@ var init_toolTypes = __esm({
   }
 });
 
+// packages/core/dist/core/tools/builtin/newlines.js
+function detectNewline(text) {
+  if (text.includes("\r\n"))
+    return "\r\n";
+  if (text.includes("\r"))
+    return "\r";
+  return "\n";
+}
+function toLF(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function fromLF(text, nl) {
+  if (nl === "\n")
+    return text;
+  return text.replace(/\n/g, nl);
+}
+function splitLinesLF(text) {
+  return toLF(text).split("\n");
+}
+var init_newlines = __esm({
+  "packages/core/dist/core/tools/builtin/newlines.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/tools/builtin/filesystem.js
 import { promises as fs4 } from "node:fs";
 import path6 from "node:path";
+function replaceFileString(text, oldString, newString, replaceAll) {
+  const exact = replaceOnceOrAll(text, oldString, newString, replaceAll);
+  if (exact.occurrences > 0)
+    return exact;
+  const nl = detectNewline(text);
+  const normalized = replaceOnceOrAll(toLF(text), toLF(oldString), toLF(newString), replaceAll);
+  if (normalized.occurrences === 0)
+    return normalized;
+  return { occurrences: normalized.occurrences, newContent: fromLF(normalized.newContent, nl) };
+}
+function replaceOnceOrAll(text, oldString, newString, replaceAll) {
+  if (replaceAll) {
+    if (!text.includes(oldString))
+      return { occurrences: 0, newContent: text };
+    const parts = text.split(oldString);
+    return { occurrences: parts.length - 1, newContent: parts.join(newString) };
+  }
+  const idx = text.indexOf(oldString);
+  if (idx === -1)
+    return { occurrences: 0, newContent: text };
+  return {
+    occurrences: 1,
+    newContent: text.slice(0, idx) + newString + text.slice(idx + oldString.length)
+  };
+}
 var ReadFileArgsSchema, readFileTool, WriteFileArgsSchema, writeFileTool, EditFileArgsSchema, editFileTool;
 var init_filesystem = __esm({
   "packages/core/dist/core/tools/builtin/filesystem.js"() {
     "use strict";
     init_zod();
     init_toolTypes();
+    init_newlines();
     ReadFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
       startLine: external_exports.number().int().nonnegative().optional().describe("0-based first line to include. Range is applied to the full file before maxBytes."),
@@ -18337,7 +18388,7 @@ var init_filesystem = __esm({
     });
     editFileTool = {
       name: "edit_file",
-      description: "Replace exact string match in a file. Idempotent: returns 0 occurrences if no match.",
+      description: "Replace a string in a file. Matching ignores CRLF vs LF; the file keeps its original line endings. Returns an error if oldString is not found.",
       permissions: ["write"],
       sideEffect: "local",
       timeoutMs: 1e4,
@@ -18347,22 +18398,7 @@ var init_filesystem = __esm({
           const absPath = path6.isAbsolute(args.path) ? args.path : path6.join(ctx.cwd, args.path);
           const content = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
           const text = typeof content === "string" ? content : content.toString("utf-8");
-          let occurrences = 0;
-          let newContent;
-          if (args.replaceAll) {
-            const parts = text.split(args.oldString);
-            occurrences = parts.length - 1;
-            newContent = parts.join(args.newString);
-          } else {
-            const idx = text.indexOf(args.oldString);
-            if (idx === -1) {
-              occurrences = 0;
-              newContent = text;
-            } else {
-              occurrences = 1;
-              newContent = text.slice(0, idx) + args.newString + text.slice(idx + args.oldString.length);
-            }
-          }
+          const { occurrences, newContent } = replaceFileString(text, args.oldString, args.newString, args.replaceAll);
           if (occurrences === 0) {
             return typedErr(`edit_file: no match for oldString in ${args.path}. Use read_file to copy the exact text (whitespace included) and retry.`);
           }
@@ -19114,7 +19150,7 @@ function formatUnified(hunks, oldLabel, newLabel) {
   return lines.join("\n");
 }
 function parseUnified(raw) {
-  const lines = raw.split("\n");
+  const lines = splitLinesLF(raw);
   if (lines.length < 2 || !lines[0].startsWith("--- ") || !lines[1].startsWith("+++ ")) {
     throw new Error("Invalid unified diff: missing --- / +++ headers");
   }
@@ -19170,6 +19206,72 @@ function parseUnified(raw) {
 function normalizeWhitespace(s) {
   return s.replace(/\s+/g, " ").trim();
 }
+function linesEqual(fileLine, opText, fuzzy) {
+  if (fileLine === opText)
+    return true;
+  if (fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(opText))
+    return true;
+  return false;
+}
+function hunkOldNeedle(hunk) {
+  return hunk.ops.filter((op) => op.kind !== "+").map((op) => op.text);
+}
+function matchAt(lines, at, needle, fuzzy) {
+  if (needle.length === 0)
+    return at >= 0 && at <= lines.length;
+  if (at < 0 || at + needle.length > lines.length)
+    return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (!linesEqual(lines[at + i] ?? "", needle[i], fuzzy))
+      return false;
+  }
+  return true;
+}
+function locateHunk(lines, hunk, fileIdx, fuzzy) {
+  const needle = hunkOldNeedle(hunk);
+  const preferred = hunk.oldStart - 1;
+  if (needle.length === 0) {
+    const start = Math.max(fileIdx, preferred >= 0 ? preferred : fileIdx);
+    return { start };
+  }
+  if (preferred >= fileIdx && matchAt(lines, preferred, needle, fuzzy)) {
+    return { start: preferred };
+  }
+  const hits = [];
+  for (let i = fileIdx; i <= lines.length - needle.length; i++) {
+    if (matchAt(lines, i, needle, fuzzy))
+      hits.push(i);
+  }
+  if (hits.length === 0) {
+    if (preferred >= fileIdx) {
+      let fileAt = preferred;
+      for (const op of hunk.ops) {
+        if (op.kind === "+")
+          continue;
+        const fileLine = lines[fileAt] ?? "";
+        if (!linesEqual(fileLine, op.text, fuzzy)) {
+          const label = op.kind === "-" ? "Delete mismatch" : "Context mismatch";
+          return {
+            error: `${label} at line ${fileAt + 1}: expected "${op.text.slice(0, 60)}", got "${fileLine.slice(0, 60)}"`
+          };
+        }
+        fileAt++;
+      }
+    }
+    return { error: `Hunk context not found (oldStart ${hunk.oldStart})` };
+  }
+  if (hits.length === 1)
+    return { start: hits[0] };
+  hits.sort((a, b) => Math.abs(a - preferred) - Math.abs(b - preferred) || a - b);
+  const bestDist = Math.abs(hits[0] - preferred);
+  const tied = hits.filter((h) => Math.abs(h - preferred) === bestDist);
+  if (tied.length > 1) {
+    return {
+      error: `Ambiguous hunk at oldStart ${hunk.oldStart}: ${tied.length} equally close matches (refusing to guess)`
+    };
+  }
+  return { start: hits[0] };
+}
 function applyAllHunks(originalLines, hunks, fuzzy) {
   const out = [];
   let fileIdx = 0;
@@ -19177,17 +19279,13 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
   let hunksSkipped = 0;
   let lastReason;
   for (const hunk of hunks) {
-    const startIdx = hunk.oldStart - 1;
-    if (startIdx < 0) {
+    const located = locateHunk(originalLines, hunk, fileIdx, fuzzy);
+    if ("error" in located) {
       hunksSkipped++;
-      lastReason = `oldStart ${hunk.oldStart} out of range (must be >= 1)`;
-      continue;
-    }
-    if (startIdx > originalLines.length) {
-      hunksSkipped++;
-      lastReason = `oldStart ${hunk.oldStart} beyond file end (length ${originalLines.length})`;
-      continue;
+      lastReason = located.error;
+      break;
     }
+    const startIdx = located.start;
     while (fileIdx < startIdx) {
       out.push(originalLines[fileIdx]);
       fileIdx++;
@@ -19200,7 +19298,7 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
       const op = hunk.ops[hunkIdx];
       if (op.kind === " ") {
         const fileLine = originalLines[hunkFileIdx] ?? "";
-        if (fileLine === op.text || fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(op.text)) {
+        if (linesEqual(fileLine, op.text, fuzzy)) {
           hunkOut.push(fileLine);
           hunkFileIdx++;
           hunkIdx++;
@@ -19211,7 +19309,7 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
         }
       } else if (op.kind === "-") {
         const fileLine = originalLines[hunkFileIdx] ?? "";
-        if (fileLine === op.text || fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(op.text)) {
+        if (linesEqual(fileLine, op.text, fuzzy)) {
           hunkFileIdx++;
           hunkIdx++;
         } else {
@@ -19244,6 +19342,7 @@ var init_diff = __esm({
     "use strict";
     init_zod();
     init_toolTypes();
+    init_newlines();
     LCS_MAX_CELLS = 4e6;
     ShowDiffArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
@@ -19268,8 +19367,8 @@ var init_diff = __esm({
               return typedErr(err instanceof Error ? err.message : String(err));
             }
           }
-          const a = current.split("\n");
-          const b = args.proposedContent.split("\n");
+          const a = splitLinesLF(current);
+          const b = splitLinesLF(args.proposedContent);
           const CONTEXT = args.contextLines;
           const rawOps = diffOps(a, b);
           if (rawOps === null) {
@@ -19355,7 +19454,7 @@ var init_diff = __esm({
     });
     applyDiffTool = {
       name: "apply_diff",
-      description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. With fuzzyMatch=true, tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
+      description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. CRLF vs LF is ignored; the file keeps its original line endings. Hunks whose @@ line numbers drifted (common after an earlier insert) are relocated by matching context. With fuzzyMatch=true, also tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
       permissions: ["write"],
       sideEffect: "local",
       timeoutMs: 15e3,
@@ -19380,9 +19479,10 @@ var init_diff = __esm({
           if (parsed.hunks.length === 0) {
             return typedErr("No hunks found in diff");
           }
-          const originalLines = current.split("\n");
+          const nl = detectNewline(current);
+          const originalLines = splitLinesLF(current);
           const result = applyAllHunks(originalLines, parsed.hunks, args.fuzzyMatch);
-          const finalContent = result.lines.join("\n");
+          const finalContent = fromLF(result.lines.join("\n"), nl);
           const ok = result.hunksSkipped === 0;
           if (ok && !args.dryRun) {
             await fs7.mkdir(path10.dirname(absPath), { recursive: true });
@@ -39312,7 +39412,7 @@ var init_taskTool = __esm({
     init_candidateRegistry();
     init_verifyReport();
     init_metrics2();
-    TASK_TOOL_TIMEOUT_MS = 9e5;
+    TASK_TOOL_TIMEOUT_MS = 27e5;
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
       "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
@@ -45291,10 +45391,10 @@ import { readFileSync as readFileSync22 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import path40 from "node:path";
 function emptyPolicySet() {
-  return { agents: /* @__PURE__ */ new Map(), warnings: [] };
+  return { agents: /* @__PURE__ */ new Map(), warnings: [], precedence: policyPrecedenceFromEnv() };
 }
-function agentRulesFor(set2, agent) {
-  return set2.agents.get(agent) ?? EMPTY_POLICY_RULE_SET;
+function agentLayersFor(set2, agent) {
+  return set2.agents.get(agent) ?? EMPTY_POLICY_LAYERS;
 }
 function globToRegExp(pattern) {
   let src = "^";
@@ -45357,6 +45457,10 @@ function isPolicyEngineDisabled() {
   const v = process.env.ZELARI_POLICY?.trim().toLowerCase();
   return v === "0" || v === "false" || v === "no" || v === "off";
 }
+function policyPrecedenceFromEnv() {
+  const v = process.env.ZELARI_POLICY_PRECEDENCE?.trim().toLowerCase();
+  return v === "legacy" ? "legacy" : "restrict-only";
+}
 function isPlainObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -45447,29 +45551,70 @@ function readPolicyFile(file2, warnings) {
 function loadPolicySet(root, opts = {}) {
   if (isPolicyEngineDisabled()) return emptyPolicySet();
   const warnings = [];
+  const precedence = policyPrecedenceFromEnv();
   const project = readPolicyFile(path40.join(root, ".zelari", "policy.json"), warnings);
   const global = readPolicyFile(path40.join(opts.homeDir ?? homedir10(), ".zelari", "policy.json"), warnings);
   const agents = /* @__PURE__ */ new Map();
-  for (const [agent, g] of global) {
-    agents.set(agent, { shell: [...g.shell], edit: [...g.edit] });
-  }
   for (const [agent, p3] of project) {
-    const g = agents.get(agent) ?? EMPTY_POLICY_RULE_SET;
-    agents.set(agent, { shell: [...p3.shell, ...g.shell], edit: [...p3.edit, ...g.edit] });
+    agents.set(agent, { project: p3, global: EMPTY_POLICY_RULE_SET });
   }
-  return { agents, warnings };
+  for (const [agent, g] of global) {
+    const l = agents.get(agent);
+    agents.set(agent, l ? { ...l, global: g } : { project: EMPTY_POLICY_RULE_SET, global: g });
+  }
+  return { agents, warnings, precedence };
 }
-var POLICY_AGENTS, KNOWN_AGENTS, EMPTY_POLICY_RULE_SET, EFFECT_RANK;
+var POLICY_AGENTS, KNOWN_AGENTS, EMPTY_POLICY_RULE_SET, EMPTY_POLICY_LAYERS, EFFECT_RANK;
 var init_policyEngine = __esm({
   "src/cli/safety/policyEngine.ts"() {
     "use strict";
     POLICY_AGENTS = ["lead", "explore", "general", "verify"];
     KNOWN_AGENTS = new Set(POLICY_AGENTS);
     EMPTY_POLICY_RULE_SET = { shell: [], edit: [] };
+    EMPTY_POLICY_LAYERS = {
+      global: EMPTY_POLICY_RULE_SET,
+      project: EMPTY_POLICY_RULE_SET
+    };
     EFFECT_RANK = { allow: 0, ask: 1, deny: 2 };
   }
 });
 
+// src/cli/safety/policyLayers.ts
+function intersectEffects(...effects) {
+  let best;
+  for (const effect of effects) {
+    if (effect === void 0) continue;
+    if (best === void 0 || EFFECT_RANK[effect] > EFFECT_RANK[best]) best = effect;
+  }
+  return best ?? "allow";
+}
+function matchAgentPolicyRuleLayered(layers, precedence, required2, args, root) {
+  if (!layers) return null;
+  if (precedence === "legacy") {
+    return matchAgentPolicyRule(
+      {
+        shell: [...layers.project.shell, ...layers.global.shell],
+        edit: [...layers.project.edit, ...layers.global.edit]
+      },
+      required2,
+      args,
+      root
+    );
+  }
+  const g = matchAgentPolicyRule(layers.global, required2, args, root);
+  const p3 = matchAgentPolicyRule(layers.project, required2, args, root);
+  if (!g) return p3;
+  if (!p3) return g;
+  const win = intersectEffects(p3.effect, g.effect);
+  return p3.effect === win ? p3 : g;
+}
+var init_policyLayers = __esm({
+  "src/cli/safety/policyLayers.ts"() {
+    "use strict";
+    init_policyEngine();
+  }
+});
+
 // src/cli/toolResultCache.ts
 import { createHash as createHash13 } from "node:crypto";
 import { promises as fs19 } from "node:fs";
@@ -45810,11 +45955,19 @@ function createBuiltinToolRegistry(options = {}) {
   const allowMutators = !readOnly && !verifyMode && !gauntletParent;
   const allowBash = (allowMutators || verifyMode) && !gauntletParent;
   const permPolicy = options.permissionPolicy ?? defaultPermissionPolicy();
-  const agentPolicyRules = agentRulesFor(
-    loadPolicySet(root),
+  const agentPolicySet = loadPolicySet(root);
+  const agentPolicyLayers = agentLayersFor(
+    agentPolicySet,
     options.policyAgent ?? "lead"
   );
-  const withPerm = (t) => wrapWithPermissions(t, permPolicy, options.onPermissionAsk, agentPolicyRules, root);
+  const withPerm = (t) => wrapWithPermissions(
+    t,
+    permPolicy,
+    options.onPermissionAsk,
+    agentPolicyLayers,
+    agentPolicySet.precedence,
+    root
+  );
   registry4.register(withPerm(safeReadFile));
   registry4.register(withPerm(safeGrepContent));
   registry4.register(withPerm(safeListFiles));
@@ -46081,7 +46234,7 @@ function createKrakenSubAgentContextFactory(opts) {
     };
   };
 }
-function wrapWithPermissions(original, policy, onAsk, agentRules, root) {
+function wrapWithPermissions(original, policy, onAsk, agentLayers, precedence = "restrict-only", root) {
   const required2 = original.permissions ?? [];
   const decisionProbe = resolveToolPermission(original.name, required2, policy);
   if (decisionProbe.action === "allow" && !required2.includes("write") && !required2.includes("execute")) {
@@ -46090,8 +46243,9 @@ function wrapWithPermissions(original, policy, onAsk, agentRules, root) {
     ...original,
     execute: async (input, ctx) => {
       const decision = resolveToolPermission(original.name, required2, policy);
-      const rule = agentRules ? matchAgentPolicyRule(
-        agentRules,
+      const rule = agentLayers ? matchAgentPolicyRuleLayered(
+        agentLayers,
+        precedence,
         required2,
         input ?? {},
         root ?? process.cwd()
@@ -46321,6 +46475,7 @@ var init_toolRegistry = __esm({
     init_toolPermissions();
     init_lifecycleHooks();
     init_policyEngine();
+    init_policyLayers();
     init_toolResultCache();
     init_toolTypes();
     init_skills2();
@@ -69165,7 +69320,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   scope_template: external_exports.array(external_exports.string()).optional(),
   /** Default: ZELARI_KRAKEN_MAX_PARALLEL. */
   max_concurrency: external_exports.number().int().positive().optional(),
-  /** Per-row timeout (ms). Default: 5 min for verify, 15 min for general. */
+  /** Per-row timeout (ms). Default: 5 min for verify, 45 min for general. */
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
@@ -69256,7 +69411,7 @@ async function runCsvFanout(args, deps, opts) {
   }
   const concurrency = args.max_concurrency ?? resolveMaxConcurrency();
   opts.onLog?.(`csv fanout: ${rows.length} rows \xD7 ${args.agent_kind} @ concurrency=${concurrency}`);
-  const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? 9e5 : 3e5;
+  const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? TASK_TOOL_TIMEOUT_MS : 3e5;
   const outputRecords = rows.map((r) => ({ ...r, status: "pending", result: "", error: "" }));
   const outHeaders = [...headers2, "status", "result", "error"];
   let writeChain2 = Promise.resolve();