reasonix 0.40.0 → 0.41.0

package/dist/index.js

@@ -773,6 +773,42 @@ var DEFAULT_INDEX_EXCLUDES = {
 var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
 
 // src/config.ts
+var BUILTIN_TYPE_DOCS = {
+  user: "role / skills / preferences",
+  feedback: "corrections or confirmed approaches",
+  project: "facts / decisions about the current work",
+  reference: "pointers to external systems the user uses"
+};
+function loadMemoryTypeRegistry(cfg = readConfig()) {
+  const out = [];
+  for (const name of ["user", "feedback", "project", "reference"]) {
+    out.push({ name, builtin: true, description: BUILTIN_TYPE_DOCS[name] });
+  }
+  const seen = new Set(out.map((e) => e.name));
+  for (const raw of cfg.memory?.customTypes ?? []) {
+    if (!raw || typeof raw.name !== "string") continue;
+    const name = raw.name.trim();
+    if (!name || !/^[a-zA-Z][a-zA-Z0-9_-]{0,31}$/.test(name)) continue;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const entry = { name, builtin: false };
+    if (typeof raw.description === "string") entry.description = raw.description;
+    if (raw.priority === "low" || raw.priority === "medium" || raw.priority === "high") {
+      entry.priority = raw.priority;
+    }
+    if (raw.expires === "project_end") entry.expires = raw.expires;
+    out.push(entry);
+  }
+  return out;
+}
+function memoryTypeDefaults(typeName, cfg = readConfig()) {
+  const found = loadMemoryTypeRegistry(cfg).find((e) => e.name === typeName);
+  if (!found) return {};
+  const out = {};
+  if (found.priority) out.priority = found.priority;
+  if (found.expires) out.expires = found.expires;
+  return out;
+}
 function defaultConfigPath() {
   return join(homedir(), ".reasonix", "config.json");
 }
@@ -891,7 +927,10 @@ var EN = {
     cancel: "Cancel",
     confirm: "Confirm",
     back: "Back",
-    next: "Next"
+    next: "Next",
+    tool: "tool",
+    running: "running",
+    noTurns: "(no turns yet)"
   },
   cli: {
     description: "DeepSeek-native agent framework \u2014 built for cache hits and cheap tokens.",
@@ -1363,9 +1402,18 @@ var EN = {
       counterDone: "{done}/{total} done ({pct}%) \xB7 {total} steps",
       counterDoneSingular: "{done}/{total} done ({pct}%) \xB7 {total} step"
     },
+    noPlanSummary: "No plan body submitted yet.",
+    detailCollapsedHint: "Ctrl+P expands full plan details.",
+    detailExpandedHint: "Ctrl+P collapses details.",
+    detailHeader: "Plan details",
+    detailWindow: "showing lines {start}-{end} of {total}",
+    detailScrollHint: "PgUp/PgDn scroll details \xB7 Home/End jump",
     reviseTitle: "Revise plan",
     reviseSteps: "{count} steps",
-    reviseFooter: "\u2191\u2193 focus  \xB7  space toggle skip  \xB7  k/j move  \xB7  \u23CE accept  \xB7  esc cancel"
+    reviseFooter: "\u2191\u2193 focus  \xB7  space toggle skip  \xB7  k/j move  \xB7  \u23CE accept  \xB7  esc cancel",
+    riskMed: " med",
+    riskHigh: " high",
+    completeMsg: "\u25B8 plan complete \u2014 all {total} step{s} done \xB7 archived"
   },
   app: {
     walkCancelledRemaining: "\u25B8 walk cancelled \u2014 {count} block(s) still pending.",
@@ -1385,6 +1433,9 @@ var EN = {
     notedVerbAppended: "appended to",
     memoryWriteFailed: "# memory write failed",
     commandFailed: "! command failed",
+    btwUsage: "\u25B8 /btw <question> \u2014 ask a side question without polluting the conversation context.",
+    btwHeader: "\u226B btw",
+    btwFailed: "/btw failed",
     restoreCodeOnly: "\u25B8 /restore is code-mode only",
     hookUserPromptSubmit: "UserPromptSubmit hook",
     hookStop: "Stop hook",
@@ -1427,6 +1478,7 @@ var EN = {
     flashEscalation: "\u21E7 flash requested escalation \u2014 retrying this turn on {model}{reasonSuffix}",
     harvestStatus: "extracting plan state from reasoning\u2026",
     autoEscalation: "\u21E7 auto-escalating to {model} for the rest of this turn \u2014 flash hit {breakdown}. Next turn falls back to {fallback} unless /pro is armed.",
+    readOnlyLoopEscalation: "\u21E7 auto-escalating to {model} \u2014 flash made {n} consecutive read-only calls without producing an edit or final answer. Next turn falls back to {fallback} unless /pro is armed.",
     repeatToolCallWarning: "Caught a repeated tool call \u2014 let the model see the issue and retry with a different approach.",
     stormStuck: "Stopped a stuck retry loop \u2014 the model kept calling the same tool with identical args after a self-correction nudge. Try /retry, rephrase, or rule out the underlying blocker.",
     stormSuppressed: "Suppressed {count} repeated tool call(s) \u2014 same name + args fired 3+ times.",
@@ -1462,6 +1514,7 @@ var EN = {
     basic: {
       newInfo: "\u25B8 new conversation \u2014 dropped {count} message(s) from context. Same session, fresh slate.",
       newInfoArchived: '\u25B8 new conversation \u2014 dropped {count} message(s) from context. Prior transcript archived as "{archived}" (visible under Sessions).',
+      newInfoSystemReloaded: " \xB7 REASONIX.md / project memory reloaded (next turn pays one cache miss)",
       helpTitle: "Commands:",
       helpShellTitle: "Shell shortcut:",
       helpShell: "  !<cmd>                   run <cmd> in the sandbox root; output goes into",
@@ -2113,7 +2166,8 @@ var EN = {
     healthy: "healthy \xB7 {ms}ms",
     slow: "slow \xB7 {ms}ms",
     verySlow: "very slow \xB7 {ms}ms",
-    slowToast: "\u26A0 MCP `{name}` slow \xB7 {seconds}s p95 over the last {sampleSize} calls"
+    slowToast: "\u26A0 MCP `{name}` slow \xB7 {seconds}s p95 over the last {sampleSize} calls",
+    emptyHint: "\u2139 no MCP servers configured \u2014 try: `reasonix setup` to re-pick, or `reasonix mcp install filesystem`"
   },
   denyContextInput: {
     description: "Tell the agent why you denied this. The next attempt will see your reason as additional context."
@@ -2237,7 +2291,10 @@ var zhCN = {
     cancel: "\u53D6\u6D88",
     confirm: "\u786E\u8BA4",
     back: "\u8FD4\u56DE",
-    next: "\u4E0B\u4E00\u6B65"
+    next: "\u4E0B\u4E00\u6B65",
+    tool: "\u5DE5\u5177",
+    running: "\u8FD0\u884C\u4E2D",
+    noTurns: "(\u6682\u65E0\u5BF9\u8BDD)"
   },
   cli: {
     description: "DeepSeek \u539F\u751F\u667A\u80FD\u4F53\u6846\u67B6 \u2014 \u4E13\u4E3A\u7F13\u5B58\u547D\u4E2D\u548C\u4F4E\u6210\u672C\u4EE4\u724C\u6784\u5EFA\u3002",
@@ -2710,9 +2767,18 @@ var zhCN = {
       counterDone: "{done}/{total} \u5DF2\u5B8C\u6210\uFF08{pct}%\uFF09 \xB7 \u5171 {total} \u6B65",
       counterDoneSingular: "{done}/{total} \u5DF2\u5B8C\u6210\uFF08{pct}%\uFF09 \xB7 \u5171 {total} \u6B65"
     },
+    noPlanSummary: "\u5C1A\u672A\u63D0\u4EA4\u8BA1\u5212\u5185\u5BB9\u3002",
+    detailCollapsedHint: "Ctrl+P \u5C55\u5F00\u5B8C\u6574\u8BA1\u5212\u8BE6\u60C5\u3002",
+    detailExpandedHint: "Ctrl+P \u6536\u8D77\u8BE6\u60C5\u3002",
+    detailHeader: "\u8BA1\u5212\u8BE6\u60C5",
+    detailWindow: "\u663E\u793A\u7B2C {start}-{end} \u884C\uFF0C\u5171 {total} \u884C",
+    detailScrollHint: "PgUp/PgDn \u6EDA\u52A8\u8BE6\u60C5 \xB7 Home/End \u8DF3\u8F6C",
     reviseTitle: "\u4FEE\u6539\u8BA1\u5212",
     reviseSteps: "{count} \u4E2A\u6B65\u9AA4",
-    reviseFooter: "\u2191\u2193 \u7126\u70B9  \xB7  \u7A7A\u683C\u5207\u6362\u8DF3\u8FC7  \xB7  k/j \u79FB\u52A8  \xB7  \u23CE \u786E\u8BA4  \xB7  Esc \u53D6\u6D88"
+    reviseFooter: "\u2191\u2193 \u7126\u70B9  \xB7  \u7A7A\u683C\u5207\u6362\u8DF3\u8FC7  \xB7  k/j \u79FB\u52A8  \xB7  \u23CE \u786E\u8BA4  \xB7  Esc \u53D6\u6D88",
+    riskMed: " \u4E2D",
+    riskHigh: " \u9AD8",
+    completeMsg: "\u25B8 \u8BA1\u5212\u5B8C\u6210 \u2014 \u5168\u90E8 {total} \u4E2A\u6B65\u9AA4\u5DF2\u5B8C\u6210 \xB7 \u5DF2\u5F52\u6863"
   },
   app: {
     walkCancelledRemaining: "\u25B8 \u6D4F\u89C8\u5DF2\u53D6\u6D88 \u2014 \u8FD8\u6709 {count} \u4E2A\u5F85\u5904\u7406\u7F16\u8F91\u5757\u3002",
@@ -2732,6 +2798,9 @@ var zhCN = {
     notedVerbAppended: "\u8FFD\u52A0\u5230",
     memoryWriteFailed: "# \u8BB0\u5FC6\u5199\u5165\u5931\u8D25",
     commandFailed: "! \u547D\u4EE4\u5931\u8D25",
+    btwUsage: "\u25B8 /btw <\u95EE\u9898> \u2014 \u987A\u4FBF\u95EE\u4E2A\u9898\u5916\u8BDD\uFF0C\u4E0D\u4F1A\u5199\u5165\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002",
+    btwHeader: "\u226B btw",
+    btwFailed: "/btw \u8C03\u7528\u5931\u8D25",
     restoreCodeOnly: "\u25B8 /restore \u4EC5\u5728\u4EE3\u7801\u6A21\u5F0F\u53EF\u7528",
     hookUserPromptSubmit: "UserPromptSubmit \u94A9\u5B50",
     hookStop: "Stop \u94A9\u5B50",
@@ -2774,6 +2843,7 @@ var zhCN = {
     flashEscalation: "\u21E7 flash \u8BF7\u6C42\u5347\u7EA7 \u2014 \u672C\u8F6E\u6539\u7528 {model}{reasonSuffix}",
     harvestStatus: "\u6B63\u5728\u4ECE\u63A8\u7406\u8FC7\u7A0B\u63D0\u53D6\u8BA1\u5212\u72B6\u6001\u2026",
     autoEscalation: "\u21E7 \u672C\u8F6E\u5269\u4F59\u8C03\u7528\u81EA\u52A8\u5347\u7EA7\u5230 {model} \u2014 flash \u547D\u4E2D {breakdown}\u3002\u4E0B\u4E00\u8F6E\u56DE\u9000\u5230 {fallback}\uFF0C\u9664\u975E\u5DF2\u88C5\u5907 /pro\u3002",
+    readOnlyLoopEscalation: "\u21E7 \u81EA\u52A8\u5347\u7EA7\u5230 {model} \u2014 flash \u8FDE\u7EED {n} \u6B21\u53EA\u8BFB\u8C03\u7528\uFF0C\u672A\u4EA7\u51FA\u4FEE\u6539\u6216\u6700\u7EC8\u7B54\u6848\u3002\u4E0B\u4E00\u8F6E\u56DE\u9000\u5230 {fallback}\uFF0C\u9664\u975E\u5DF2\u88C5\u5907 /pro\u3002",
     repeatToolCallWarning: "\u62E6\u622A\u5230\u91CD\u590D\u5DE5\u5177\u8C03\u7528 \u2014 \u8BA9\u6A21\u578B\u5BDF\u89C9\u95EE\u9898\u5E76\u6362\u79CD\u65B9\u5F0F\u91CD\u8BD5\u3002",
     stormStuck: "\u5DF2\u505C\u6B62\u5361\u6B7B\u7684\u91CD\u8BD5\u5FAA\u73AF \u2014 \u6A21\u578B\u5728\u81EA\u7EA0\u63D0\u793A\u540E\u4ECD\u4EE5\u76F8\u540C\u53C2\u6570\u91CD\u590D\u8C03\u7528\u540C\u4E00\u5DE5\u5177\u3002\u8BF7\u5C1D\u8BD5 /retry\u3001\u6362\u79CD\u8BF4\u6CD5\uFF0C\u6216\u6392\u67E5\u5E95\u5C42\u963B\u585E\u3002",
     stormSuppressed: "\u5DF2\u6291\u5236 {count} \u6B21\u91CD\u590D\u5DE5\u5177\u8C03\u7528 \u2014 \u540C\u4E00\u540D\u79F0 + \u53C2\u6570\u89E6\u53D1 3 \u6B21\u4EE5\u4E0A\u3002",
@@ -2809,6 +2879,7 @@ var zhCN = {
     basic: {
       newInfo: "\u25B8 \u65B0\u5BF9\u8BDD \u2014 \u5DF2\u4ECE\u4E0A\u4E0B\u6587\u4E2D\u4E22\u5F03 {count} \u6761\u6D88\u606F\u3002\u540C\u4E00\u4F1A\u8BDD\uFF0C\u5168\u65B0\u5F00\u59CB\u3002",
       newInfoArchived: "\u25B8 \u65B0\u5BF9\u8BDD \u2014 \u5DF2\u4ECE\u4E0A\u4E0B\u6587\u4E2D\u4E22\u5F03 {count} \u6761\u6D88\u606F\u3002\u539F\u5BF9\u8BDD\u5DF2\u5F52\u6863\u4E3A\u300C{archived}\u300D\uFF0C\u53EF\u5728 Sessions \u9762\u677F\u67E5\u770B\u3002",
+      newInfoSystemReloaded: " \xB7 REASONIX.md / \u9879\u76EE\u8BB0\u5FC6\u5DF2\u91CD\u65B0\u52A0\u8F7D\uFF08\u4E0B\u4E00\u8F6E\u4E00\u6B21\u6027 cache miss\uFF09",
       helpTitle: "\u547D\u4EE4\uFF1A",
       helpShellTitle: "Shell \u5FEB\u6377\u65B9\u5F0F\uFF1A",
       helpShell: "  !<cmd>                   \u5728\u6C99\u7BB1\u6839\u76EE\u5F55\u8FD0\u884C <cmd>\uFF1B\u8F93\u51FA\u8FDB\u5165\u5BF9\u8BDD",
@@ -3460,7 +3531,8 @@ var zhCN = {
     healthy: "\u6B63\u5E38 \xB7 {ms}ms",
     slow: "\u7F13\u6162 \xB7 {ms}ms",
     verySlow: "\u975E\u5E38\u6162 \xB7 {ms}ms",
-    slowToast: "\u26A0 MCP `{name}` \u54CD\u5E94\u7F13\u6162 \xB7 P95 {seconds}s \xB7 \u6700\u8FD1 {sampleSize} \u6B21\u8C03\u7528"
+    slowToast: "\u26A0 MCP `{name}` \u54CD\u5E94\u7F13\u6162 \xB7 P95 {seconds}s \xB7 \u6700\u8FD1 {sampleSize} \u6B21\u8C03\u7528",
+    emptyHint: "\u2139 \u672A\u914D\u7F6E MCP \u670D\u52A1\u5668 \u2014\u2014 \u53EF\u5C1D\u8BD5\uFF1A`reasonix setup` \u91CD\u65B0\u9009\u62E9\uFF0C\u6216 `reasonix mcp install filesystem`"
   },
   denyContextInput: {
     description: "\u544A\u8BC9\u6A21\u578B\u4F60\u4E3A\u4EC0\u4E48\u62D2\u7EDD\u4E86\u3002\u6A21\u578B\u4E0B\u6B21\u4F1A\u770B\u5230\u4F60\u7684\u7406\u7531\u4F5C\u4E3A\u989D\u5916\u7684\u4E0A\u4E0B\u6587\u3002"
@@ -5184,6 +5256,10 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
 }
 
 // src/loop/healing.ts
+var _stampSeq = 0;
+function stampMissingIds(calls) {
+  return calls.map((c) => c.id ? c : { ...c, id: `z-ext-${Date.now()}-${_stampSeq++}` });
+}
 function fixToolCallPairing(messages) {
   const out = [];
   let droppedAssistantCalls = 0;
@@ -5191,9 +5267,10 @@ function fixToolCallPairing(messages) {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
     if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+      const calls = stampMissingIds(msg.tool_calls);
       const needed = /* @__PURE__ */ new Set();
-      for (const call of msg.tool_calls) {
-        if (call?.id) needed.add(call.id);
+      for (const call of calls) {
+        if (call.id) needed.add(call.id);
       }
       const candidates = [];
       let j = i + 1;
@@ -5207,7 +5284,7 @@ function fixToolCallPairing(messages) {
         j++;
       }
       if (needed.size === 0) {
-        out.push(msg);
+        out.push({ ...msg, tool_calls: calls });
         for (const r of candidates) out.push(r);
         i = j - 1;
       } else {
@@ -5271,6 +5348,32 @@ function* hookWarnings(outcomes, turn) {
   }
 }
 
+// src/loop/read-only-loop-tracker.ts
+var READONLY_LOOP_ESCALATION_THRESHOLD = 8;
+var ReadOnlyLoopTracker = class {
+  streak = 0;
+  threshold;
+  constructor(threshold = READONLY_LOOP_ESCALATION_THRESHOLD) {
+    this.threshold = Math.max(1, threshold);
+  }
+  reset() {
+    this.streak = 0;
+  }
+  /** True ONLY on the call where the streak crosses the configured threshold. */
+  noteAndCrossedThreshold(isReadOnly) {
+    if (!isReadOnly) {
+      this.streak = 0;
+      return false;
+    }
+    const before = this.streak;
+    this.streak += 1;
+    return before < this.threshold && this.streak >= this.threshold;
+  }
+  get currentStreak() {
+    return this.streak;
+  }
+};
+
 // src/loop/turn-failure-tracker.ts
 var FAILURE_ESCALATION_THRESHOLD = 3;
 var TurnFailureTracker = class {
@@ -5310,17 +5413,25 @@ var TurnFailureTracker = class {
 // src/memory/runtime.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
+  /** Stable across turns; rebuilt only on /new when REASONIX.md changed on disk. */
   system;
   /** Each `addTool` costs one cache-miss turn — DeepSeek's prefix cache is keyed by full tool list. */
   _toolSpecs;
   fewShots;
-  /** Invalidated only via `addTool`; bypassing it leaves cache stale → fingerprint diverges from sent prefix. */
+  /** Invalidated by addTool / removeTool / replaceSystem; bypassing any of those leaves cache stale → fingerprint diverges from sent prefix. */
   _fingerprintCache = null;
   constructor(opts) {
     this.system = opts.system;
     this._toolSpecs = [...opts.toolSpecs ?? []];
     this.fewShots = Object.freeze([...opts.fewShots ?? []]);
   }
+  /** Replaces the system prompt; returns true iff the string actually changed. Caller must accept a cache miss on the next turn. */
+  replaceSystem(s) {
+    if (this.system === s) return false;
+    this.system = s;
+    this._fingerprintCache = null;
+    return true;
+  }
   get toolSpecs() {
     return this._toolSpecs;
   }
@@ -5751,6 +5862,7 @@ var CacheFirstLoop = class {
   confirmationGate;
   /** Number of messages that were pre-loaded from the session file. */
   resumedMessageCount;
+  _rebuildSystem;
   _turn = 0;
   _streamPreference;
   /** Threaded through HTTP + every tool dispatch so Esc cancels in-flight work, not after. */
@@ -5760,6 +5872,7 @@ var CacheFirstLoop = class {
   _proArmedForNextTurn = false;
   _escalateThisTurn = false;
   _turnFailures;
+  _readOnlyLoop;
   _turnSelfCorrected = false;
   _foldedThisTurn = false;
   _toolDispatchesThisStep = 0;
@@ -5782,34 +5895,18 @@ var CacheFirstLoop = class {
     this._turnFailures = new TurnFailureTracker(
       resolveFailureThreshold(opts.failureThreshold, FAILURE_ESCALATION_THRESHOLD)
     );
+    this._readOnlyLoop = new ReadOnlyLoopTracker(
+      parsePositiveIntEnv(process.env.REASONIX_READONLY_LOOP_THRESHOLD) ?? READONLY_LOOP_ESCALATION_THRESHOLD
+    );
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
     this.confirmationGate = opts.confirmationGate ?? pauseGate;
+    this._rebuildSystem = opts.rebuildSystem ?? null;
     this._streamPreference = opts.stream ?? true;
     this.stream = this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     const registry = this.tools;
-    const isMutating = (call) => {
-      const name = call.function?.name;
-      if (!name) return false;
-      const def = registry.get(name);
-      if (!def) return false;
-      if (def.readOnlyCheck) {
-        let args = {};
-        try {
-          args = JSON.parse(call.function?.arguments ?? "{}") ?? {};
-        } catch {
-        }
-        try {
-          if (def.readOnlyCheck(args)) return false;
-        } catch (err) {
-          process.stderr.write(`readOnlyCheck for ${name} threw: ${err.message}
-`);
-        }
-      }
-      return def.readOnly !== true;
-    };
     const isStormExempt = (call) => {
       const name = call.function?.name;
       if (!name) return false;
@@ -5817,7 +5914,7 @@ var CacheFirstLoop = class {
     };
     this.repair = new ToolCallRepair({
       allowedToolNames: allowedNames,
-      isMutating,
+      isMutating: (call) => this.isMutating(call),
       isStormExempt,
       stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
       stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
@@ -5910,7 +6007,7 @@ var CacheFirstLoop = class {
       }
     }
   }
-  /** "New chat" — drops in-memory messages, archives the on-disk transcript so it survives in Sessions, keeps sessionName so the prefix cache stays warm. */
+  /** "New chat" — drops in-memory messages, archives the on-disk transcript so it survives in Sessions, keeps sessionName so the prefix cache stays warm. Re-runs the system-prompt builder if one was wired (issue #778: REASONIX.md edits otherwise need a restart). */
   clearLog() {
     const dropped = this.log.length;
     this.log.compactInPlace([]);
@@ -5924,7 +6021,14 @@ var CacheFirstLoop = class {
     }
     this.scratch.reset();
     this._inflight.clear();
-    return { dropped, archived };
+    let systemRebuilt = false;
+    if (this._rebuildSystem) {
+      try {
+        systemRebuilt = this.prefix.replaceSystem(this._rebuildSystem());
+      } catch {
+      }
+    }
+    return { dropped, archived, systemRebuilt };
   }
   configure(opts) {
     if (opts.model !== void 0) this.model = opts.model;
@@ -5970,6 +6074,35 @@ var CacheFirstLoop = class {
     this._escalateThisTurn = true;
     return true;
   }
+  /** Returns true ONLY on the call where the read-only streak crosses the threshold (#681). */
+  noteReadOnlyToolCall(call) {
+    const isReadOnly = !this.isMutating(call);
+    if (!this._readOnlyLoop.noteAndCrossedThreshold(isReadOnly)) return false;
+    if (this._escalateThisTurn || !this.autoEscalate) return false;
+    this._escalateThisTurn = true;
+    return true;
+  }
+  /** A call counts as mutating when its definition reports `readOnly !== true` and any dynamic `readOnlyCheck` doesn't override that for these args. */
+  isMutating(call) {
+    const name = call.function?.name;
+    if (!name) return false;
+    const def = this.tools.get(name);
+    if (!def) return false;
+    if (def.readOnlyCheck) {
+      let args = {};
+      try {
+        args = JSON.parse(call.function?.arguments ?? "{}") ?? {};
+      } catch {
+      }
+      try {
+        if (def.readOnlyCheck(args)) return false;
+      } catch (err) {
+        process.stderr.write(`readOnlyCheck for ${name} threw: ${err.message}
+`);
+      }
+    }
+    return def.readOnly !== true;
+  }
   async runOneToolCall(call, signal) {
     const name = call.function?.name ?? "";
     const args = call.function?.arguments ?? "{}";
@@ -6090,6 +6223,7 @@ ${reason}`
     this.scratch.reset();
     this.repair.resetStorm();
     this._turnFailures.reset();
+    this._readOnlyLoop.reset();
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
@@ -6516,6 +6650,17 @@ ${reason}`
               })
             };
           }
+          if (this.noteReadOnlyToolCall(call)) {
+            yield {
+              turn: this._turn,
+              role: "warning",
+              content: t("loop.readOnlyLoopEscalation", {
+                model: ESCALATION_MODEL,
+                n: this._readOnlyLoop.currentStreak,
+                fallback: this.model
+              })
+            };
+          }
           yield {
             turn: this._turn,
             role: "tool",
@@ -6844,7 +6989,7 @@ function parseAtQuery(query) {
     trailingSlash: false
   };
 }
-var AT_PICKER_PREFIX = /(?:^|\s)@([a-zA-Z0-9_./\\-]*)$/;
+var AT_PICKER_PREFIX = /(?:^|\s)@([\p{L}\p{N}_./\\-]*)$/u;
 function detectAtPicker(input) {
   const m = AT_PICKER_PREFIX.exec(input);
   if (!m) return null;
@@ -6930,7 +7075,7 @@ function fuzzySubseqScore(needle, target) {
   const lengthPenalty = Math.floor(target.length / 4);
   return quality + lengthPenalty;
 }
-var AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
+var AT_MENTION_PATTERN = /(?<=^|\s)@([\p{L}\p{N}_./\\-]+)/gu;
 function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
   const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
@@ -7620,16 +7765,24 @@ function ensureDir(p) {
   if (!existsSync7(p)) mkdirSync4(p, { recursive: true });
 }
 function formatFrontmatter(e) {
-  return [
+  const lines = [
     "---",
     `name: ${e.name}`,
     `description: ${e.description.replace(/\n/g, " ")}`,
     `type: ${e.type}`,
     `scope: ${e.scope}`,
-    `created: ${e.createdAt}`,
-    "---",
-    ""
-  ].join("\n");
+    `created: ${e.createdAt}`
+  ];
+  if (e.priority) lines.push(`priority: ${e.priority}`);
+  if (e.expires) lines.push(`expires: ${e.expires}`);
+  lines.push("---", "");
+  return lines.join("\n");
+}
+function coercePriority(v) {
+  return v === "low" || v === "medium" || v === "high" ? v : void 0;
+}
+function coerceExpires(v) {
+  return v === "project_end" ? v : void 0;
 }
 function todayIso() {
   const d = /* @__PURE__ */ new Date();
@@ -7691,7 +7844,7 @@ var MemoryStore = class {
     }
     const raw = readFileSync9(file, "utf8");
     const { data, body } = parseFrontmatter(raw);
-    return {
+    const entry = {
       name: data.name ?? name,
       type: data.type ?? "project",
       scope: data.scope ?? scope,
@@ -7699,6 +7852,11 @@ var MemoryStore = class {
       body: body.trim(),
       createdAt: data.created ?? ""
     };
+    const priority = coercePriority(data.priority);
+    if (priority) entry.priority = priority;
+    const expires = coerceExpires(data.expires);
+    if (expires) entry.expires = expires;
+    return entry;
   }
   /** Skips malformed files — index stays queryable even if one file is hand-edited into nonsense. */
   list() {
@@ -7741,6 +7899,8 @@ var MemoryStore = class {
       body,
       createdAt: todayIso()
     };
+    if (input.priority) entry.priority = input.priority;
+    if (input.expires) entry.expires = input.expires;
     const dir = this.dir(input.scope);
     const file = join8(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
@@ -7824,13 +7984,36 @@ function applyGlobalReasonixMemory(basePrompt, homeDir) {
     "```"
   ].join("\n");
 }
+function effectivePriority(entry, cfg) {
+  if (entry.priority) return entry.priority;
+  return memoryTypeDefaults(entry.type, cfg).priority;
+}
+function highPriorityBlock(entries, cfg) {
+  const high = entries.filter((e) => effectivePriority(e, cfg) === "high");
+  if (high.length === 0) return null;
+  const lines = [
+    "# HIGH PRIORITY constraints (must observe)",
+    "",
+    "These memories were declared `priority: high` (via config.memory.customTypes or the memory file itself). Treat them as hard rules \u2014 violations override any other guidance below.",
+    ""
+  ];
+  for (const e of high) {
+    const head = `!!! [${e.scope}/${e.type}/${e.name}] ${e.description || "(no description)"}`;
+    lines.push(head);
+    if (e.body) lines.push("", e.body);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
 function applyUserMemory(basePrompt, opts = {}) {
   if (!memoryEnabled()) return basePrompt;
   const store = new MemoryStore(opts);
   const global = store.loadIndex("global");
   const project = store.hasProjectScope() ? store.loadIndex("project") : null;
-  if (!global && !project) return basePrompt;
+  const high = highPriorityBlock(store.list(), opts.cfg);
+  if (!global && !project && !high) return basePrompt;
   const parts = [basePrompt];
+  if (high) parts.push("", high);
   if (global) {
     parts.push(
       "",
@@ -7866,7 +8049,7 @@ function applyMemoryStack(basePrompt, rootDir) {
 
 // src/tools/filesystem.ts
 import { promises as fs4 } from "fs";
-import * as pathMod4 from "path";
+import * as pathMod5 from "path";
 import picomatch3 from "picomatch";
 
 // src/tools/fs/edit.ts
@@ -8088,15 +8271,149 @@ async function globFiles(ctx, startAbs, args) {
   return lines.join("\n");
 }
 
+// src/tools/fs/outline.ts
+import * as pathMod3 from "path";
+var OUTLINE_MAX_ENTRIES = 30;
+var OUTLINE_TAIL_KEEP = 5;
+var TS_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type|enum)\s+\*?\s*(\w+)/;
+var PY_DECL_RE = /^(?:async\s+)?(def|class)\s+(\w+)/;
+var GO_DECL_RE = /^(func|type|var|const)\s+(?:\([^)]+\)\s+)?(\w+)/;
+var RUST_DECL_RE = /^(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(fn|struct|enum|trait|mod|type|const|static|union)\s+(\w+)/;
+var RUST_IMPL_RE = /^(?:unsafe\s+)?impl(?:\s*<[^>]+>)?\s+(?:[^{]+\s+for\s+)?(\w+)/;
+var MD_HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+var MD_FENCE_RE = /^```/;
+var EXT_TO_LANG = {
+  ".ts": "ts",
+  ".tsx": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".js": "ts",
+  ".jsx": "ts",
+  ".mjs": "ts",
+  ".cjs": "ts",
+  ".py": "py",
+  ".pyi": "py",
+  ".go": "go",
+  ".rs": "rust",
+  ".md": "md",
+  ".markdown": "md",
+  ".mdx": "md"
+};
+function extractOutline(filename, lines) {
+  const ext = pathMod3.extname(filename).toLowerCase();
+  const lang = EXT_TO_LANG[ext];
+  if (!lang) return [];
+  switch (lang) {
+    case "ts":
+      return extractTs(lines);
+    case "py":
+      return extractPython(lines);
+    case "go":
+      return extractGo(lines);
+    case "rust":
+      return extractRust(lines);
+    case "md":
+      return extractMarkdown(lines);
+  }
+}
+function extractTs(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.startsWith("export ")) continue;
+    const m = TS_EXPORT_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `export ${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractPython(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const m = PY_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractGo(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const m = GO_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractRust(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith(" ") || line.startsWith("	")) continue;
+    const implMatch = RUST_IMPL_RE.exec(line);
+    if (implMatch) {
+      out.push({ line: i + 1, text: `impl ${implMatch[1]}` });
+      continue;
+    }
+    const m = RUST_DECL_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function extractMarkdown(lines) {
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (MD_FENCE_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const m = MD_HEADING_RE.exec(line);
+    if (!m) continue;
+    out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+  }
+  return out;
+}
+function formatOutline(entries) {
+  const total = entries.length;
+  if (total === 0) return "";
+  const lastEntry = entries[total - 1];
+  const width = String(lastEntry.line).length;
+  const fmt = (e) => `  L${String(e.line).padStart(width, " ")}  ${e.text}`;
+  const header = `[outline: ${total} symbol${total === 1 ? "" : "s"}]`;
+  if (total <= OUTLINE_MAX_ENTRIES) {
+    return [header, ...entries.map(fmt)].join("\n");
+  }
+  const headCount = OUTLINE_MAX_ENTRIES - OUTLINE_TAIL_KEEP;
+  const headEntries = entries.slice(0, headCount);
+  const tailEntries = entries.slice(-OUTLINE_TAIL_KEEP);
+  const omitted = total - OUTLINE_MAX_ENTRIES;
+  const gapStart = headEntries[headEntries.length - 1].line;
+  const gapEnd = tailEntries[0].line;
+  return [
+    header,
+    ...headEntries.map(fmt),
+    `  [\u2026 ${omitted} more symbol${omitted === 1 ? "" : "s"} between L${gapStart} and L${gapEnd} \u2026]`,
+    ...tailEntries.map(fmt)
+  ].join("\n");
+}
+
 // src/tools/fs/search.ts
 import { promises as fs3 } from "fs";
-import * as pathMod3 from "path";
+import * as pathMod4 from "path";
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   throw new DOMException("search aborted by user", "AbortError");
 }
 function displayRel3(rootDir, full) {
-  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
+  return pathMod4.relative(rootDir, full).replaceAll("\\", "/");
 }
 async function searchFiles(ctx, startAbs, args) {
   throwIfAborted(args.signal);
@@ -8120,7 +8437,7 @@ async function searchFiles(ctx, startAbs, args) {
     }
     for (const e of entries) {
       throwIfAborted(args.signal);
-      const full = pathMod3.join(dir, e.name);
+      const full = pathMod4.join(dir, e.name);
       const lower = e.name.toLowerCase();
       const hit = re ? re.test(e.name) : lower.includes(needle);
       if (hit) {
@@ -8199,11 +8516,11 @@ async function searchContent(ctx, startAbs, args) {
       throwIfAborted(args.signal);
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
-        await walk2(pathMod3.join(dir, e.name));
+        await walk2(pathMod4.join(dir, e.name));
         continue;
       }
       if (!e.isFile()) continue;
-      const full = pathMod3.join(dir, e.name);
+      const full = pathMod4.join(dir, e.name);
       if (ctx.nameMatch && !ctx.nameMatch(e.name, displayRel3(ctx.rootDir, full))) continue;
       if (ctx.isBinaryByName(e.name)) continue;
       let fh;
@@ -8300,47 +8617,11 @@ var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
 var DEFAULT_AUTO_PREVIEW_LINES = 200;
 var AUTO_PREVIEW_HEAD_LINES = 80;
 var AUTO_PREVIEW_TAIL_LINES = 40;
-var OUTLINE_MAX_ENTRIES = 30;
-var OUTLINE_TAIL_KEEP = 5;
-var TS_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type|enum)\s+\*?\s*(\w+)/;
-function extractTsExportOutline(lines) {
-  const out = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.startsWith("export ")) continue;
-    const m = TS_EXPORT_RE.exec(line);
-    if (!m) continue;
-    out.push({ line: i + 1, kind: m[1], name: m[2] });
-  }
-  return out;
-}
-function formatOutline(entries) {
-  const total = entries.length;
-  if (total === 0) return "";
-  const lastEntry = entries[total - 1];
-  const width = String(lastEntry.line).length;
-  const fmt = (e) => `  L${String(e.line).padStart(width, " ")}  export ${e.kind} ${e.name}`;
-  const header = `[outline: ${total} top-level export${total === 1 ? "" : "s"}]`;
-  if (total <= OUTLINE_MAX_ENTRIES) {
-    return [header, ...entries.map(fmt)].join("\n");
-  }
-  const headCount = OUTLINE_MAX_ENTRIES - OUTLINE_TAIL_KEEP;
-  const headEntries = entries.slice(0, headCount);
-  const tailEntries = entries.slice(-OUTLINE_TAIL_KEEP);
-  const omitted = total - OUTLINE_MAX_ENTRIES;
-  const gapStart = headEntries[headEntries.length - 1].line;
-  const gapEnd = tailEntries[0].line;
-  return [
-    header,
-    ...headEntries.map(fmt),
-    `  [\u2026 ${omitted} more export${omitted === 1 ? "" : "s"} between L${gapStart} and L${gapEnd} \u2026]`,
-    ...tailEntries.map(fmt)
-  ].join("\n");
-}
+var OUTLINE_MAX_ENTRIES2 = 30;
 var SKIP_DIR_NAMES = new Set(DEFAULT_INDEX_EXCLUDES.dirs);
 var BINARY_EXTENSIONS = new Set(DEFAULT_INDEX_EXCLUDES.exts);
 function displayRel4(rootDir, full) {
-  return pathMod4.relative(rootDir, full).replaceAll("\\", "/");
+  return pathMod5.relative(rootDir, full).replaceAll("\\", "/");
 }
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
@@ -8359,16 +8640,16 @@ function isLikelyBinaryByName(name) {
   return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
 function registerFilesystemTools(registry, opts) {
-  const rootDir = pathMod4.resolve(opts.rootDir);
+  const rootDir = pathMod5.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
   const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
   const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
-  const normRoot = pathMod4.resolve(rootDir);
+  const normRoot = pathMod5.resolve(rootDir);
   const sessionApproved = /* @__PURE__ */ new Set();
   const inflightGate = /* @__PURE__ */ new Map();
   function pathIsUnder(child, parent) {
-    const rel = pathMod4.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !pathMod4.isAbsolute(rel);
+    const rel = pathMod5.relative(parent, child);
+    return rel === "" || !rel.startsWith("..") && !pathMod5.isAbsolute(rel);
   }
   function looksLikeAbsoluteSystemPath(raw) {
     if (/^[A-Za-z]:[\\/]/.test(raw)) return true;
@@ -8384,7 +8665,7 @@ function registerFilesystemTools(registry, opts) {
       if (pathIsUnder(abs, dir)) return;
     }
     const stat2 = await safeLstat(abs);
-    const allowPrefix = stat2?.isDirectory() ? abs : pathMod4.dirname(abs);
+    const allowPrefix = stat2?.isDirectory() ? abs : pathMod5.dirname(abs);
     let pending = inflightGate.get(allowPrefix);
     if (!pending) {
       const gate = ctx?.confirmationGate ?? pauseGate;
@@ -8412,7 +8693,7 @@ function registerFilesystemTools(registry, opts) {
       throw new Error("path must be a non-empty string");
     }
     if (looksLikeAbsoluteSystemPath(raw)) {
-      const abs = pathMod4.resolve(raw);
+      const abs = pathMod5.resolve(raw);
       if (pathIsUnder(abs, normRoot)) return abs;
       await ensureOutsideSandboxAllowed(abs, intent, toolName, ctx);
       return abs;
@@ -8422,7 +8703,7 @@ function registerFilesystemTools(registry, opts) {
       normalized = normalized.slice(1);
     }
     if (normalized.length === 0) normalized = ".";
-    const resolved = pathMod4.resolve(rootDir, normalized);
+    const resolved = pathMod5.resolve(rootDir, normalized);
     if (!pathIsUnder(resolved, normRoot)) {
       throw new Error(
         `path escapes sandbox root (${normRoot}): ${raw} \u2014 use an absolute system path like /Users/foo or C:\\Users\\foo to request approved outside-sandbox access`
@@ -8444,7 +8725,7 @@ function registerFilesystemTools(registry, opts) {
   - head: N  \u2192 first N lines (imports, public API, small configs)
   - tail: N  \u2192 last N lines (recently-added code, log tails)
   - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
-When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker, plus a top-level export outline (function / class / const / interface / type / enum names with line numbers, capped at ${OUTLINE_MAX_ENTRIES}) so you can pick a smart range without a follow-up grep. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first only when the outline doesn't have what you want \u2014 one scoped read beats three full-file reads.`,
+When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker, plus a top-level symbol outline (TS/JS exports, Python def/class, Go func/type, Rust fn/struct/impl/trait, Markdown headings, with line numbers, capped at ${OUTLINE_MAX_ENTRIES2}) so you can pick a smart range without a follow-up grep. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first only when the outline doesn't have what you want \u2014 one scoped read beats three full-file reads.`,
     readOnly: true,
     stormExempt: true,
     parameters: {
@@ -8512,7 +8793,7 @@ ${slice.join("\n")}`;
       const head = lines.slice(0, AUTO_PREVIEW_HEAD_LINES).join("\n");
       const tail = lines.slice(totalLines - AUTO_PREVIEW_TAIL_LINES).join("\n");
       const omitted = totalLines - AUTO_PREVIEW_HEAD_LINES - AUTO_PREVIEW_TAIL_LINES;
-      const outline = formatOutline(extractTsExportOutline(lines));
+      const outline = formatOutline(extractOutline(abs, lines));
       const parts = [
         `[auto-preview: head ${AUTO_PREVIEW_HEAD_LINES} + tail ${AUTO_PREVIEW_TAIL_LINES} of ${totalLines} lines]`,
         head
@@ -8620,7 +8901,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
           lines.push(line);
           emitted++;
           if (e.isDirectory() && !skip) {
-            await walk2(pathMod4.join(dir, e.name), depth + 1);
+            await walk2(pathMod5.join(dir, e.name), depth + 1);
           }
         }
       };
@@ -8780,7 +9061,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args, ctx) => {
       const abs = await safePath(args.path, "write_file", ctx, "write");
-      await fs4.mkdir(pathMod4.dirname(abs), { recursive: true });
+      await fs4.mkdir(pathMod5.dirname(abs), { recursive: true });
       await fs4.writeFile(abs, args.content, "utf8");
       return `wrote ${args.content.length} chars to ${displayRel4(rootDir, abs)}`;
     }
@@ -8866,7 +9147,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     fn: async (args, ctx) => {
       const src = await safePath(args.source, "move_file", ctx, "write");
       const dst = await safePath(args.destination, "move_file", ctx, "write");
-      await fs4.mkdir(pathMod4.dirname(dst), { recursive: true });
+      await fs4.mkdir(pathMod5.dirname(dst), { recursive: true });
       await fs4.rename(src, dst);
       return `moved ${displayRel4(rootDir, src)} \u2192 ${displayRel4(rootDir, dst)}`;
     }
@@ -8934,7 +9215,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     fn: async (args, ctx) => {
       const src = await safePath(args.source, "copy_file", ctx);
       const dst = await safePath(args.destination, "copy_file", ctx, "write");
-      await fs4.mkdir(pathMod4.dirname(dst), { recursive: true });
+      await fs4.mkdir(pathMod5.dirname(dst), { recursive: true });
       await fs4.cp(src, dst, { recursive: true, force: false, errorOnExist: true });
       return `copied ${displayRel4(rootDir, src)} \u2192 ${displayRel4(rootDir, dst)}`;
     }
@@ -8946,6 +9227,16 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
 function registerMemoryTools(registry, opts = {}) {
   const store = new MemoryStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
   const hasProject = store.hasProjectScope();
+  const registry_types = loadMemoryTypeRegistry();
+  const customTypeNames = registry_types.filter((r) => !r.builtin).map((r) => r.name);
+  const typeDescParts = [
+    "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses."
+  ];
+  if (customTypeNames.length > 0) {
+    typeDescParts.push(
+      `Custom types declared in config: ${customTypeNames.join(", ")}. Any string is accepted; unknown types are stored verbatim and treated as 'reference' priority.`
+    );
+  }
   registry.register({
     name: "remember",
     description: "Save a memory for future sessions. Use when the user states a preference, corrects your approach, shares a non-obvious fact about this project, or explicitly asks you to remember something. Don't remember transient task state \u2014 only things worth recalling next session. The memory is written now but won't re-load into the system prompt until the next `/new` or launch.",
@@ -8954,8 +9245,7 @@ function registerMemoryTools(registry, opts = {}) {
       properties: {
         type: {
           type: "string",
-          enum: ["user", "feedback", "project", "reference"],
-          description: "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses."
+          description: typeDescParts.join(" ")
         },
         scope: {
           type: "string",
@@ -8973,6 +9263,16 @@ function registerMemoryTools(registry, opts = {}) {
         content: {
           type: "string",
           description: "Full memory body in markdown. For feedback/project types, structure as: rule/fact, then **Why:** line, then **How to apply:** line."
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: "Optional per-memory priority. `high` injects the entry into a `# HIGH PRIORITY constraints` block at the top of the system prompt \u2014 use sparingly, only for hard rules the model must never violate."
+        },
+        expires: {
+          type: "string",
+          enum: ["project_end"],
+          description: "Optional lifecycle hint. `project_end` causes `/memory clear project` to also remove this entry even when it's stored at global scope."
         }
       },
       required: ["type", "scope", "name", "description", "content"]
@@ -8989,7 +9289,9 @@ function registerMemoryTools(registry, opts = {}) {
           type: args.type,
           scope: args.scope,
           description: args.description,
-          body: args.content
+          body: args.content,
+          ...args.priority ? { priority: args.priority } : {},
+          ...args.expires ? { expires: args.expires } : {}
         });
         const key = sanitizeMemoryName(args.name);
         return [
@@ -9932,11 +10234,11 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 }
 
 // src/tools/shell.ts
-import * as pathMod8 from "path";
+import * as pathMod9 from "path";
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
-import * as pathMod5 from "path";
+import * as pathMod6 from "path";
 function killProcessTree(pid, signal) {
   if (process.platform === "win32") {
     const args = ["/pid", String(pid), "/T"];
@@ -9996,7 +10298,7 @@ var JobRegistry = class {
     const maxBytes = opts.maxBufferBytes ?? DEFAULT_OUTPUT_CAP_BYTES;
     const { bin, args, spawnOverrides } = prepareSpawn(argv);
     const spawnOpts = {
-      cwd: pathMod5.resolve(opts.cwd),
+      cwd: pathMod6.resolve(opts.cwd),
       shell: false,
       windowsHide: true,
       env: process.env,
@@ -10109,12 +10411,15 @@ ${job.output.slice(start)}`;
       job.signalReady();
       job.signalClosed();
     });
-    child.on("close", (code) => {
+    const settleClosed = (code) => {
+      if (!job.running && job.exitCode !== null) return;
       job.running = false;
       job.exitCode = code;
       job.signalReady();
       job.signalClosed();
-    });
+    };
+    child.on("exit", settleClosed);
+    child.on("close", settleClosed);
     const onAbort = () => this.stop(id, { graceMs: 100 });
     if (opts.signal?.aborted) {
       onAbort();
@@ -10171,21 +10476,26 @@ ${job.output.slice(start)}`;
         latestOutput: job.output
       };
     }
-    const timeoutMs = Math.max(0, Math.min(3e4, opts.timeoutMs ?? 5e3));
+    const timeoutMs = Math.max(0, Math.min(3e5, opts.timeoutMs ?? 5e3));
+    const waitFor = opts.waitFor ?? "exit";
     const startOutput = job.output;
+    const racers = [job.closedPromise];
     let wakeOutput = null;
-    const outputPromise = new Promise((resolve10) => {
-      wakeOutput = resolve10;
-      job.outputWaiters.add(resolve10);
-    });
+    if (waitFor === "output-or-exit") {
+      racers.push(
+        new Promise((resolve10) => {
+          wakeOutput = resolve10;
+          job.outputWaiters.add(resolve10);
+        })
+      );
+    }
     let timer = null;
-    await Promise.race([
-      job.closedPromise,
-      outputPromise,
+    racers.push(
       new Promise((resolve10) => {
         timer = setTimeout(resolve10, timeoutMs);
       })
-    ]);
+    );
+    await Promise.race(racers);
     if (timer) clearTimeout(timer);
     if (wakeOutput) job.outputWaiters.delete(wakeOutput);
     return {
@@ -10219,6 +10529,10 @@ ${job.output.slice(start)}`;
         }
       }
       await Promise.race([job.closedPromise, new Promise((res) => setTimeout(res, 5e3))]);
+      if (job.running) {
+        job.running = false;
+        job.signalClosed();
+      }
     }
     return snapshot(job);
   }
@@ -10252,6 +10566,12 @@ ${job.output.slice(start)}`;
     }
     const remaining = Math.max(800, deadlineMs - elapsed());
     await Promise.race([allClose, new Promise((res) => setTimeout(res, remaining))]);
+    for (const job of runningJobs) {
+      if (job.running) {
+        job.running = false;
+        job.signalClosed();
+      }
+    }
   }
   /** Count of still-running jobs — drives the TUI status-bar indicator. */
   runningCount() {
@@ -10282,12 +10602,12 @@ function latestOutputSince(before, after) {
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync8, statSync as statSync5 } from "fs";
-import * as pathMod7 from "path";
+import * as pathMod8 from "path";
 
 // src/tools/shell-chain.ts
 import { spawn as spawn3 } from "child_process";
 import { closeSync, openSync } from "fs";
-import * as pathMod6 from "path";
+import * as pathMod7 from "path";
 var UnsupportedSyntaxError = class extends Error {
   constructor(detail) {
     super(`run_command: ${detail}`);
@@ -10554,7 +10874,7 @@ function openRedirects(redirects, cwd) {
   let bothFd = null;
   const toClose = [];
   const open = (target, flags) => {
-    const resolved = pathMod6.resolve(cwd, target);
+    const resolved = pathMod7.resolve(cwd, target);
     const fd = openSync(resolved, flags);
     toClose.push(fd);
     return fd;
@@ -11051,16 +11371,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod7.isAbsolute(cmd)) return cmd;
-  if (pathMod7.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod8.isAbsolute(cmd)) return cmd;
+  if (pathMod8.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (getEnvCaseInsensitive(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod7.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod8.delimiter);
   const pathDirs = (getEnvCaseInsensitive(env, "PATH") ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod7.win32.join(dir, cmd + ext);
+      const full = pathMod8.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -11176,8 +11496,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod7.isAbsolute(s)) return false;
-  if (pathMod7.extname(s)) return false;
+  if (pathMod8.isAbsolute(s)) return false;
+  if (pathMod8.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -11198,7 +11518,7 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod8.resolve(opts.rootDir);
+  const rootDir = pathMod9.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const jobs = opts.jobs ?? new JobRegistry();
@@ -11264,7 +11584,7 @@ function registerShellTools(registry, opts) {
   });
   registry.register({
     name: "run_background",
-    description: "Spawn a long-running process (dev server, watcher) and detach. Waits up to `waitSec` for startup or a readiness signal ('Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. Tail logs with `job_output`, kill with `stop_job`, list with `list_jobs`.\n\nSingle process only \u2014 chains / redirects / `cd` work as in run_command, but a typical dev-server invocation is one binary. Use the binary's own --cwd / --prefix flag for subdirectories. Vite gotcha: npm's `--prefix` only finds package.json; vite's server root still uses process cwd \u2014 pass `vite <project-dir>` instead.\n\nUSE THIS \u2014 not run_command \u2014 for: npm/yarn/pnpm dev, uvicorn / flask run, cargo watch, tsc --watch, webpack serve, anything with dev/serve/watch in the name.",
+    description: "Spawn a long-running process and detach. Waits up to `waitSec` for startup or a readiness signal ('Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. Tail logs with `job_output`, block on completion with `wait_for_job`, kill with `stop_job`, list with `list_jobs`.\n\nSingle process only \u2014 chains / redirects / `cd` work as in run_command, but a typical invocation is one binary. Use the binary's own --cwd / --prefix flag for subdirectories. Vite gotcha: npm's `--prefix` only finds package.json; vite's server root still uses process cwd \u2014 pass `vite <project-dir>` instead.\n\nUSE THIS \u2014 not run_command \u2014 for:\n- Dev servers / watchers: npm/yarn/pnpm dev, uvicorn / flask run, cargo watch, tsc --watch, webpack serve, anything with dev/serve/watch in the name.\n- One-shot long jobs: curl / wget large downloads, `huggingface-cli download`, multi-GB `pip install` / `npm install`, big `cargo build` / `docker build`. Start with `run_background`, then call `wait_for_job` once (default `waitFor: 'exit'`, timeoutMs up to 300_000) \u2014 the harness blocks server-side so a 5-minute download costs ONE tool call, not 30 polls.",
     parameters: {
       type: "object",
       properties: {
@@ -11337,7 +11657,7 @@ function registerShellTools(registry, opts) {
   });
   registry.register({
     name: "wait_for_job",
-    description: "Block until a background job exits or produces new output, bounded by `timeoutMs`. Use this instead of polling `job_output` with identical args when you're intentionally waiting for state to change. Returns JSON with `exited`, `exitCode`, and `latestOutput`.",
+    description: "Block server-side until a background job finishes (or, opt-in, until it produces new output), bounded by `timeoutMs`. Costs ONE tool call regardless of how long the wait runs \u2014 use this instead of polling `job_output` in a loop. Returns JSON with `exited`, `exitCode`, and `latestOutput`.\n\n`waitFor` controls the wake condition:\n- `'exit'` (default) \u2014 only wake on the job exiting (or the timeout). Right for downloads, installs, builds, anything one-shot. Chatty progress bars do NOT wake the wait.\n- `'output-or-exit'` \u2014 also wake whenever the job writes a new line. Right for tailing a dev server / watcher and reacting to a specific log line.\n\nFor a download or install, set `timeoutMs` to the slowest reasonable end-to-end (e.g. 300_000 for a 5-min wheel install).",
     readOnly: true,
     parallelSafe: true,
     stormExempt: true,
@@ -11347,13 +11667,21 @@ function registerShellTools(registry, opts) {
         jobId: { type: "integer", description: "Job id returned by run_background." },
         timeoutMs: {
           type: "integer",
-          description: "Max time to block before returning if nothing changes. Clamped to 0..30000. Default 5000."
+          description: "Max time to block before returning if the wake condition hasn't fired. Clamped to 0..300000. Default 5000."
+        },
+        waitFor: {
+          type: "string",
+          enum: ["exit", "output-or-exit"],
+          description: "Wake condition. 'exit' = only on job exit (right for downloads / installs / builds). 'output-or-exit' = also on any new output (right for tailing a dev server). Default 'exit'."
         }
       },
       required: ["jobId"]
     },
     fn: async (args) => {
-      const out = await jobs.waitForJob(args.jobId, { timeoutMs: args.timeoutMs });
+      const out = await jobs.waitForJob(args.jobId, {
+        timeoutMs: args.timeoutMs,
+        waitFor: args.waitFor
+      });
       if (!out) return `job ${args.jobId}: not found (use list_jobs)`;
       return {
         jobId: args.jobId,
@@ -12558,8 +12886,12 @@ var McpClient = class {
       }
     });
     promise.catch(() => void 0);
+    const promiseSettled = promise.then(
+      () => void 0,
+      () => void 0
+    );
     try {
-      await Promise.race([this.transport.send(frame), promise.then(() => void 0)]);
+      await Promise.race([this.transport.send(frame), promiseSettled]);
     } catch (err) {
       const pending = this.pending.get(id);
       if (pending) clearTimeout(pending.timeout);
@@ -13502,13 +13834,15 @@ Do NOT try to switch via \`run_command\` (\`cd\`, \`pushd\`, etc.) \u2014 your t
 You have TWO tools for running shell commands, and picking the right one is non-negotiable:
 
 - \`run_command\` \u2014 blocks until the process exits. Use for: **tests, builds, lints, typechecks, git operations, one-shot scripts**. Anything that naturally returns in under a minute.
-- \`run_background\` \u2014 spawns and detaches after a brief startup window. Use for: **dev servers, watchers, any command with "dev" / "serve" / "watch" / "start" in the name**. Examples: \`npm run dev\`, \`pnpm dev\`, \`yarn start\`, \`vite\`, \`next dev\`, \`uvicorn app:app --reload\`, \`flask run\`, \`python -m http.server\`, \`cargo watch\`, \`tsc --watch\`, \`webpack serve\`.
+- \`run_background\` \u2014 spawns and detaches after a brief startup window. Use for:
+  - **Dev servers / watchers / anything with "dev" / "serve" / "watch" / "start" in the name.** Examples: \`npm run dev\`, \`pnpm dev\`, \`yarn start\`, \`vite\`, \`next dev\`, \`uvicorn app:app --reload\`, \`flask run\`, \`python -m http.server\`, \`cargo watch\`, \`tsc --watch\`, \`webpack serve\`.
+  - **One-shot long jobs that would blow run_command's 60s ceiling.** Examples: \`curl -L -O <big-url>\`, \`wget\`, \`huggingface-cli download\`, multi-GB \`pip install\` / \`npm install\`, big \`cargo build\` / \`docker build\`. Start with \`run_background\`, then call \`wait_for_job\` ONCE with a long \`timeoutMs\` \u2014 that costs one tool call total, not one per poll.
 
-**Never use run_command for a dev server.** It will block for 60s, time out, and the user will see a frozen tool call while the server was actually running fine. Always \`run_background\`, then \`job_output\` to peek at the logs when you need to verify something.
+**Never use run_command for a dev server or a download likely to exceed a minute.** It will block, time out, and the user will see a frozen tool call while the work was actually running fine. Always \`run_background\` + \`wait_for_job\` / \`job_output\`.
 
 After \`run_background\`, tools available to you:
 - \`job_output(jobId, tailLines?)\` \u2014 read recent logs to verify startup / debug errors.
-- \`wait_for_job(jobId, timeoutMs?)\` \u2014 block until the job exits or emits new output. Prefer this over repeating identical \`job_output\` calls while you're intentionally waiting.
+- \`wait_for_job(jobId, timeoutMs?, waitFor?)\` \u2014 block server-side until the job finishes (or, with \`waitFor: 'output-or-exit'\`, until it writes a new line). ONE tool call per wait regardless of duration. \`timeoutMs\` clamps at 300_000. For downloads / installs / builds: leave \`waitFor\` at the default \`'exit'\` and set \`timeoutMs\` to the slowest reasonable end-to-end. For tailing a dev server and reacting to a specific log line: pass \`waitFor: 'output-or-exit'\` with a short \`timeoutMs\`.
 - \`list_jobs\` \u2014 see every job this session (running + exited).
 - \`stop_job(jobId)\` \u2014 SIGTERM \u2192 SIGKILL after grace. Stop before switching port / config.