@garuda-agent/garuda 0.16.1 → 0.18.0

package/dist/{chunk-ZAE25JM2.js → chunk-QANRZW7W.js}

@@ -57,6 +57,12 @@ async function loadMcpConfig({ home, root } = { home: homedir(), root: process.c
       problems.push(`${file}: invalid JSON: ${error.message}`);
       return [];
     }
+    if (Array.isArray(json?.servers)) {
+      problems.push(
+        `${file}: "servers" must be an object of name \u2192 server, not a list: { "servers": { "graphify": { "command": "\u2026" }, "linear": { "url": "\u2026" } } }`
+      );
+      return [];
+    }
     const parsed = fileSchema.safeParse(json);
     if (!parsed.success) {
       problems.push(`${file}: ${z.prettifyError(parsed.error)}`);
@@ -147,6 +153,7 @@ function commandLine(def) {
 }
 
 export {
+  MCP_FILE,
   SERVER_NAME,
   isHttp,
   loadMcpConfig,
@@ -155,4 +162,4 @@ export {
   expandEnv,
   commandLine
 };
-//# sourceMappingURL=chunk-ZAE25JM2.js.map
+//# sourceMappingURL=chunk-QANRZW7W.js.map

package/dist/chunk-UIRJOQQS.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import {
+  realpathOfNearestExisting
+} from "./chunk-4LFJFDCF.js";
+
+// src/permissions/writeScope.ts
+import { existsSync, lstatSync, mkdirSync, realpathSync } from "fs";
+import { realpath } from "fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+function scopeEntryProblem(entry) {
+  if (entry === "" || entry === "/" || entry === "." || entry === "./") {
+    return `"${entry}" is the whole worktree, not a scope`;
+  }
+  if (entry.startsWith("/") || /^[A-Za-z]:/.test(entry)) return `"${entry}" is not relative`;
+  const control = [...entry].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
+  if (entry.includes("\\") || control) {
+    return `"${entry}" has a backslash or a control character`;
+  }
+  const parts = entry.replace(/\/$/, "").split("/");
+  if (parts.some((p) => p === "" || p === "." || p === "..")) {
+    return `"${entry}" has an empty, "." or ".." part`;
+  }
+  if (parts[0] === ".git" || parts[0] === ".garuda") return `"${entry}" is a protected folder`;
+  return void 0;
+}
+function inWriteScope(path, scope) {
+  const clean = path.replace(/^\.\//, "").replace(/\/+$/, "");
+  return scope.some(
+    (entry) => entry.endsWith("/") ? clean === entry.slice(0, -1) || clean.startsWith(entry) : clean === entry
+  );
+}
+function scopePaths(root, scope) {
+  return scope.map((entry) => join(root, ...entry.replace(/\/$/, "").split("/")));
+}
+function prepareWriteScope(root, scope) {
+  for (const entry of scope) {
+    const problem = scopeEntryProblem(entry);
+    if (problem !== void 0) return problem;
+  }
+  const realRoot = realpathSync(root);
+  for (const [i, path] of scopePaths(root, scope).entries()) {
+    const entry = scope[i];
+    let current = root;
+    for (const part of entry.replace(/\/$/, "").split("/")) {
+      current = join(current, part);
+      if (existsSync(current) && lstatSync(current).isSymbolicLink()) {
+        return `"${entry}" goes through a symbolic link (${current})`;
+      }
+    }
+    if (!existsSync(path) && entry.endsWith("/")) mkdirSync(path, { recursive: true });
+    if (existsSync(path)) {
+      const real = realpathSync(path);
+      if (real !== realRoot && !real.startsWith(`${realRoot}${sep}`)) {
+        return `"${entry}" is outside the worktree`;
+      }
+    }
+  }
+  return void 0;
+}
+var BUILD_OUTPUTS = [
+  { marker: "pom.xml", folders: ["target/"] },
+  { marker: "build.gradle", folders: ["build/", ".gradle/"] },
+  { marker: "build.gradle.kts", folders: ["build/", ".gradle/"] },
+  { marker: "package.json", folders: ["dist/", "coverage/"] },
+  { marker: "pyproject.toml", folders: ["build/", "dist/", ".pytest_cache/"] },
+  { marker: "setup.py", folders: ["build/", "dist/", ".pytest_cache/"] },
+  { marker: "Cargo.toml", folders: ["target/"] },
+  { marker: "go.mod", folders: [] }
+];
+function proposeWriteScope(rules, root) {
+  const entries = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    const m = /^(edit_file|write_file)\((.*)\)$/.exec(rule.trim());
+    if (m === null) continue;
+    const pattern = m[2].replace(/^\.\//, "");
+    const glob = pattern.search(/[*?[{]/);
+    const entry = glob === -1 ? pattern : pattern.slice(0, pattern.lastIndexOf("/", glob) + 1);
+    if (entry === "" || scopeEntryProblem(entry) !== void 0) {
+      return { scope: void 0, reason: `the rule ${rule} names no folder` };
+    }
+    entries.add(entry);
+  }
+  for (const { marker, folders } of BUILD_OUTPUTS) {
+    if (existsSync(join(root, marker))) for (const f of folders) entries.add(f);
+  }
+  return { scope: [...entries].sort() };
+}
+async function scopeDenial(root, path, scope) {
+  const absolute = isAbsolute(path) ? path : resolve(root, path);
+  const named = relative(root, absolute).split(sep).join("/");
+  const outside = (shown) => `${shown} is outside this job's write scope (${scope.join(", ")})`;
+  if (named.startsWith("..") || !inWriteScope(named, scope)) return outside(named);
+  let realRoot;
+  let real;
+  try {
+    realRoot = await realpath(root);
+    real = await realpathOfNearestExisting(absolute);
+  } catch {
+    return `${named}: its real place cannot be checked`;
+  }
+  const reached = relative(realRoot, real).split(sep).join("/");
+  if (reached === "" || reached.startsWith("..") || isAbsolute(reached)) {
+    return `${named} leads outside the worktree`;
+  }
+  if (!inWriteScope(reached, scope))
+    return `${named} leads to ${reached}, which ${outside(reached).slice(reached.length + 1)}`;
+  return void 0;
+}
+
+export {
+  scopeEntryProblem,
+  inWriteScope,
+  scopePaths,
+  prepareWriteScope,
+  proposeWriteScope,
+  scopeDenial
+};
+//# sourceMappingURL=chunk-UIRJOQQS.js.map

package/dist/chunk-UKIE4AAM.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import {
+  Redactor,
+  contextSize,
+  totalTokens
+} from "./chunk-7KBOIPUT.js";
+import {
+  cleanLine
+} from "./chunk-PZS3V6P3.js";
+import {
+  ZERO_USAGE,
+  addUsage,
+  reportedUsage
+} from "./chunk-BHZ6G65V.js";
+import {
+  formatRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/session/store.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, mkdirSync } from "fs";
+import { readdir, readFile, rm, stat, utimes } from "fs/promises";
+import { basename, join } from "path";
+var SESSIONS_DIR = join(".garuda", "sessions");
+var FileSessionStore = class {
+  dir;
+  redactor;
+  constructor(root, redactor = new Redactor()) {
+    this.dir = join(root, SESSIONS_DIR);
+    this.redactor = redactor;
+  }
+  path(sessionId) {
+    if (!SESSION_ID.test(sessionId)) throw new Error(`"${sessionId}" is not a session id.`);
+    return join(this.dir, `${sessionId}.jsonl`);
+  }
+  open(sessionId) {
+    return this.journal(this.dir, this.path(sessionId));
+  }
+  /** `.garuda/sessions/<session id>/<child id>.jsonl`. */
+  childPath(sessionId, childId) {
+    return join(this.dir, safeId(sessionId), `${safeId(childId)}.jsonl`);
+  }
+  openChild(sessionId, childId) {
+    return this.journal(join(this.dir, safeId(sessionId)), this.childPath(sessionId, childId));
+  }
+  journal(dir, file) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    return {
+      write: (record) => {
+        const line = { t: (/* @__PURE__ */ new Date()).toISOString(), ...record };
+        appendFileSync(file, `${JSON.stringify(this.redactor.value(line))}
+`, { mode: 384 });
+      }
+    };
+  }
+  async read(sessionId) {
+    return parseRecords(await readFile(this.path(sessionId), "utf8"));
+  }
+  async setTitle(sessionId, title) {
+    const file = this.path(sessionId);
+    const before = await stat(file);
+    this.open(sessionId).write({ type: "title", title });
+    await utimes(file, before.atime, before.mtime);
+  }
+  async remove(sessionId) {
+    await rm(this.path(sessionId));
+    await rm(join(this.dir, safeId(sessionId)), { recursive: true, force: true });
+  }
+  async latest() {
+    return (await this.list())[0]?.id;
+  }
+  async list() {
+    let names;
+    try {
+      names = (await readdir(this.dir)).filter((name) => name.endsWith(".jsonl"));
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      const info = await stat(join(this.dir, name)).catch(() => void 0);
+      if (info?.isFile()) out.push({ id: basename(name, ".jsonl"), updated: info.mtime });
+    }
+    return out.sort((a, b) => b.updated.getTime() - a.updated.getTime());
+  }
+};
+var SESSION_ID = /^[A-Za-z0-9_-]{1,80}$/;
+function safeId(id) {
+  return id.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80) || "_";
+}
+function parseRecords(text) {
+  const lines = text.split("\n").filter((line) => line.trim() !== "");
+  const records = [];
+  lines.forEach((line, i) => {
+    try {
+      records.push(JSON.parse(line));
+    } catch (error) {
+      if (i < lines.length - 1) throw new Error(`Session file line ${i + 1} is not valid JSON.`);
+      void error;
+    }
+  });
+  return records;
+}
+function newSessionId(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  return `${date}-${time}-${randomBytes(2).toString("hex")}`;
+}
+
+// src/session/fileTracker.ts
+import { createHash } from "crypto";
+var FileTracker = class {
+  seen = /* @__PURE__ */ new Map();
+  /** "path|offset|limit" → hash of the whole file at that read. */
+  reads = /* @__PURE__ */ new Map();
+  /** Record the content the agent now knows for `path` (absolute). */
+  record(path, content) {
+    this.seen.set(path, hash(content));
+  }
+  /** "unread", "changed" or "current". */
+  status(path, content) {
+    const known = this.seen.get(path);
+    if (known === void 0) return "unread";
+    return known === hash(content) ? "current" : "changed";
+  }
+  /**
+   * Record a read of some lines. Returns true when the agent already read the same lines
+   * of the same content, so the output is still in its context.
+   */
+  noteRead(path, content, offset, limit) {
+    const key = `${path}|${offset}|${limit}`;
+    const digest = hash(content);
+    const repeat = this.reads.get(key) === digest;
+    this.reads.set(key, digest);
+    return repeat;
+  }
+  /**
+   * Compaction cuts or summarises old tool outputs, so earlier reads may no longer be in the context.
+   * The edit freshness records stay: they are about the file, not the context.
+   */
+  forgetReads() {
+    this.reads.clear();
+  }
+};
+function hash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/session/undo.ts
+var MAX_UNDO_POINTS = 50;
+var PROMPT_CHARS = 80;
+function emptyUndoState() {
+  return { points: [], redo: [] };
+}
+function pushPoint(state, tree, messages, prompt) {
+  const line = prompt.replace(/\s+/g, " ").trim();
+  state.points.push({
+    tree,
+    messages,
+    conversation: true,
+    prompt: line.length > PROMPT_CHARS ? `${line.slice(0, PROMPT_CHARS)}\u2026` : line
+  });
+  if (state.points.length > MAX_UNDO_POINTS) state.points.shift();
+  state.redo = [];
+}
+function popPoint(state, messages, after) {
+  const point = state.points.pop();
+  if (point === void 0) return void 0;
+  const removed = point.conversation ? messages.splice(point.messages) : [];
+  state.redo.push({ point, after, removed });
+  return point;
+}
+function redoPoint(state, messages) {
+  const entry = state.redo.pop();
+  if (entry === void 0) return void 0;
+  messages.push(...entry.removed);
+  state.points.push(entry.point);
+  return entry;
+}
+function compacted(state) {
+  for (const point of state.points) point.conversation = false;
+  for (const entry of state.redo) {
+    entry.point.conversation = false;
+    entry.removed = [];
+  }
+}
+function newUserMessage(state) {
+  state.redo = [];
+}
+
+// src/session/session.ts
+function createSession(root, id = newSessionId(), journal) {
+  const session = {
+    id,
+    root,
+    messages: [],
+    usage: { ...ZERO_USAGE },
+    costUsd: 0,
+    costIncomplete: false,
+    contextTokens: 0,
+    unreportedTokens: 0,
+    childDebits: /* @__PURE__ */ new Map(),
+    files: new FileTracker(),
+    undo: emptyUndoState()
+  };
+  if (journal !== void 0) session.journal = journal;
+  return session;
+}
+function addUserMessage(session, text, notes = [], attachments = []) {
+  const message = {
+    role: "user",
+    content: [
+      { type: "text", text },
+      ...attachments.map((a) => ({ type: "text", text: a })),
+      ...notes.map((note) => ({
+        type: "text",
+        text: `<garuda_note>${note}</garuda_note>`
+      }))
+    ]
+  };
+  session.messages.push(message);
+  newUserMessage(session.undo);
+  session.journal?.write({ type: "user", message });
+}
+function addSnapshot(session, tree, prompt, durationMs) {
+  const messages = session.messages.length;
+  pushPoint(session.undo, tree, messages, prompt);
+  const point = session.undo.points.at(-1);
+  session.journal?.write({ type: "snapshot", tree, messages, prompt: point.prompt, durationMs });
+}
+function undoTurn(session, after) {
+  const point = popPoint(session.undo, session.messages, after);
+  if (point !== void 0) {
+    session.journal?.write({ type: "undo", after });
+    session.files.forgetReads();
+  }
+  return point;
+}
+function redoTurn(session) {
+  const entry = redoPoint(session.undo, session.messages);
+  if (entry !== void 0) {
+    session.journal?.write({ type: "redo" });
+    session.files.forgetReads();
+  }
+  return entry;
+}
+function addAssistantResponse(session, response, step, costUsd) {
+  if (response.usageReported === false) {
+    session.costIncomplete = true;
+    costUsd = void 0;
+    addCost(session, reportedUsage(response), session.costUsd === void 0 ? void 0 : 0);
+  } else addCost(session, reportedUsage(response), costUsd);
+  session.contextTokens = contextSize(response.usage);
+  if (response.content.length > 0) {
+    session.messages.push({ role: "assistant", content: response.content });
+  }
+  session.journal?.write({
+    type: "assistant",
+    step,
+    response,
+    ...costUsd === void 0 ? {} : { costUsd }
+  });
+}
+function addToolResults(session, results, calls, synthetic = false) {
+  const message = { role: "user", content: results };
+  session.messages.push(message);
+  session.journal?.write({
+    type: "tool_results",
+    message,
+    calls,
+    ...synthetic ? { synthetic } : {}
+  });
+}
+function addContinuation(session, text, maxTokens) {
+  const message = { role: "user", content: [{ type: "text", text }] };
+  session.messages.push(message);
+  session.journal?.write({ type: "continue", message, maxTokens });
+}
+function addCost(session, usage, costUsd) {
+  session.usage = addUsage(session.usage, usage);
+  session.costUsd = session.costUsd === void 0 || costUsd === void 0 ? void 0 : session.costUsd + costUsd;
+}
+function closeOpenToolCalls(session) {
+  const last = session.messages.at(-1);
+  if (last?.role !== "assistant") return 0;
+  const open = last.content.filter((b) => b.type === "tool_use");
+  if (open.length === 0) return 0;
+  session.files.forgetReads();
+  addToolResults(
+    session,
+    open.map((call) => ({
+      type: "tool_result",
+      toolUseId: call.id,
+      content: "Error: this call was interrupted. It may or may not have run. Check before you retry.",
+      isError: true
+    })),
+    open.map((call) => ({ toolUseId: call.id, name: call.name, durationMs: 0 })),
+    true
+  );
+  return open.length;
+}
+function addUnreported(session, tokens) {
+  if (tokens <= 0) return;
+  session.unreportedTokens += tokens;
+  session.costIncomplete = true;
+  session.journal?.write({ type: "unreported", tokens });
+}
+function budgetSpent(session) {
+  return totalTokens(session.usage) + session.unreportedTokens + pendingChildTokens(session);
+}
+function pendingChildTokens(session) {
+  let tokens = 0;
+  for (const value of session.childDebits.values()) tokens += value;
+  return tokens;
+}
+function isCostIncomplete(session) {
+  return session.costIncomplete || pendingChildTokens(session) > 0;
+}
+function addChildDebit(session, childSessionId, tokens) {
+  if (tokens <= 0) return;
+  session.childDebits.set(childSessionId, (session.childDebits.get(childSessionId) ?? 0) + tokens);
+  session.journal?.write({ type: "child_debit", childSessionId, tokens });
+}
+function addChildReport(session, report) {
+  addCost(session, report.usage, report.costUsd);
+  if (report.costIncomplete === true) session.costIncomplete = true;
+  settleChildDebits(session.childDebits, report);
+}
+function settleChildDebits(debits, report) {
+  const rest = Math.max(0, (debits.get(report.sessionId) ?? 0) - totalTokens(report.usage));
+  if (rest === 0) debits.delete(report.sessionId);
+  else debits.set(report.sessionId, rest);
+}
+function addSideUsage(session, purpose, response, costUsd) {
+  if (response.usageReported === false) return;
+  addCost(session, response.usage, costUsd);
+  session.journal?.write({
+    type: "side_usage",
+    purpose,
+    usage: response.usage,
+    ...costUsd === void 0 ? {} : { costUsd }
+  });
+}
+
+// src/permissions/projectSettings.ts
+import { createHash as createHash2 } from "crypto";
+function settingsRisk(settings) {
+  const risk = {
+    executorHost: settings.executor === "host",
+    allow: settings.allow.map(formatRule),
+    writePaths: [...settings.sandbox?.writePaths ?? []],
+    envAllow: [...settings.envAllow],
+    allowLocalhost: settings.web?.allowLocalhost === true
+  };
+  const formatterCommands = Object.entries(settings.formatters?.commands ?? {}).flatMap(
+    ([name, f]) => f === false ? [] : [`${name}: ${f.command.join(" ")}`]
+  );
+  if (formatterCommands.length > 0) risk.formatterCommands = formatterCommands;
+  const none = !risk.executorHost && risk.allow.length === 0 && risk.writePaths.length === 0 && risk.envAllow.length === 0 && !risk.allowLocalhost && risk.formatterCommands === void 0;
+  return none ? void 0 : risk;
+}
+function settingsRiskHash(risk) {
+  return createHash2("sha256").update(JSON.stringify(risk)).digest("hex");
+}
+function settingsRiskLines(risk) {
+  const lines = [];
+  if (risk.executorHost) lines.push('executor: "host" (commands run with no OS sandbox)');
+  if (risk.allow.length > 0) {
+    lines.push(`permissions.allow (no question for these): ${risk.allow.join(", ")}`);
+  }
+  if (risk.writePaths.length > 0) {
+    lines.push(`sandbox.writePaths (commands may write there): ${risk.writePaths.join(", ")}`);
+  }
+  if (risk.envAllow.length > 0) {
+    lines.push(`env.allow (commands see these variables): ${risk.envAllow.join(", ")}`);
+  }
+  if (risk.allowLocalhost) lines.push("web.allowLocalhost (web_fetch may reach this machine)");
+  if (risk.formatterCommands !== void 0) {
+    lines.push(
+      `formatters.commands (run after each edit): ${risk.formatterCommands.map(cleanLine).join("; ")}`
+    );
+  }
+  return lines;
+}
+function withoutRisk(settings) {
+  const { sandbox, web, formatters, ...rest } = settings;
+  const { writePaths: _writePaths, ...sandboxRest } = sandbox ?? {};
+  const keptCommands = Object.fromEntries(
+    Object.entries(formatters?.commands ?? {}).filter(([, f]) => f === false)
+  );
+  return {
+    ...rest,
+    ...formatters === void 0 ? {} : { formatters: { ...formatters, commands: keptCommands } },
+    executor: settings.executor === "host" ? "auto" : settings.executor,
+    allow: [],
+    envAllow: [],
+    ...sandbox === void 0 ? {} : { sandbox: sandboxRest },
+    ...web === void 0 ? {} : { web: { ...web, allowLocalhost: false } }
+  };
+}
+async function gateProjectSettings(options) {
+  const risk = settingsRisk(options.settings);
+  if (risk === void 0) return { settings: options.settings };
+  const hash2 = settingsRiskHash(risk);
+  const known = options.trust?.settingsHash(options.root);
+  if (known === hash2) return { settings: options.settings };
+  const lines = settingsRiskLines(risk);
+  if (options.ask !== void 0) {
+    const choice = await options.ask({
+      tool: "settings",
+      target: { kind: "input", json: "" },
+      title: "Project settings that loosen safety",
+      preview: [
+        `This project's .garuda/settings.json ${known === void 0 ? "asks for" : "changed and now asks for"}:`,
+        ...lines.map((line) => `  - ${line}`),
+        "A cloned repository can ship this file. Without your yes, Garuda uses safe defaults for these",
+        "parts; the rest of the file applies."
+      ].join("\n"),
+      isolation: options.isolation ?? "os",
+      question: "Use these project settings?",
+      choices: ["once", "session", "deny"],
+      labels: {
+        once: "Yes, for this run",
+        session: "Yes, and remember (asks again when they change)",
+        deny: "No, use safe defaults"
+      }
+    });
+    if (choice === "session") await options.trust?.setSettingsHash(options.root, hash2);
+    if (choice !== "deny") return { settings: options.settings };
+  }
+  return {
+    settings: withoutRisk(options.settings),
+    notice: [
+      `Project settings not applied (not approved): ${lines.join("; ")}.`,
+      "Start the chat in a terminal and answer yes to use them."
+    ].join(" ")
+  };
+}
+
+export {
+  FileTracker,
+  FileSessionStore,
+  parseRecords,
+  newSessionId,
+  emptyUndoState,
+  pushPoint,
+  popPoint,
+  redoPoint,
+  compacted,
+  newUserMessage,
+  createSession,
+  addUserMessage,
+  addSnapshot,
+  undoTurn,
+  redoTurn,
+  addAssistantResponse,
+  addToolResults,
+  addContinuation,
+  addCost,
+  closeOpenToolCalls,
+  addUnreported,
+  budgetSpent,
+  pendingChildTokens,
+  isCostIncomplete,
+  addChildDebit,
+  addChildReport,
+  settleChildDebits,
+  addSideUsage,
+  gateProjectSettings
+};
+//# sourceMappingURL=chunk-UKIE4AAM.js.map

package/dist/{chunk-KKB5W47S.js → chunk-VTMD5IHD.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  scopeEntryProblem
+} from "./chunk-UIRJOQQS.js";
 import {
   parseRule
 } from "./chunk-3NJNVZTK.js";
@@ -29,6 +32,8 @@ var resultSchema = z.object({
   steps: z.number(),
   tokens: z.number(),
   costUsd: z.number().optional(),
+  /** The cost leaves out some spending: `costUsd` is a minimum (review of 1370184). */
+  costIncomplete: z.boolean().optional(),
   durationMs: z.number(),
   sessionId: z.string().optional(),
   commit: z.string().optional(),
@@ -55,7 +60,12 @@ var resultSchema = z.object({
       text: z.string(),
       costUsd: z.number().optional()
     }).optional(),
-    reviewError: z.string().optional()
+    reviewError: z.string().optional(),
+    /**
+     * The review spent tokens with no reported usage (a failed attempt, an estimate): its cost is
+     * a minimum or unrecorded (review of 3a9f51b).
+     */
+    reviewCostIncomplete: z.boolean().optional()
   }).optional()
 });
 var jobSchema = z.object({
@@ -76,6 +86,16 @@ var jobSchema = z.object({
   model: z.string().optional(),
   /** Permission rules for this job only, in the settings format ("edit_file(src/**)"). */
   allow: z.array(z.string()),
+  /**
+   * The write scope (0.17, review T6): the paths in the worktree that the job's commands and edits
+   * may change ("src/" is a folder, "README.md" one file). The OS sandbox enforces it for commands.
+   * Absent (a job made before 0.17, or a plan whose rules name no folder): the whole worktree.
+   */
+  writeScope: z.array(
+    z.string().refine((entry) => scopeEntryProblem(entry) === void 0, {
+      message: 'a scope entry is a path in the worktree, such as "src/" or "README.md"'
+    })
+  ).optional(),
   onUnapproved: z.literal("deny-and-continue"),
   /** "01:00" (local time) for `garuda run --at`, when the user gave one. */
   at: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional(),
@@ -114,6 +134,9 @@ var jobSchema = z.object({
   endedAt: z.string().optional(),
   result: resultSchema.optional()
 });
+function parseJob(json) {
+  return jobSchema.parse(json);
+}
 function newJobId(now = /* @__PURE__ */ new Date()) {
   const pad = (n) => String(n).padStart(2, "0");
   const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
@@ -218,6 +241,7 @@ export {
   JOBS_DIR,
   DEFAULT_JOB_MAX_STEPS,
   JOB_STATUSES,
+  parseJob,
   newJobId,
   jobPath,
   failJobSync,
@@ -228,4 +252,4 @@ export {
   planPermissions,
   planTitle
 };
-//# sourceMappingURL=chunk-KKB5W47S.js.map
+//# sourceMappingURL=chunk-VTMD5IHD.js.map