@buildaharness/aielia 0.3.1 → 0.3.2

package/dist/{cli-session-D0uLdT2A.js → cli-session-BiX2DOni.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { loadHarnessCheckpoint, deleteHarnessCheckpoint, ControlState, FailureDiagnostics, Diagnostics, WorldModel, EvidenceStore, gatherEvidence, applyToolReliability, updateWorldModel, normalise, DimensionType, resolveControlState, containsCJK, Budget, validateInvestigationTools, tokenize, validateAskQuestion, validateAskResponse, makeQuestionsBatch, HarnessRuntime, saveHarnessCheckpoint, supervisorEnabled, EscalationHalt, riskSummary, InMemoryExperienceStore, resolveAskMode as resolveAskMode$1 } from "@buildaharness/harness";
+import { loadHarnessCheckpoint, deleteHarnessCheckpoint, ControlState, FailureDiagnostics, Diagnostics, WorldModel, EvidenceStore, gatherEvidence, applyToolReliability, updateWorldModel, normalise, DimensionType, resolveControlState, containsCJK, Budget, validateInvestigationTools, tokenize as tokenize$1, validateAskQuestion, validateAskResponse, makeQuestionsBatch, HarnessRuntime, saveHarnessCheckpoint, supervisorEnabled, EscalationHalt, riskSummary, InMemoryExperienceStore, resolveAskMode as resolveAskMode$1 } from "@buildaharness/harness";
 import { ANTHROPIC_DEFAULT_MODEL, InMemoryAdapter, InMemoryReminderStore, IndexedDBAdapter, DexieExperienceStore } from "@buildaharness/runtime";
 const en$9 = {
   factMarkers: "\\b(my(?:\\s+\\w+(?:'s)?){0,3}\\s+name is|i(?:\\s+\\w+){0,4}\\s+live(?:\\s+\\w+){0,2}\\s+in|i(?:\\s+\\w+){0,4}\\s+work(?:\\s+\\w+){0,4}\\s+(at|as|for)|i am(?:\\s+(?!\\w*ing\\b)\\w+){0,4}\\s+an?\\b|i'm(?:\\s+(?!\\w*ing\\b)\\w+){0,4}\\s+an?\\b|i prefer|remember that|note that|for future reference|call me|i go by|i have (?:a|an|\\d+)(?:\\s+\\w+){0,4}\\s+named)\\b",
@@ -625,7 +625,7 @@ function compileRiskPatternsAcrossLanguages(data) {
     mediumRiskPatterns: languages.flatMap((lang) => lang.mediumRiskPatterns.map(compileRiskPattern)),
     // Reason text stays whichever language declared it first (today: "en") — the assistant's own
     // output isn't translated by this change, only its ability to understand non-English input;
-    // see plans/personal_assistant_chinese_lexical_checks_plan.html's Phase 4 for that separate,
+    // see the internal plan's Phase 4 for that separate,
     // later concern.
     reminderPattern: { pattern: new RegExp(languages.map((lang) => lang.reminderPattern.source).join("|"), "i"), reason: first.reminderPattern.reason },
     reminderRecallQuestion: languages.map((lang) => new RegExp(lang.reminderRecallQuestion, "i")),
@@ -877,7 +877,7 @@ function migrateFact(fact) {
 const TIER_RULES = {
   episodic: { allowedSources: ["user_asserted", "model_inferred", "observed", "externally_verified"], retention: "session", contradictionChecked: false },
   // model_inferred added to semantic/identity/preference in Phase 4 of
-  // plans/personal_assistant_fact_extraction_llm_confidence_plan.html: tierForFact() now routes a
+  // the internal plan: tierForFact() now routes a
   // model_inferred fact here too, but only once it's durable AND high-confidence — see that
   // function's doc comment.
   semantic: { allowedSources: ["user_asserted", "model_inferred", "externally_verified"], retention: "durable", contradictionChecked: true },
@@ -1570,6 +1570,11 @@ async function resolveAndVerify(ctx, requestedPath) {
   await assertRealPathInWorkspace(ctx.backend, ctx.workspaceRoot, resolved);
   return resolved;
 }
+async function readCurrentFileContent(backend, workspaceRoot, requestedPath) {
+  const resolved = resolveInWorkspace(workspaceRoot, requestedPath);
+  await assertRealPathInWorkspace(backend, workspaceRoot, resolved);
+  return backend.readTextFile(resolved);
+}
 const READ_FILE_TOOL = {
   name: "read_file",
   description: "Read a text file inside the sandboxed workspace directory. `path` is relative to the workspace root (or an absolute path that is still inside it) — any path outside the workspace is rejected.",
@@ -1681,7 +1686,10 @@ async function applyPendingAction(backend, workspaceRoot, id, options = {}) {
     await backend.writeTextFile(resolved, record.content);
     await recordUndoLogEntry(backend, workspaceRoot, undoEntry2);
     await backend.removeFile(pendingActionPath(workspaceRoot, id));
-    return record;
+    return {
+      ...record,
+      previousContent: snapshot.undoable ? snapshot.previousContent ?? void 0 : void 0
+    };
   }
   if (record.kind === "email") {
     if (!options.sendEmail) {
@@ -2289,6 +2297,407 @@ function classifyToolYield(toolName, resultText) {
   if (testAny(DEAD_END_MARKERS, resultText)) return "dead_end";
   return "productive";
 }
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+const lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+const DEFAULT_MAX_LINES = 20;
+const DIFF_INDENT = "  ";
+function formatWriteDiff(oldContent, newContent, maxLines = DEFAULT_MAX_LINES) {
+  if (oldContent === void 0) return previewContent(newContent, maxLines);
+  const hunks = structuredPatch("before", "after", oldContent, newContent, "", "", { context: 3 }).hunks;
+  const entries = [];
+  for (const hunk of hunks) {
+    let oldLine = hunk.oldStart;
+    let newLine = hunk.newStart;
+    for (const rawLine of hunk.lines) {
+      if (rawLine.startsWith("\\")) continue;
+      const sign = rawLine[0];
+      const content = rawLine.slice(1);
+      if (sign === "-") {
+        entries.push({ lineNumber: oldLine, sign, content });
+        oldLine++;
+      } else if (sign === "+") {
+        entries.push({ lineNumber: newLine, sign, content });
+        newLine++;
+      } else {
+        entries.push({ lineNumber: newLine, sign, content });
+        oldLine++;
+        newLine++;
+      }
+    }
+  }
+  if (entries.length === 0) return "(no changes)";
+  const gutterWidth = Math.max(...entries.map((e) => String(e.lineNumber).length));
+  const diffLines2 = entries.map((e) => `${DIFF_INDENT}${String(e.lineNumber).padStart(gutterWidth, " ")} ${e.sign}${e.content}`);
+  return previewLines(diffLines2, maxLines);
+}
+function previewContent(content, maxLines = DEFAULT_MAX_LINES) {
+  return previewLines(content.split("\n"), maxLines);
+}
+function previewLines(lines, maxLines) {
+  if (lines.length <= maxLines) return lines.join("\n");
+  return `${lines.slice(0, maxLines).join("\n")}
+… (truncated)`;
+}
 class PrivateNetworkTargetError extends Error {
   constructor(requestedUrl, detail) {
     super(`Refusing to fetch "${requestedUrl}": ${detail}`);
@@ -2863,12 +3272,6 @@ const UNPARSED_TOOL_CALL_PATTERN = /<tool_call>|<\/?｜[^｜<>]{1,32}｜(?:tool_
 function looksLikeUnparsedToolCall(content) {
   return UNPARSED_TOOL_CALL_PATTERN.test(content);
 }
-function previewContent$1(content, maxLines = 20) {
-  const lines = content.split("\n");
-  if (lines.length <= maxLines) return content;
-  return `${lines.slice(0, maxLines).join("\n")}
-… (truncated)`;
-}
 function shellApprovalReason(command, cwd) {
   const base = `Proposes running: ${command}
   (cwd: ${cwd})`;
@@ -2910,7 +3313,7 @@ class AgentLoop {
     return createTurnControlPlaneState(toolNames);
   }
   /**
-   * R2 of plans/harness_d2_one_loop_rewire_plan.html: builds the real toolExecutors['default']
+   * R2 of the internal plan: builds the real toolExecutors['default']
    * entry HarnessBridge.run() swaps in when the one-loop flag is enabled — a proposer that calls
    * runToolIterationStep once per driveMainLoop iteration and translates its discriminated result
    * into the primitives D0/D1 already built: a plain return (status 'continue', no output yet) for
@@ -2981,7 +3384,7 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
     };
   }
   /**
-   * R3 of plans/harness_d2_one_loop_rewire_plan.html: the wiring-level counterpart to
+   * R3 of the internal plan: the wiring-level counterpart to
    * `createHarnessProposer` above — builds the same `messages`/`tools` shape `runToolLoop` builds
    * (system prompt + transcript + user message; whichever of FILE_TOOLS/WEB_TOOLS/SHELL_TOOLS/
    * ACTION_TOOLS/REMINDER_TOOLS are configured) so `assistant.ts`'s `runTurn` doesn't need to
@@ -3020,7 +3423,7 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
     return { proposer, sources };
   }
   /**
-   * R4 of plans/harness_d2_one_loop_rewire_plan.html: the batch-research counterpart to
+   * R4 of the internal plan: the batch-research counterpart to
    * `createOneLoopProposer` above — routes `runBatchToolLoop`'s probe → calibrate → confirm-gate
    * → resolve-remaining → synthesize sequence through the same harness-driven proposer mechanism,
    * instead of batch research remaining a second code path that (per R3) never reached the
@@ -3199,7 +3602,7 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
   }
   /**
    * One iteration's worth of `runToolIterations`' ReAct loop, extracted (R1 of the D2
-   * one-loop-rewire follow-up plan, `plans/harness_d2_one_loop_rewire_plan.html`) so a
+   * one-loop-rewire follow-up plan, the internal plan) so a
    * harness-driven proposer (R2) can call this directly, once per `driveMainLoop` iteration,
    * instead of only ever being driven by `runToolIterations`' own `for` loop. Preserves every
    * early-return branch of the original loop body exactly — the unparsed-tool-call retry,
@@ -3217,6 +3620,9 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
     const reportStep = (tool, input) => {
       onToolStep == null ? void 0 : onToolStep({ tool, input, summary: summarizeToolStep(tool, input) });
     };
+    const reportDenied = (tool, input, reason) => {
+      onToolStep == null ? void 0 : onToolStep({ tool, input, summary: summarizeToolStep(tool, input), deniedReason: reason });
+    };
     {
       const response = await this.llmClient.callChatStructured(messages, tools, {
         model: this.model(),
@@ -3229,9 +3635,10 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
         // makes directly, now also covering the calls this backend used to resolve invisibly.
         // A backend without such an internal loop (the proxy client) never calls this — its
         // calls come back as response.toolCalls and are gated inline below instead.
-        onToolProposal: async (tool) => {
+        onToolProposal: async (tool, input) => {
           const policy = this.checkToolPolicy(tool, riskHint, controlPlaneState == null ? void 0 : controlPlaneState.controlState);
           if (policy.decision === "ALLOW") return { decision: "allow" };
+          reportDenied(tool, input, policy.reason);
           return { decision: "deny", reason: policy.reason };
         }
       });
@@ -3261,12 +3668,13 @@ ${freshFindings.map((o) => o.content).join("\n\n")}`
         const { id, kind, ...payload } = alreadyStagedCall.input;
         if (kind === "write") {
           const { path, content } = payload;
+          const previousContent = this.fileTools ? await readCurrentFileContent(this.fileTools.backend, this.fileTools.workspaceRoot, path) : void 0;
           return {
             done: true,
             result: {
               kind: "needs_approval",
               reason: `Proposes writing to "${path}":
-${previewContent$1(content)}`,
+${formatWriteDiff(previousContent, content)}`,
               pendingActionId: id,
               pendingActionKind: "write"
             }
@@ -3303,12 +3711,13 @@ ${previewContent$1(content)}`,
         if (result.kind !== "staged_write") {
           throw new Error("write_file executor returned an unexpected result kind");
         }
+        const previousContent = await readCurrentFileContent(this.fileTools.backend, this.fileTools.workspaceRoot, result.path);
         return {
           done: true,
           result: {
             kind: "needs_approval",
             reason: `Proposes writing to "${result.path}":
-${previewContent$1(result.content)}`,
+${formatWriteDiff(previousContent, result.content)}`,
             pendingActionId: result.id,
             pendingActionKind: "write"
           }
@@ -3350,6 +3759,7 @@ ${previewContent$1(result.content)}`,
         const policy = this.checkToolPolicy(call.name, riskHint, controlPlaneState == null ? void 0 : controlPlaneState.controlState);
         if (policy.decision === "DENY") {
           const resultText2 = `Denied by tool policy: ${policy.reason}`;
+          reportDenied(call.name, call.input, policy.reason);
           messages.push({ role: "tool", content: resultText2, toolCallId: call.id });
           (_a = this.onTrace) == null ? void 0 : _a.call(this, { kind: "tool_call", tool: call.name, ok: false });
           continue;
@@ -3614,7 +4024,7 @@ ${text}` : text;
   }
   /**
    * Trajectory Supervisor GATHER_EVIDENCE host (S5 of
-   * plans/harness_trajectory_supervisor_plan.html). A bounded, strictly read-only tool
+   * the internal plan). A bounded, strictly read-only tool
    * loop the harness calls (via HarnessRunOptions.runInvestigation) when the supervisor
    * decides the run is stuck for lack of a fact.
    *
@@ -3692,12 +4102,6 @@ ${content}`.slice(0, 800), tool: "read_file", reliability: "MEDIUM" });
     return findings;
   }
 }
-function previewContent(content, maxLines = 20) {
-  const lines = content.split("\n");
-  if (lines.length <= maxLines) return content;
-  return `${lines.slice(0, maxLines).join("\n")}
-… (truncated)`;
-}
 class ActionApprovalService {
   constructor(memory, llmClient, model, fileTools, shellTools, actionTools, session, agentLoop, onTrace, onDebugLog) {
     this.memory = memory;
@@ -3829,19 +4233,27 @@ ${reply.slice(0, 4e3)}${reply.length > 4e3 ? `
   async loadChainedApproval(backend, workspaceRoot, nextPendingActionId, previousOutcome) {
     const next = await loadPendingAction(backend, workspaceRoot, nextPendingActionId);
     if (!next) return void 0;
-    const reason = next.kind === "write" ? `${previousOutcome}
+    let reason;
+    if (next.kind === "write") {
+      const previousContent = await readCurrentFileContent(backend, workspaceRoot, next.path);
+      reason = `${previousOutcome}
 
 Next, it also proposes writing to "${next.path}":
-${previewContent(next.content)}` : next.kind === "shell" ? `${previousOutcome}
+${formatWriteDiff(previousContent, next.content)}`;
+    } else if (next.kind === "shell") {
+      reason = `${previousOutcome}
 
 Next, it also proposes running: ${next.command}
-  (cwd: ${next.cwd})` : next.kind === "email" ? `${previousOutcome}
+  (cwd: ${next.cwd})`;
+    } else if (next.kind === "email") {
+      reason = `${previousOutcome}
 
 Next, it also proposes sending an email:
   To: ${next.to}
   Subject: ${next.subject}
 
-${previewContent(next.body)}` : void 0;
+${previewContent(next.body)}`;
+    }
     if (!reason) return void 0;
     return {
       status: "needs_approval",
@@ -4060,7 +4472,7 @@ function matchTaskCancelAttempt(message, plan) {
   const lower = message.toLowerCase();
   for (const task of plan.tasks) {
     if (task.status === "COMPLETE" || task.cancelled) continue;
-    const words = tokenize(`${task.id} ${task.description}`.toLowerCase()).filter(
+    const words = tokenize$1(`${task.id} ${task.description}`.toLowerCase()).filter(
       (w) => !CANCEL_MATCH_STOPWORDS.has(w) && (containsCJK(w) || w.length >= 4)
     );
     if (words.some((w) => lower.includes(w))) {
@@ -6006,7 +6418,7 @@ class HarnessBridge {
         // task-graph *shape* (visible in stepsUsed/nodeExecutionOrder), not the number of
         // distinct replies produced.
         //
-        // R2 of plans/harness_d2_one_loop_rewire_plan.html: flag-OFF (the default) and flag-ON
+        // R2 of the internal plan: flag-OFF (the default) and flag-ON
         // with no caller-supplied proposer are byte-identical to the line above — `() =>
         // draftReply` — satisfying INV-19. Flag-ON with a real oneLoopProposer swaps it in as the
         // 'default' toolExecutor instead, read once per turn right here.
@@ -6043,7 +6455,7 @@ class HarnessBridge {
         // Trajectory Supervisor decider (S5) — the single stall-edge LLM call. Flag-gated on
         // HARNESS_TRAJECTORY_SUPERVISOR (default OFF); when off, the harness never consults it
         // and the whole supervisor path stays inert (INV-22). The harness itself only calls this
-        // inside its own cannotMakeProgress() branch. Twin of planner_api.py's _run_planner gate.
+        // inside its own cannotMakeProgress() branch. Twin of the planner driver's _run_planner gate.
         supervisorDecider: supervisorEnabled() ? (digest) => decideSupervisorDirective(digest, this.llmClient, this.model(), onUsage) : void 0,
         onSupervisorDirective: (directive) => {
           var _a2;
@@ -6328,7 +6740,7 @@ class AskClarificationService {
         sessionId,
         userMessage: answerText,
         facts: staged.facts,
-        // Phase 4 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html — same
+        // Phase 4 of the internal plan — same
         // reasoning as assistant.ts's own call site: buildSuccessResult below runs recordFacts()
         // with this same (sessionId, answerText, staged.classification.statesDurableFacts) triple,
         // so this stays consistent with what actually gets written to the fact stores this turn.
@@ -6539,7 +6951,7 @@ class PersonalAssistant {
     __publicField(this, "dangerouslySkipPermissions");
     /** Whenever any of fileTools/webTools/shellTools is configured, `turn()` routes through AgentLoop instead of a single plain chat call — computed once here since it never changes for the lifetime of an instance. */
     __publicField(this, "toolLoopWillRun");
-    /** R3 of plans/harness_d2_one_loop_rewire_plan.html — mirrors the same flag HarnessBridge was given at construction, kept here too so runTurn can decide whether to defer the tool loop into a harness-driven proposer instead of precomputing draftReply. See PersonalAssistantOptions.oneLoopMode's doc comment. */
+    /** R3 of the internal plan — mirrors the same flag HarnessBridge was given at construction, kept here too so runTurn can decide whether to defer the tool loop into a harness-driven proposer instead of precomputing draftReply. See PersonalAssistantOptions.oneLoopMode's doc comment. */
     __publicField(this, "oneLoopMode");
     /** Q2 — global-flag tier of the ask-question mechanism's three-tier INV-29 resolution. See PersonalAssistantOptions.askMode's doc comment. */
     __publicField(this, "askMode");
@@ -6550,7 +6962,7 @@ class PersonalAssistant {
      * AssistantTurnResult.proposerKind, and emitted as a 'proposer_selected' trace event from
      * runTurn itself. A single mutable field is safe because `turn()` is awaited end to end (turns
      * never overlap within one instance). See AssistantTurnResult.proposerKind and
-     * plans/chat_ui_browser_e2e_plan.html phase B1.
+     * the internal plan phase B1.
      */
     __publicField(this, "lastProposerKind", "posthoc");
     __publicField(this, "memoryService");
@@ -6708,7 +7120,7 @@ class PersonalAssistant {
     return this.session.clearSession(sessionId);
   }
   /**
-   * P1 of plans/ask_question_and_plan_mode_plan.html — explicit entry point into plan mode's
+   * P1 of the internal plan — explicit entry point into plan mode's
    * exclusive drafting state. No production caller yet: P3 will later set this automatically from
    * a judgment-based trigger ahead of TurnInterpreter's classification. Until then this is reached
    * only by a caller (a future `/plan` CLI command, or a test) that wants to exercise the drafting
@@ -6720,7 +7132,7 @@ class PersonalAssistant {
     return this.session.enterPlanMode(sessionId);
   }
   /**
-   * P7 of plans/ask_question_and_plan_mode_plan.html — the raw current `PlanRecord` for this
+   * P7 of the internal plan — the raw current `PlanRecord` for this
    * session, regardless of `mode`, so a caller (chat-ui's persistent banner, the CLI's `/plan
    * show`) can display live drafting/awaiting-approval state independent of any single turn's
    * own result (a `needs_plan_approval` result only carries a snapshot at the moment it's
@@ -6731,7 +7143,7 @@ class PersonalAssistant {
     return this.planService.loadPlanRecord(sessionId);
   }
   /**
-   * P9 of plans/ask_question_and_plan_mode_plan.html — the lightweight plan-sketch delegate: a
+   * P9 of the internal plan — the lightweight plan-sketch delegate: a
    * cheaper "just go research and draft an approach" path than plan mode's durable task-graph
    * machinery (P0-P8), explicitly invoked (a CLI `/plan sketch <request>` command, a chat-ui
    * "Sketch a plan" action) rather than auto-triggered. Returns advice in the reply text — it
@@ -6785,7 +7197,7 @@ class PersonalAssistant {
   /**
    * `/memory confirm <n|category>` — `selector` is either a 1-based index into `/memory`'s
    * flat, display-order "Pending confirmation" listing, or one of FactCategory's names for a
-   * bulk confirm. Phase 3 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html.
+   * bulk confirm. Phase 3 of the internal plan.
    * `conflictNotices` (if any) are advisory only — every confirmed fact is promoted regardless,
    * matching how every other contradiction check in this codebase never gates belief admission.
    */
@@ -7009,7 +7421,7 @@ class PersonalAssistant {
         sessionId,
         userMessage,
         facts,
-        // Phase 4 of plans/personal_assistant_fact_extraction_llm_confidence_plan.html: the same
+        // Phase 4 of the internal plan: the same
         // merged lexical+LLM list recordFacts() (called later, in responseService's build*Result)
         // derives its writes from — computed independently here (both calls are pure given the
         // same sessionId/userMessage/statedFacts) so the harness's World Model sees a same-turn
@@ -7088,7 +7500,7 @@ class PersonalAssistant {
   /**
    * Shared by the flag-OFF flat/batch tool loop's own needs_approval/escalated ToolLoopResult and
    * the flag-ON harness-driven proposer's equivalent OneLoopPause (R3 of
-   * plans/harness_d2_one_loop_rewire_plan.html, see runTurn's two call sites) — "the model wants
+   * the internal plan, see runTurn's two call sites) — "the model wants
    * to write/run/send something" or "the tool loop gave up" means the same thing to the caller
    * regardless of which loop discovered it.
    */
@@ -7363,6 +7775,7 @@ const CONFIG_KEYS = [
   "askMode",
   "planMode",
   "tuiMode",
+  "updateCheck",
   "activeProject"
 ];
 const DEFAULT_CONFIG = {
@@ -7430,6 +7843,16 @@ function resolveTuiMode(env) {
 function shouldLaunchTuiApp(tuiMode, stdoutIsTty, stdinIsTty) {
   return tuiMode === "enabled" && stdoutIsTty && stdinIsTty;
 }
+const DEFAULT_UPDATE_CHECK_MODE = "enabled";
+function normalizeUpdateCheckMode(raw, varName = "ASSISTANT_UPDATE_CHECK") {
+  if (raw === void 0 || raw === "") return DEFAULT_UPDATE_CHECK_MODE;
+  if (raw === "enabled" || raw === "disabled") return raw;
+  console.error(`[warning] ${varName}="${raw}" is not "enabled" or "disabled" — using the default (${DEFAULT_UPDATE_CHECK_MODE}).`);
+  return DEFAULT_UPDATE_CHECK_MODE;
+}
+function resolveUpdateCheckMode(env) {
+  return normalizeUpdateCheckMode(env.ASSISTANT_UPDATE_CHECK);
+}
 const SECRET_CONFIG_KEYS = /* @__PURE__ */ new Set(["authToken", "apiKey", "braveApiKey"]);
 const ENV_VAR_FOR_CONFIG_KEY = {
   llmBackend: "ASSISTANT_LLM_BACKEND",
@@ -7458,6 +7881,7 @@ const ENV_VAR_FOR_CONFIG_KEY = {
   askMode: "ASSISTANT_ASK_MODE",
   planMode: "ASSISTANT_PLAN_MODE",
   tuiMode: "ASSISTANT_TUI",
+  updateCheck: "ASSISTANT_UPDATE_CHECK",
   activeProject: "ASSISTANT_ACTIVE_PROJECT"
 };
 function isConfigKey(key) {
@@ -7505,6 +7929,7 @@ function envOverridesFromProcessEnv(env) {
   if (env.ASSISTANT_ASK_MODE !== void 0) overrides.askMode = resolveAskMode(env);
   if (env.ASSISTANT_PLAN_MODE !== void 0) overrides.planMode = resolvePlanMode(env);
   if (env.ASSISTANT_TUI !== void 0) overrides.tuiMode = resolveTuiMode(env);
+  if (env.ASSISTANT_UPDATE_CHECK !== void 0) overrides.updateCheck = resolveUpdateCheckMode(env);
   if (env.ASSISTANT_ACTIVE_PROJECT !== void 0) overrides.activeProject = env.ASSISTANT_ACTIVE_PROJECT;
   return overrides;
 }
@@ -7560,6 +7985,9 @@ function parseConfigValue(key, raw) {
     case "tuiMode":
       if (raw !== "enabled" && raw !== "disabled") throw new ConfigValueParseError('tuiMode must be "enabled" or "disabled"');
       return raw;
+    case "updateCheck":
+      if (raw !== "enabled" && raw !== "disabled") throw new ConfigValueParseError('updateCheck must be "enabled" or "disabled"');
+      return raw;
     default:
       return raw;
   }
@@ -7761,103 +8189,104 @@ function formatDoctorReport(checks) {
   return checks.map((c) => `  ${c.ok ? "✓" : "✗"} ${c.label}${!c.ok && c.detail ? ` — ${c.detail}` : ""}`).join("\n");
 }
 export {
-  formatConfigListing as $,
+  executeWebTool as $,
   ACTION_TOOLS as A,
-  classifyToolYield as B,
+  classifyRisk as B,
   CONFIG_KEYS as C,
   DEFAULT_ASK_MODE as D,
   ENV_VAR_FOR_CONFIG_KEY as E,
   FETCH_URL_TOOL as F,
-  classifyTurnIntent as G,
-  computePlanPosition as H,
+  classifyToolYield as G,
+  classifyTurnIntent as H,
   InvalidEmailArgsError as I,
-  createPlanRecord as J,
-  createResendSender as K,
+  computePlanPosition as J,
+  createPlanRecord as K,
   LAYER_DISPLAY_NAME as L,
-  createSmtpSender as M,
-  defaultExportFilename as N,
-  defaultMemoryExportFilename as O,
+  createResendSender as M,
+  createSmtpSender as N,
+  defaultExportFilename as O,
   PathOutsideWorkspaceError as P,
-  detectHomogeneousBatchList as Q,
+  defaultMemoryExportFilename as Q,
   READ_FILE_TOOL as R,
   SEND_EMAIL_TOOL as S,
-  discardPendingAction as T,
-  envOverridesFromProcessEnv as U,
-  estimateCostUsd as V,
+  detectHomogeneousBatchList as T,
+  discardPendingAction as U,
+  envOverridesFromProcessEnv as V,
   WEB_SEARCH_TOOL as W,
-  executeActionTool as X,
-  executeFileTool as Y,
-  executeShellTool as Z,
-  executeWebTool as _,
+  estimateCostUsd as X,
+  executeActionTool as Y,
+  executeFileTool as Z,
+  executeShellTool as _,
   ALREADY_STAGED_ACTION_TOOL as a,
-  formatCostSummary as a0,
-  formatDoctorReport as a1,
-  formatEmailApprovalReason as a2,
-  formatHelp as a3,
-  formatMemoryExport as a4,
-  formatMemoryPendingOutcome as a5,
-  formatMemorySummary as a6,
-  formatPlanProgress as a7,
-  formatSearchResults as a8,
-  formatSpendCapStatus as a9,
-  shouldLaunchTuiApp as aA,
-  stagePendingAction as aB,
-  stagedActionInput as aC,
-  stripJsonCodeFence as aD,
-  stripMcpToolPrefix as aE,
-  summarizeToolStep as aF,
-  updatePlanFromRun as aG,
-  validateConfig as aH,
-  formatStatus as aa,
-  formatTranscriptMarkdown as ab,
-  formatUndoLogListing as ac,
-  isConfigKey as ad,
-  isLikelyEmailAddress as ae,
-  listTemplateNames as af,
-  loadActivePlan as ag,
-  loadPendingAction as ah,
-  loadTemplate as ai,
-  matchTemplateIfConfident as aj,
-  nextPendingTask as ak,
-  nodeDisplayName as al,
-  nodeToLayer as am,
-  normalizeAskMode as an,
-  normalizeOneLoopMode as ao,
-  normalizePlanMode as ap,
-  parseClaudeCliOutput as aq,
-  parseConfigValue as ar,
-  pickTemplateForTask as as,
-  planCompletionPct as at,
-  resolveAskMode as au,
-  resolveConfig as av,
-  resolveInWorkspace as aw,
-  resolveOneLoopMode as ax,
-  resolvePlanMode as ay,
-  savePlan as az,
+  formatConfigListing as a0,
+  formatCostSummary as a1,
+  formatDoctorReport as a2,
+  formatEmailApprovalReason as a3,
+  formatHelp as a4,
+  formatMemoryExport as a5,
+  formatMemoryPendingOutcome as a6,
+  formatMemorySummary as a7,
+  formatPlanProgress as a8,
+  formatSearchResults as a9,
+  savePlan as aA,
+  shouldLaunchTuiApp as aB,
+  stagePendingAction as aC,
+  stagedActionInput as aD,
+  stripJsonCodeFence as aE,
+  stripMcpToolPrefix as aF,
+  summarizeToolStep as aG,
+  updatePlanFromRun as aH,
+  validateConfig as aI,
+  formatSpendCapStatus as aa,
+  formatStatus as ab,
+  formatTranscriptMarkdown as ac,
+  formatUndoLogListing as ad,
+  isConfigKey as ae,
+  isLikelyEmailAddress as af,
+  listTemplateNames as ag,
+  loadActivePlan as ah,
+  loadPendingAction as ai,
+  loadTemplate as aj,
+  matchTemplateIfConfident as ak,
+  nextPendingTask as al,
+  nodeDisplayName as am,
+  nodeToLayer as an,
+  normalizeAskMode as ao,
+  normalizeOneLoopMode as ap,
+  normalizePlanMode as aq,
+  parseClaudeCliOutput as ar,
+  parseConfigValue as as,
+  pickTemplateForTask as at,
+  planCompletionPct as au,
+  resolveAskMode as av,
+  resolveConfig as aw,
+  resolveInWorkspace as ax,
+  resolveOneLoopMode as ay,
+  resolvePlanMode as az,
   AskClarificationService as b,
   ConfigValidationError as c,
   ConfigValueParseError as d,
   DEFAULT_CONFIG as e,
   DEFAULT_ONE_LOOP_MODE as f,
   DEFAULT_PLAN_MODE as g,
-  EmailDeliveryError as h,
-  FILE_TOOLS as i,
-  LAYER_ORDER as j,
-  LAYER_SHORT_CODE as k,
-  LIST_DIRECTORY_TOOL as l,
-  PersonalAssistant as m,
-  PrivateNetworkTargetError as n,
-  RUN_SHELL_COMMAND_TOOL as o,
-  SHELL_TOOLS as p,
-  WEB_TOOLS as q,
-  WRITE_FILE_TOOL as r,
-  abandonPlan as s,
-  applyPendingAction as t,
-  assertPublicHttpUrl as u,
-  braveSearch as v,
-  buildClaudePrompt as w,
-  buildWhyChain as x,
-  classifyError as y,
-  classifyRisk as z
+  DIFF_INDENT as h,
+  EmailDeliveryError as i,
+  FILE_TOOLS as j,
+  LAYER_ORDER as k,
+  LAYER_SHORT_CODE as l,
+  LIST_DIRECTORY_TOOL as m,
+  PersonalAssistant as n,
+  PrivateNetworkTargetError as o,
+  RUN_SHELL_COMMAND_TOOL as p,
+  SHELL_TOOLS as q,
+  WEB_TOOLS as r,
+  WRITE_FILE_TOOL as s,
+  abandonPlan as t,
+  applyPendingAction as u,
+  assertPublicHttpUrl as v,
+  braveSearch as w,
+  buildClaudePrompt as x,
+  buildWhyChain as y,
+  classifyError as z
 };
-//# sourceMappingURL=cli-session-D0uLdT2A.js.map
+//# sourceMappingURL=cli-session-BiX2DOni.js.map