@spotpatch/agent 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/engine/execute-agent-change.ts
 import {
-  ERROR_CODES as ERROR_CODES18,
-  SpotPatchError as SpotPatchError18
+  ERROR_CODES as ERROR_CODES19,
+  SpotPatchError as SpotPatchError19
 } from "@spotpatch/shared";
 
 // src/provider/openai-compatible-provider.ts
@@ -29,9 +29,27 @@ function parseJsonRecord(value) {
 }
 function parseToolArguments(value) {
   if (typeof value !== "string") {
-    throw new SpotPatchError(ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED);
+    throw new SpotPatchError(ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new SpotPatchError(ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  if (!isRecord(parsed)) {
+    throw new SpotPatchError(ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  return parsed;
+}
+function assertUniqueToolCallIds(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (ids.has(call.id)) {
+      throw new SpotPatchError(ERROR_CODES.TOOL_CALL_ID_CONFLICT);
+    }
+    ids.add(call.id);
   }
-  return parseJsonRecord(value);
 }
 function requireString(record, field) {
   const value = record[field];
@@ -41,6 +59,7 @@ function requireString(record, field) {
   return value;
 }
 function validateToolResults(pendingCalls, results) {
+  assertUniqueToolCallIds(pendingCalls);
   if (pendingCalls.length === 0) {
     if (results !== void 0 && results.length > 0) {
       throw new SpotPatchError(ERROR_CODES.INTERNAL_ERROR);
@@ -441,6 +460,7 @@ function parseChatEvents(events) {
   }
   const finalText = content.join("");
   const toolCalls = finalizeToolCalls(calls);
+  assertUniqueToolCallIds(toolCalls);
   if (toolCalls.length === 0 && finalText.trim().length === 0) {
     throw new SpotPatchError5(ERROR_CODES5.PROVIDER_PROTOCOL_UNSUPPORTED);
   }
@@ -537,7 +557,7 @@ function collectFunctionCall(item, calls) {
   });
   const existing = calls.get(id);
   if (existing !== void 0 && (existing.name !== call.name || JSON.stringify(existing.arguments) !== JSON.stringify(call.arguments))) {
-    throw new SpotPatchError6(ERROR_CODES6.PROVIDER_PROTOCOL_UNSUPPORTED);
+    throw new SpotPatchError6(ERROR_CODES6.TOOL_CALL_ID_CONFLICT);
   }
   calls.set(id, call);
 }
@@ -716,7 +736,7 @@ var PROTECTED_FILE_NAMES = /* @__PURE__ */ new Set([
   "yarn.lock"
 ]);
 function deny() {
-  throw new SpotPatchError8(ERROR_CODES8.TOOL_DENIED);
+  throw new SpotPatchError8(ERROR_CODES8.TOOL_PATH_DENIED);
 }
 function hasControlCharacter(value) {
   for (let index = 0; index < value.length; index += 1) {
@@ -821,13 +841,13 @@ async function readAgentTextFile(root, relativePath, maximumBytes) {
   }
   const bytes = await readFile(absolutePath);
   if (bytes.includes(0)) {
-    throw new SpotPatchError9(ERROR_CODES9.TOOL_DENIED);
+    throw new SpotPatchError9(ERROR_CODES9.TOOL_PATH_DENIED);
   }
   let content;
   try {
     content = utf8Decoder.decode(bytes);
   } catch {
-    throw new SpotPatchError9(ERROR_CODES9.TOOL_DENIED);
+    throw new SpotPatchError9(ERROR_CODES9.TOOL_PATH_DENIED);
   }
   return Object.freeze({ content, relativePath, size: metadata.size });
 }
@@ -840,7 +860,7 @@ function encodeUtf8Text(content, includeByteOrderMark) {
 }
 async function writeAgentTextFileIfContentMatches(root, relativePath, expectedContent, nextContent, maximumBytes) {
   if (nextContent.includes("\0")) {
-    throw new SpotPatchError9(ERROR_CODES9.TOOL_DENIED);
+    throw new SpotPatchError9(ERROR_CODES9.TOOL_ARGUMENTS_INVALID);
   }
   const absolutePath = await resolveExistingAgentPath(root, relativePath);
   const [metadata, currentBytes] = await Promise.all([
@@ -854,7 +874,7 @@ async function writeAgentTextFileIfContentMatches(root, relativePath, expectedCo
   try {
     currentContent = utf8Decoder.decode(currentBytes);
   } catch {
-    throw new SpotPatchError9(ERROR_CODES9.TOOL_DENIED);
+    throw new SpotPatchError9(ERROR_CODES9.TOOL_PATH_DENIED);
   }
   if (currentBytes.includes(0) || currentContent !== expectedContent) {
     throw new SpotPatchError9(ERROR_CODES9.PATCH_REJECTED);
@@ -1113,7 +1133,7 @@ async function runConfiguredCheck(options) {
 function requireConfiguredCheck(checkId, checks) {
   const check = checks[checkId];
   if (check === void 0) {
-    throw new SpotPatchError10(ERROR_CODES10.TOOL_DENIED);
+    throw new SpotPatchError10(ERROR_CODES10.TOOL_ARGUMENTS_INVALID);
   }
   return check;
 }
@@ -1308,9 +1328,16 @@ async function applyAgentPatch(worktreeRoot, patch, limits, signal) {
     throw new SpotPatchError13(ERROR_CODES13.AGENT_LIMIT_EXCEEDED);
   }
   await Promise.all(
-    files.map(
-      async (file) => resolveWritableAgentPath(worktreeRoot, file.relativePath)
-    )
+    files.map(async (file) => {
+      await resolveWritableAgentPath(worktreeRoot, file.relativePath);
+      if (file.kind !== "added") {
+        await readAgentTextFile(
+          worktreeRoot,
+          file.relativePath,
+          limits.maxReadBytesPerFile
+        );
+      }
+    })
   );
   await runGitCommand({
     cwd: worktreeRoot,
@@ -1424,7 +1451,7 @@ var MAX_DISCOVERED_FILES = 2e4;
 var TEXT_SAMPLE_BYTES = 8192;
 function compileGlob(glob) {
   if (glob.length === 0 || glob.length > 256 || glob.includes("\0") || glob.includes("\\") || glob.startsWith("/") || ["[", "]", "{", "}", "(", ")", "!"].some((character) => glob.includes(character)) || glob.split("/").some((segment) => segment === "..")) {
-    throw new SpotPatchError14(ERROR_CODES14.TOOL_DENIED);
+    throw new SpotPatchError14(ERROR_CODES14.TOOL_ARGUMENTS_INVALID);
   }
   let expression = "^";
   for (let index = 0; index < glob.length; index += 1) {
@@ -1663,7 +1690,7 @@ var runCheckSchema = z.strictObject({
   checkId: z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u)
 });
 function invalidTool() {
-  throw new SpotPatchError15(ERROR_CODES15.TOOL_DENIED);
+  throw new SpotPatchError15(ERROR_CODES15.TOOL_ARGUMENTS_INVALID);
 }
 function parseArguments(schema, value) {
   const parsed = schema.safeParse(value);
@@ -1720,8 +1747,16 @@ function retryableWriteRejection(reason, guidance) {
     guidance
   });
 }
+function retryableArgumentsRejection() {
+  return Object.freeze({
+    errorCode: ERROR_CODES15.TOOL_ARGUMENTS_INVALID,
+    retryable: true,
+    reason: "ARGUMENTS_DO_NOT_MATCH_CONTRACT",
+    guidance: "No files changed. Retry once with a new tool call ID and only the declared fields and value types."
+  });
+}
 function createAgentToolExecutor(options) {
-  const cache = /* @__PURE__ */ new Map();
+  const cacheByTurn = /* @__PURE__ */ new Map();
   const touchedPaths = /* @__PURE__ */ new Set();
   const executeUncached = async (call, signal) => {
     switch (call.name) {
@@ -1937,20 +1972,32 @@ function createAgentToolExecutor(options) {
     }
   };
   return Object.freeze({
-    async execute(call, signal) {
+    async execute(call, scope, signal) {
+      if (!Number.isSafeInteger(scope.turn) || scope.turn < 1) {
+        throw new SpotPatchError15(ERROR_CODES15.INTERNAL_ERROR);
+      }
+      const turnCache = cacheByTurn.get(scope.turn) ?? /* @__PURE__ */ new Map();
+      cacheByTurn.set(scope.turn, turnCache);
       const signature = `${call.name}\0${JSON.stringify(call.arguments)}`;
-      const cached = cache.get(call.id);
+      const cached = turnCache.get(call.id);
       if (cached !== void 0) {
         if (cached.signature !== signature) {
-          return invalidTool();
+          throw new SpotPatchError15(ERROR_CODES15.TOOL_CALL_ID_CONFLICT);
         }
         return cached.result;
       }
-      const result = Object.freeze({
-        toolCallId: call.id,
-        output: await executeUncached(call, signal)
-      });
-      cache.set(call.id, Object.freeze({ signature, result }));
+      let output;
+      try {
+        output = await executeUncached(call, signal);
+      } catch (error) {
+        if (error instanceof SpotPatchError15 && error.code === ERROR_CODES15.TOOL_ARGUMENTS_INVALID) {
+          output = retryableArgumentsRejection();
+        } else {
+          throw error;
+        }
+      }
+      const result = Object.freeze({ toolCallId: call.id, output });
+      turnCache.set(call.id, Object.freeze({ signature, result }));
       return result;
     },
     touchedPaths() {
@@ -1960,67 +2007,354 @@ function createAgentToolExecutor(options) {
 }
 
 // src/worktree/git-worktree.ts
-import { lstat as lstat3, mkdtemp, realpath as realpath2, rm as rm2 } from "fs/promises";
+import {
+  copyFile,
+  lstat as lstat4,
+  mkdir,
+  mkdtemp,
+  readFile as readFile2,
+  realpath as realpath3,
+  rm as rm2
+} from "fs/promises";
+import { createHash as createHash2 } from "crypto";
 import os from "os";
+import path6 from "path";
+import {
+  ERROR_CODES as ERROR_CODES17,
+  SpotPatchError as SpotPatchError17
+} from "@spotpatch/shared";
+
+// src/worktree/workspace-health.ts
+import { lstat as lstat3, realpath as realpath2 } from "fs/promises";
 import path5 from "path";
-import { ERROR_CODES as ERROR_CODES16, SpotPatchError as SpotPatchError16 } from "@spotpatch/shared";
-async function assertCleanGitBaseline(options) {
-  const root = await realpath2(options.root).catch(() => {
-    throw new SpotPatchError16(ERROR_CODES16.WORKTREE_DIRTY);
+import {
+  AGENT_WORKSPACE_SNAPSHOT_LIMITS,
+  ERROR_CODES as ERROR_CODES16,
+  SpotPatchError as SpotPatchError16
+} from "@spotpatch/shared";
+var CONFLICTED_STATUSES = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+var OPERATION_MARKERS = Object.freeze([
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REVERT_HEAD",
+  "rebase-apply",
+  "rebase-merge"
+]);
+function emptyChanges() {
+  return Object.freeze({
+    staged: 0,
+    unstaged: 0,
+    untracked: 0,
+    conflicted: 0,
+    total: 0
+  });
+}
+function blockedHealth(errorCode) {
+  return Object.freeze({
+    state: "blocked",
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    changes: emptyChanges(),
+    canIncludeLocalChanges: false,
+    errorCode
+  });
+}
+function parsePorcelainStatus(value) {
+  const records = value.split("\0");
+  const untrackedPaths = [];
+  let staged = 0;
+  let unstaged = 0;
+  let conflicted = 0;
+  let total = 0;
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index] ?? "";
+    if (record.length === 0) {
+      continue;
+    }
+    if (record.length < 4 || record[2] !== " ") {
+      throw new SpotPatchError16(ERROR_CODES16.WORKTREE_LOCAL_CHANGES_UNSUPPORTED);
+    }
+    const status = record.slice(0, 2);
+    const relativePath = record.slice(3);
+    if (relativePath.length === 0) {
+      throw new SpotPatchError16(ERROR_CODES16.WORKTREE_LOCAL_CHANGES_UNSUPPORTED);
+    }
+    total += 1;
+    if (status === "??") {
+      untrackedPaths.push(relativePath);
+      continue;
+    }
+    const indexStatus = status[0] ?? " ";
+    const worktreeStatus = status[1] ?? " ";
+    if (CONFLICTED_STATUSES.has(status) || indexStatus === "U" || worktreeStatus === "U") {
+      conflicted += 1;
+    }
+    if (indexStatus !== " ") {
+      staged += 1;
+    }
+    if (worktreeStatus !== " ") {
+      unstaged += 1;
+    }
+    if (indexStatus === "R" || indexStatus === "C") {
+      index += 1;
+      if ((records[index] ?? "").length === 0) {
+        throw new SpotPatchError16(ERROR_CODES16.WORKTREE_LOCAL_CHANGES_UNSUPPORTED);
+      }
+    }
+  }
+  return Object.freeze({
+    changes: Object.freeze({
+      staged,
+      unstaged,
+      untracked: untrackedPaths.length,
+      conflicted,
+      total
+    }),
+    untrackedPaths: Object.freeze(untrackedPaths)
   });
-  const topLevel = (await runGitCommand({
+}
+async function operationInProgress(root, signal) {
+  for (const marker of OPERATION_MARKERS) {
+    const markerPath = (await runGitCommand({
+      cwd: root,
+      args: ["rev-parse", "--git-path", marker],
+      errorCode: ERROR_CODES16.WORKTREE_NOT_REPOSITORY,
+      ...signal === void 0 ? {} : { signal }
+    })).trim();
+    if (await lstat3(path5.resolve(root, markerPath)).catch(() => void 0) !== void 0) {
+      return true;
+    }
+  }
+  return false;
+}
+async function inspectUntrackedFiles(root, relativePaths) {
+  if (relativePaths.length > AGENT_WORKSPACE_SNAPSHOT_LIMITS.maxUntrackedFiles) {
+    return ERROR_CODES16.WORKTREE_LOCAL_CHANGES_TOO_LARGE;
+  }
+  let totalBytes = 0;
+  for (const relativePath of relativePaths) {
+    const absolutePath = path5.resolve(root, relativePath);
+    const relative = path5.relative(root, absolutePath);
+    if (relative === ".." || relative.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative)) {
+      return ERROR_CODES16.WORKTREE_UNTRACKED_UNSUPPORTED;
+    }
+    const metadata = await lstat3(absolutePath).catch(() => void 0);
+    if (metadata === void 0 || !metadata.isFile() || metadata.isSymbolicLink()) {
+      return ERROR_CODES16.WORKTREE_UNTRACKED_UNSUPPORTED;
+    }
+    totalBytes += metadata.size;
+    if (totalBytes > AGENT_WORKSPACE_SNAPSHOT_LIMITS.maxUntrackedBytes) {
+      return ERROR_CODES16.WORKTREE_LOCAL_CHANGES_TOO_LARGE;
+    }
+  }
+  return void 0;
+}
+async function inspectGitWorkspace(rootValue, signal) {
+  const root = await realpath2(rootValue).catch(() => {
+    throw new SpotPatchError16(ERROR_CODES16.WORKTREE_NOT_REPOSITORY);
+  });
+  const topLevelResult = await runRawGitCommand({
     cwd: root,
     args: ["rev-parse", "--show-toplevel"],
-    errorCode: ERROR_CODES16.WORKTREE_DIRTY,
-    ...options.signal === void 0 ? {} : { signal: options.signal }
-  })).trim();
+    ...signal === void 0 ? {} : { signal }
+  });
+  if (topLevelResult.exitCode !== 0 || topLevelResult.cancelled || topLevelResult.timedOut) {
+    throw new SpotPatchError16(ERROR_CODES16.WORKTREE_NOT_REPOSITORY);
+  }
+  const topLevel = topLevelResult.stdout.trim();
   if (!samePath(root, topLevel)) {
-    throw new SpotPatchError16(ERROR_CODES16.WORKTREE_DIRTY);
+    throw new SpotPatchError16(ERROR_CODES16.WORKTREE_NOT_REPOSITORY);
   }
   const head = (await runGitCommand({
     cwd: root,
     args: ["rev-parse", "--verify", "HEAD"],
-    errorCode: ERROR_CODES16.WORKTREE_DIRTY,
-    ...options.signal === void 0 ? {} : { signal: options.signal }
+    errorCode: ERROR_CODES16.WORKTREE_NOT_REPOSITORY,
+    ...signal === void 0 ? {} : { signal }
   })).trim();
-  if (options.expectedHead !== void 0 && head !== options.expectedHead) {
-    throw new SpotPatchError16(ERROR_CODES16.APPLY_CONFLICT);
+  const parsed = parsePorcelainStatus(
+    await runGitCommand({
+      cwd: root,
+      args: ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
+      errorCode: ERROR_CODES16.WORKTREE_NOT_REPOSITORY,
+      ...signal === void 0 ? {} : { signal }
+    })
+  );
+  const operationActive = await operationInProgress(root, signal);
+  const untrackedError = await inspectUntrackedFiles(root, parsed.untrackedPaths);
+  const errorCode = operationActive ? ERROR_CODES16.WORKTREE_OPERATION_IN_PROGRESS : parsed.changes.conflicted > 0 ? ERROR_CODES16.WORKTREE_CONFLICTED : untrackedError;
+  const health = Object.freeze({
+    state: errorCode !== void 0 ? "blocked" : parsed.changes.total === 0 ? "ready" : "consent-required",
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    changes: parsed.changes,
+    canIncludeLocalChanges: errorCode === void 0 && parsed.changes.total > 0,
+    ...errorCode === void 0 ? {} : { errorCode }
+  });
+  return Object.freeze({
+    root,
+    head,
+    health,
+    untrackedPaths: parsed.untrackedPaths
+  });
+}
+async function inspectAgentWorkspace(root, signal) {
+  try {
+    return (await inspectGitWorkspace(root, signal)).health;
+  } catch (error) {
+    if (error instanceof SpotPatchError16) {
+      return blockedHealth(error.code);
+    }
+    return blockedHealth(ERROR_CODES16.INTERNAL_ERROR);
   }
-  const status = await runGitCommand({
-    cwd: root,
-    args: ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
-    errorCode: ERROR_CODES16.WORKTREE_DIRTY,
-    ...options.signal === void 0 ? {} : { signal: options.signal }
+}
+
+// src/worktree/git-worktree.ts
+function workspacePath(root, relativePath) {
+  const candidate = path6.resolve(root, relativePath);
+  const relative = path6.relative(root, candidate);
+  if (relative === ".." || relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative)) {
+    throw new SpotPatchError17(ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED);
+  }
+  return candidate;
+}
+async function fileDigest(filePath) {
+  return createHash2("sha256").update(await readFile2(filePath)).digest("hex");
+}
+async function copyUntrackedFiles(sourceRoot, worktreeRoot, relativePaths) {
+  for (const relativePath of relativePaths) {
+    const sourcePath = workspacePath(sourceRoot, relativePath);
+    const targetPath = workspacePath(worktreeRoot, relativePath);
+    const metadata = await lstat4(sourcePath).catch(() => void 0);
+    if (metadata === void 0 || !metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new SpotPatchError17(ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED);
+    }
+    await mkdir(path6.dirname(targetPath), { recursive: true });
+    await copyFile(sourcePath, targetPath);
+    const [sourceDigest, targetDigest] = await Promise.all([
+      fileDigest(sourcePath),
+      fileDigest(targetPath)
+    ]).catch(() => {
+      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    });
+    if (sourceDigest !== targetDigest) {
+      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    }
+  }
+}
+async function assertUntrackedFilesUnchanged(sourceRoot, worktreeRoot, relativePaths) {
+  for (const relativePath of relativePaths) {
+    const sourcePath = workspacePath(sourceRoot, relativePath);
+    const targetPath = workspacePath(worktreeRoot, relativePath);
+    const [sourceDigest, targetDigest] = await Promise.all([
+      fileDigest(sourcePath),
+      fileDigest(targetPath)
+    ]).catch(() => {
+      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    });
+    if (sourceDigest !== targetDigest) {
+      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    }
+  }
+}
+async function materializeLocalBaseline(sourceRoot, worktreeRoot, expectedHead, untrackedPaths, signal) {
+  const sourceDiff = await runGitCommand({
+    cwd: sourceRoot,
+    args: [
+      "diff",
+      "--binary",
+      "--full-index",
+      "--no-ext-diff",
+      "--no-color",
+      "--no-renames",
+      "HEAD",
+      "--"
+    ],
+    signal,
+    errorCode: ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED
   });
-  if (status.length > 0) {
-    throw new SpotPatchError16(
-      options.expectedHead === void 0 ? ERROR_CODES16.WORKTREE_DIRTY : ERROR_CODES16.APPLY_CONFLICT
-    );
+  if (sourceDiff.length > 0) {
+    await runGitCommand({
+      cwd: worktreeRoot,
+      args: ["apply", "--binary", "--whitespace=nowarn", "-"],
+      stdin: sourceDiff,
+      signal,
+      errorCode: ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED
+    });
   }
-  return Object.freeze({ root, head });
+  await copyUntrackedFiles(sourceRoot, worktreeRoot, untrackedPaths);
+  const confirmation = await inspectGitWorkspace(sourceRoot, signal);
+  const confirmationDiff = await runGitCommand({
+    cwd: sourceRoot,
+    args: [
+      "diff",
+      "--binary",
+      "--full-index",
+      "--no-ext-diff",
+      "--no-color",
+      "--no-renames",
+      "HEAD",
+      "--"
+    ],
+    signal,
+    errorCode: ERROR_CODES17.APPLY_CONFLICT
+  });
+  if (confirmation.head !== expectedHead || confirmationDiff !== sourceDiff || confirmation.untrackedPaths.length !== untrackedPaths.length || confirmation.untrackedPaths.some((value, index) => value !== untrackedPaths[index])) {
+    throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+  }
+  await assertUntrackedFilesUnchanged(sourceRoot, worktreeRoot, untrackedPaths);
+  await runGitCommand({
+    cwd: worktreeRoot,
+    args: ["add", "--all"],
+    signal,
+    errorCode: ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED
+  });
+  await runGitCommand({
+    cwd: worktreeRoot,
+    args: [
+      "-c",
+      "user.name=SpotPatch Agent",
+      "-c",
+      "user.email=spotpatch-agent@example.invalid",
+      "commit",
+      "--quiet",
+      "-m",
+      "SpotPatch local workspace baseline"
+    ],
+    signal,
+    errorCode: ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED
+  });
 }
 async function defaultTemporaryBase(root) {
-  const dependencyDirectory = path5.join(root, "node_modules");
+  const dependencyDirectory = path6.join(root, "node_modules");
   try {
-    const stats = await lstat3(dependencyDirectory);
+    const stats = await lstat4(dependencyDirectory);
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
       return os.tmpdir();
     }
-    return await realpath2(dependencyDirectory);
+    return await realpath3(dependencyDirectory);
   } catch {
     return os.tmpdir();
   }
 }
 async function createIsolatedGitWorktree(options) {
-  const baseline = await assertCleanGitBaseline({
-    root: options.root,
-    signal: options.signal
+  const workingTreeMode = options.workingTreeMode ?? "require-clean";
+  const inspection = await inspectGitWorkspace(options.root, options.signal);
+  if (inspection.health.state === "blocked") {
+    throw new SpotPatchError17(
+      inspection.health.errorCode ?? ERROR_CODES17.WORKTREE_LOCAL_CHANGES_UNSUPPORTED
+    );
+  }
+  if (inspection.health.state === "consent-required" && workingTreeMode === "require-clean") {
+    throw new SpotPatchError17(ERROR_CODES17.WORKTREE_DIRTY);
+  }
+  const baseline = Object.freeze({
+    root: inspection.root,
+    head: inspection.head,
+    workingTreeMode
   });
   const temporaryBase = options.temporaryBase ?? await defaultTemporaryBase(baseline.root);
   const temporaryDirectory = await mkdtemp(
-    path5.join(temporaryBase, "spotpatch-agent-")
+    path6.join(temporaryBase, "spotpatch-agent-")
   );
-  const worktreePath = path5.join(temporaryDirectory, "worktree");
+  const worktreePath = path6.join(temporaryDirectory, "worktree");
   let registered = false;
   let cleaned = false;
   const cleanup = async () => {
@@ -2035,7 +2369,7 @@ async function createIsolatedGitWorktree(options) {
         timeoutMs: 3e4
       }).catch(() => void 0);
     }
-    if (path5.basename(temporaryDirectory).startsWith("spotpatch-agent-")) {
+    if (path6.basename(temporaryDirectory).startsWith("spotpatch-agent-")) {
       await rm2(temporaryDirectory, { recursive: true, force: true }).catch(
         () => void 0
       );
@@ -2045,12 +2379,12 @@ async function createIsolatedGitWorktree(options) {
     await runGitCommand({
       cwd: baseline.root,
       args: ["worktree", "add", "--detach", worktreePath, baseline.head],
-      errorCode: ERROR_CODES16.INTERNAL_ERROR,
+      errorCode: ERROR_CODES17.INTERNAL_ERROR,
       signal: options.signal,
       timeoutMs: 3e4
     });
     registered = true;
-    const worktreeRoot = await realpath2(worktreePath);
+    const worktreeRoot = await realpath3(worktreePath);
     const actualHead = (await runGitCommand({
       cwd: worktreeRoot,
       args: ["rev-parse", "--verify", "HEAD"],
@@ -2062,7 +2396,16 @@ async function createIsolatedGitWorktree(options) {
       signal: options.signal
     })).trim();
     if (actualHead !== baseline.head || !samePath(actualRoot, worktreeRoot)) {
-      throw new SpotPatchError16(ERROR_CODES16.INTERNAL_ERROR);
+      throw new SpotPatchError17(ERROR_CODES17.INTERNAL_ERROR);
+    }
+    if (inspection.health.state === "consent-required") {
+      await materializeLocalBaseline(
+        baseline.root,
+        worktreeRoot,
+        baseline.head,
+        inspection.untrackedPaths,
+        options.signal
+      );
     }
     return Object.freeze({ baseline, root: worktreeRoot, cleanup });
   } catch (error) {
@@ -2072,17 +2415,19 @@ async function createIsolatedGitWorktree(options) {
 }
 
 // src/worktree/prepared-change.ts
-import { createHash as createHash2 } from "crypto";
-import { lstat as lstat4, readFile as readFile2 } from "fs/promises";
-import { ERROR_CODES as ERROR_CODES17, SpotPatchError as SpotPatchError17 } from "@spotpatch/shared";
+import { createHash as createHash3 } from "crypto";
+import { lstat as lstat5, readFile as readFile3 } from "fs/promises";
+import { ERROR_CODES as ERROR_CODES18, SpotPatchError as SpotPatchError18 } from "@spotpatch/shared";
 var privateChanges = /* @__PURE__ */ new WeakMap();
 var DELETED_HASH = "<deleted>";
 function createPreparedAgentChange(options) {
   const touchedPaths = Object.freeze(
     options.result.files.map((file) => file.relativePath)
   );
-  if (options.expectedHashes.size !== touchedPaths.length || touchedPaths.some((relativePath) => !options.expectedHashes.has(relativePath))) {
-    throw new SpotPatchError17(ERROR_CODES17.INTERNAL_ERROR);
+  if (options.baselineHashes.size !== touchedPaths.length || options.expectedHashes.size !== touchedPaths.length || touchedPaths.some(
+    (relativePath) => !options.baselineHashes.has(relativePath) || !options.expectedHashes.has(relativePath)
+  )) {
+    throw new SpotPatchError18(ERROR_CODES18.INTERNAL_ERROR);
   }
   const change = Object.freeze({
     kind: "prepared-agent-change",
@@ -2092,6 +2437,7 @@ function createPreparedAgentChange(options) {
   });
   privateChanges.set(change, {
     baselineHead: options.baselineHead,
+    baselineHashes: new Map(options.baselineHashes),
     diff: options.result.diff,
     expectedHashes: new Map(options.expectedHashes),
     root: options.root,
@@ -2103,28 +2449,30 @@ function createPreparedAgentChange(options) {
 function requirePrivateChange(change) {
   const privateChange = privateChanges.get(change);
   if (privateChange === void 0) {
-    throw new SpotPatchError17(ERROR_CODES17.INTERNAL_ERROR);
+    throw new SpotPatchError18(ERROR_CODES18.INTERNAL_ERROR);
   }
   return privateChange;
 }
-async function currentHead(root) {
-  return (await runGitCommand({
-    cwd: root,
-    args: ["rev-parse", "--verify", "HEAD"],
-    errorCode: ERROR_CODES17.APPLY_CONFLICT
-  })).trim();
+async function assertWorkspaceOperationSafe(root, expectedHead) {
+  const inspection = await inspectGitWorkspace(root).catch(() => {
+    throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
+  });
+  const blockingOperation = inspection.health.errorCode === ERROR_CODES18.WORKTREE_OPERATION_IN_PROGRESS || inspection.health.errorCode === ERROR_CODES18.WORKTREE_CONFLICTED;
+  if (inspection.head !== expectedHead || blockingOperation) {
+    throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
+  }
 }
 async function fileHash(root, relativePath) {
   const normalized = assertAgentPathAllowed(relativePath);
   const absolutePath = await resolveWritableAgentPath(root, normalized);
-  const metadata = await lstat4(absolutePath).catch(() => void 0);
+  const metadata = await lstat5(absolutePath).catch(() => void 0);
   if (metadata === void 0) {
     return DELETED_HASH;
   }
   if (!metadata.isFile() || metadata.isSymbolicLink()) {
-    throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
   }
-  return createHash2("sha256").update(await readFile2(absolutePath)).digest("hex");
+  return createHash3("sha256").update(await readFile3(absolutePath)).digest("hex");
 }
 async function captureAgentFileHashes(root, paths) {
   const entries = await Promise.all(
@@ -2140,34 +2488,38 @@ function hashesMatch(expected, actual) {
 async function applyPreparedAgentChange(change) {
   const privateChange = requirePrivateChange(change);
   if (privateChange.state !== "prepared" || !change.validationPassed || privateChange.diff.length === 0) {
-    throw new SpotPatchError17(
-      change.validationPassed ? ERROR_CODES17.APPLY_CONFLICT : ERROR_CODES17.VALIDATION_FAILED
+    throw new SpotPatchError18(
+      change.validationPassed ? ERROR_CODES18.APPLY_CONFLICT : ERROR_CODES18.VALIDATION_FAILED
     );
   }
   privateChange.state = "applying";
   try {
-    await assertCleanGitBaseline({
-      root: privateChange.root,
-      expectedHead: privateChange.baselineHead
-    });
+    await assertWorkspaceOperationSafe(privateChange.root, privateChange.baselineHead);
+    const currentHashes = await captureAgentFileHashes(
+      privateChange.root,
+      privateChange.touchedPaths
+    );
+    if (!hashesMatch(privateChange.baselineHashes, currentHashes)) {
+      throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
+    }
     await runGitCommand({
       cwd: privateChange.root,
       args: ["apply", "--check", "--whitespace=error-all", "-"],
       stdin: privateChange.diff,
-      errorCode: ERROR_CODES17.APPLY_CONFLICT
+      errorCode: ERROR_CODES18.APPLY_CONFLICT
     });
     await runGitCommand({
       cwd: privateChange.root,
       args: ["apply", "--whitespace=error-all", "-"],
       stdin: privateChange.diff,
-      errorCode: ERROR_CODES17.APPLY_CONFLICT
+      errorCode: ERROR_CODES18.APPLY_CONFLICT
     });
     const appliedHashes = await captureAgentFileHashes(
       privateChange.root,
       privateChange.touchedPaths
     );
     if (!hashesMatch(privateChange.expectedHashes, appliedHashes)) {
-      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+      throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
     }
     privateChange.appliedHashes = appliedHashes;
     privateChange.state = "applied";
@@ -2179,34 +2531,39 @@ async function applyPreparedAgentChange(change) {
 async function revertPreparedAgentChange(change) {
   const privateChange = requirePrivateChange(change);
   if (privateChange.state !== "applied" || privateChange.appliedHashes === void 0) {
-    throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+    throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
   }
   privateChange.state = "reverting";
   try {
-    if (await currentHead(privateChange.root) !== privateChange.baselineHead) {
-      throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
-    }
+    await assertWorkspaceOperationSafe(privateChange.root, privateChange.baselineHead);
     const currentHashes = await captureAgentFileHashes(
       privateChange.root,
       privateChange.touchedPaths
     );
     for (const [relativePath, expectedHash] of privateChange.appliedHashes) {
       if (currentHashes.get(relativePath) !== expectedHash) {
-        throw new SpotPatchError17(ERROR_CODES17.APPLY_CONFLICT);
+        throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
       }
     }
     await runGitCommand({
       cwd: privateChange.root,
       args: ["apply", "--reverse", "--check", "--whitespace=error-all", "-"],
       stdin: privateChange.diff,
-      errorCode: ERROR_CODES17.APPLY_CONFLICT
+      errorCode: ERROR_CODES18.APPLY_CONFLICT
     });
     await runGitCommand({
       cwd: privateChange.root,
       args: ["apply", "--reverse", "--whitespace=error-all", "-"],
       stdin: privateChange.diff,
-      errorCode: ERROR_CODES17.APPLY_CONFLICT
+      errorCode: ERROR_CODES18.APPLY_CONFLICT
     });
+    const revertedHashes = await captureAgentFileHashes(
+      privateChange.root,
+      privateChange.touchedPaths
+    );
+    if (!hashesMatch(privateChange.baselineHashes, revertedHashes)) {
+      throw new SpotPatchError18(ERROR_CODES18.APPLY_CONFLICT);
+    }
     privateChange.state = "reverted";
   } catch (error) {
     privateChange.state = "applied";
@@ -2229,6 +2586,7 @@ Follow these rules exactly:
 - Use apply_patch only when creating or deleting a file, or when the change cannot be expressed as one exact replacement. apply_patch accepts only a raw canonical unified Git diff.
 - Every patch must begin with 'diff --git a/<path> b/<path>', include matching '--- a/<path>' and '+++ b/<path>' headers and valid '@@' hunks. Send only the raw diff: no Markdown fences, prose, shell commands, or '*** Begin Patch' markers.
 - If a write tool returns a retryable PATCH_REJECTED result, no file changed. Follow its guidance, re-read the current file, and retry once with a new tool call ID.
+- If any tool returns a retryable TOOL_ARGUMENTS_INVALID result, no file changed. Retry once with a new tool call ID using only the declared fields and value types.
 - Never modify credentials, environment files, lockfiles, generated output, Git metadata, or dependencies.
 - Do not claim a check passed unless run_check returned a passed status.
 - Finish with a concise factual summary after all needed tool calls. Do not include secrets or absolute paths.`;
@@ -2388,11 +2746,11 @@ function isRetryableToolFailure(result) {
     return false;
   }
   const candidate = output;
-  return candidate.errorCode === ERROR_CODES18.PATCH_REJECTED && candidate.retryable === true;
+  return candidate.retryable === true && (candidate.errorCode === ERROR_CODES19.PATCH_REJECTED || candidate.errorCode === ERROR_CODES19.TOOL_ARGUMENTS_INVALID);
 }
 function throwIfCancelled(signal) {
   if (signal.aborted) {
-    throw new SpotPatchError18(ERROR_CODES18.AGENT_CANCELLED);
+    throw new SpotPatchError19(ERROR_CODES19.AGENT_CANCELLED);
   }
 }
 function linkSignal(source, target) {
@@ -2430,6 +2788,7 @@ async function executeAgentChange(options) {
     worktree = await createIsolatedGitWorktree({
       root: options.root,
       signal: controller.signal,
+      workingTreeMode: options.workingTreeMode ?? "require-clean",
       ...options.temporaryBase === void 0 ? {} : { temporaryBase: options.temporaryBase }
     });
     options.callbacks?.onPhase?.(
@@ -2463,30 +2822,38 @@ async function executeAgentChange(options) {
     let summary;
     let toolCallCount = 0;
     for (let turn = 0; turn < options.execution.limits.maxTurns; turn += 1) {
+      const turnNumber = turn + 1;
       throwIfCancelled(controller.signal);
       const response = await session.next(pendingResults, controller.signal);
+      assertUniqueToolCallIds(response.toolCalls);
       if (response.toolCalls.length === 0) {
         summary = response.finalText.trim().slice(0, options.execution.limits.maxToolOutputCharacters);
         break;
       }
       toolCallCount += response.toolCalls.length;
       if (toolCallCount > options.execution.limits.maxToolCalls) {
-        throw new SpotPatchError18(ERROR_CODES18.AGENT_LIMIT_EXCEEDED);
+        throw new SpotPatchError19(ERROR_CODES19.AGENT_LIMIT_EXCEEDED);
       }
       const results = [];
       for (const call of response.toolCalls) {
         options.callbacks?.onTool?.(
           Object.freeze({
+            turn: turnNumber,
             toolCallId: call.id,
             toolName: call.name,
             state: "started"
           })
         );
         try {
-          const result2 = await executor.execute(call, controller.signal);
+          const result2 = await executor.execute(
+            call,
+            Object.freeze({ turn: turnNumber }),
+            controller.signal
+          );
           results.push(result2);
           options.callbacks?.onTool?.(
             Object.freeze({
+              turn: turnNumber,
               toolCallId: call.id,
               toolName: call.name,
               state: isRetryableToolFailure(result2) ? "failed" : "succeeded"
@@ -2495,6 +2862,7 @@ async function executeAgentChange(options) {
         } catch (error) {
           options.callbacks?.onTool?.(
             Object.freeze({
+              turn: turnNumber,
               toolCallId: call.id,
               toolName: call.name,
               state: "failed"
@@ -2506,7 +2874,7 @@ async function executeAgentChange(options) {
       pendingResults = Object.freeze(results);
     }
     if (summary === void 0) {
-      throw new SpotPatchError18(ERROR_CODES18.AGENT_LIMIT_EXCEEDED);
+      throw new SpotPatchError19(ERROR_CODES19.AGENT_LIMIT_EXCEEDED);
     }
     options.callbacks?.onPhase?.(
       Object.freeze({
@@ -2539,7 +2907,7 @@ async function executeAgentChange(options) {
         controller.signal
       );
       if (afterCheck.diff !== initialChangeSet.diff) {
-        throw new SpotPatchError18(ERROR_CODES18.VALIDATION_FAILED);
+        throw new SpotPatchError19(ERROR_CODES19.VALIDATION_FAILED);
       }
     }
     const validationPassed = finalChecks.every((check) => check.status === "passed");
@@ -2555,9 +2923,14 @@ async function executeAgentChange(options) {
       worktree.root,
       initialChangeSet.touchedPaths
     );
+    const baselineHashes = await captureAgentFileHashes(
+      worktree.baseline.root,
+      initialChangeSet.touchedPaths
+    );
     return createPreparedAgentChange({
       autoApplyEligible,
       baselineHead: worktree.baseline.head,
+      baselineHashes,
       expectedHashes,
       result,
       root: worktree.baseline.root,
@@ -2565,15 +2938,15 @@ async function executeAgentChange(options) {
     });
   } catch (error) {
     if (options.signal.aborted) {
-      throw new SpotPatchError18(ERROR_CODES18.AGENT_CANCELLED);
+      throw new SpotPatchError19(ERROR_CODES19.AGENT_CANCELLED);
     }
     if (hasJobTimedOut()) {
-      throw new SpotPatchError18(ERROR_CODES18.AGENT_LIMIT_EXCEEDED);
+      throw new SpotPatchError19(ERROR_CODES19.AGENT_LIMIT_EXCEEDED);
     }
-    if (error instanceof SpotPatchError18) {
+    if (error instanceof SpotPatchError19) {
       throw error;
     }
-    throw new SpotPatchError18(ERROR_CODES18.INTERNAL_ERROR);
+    throw new SpotPatchError19(ERROR_CODES19.INTERNAL_ERROR);
   } finally {
     clearTimeout(timeout);
     unlink();
@@ -2583,15 +2956,15 @@ async function executeAgentChange(options) {
 
 // src/provider/capability-probe.ts
 import {
-  ERROR_CODES as ERROR_CODES19,
-  SpotPatchError as SpotPatchError19
+  ERROR_CODES as ERROR_CODES20,
+  SpotPatchError as SpotPatchError20
 } from "@spotpatch/shared";
 var PROBE_TOOL_NAME = "spotpatch_capability_probe";
 var PROBE_TOKEN = "spotpatch-ready-v1";
 async function probeProviderCapability(options) {
   const model = options.provider.models[options.modelProfileId];
   if (model === void 0) {
-    throw new SpotPatchError19(ERROR_CODES19.MODEL_NOT_ALLOWED);
+    throw new SpotPatchError20(ERROR_CODES20.MODEL_NOT_ALLOWED);
   }
   const credential = options.credential ?? resolveProviderCredential(options.provider.apiKeyEnv, options.environment);
   const session = createOpenAICompatibleProviderSession({
@@ -2620,7 +2993,7 @@ async function probeProviderCapability(options) {
   const first = await session.next(void 0, options.signal);
   const probeCall = first.toolCalls[0];
   if (first.toolCalls.length !== 1 || probeCall?.name !== PROBE_TOOL_NAME || probeCall.arguments.token !== PROBE_TOKEN) {
-    throw new SpotPatchError19(ERROR_CODES19.MODEL_TOOL_CALL_UNSUPPORTED);
+    throw new SpotPatchError20(ERROR_CODES20.MODEL_TOOL_CALL_UNSUPPORTED);
   }
   const second = await session.next(
     Object.freeze([
@@ -2632,7 +3005,7 @@ async function probeProviderCapability(options) {
     options.signal
   );
   if (second.toolCalls.length !== 0 || second.finalText.trim().length === 0) {
-    throw new SpotPatchError19(ERROR_CODES19.MODEL_TOOL_CALL_UNSUPPORTED);
+    throw new SpotPatchError20(ERROR_CODES20.MODEL_TOOL_CALL_UNSUPPORTED);
   }
   return Object.freeze({
     providerProfileId: options.provider.id,
@@ -2654,6 +3027,7 @@ export {
   createOpenAICompatibleProviderSession,
   createProviderCredential,
   executeAgentChange,
+  inspectAgentWorkspace,
   probeProviderCapability,
   resolveProviderCredential,
   revertPreparedAgentChange