reasonix 0.40.0 → 0.43.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.",
@@ -927,6 +966,7 @@ var EN = {
     applied: "applied",
     rejected: "rejected",
     noDashboard: "Suppress the auto-launched embedded web dashboard.",
+    openDashboardHint: "Open the dashboard URL in your default browser as soon as the server is ready. No-op when --no-dashboard is set.",
     dashboardPortHint: "Pin the dashboard to a fixed port (1\u201365535). Stable across restarts \u2014 required for SSH tunnels. Default: ephemeral.",
     dashboardPortInvalid: "\u25B2 ignoring --dashboard-port={value} (must be an integer 1\u201365535) \u2014 falling back to ephemeral",
     dashboardAutoStartFailed: "\u25B2 dashboard auto-start failed ({reason}) \u2014 try /dashboard, or pass --no-dashboard to silence",
@@ -1091,7 +1131,13 @@ var EN = {
     jsonHintCatalog: "output as JSON",
     jsonHintReport: "output the inspection report as JSON",
     modelOverrideFlash: "override the model (default: deepseek-v4-flash)",
-    skipConfirmHint: "skip the confirmation prompt"
+    skipConfirmHint: "skip the confirmation prompt",
+    yoloHint: "auto-approve plan checkpoints for this invocation (equivalent to editMode=yolo without mutating config)"
+  },
+  code: {
+    workspaceConflict: "\u26A0 workspace contains another agent platform's files ({platforms}). Reasonix Code may read them as project content; relaunch with --dir <your-project> if that's not what you want.\n",
+    systemAppendEmpty: "--system-append is empty \u2014 no prompt text will be appended\n",
+    systemAppendFileReadError: 'Error: cannot read --system-append-file "{filePath}": {errorDetails}\n'
   },
   slash: {
     help: { description: "show the full command reference" },
@@ -1237,6 +1283,14 @@ var EN = {
     logs: {
       description: "tail a background job's output (default last 80 lines)",
       argsHint: "<id> [lines]"
+    },
+    btw: {
+      description: "ask a quick side question \u2014 answered from a blank slate, never added to the conversation context",
+      argsHint: "<question>"
+    },
+    "search-engine": {
+      description: "switch web search backend \u2014 mojeek (default, no deps) or searxng (self-hosted)",
+      argsHint: "<mojeek|searxng> [<endpoint>]"
     }
   },
   wizard: {
@@ -1363,9 +1417,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 +1448,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",
@@ -1462,6 +1528,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",
@@ -1806,7 +1873,8 @@ var EN = {
     mb: " MB",
     evt: " evt",
     editsLabel: "edits:",
-    mcpLoading: "MCP"
+    mcpLoading: "MCP",
+    ctx: "ctx"
   },
   editMode: {
     plan: "PLAN MODE",
@@ -2113,7 +2181,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."
@@ -2178,7 +2247,9 @@ var EN = {
     reconnect: "reconnect\u2026",
     initDetail: "initialise \u2192 tools/list \u2192 resources/list",
     reconnectDetail: "tearing down \xB7 re-handshake \xB7 listing tools",
-    disabledDetail: "via /mcp disable {name}"
+    disabledDetail: "via /mcp disable {name}",
+    failedSetupHint: "\u2192 run `reasonix setup` to remove this entry, or fix the underlying issue (missing npm package, network, etc.).",
+    failedSetupConfigHint: "\u2192 run `reasonix setup` to remove broken entries from your saved config."
   },
   checkpointPicker: {
     title: "restore a checkpoint \u2014 {workspace}",
@@ -2237,7 +2308,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",
@@ -2273,6 +2347,7 @@ var zhCN = {
     applied: "\u5DF2\u5E94\u7528",
     rejected: "\u5DF2\u62D2\u7EDD",
     noDashboard: "\u7981\u6B62\u81EA\u52A8\u542F\u52A8\u5D4C\u5165\u5F0F Web \u4EEA\u8868\u677F\u3002",
+    openDashboardHint: "\u670D\u52A1\u5C31\u7EEA\u540E\u7ACB\u5373\u5728\u9ED8\u8BA4\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u4EEA\u8868\u677F\u5730\u5740\u3002\u8BBE\u7F6E\u4E86 --no-dashboard \u65F6\u4E0D\u751F\u6548\u3002",
     dashboardPortHint: "\u5C06\u4EEA\u8868\u677F\u7ED1\u5B9A\u5230\u56FA\u5B9A\u7AEF\u53E3 (1\u201365535)\u3002\u91CD\u542F\u540E\u4FDD\u6301\u7A33\u5B9A \u2014 SSH \u96A7\u9053\u8BBF\u95EE\u5FC5\u9700\u3002\u9ED8\u8BA4\u4E3A\u4E34\u65F6\u7AEF\u53E3\u3002",
     dashboardPortInvalid: "\u25B2 \u5FFD\u7565 --dashboard-port={value} (\u5FC5\u987B\u4E3A 1\u201365535 \u4E4B\u95F4\u7684\u6574\u6570) \u2014 \u56DE\u9000\u5230\u4E34\u65F6\u7AEF\u53E3",
     dashboardAutoStartFailed: "\u25B2 \u4EEA\u8868\u677F\u81EA\u52A8\u542F\u52A8\u5931\u8D25 ({reason}) \u2014 \u5C1D\u8BD5 /dashboard\uFF0C\u6216\u4F20\u9012 --no-dashboard \u4EE5\u9759\u9ED8",
@@ -2434,7 +2509,13 @@ var zhCN = {
     jsonHintCatalog: "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA",
     jsonHintReport: "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u68C0\u67E5\u62A5\u544A",
     modelOverrideFlash: "\u8986\u76D6\u6A21\u578B\uFF08\u9ED8\u8BA4\uFF1Adeepseek-v4-flash\uFF09",
-    skipConfirmHint: "\u8DF3\u8FC7\u786E\u8BA4\u63D0\u793A"
+    skipConfirmHint: "\u8DF3\u8FC7\u786E\u8BA4\u63D0\u793A",
+    yoloHint: "\u81EA\u52A8\u6279\u51C6\u672C\u6B21\u8C03\u7528\u7684\u8BA1\u5212\u68C0\u67E5\u70B9\uFF08\u7B49\u540C\u4E8E editMode=yolo\uFF0C\u4F46\u4E0D\u4FEE\u6539\u914D\u7F6E\u6587\u4EF6\uFF09"
+  },
+  code: {
+    workspaceConflict: "\u26A0 \u5DE5\u4F5C\u533A\u5305\u542B\u53E6\u4E00\u4E2A\u667A\u80FD\u4F53\u5E73\u53F0\u7684\u6587\u4EF6 ({platforms})\u3002Reasonix Code \u53EF\u80FD\u4F1A\u5C06\u5176\u4F5C\u4E3A\u9879\u76EE\u5185\u5BB9\u8BFB\u53D6\uFF1B\u5982\u679C\u4E0D\u662F\u60A8\u60F3\u8981\u7684\uFF0C\u8BF7\u4F7F\u7528 --dir <your-project> \u91CD\u65B0\u542F\u52A8\u3002\n",
+    systemAppendEmpty: "--system-append \u4E3A\u7A7A \u2014 \u4E0D\u4F1A\u8FFD\u52A0\u4EFB\u4F55\u63D0\u793A\u6587\u672C\n",
+    systemAppendFileReadError: '\u9519\u8BEF\uFF1A\u65E0\u6CD5\u8BFB\u53D6 --system-append-file "{filePath}"\uFF1A{errorDetails}\n'
   },
   slash: {
     help: { description: "\u663E\u793A\u5B8C\u6574\u547D\u4EE4\u53C2\u8003" },
@@ -2584,6 +2665,14 @@ var zhCN = {
     logs: {
       description: "\u8DDF\u8E2A\u540E\u53F0\u4F5C\u4E1A\u7684\u8F93\u51FA\uFF08\u9ED8\u8BA4\u6700\u540E 80 \u884C\uFF09",
       argsHint: "<id> [lines]"
+    },
+    btw: {
+      description: "\u987A\u4FBF\u95EE\u4E00\u4E0B \u2014 \u4ECE\u7A7A\u767D\u4E0A\u4E0B\u6587\u56DE\u7B54\uFF0C\u4E0D\u5199\u5165\u4F1A\u8BDD\u5386\u53F2",
+      argsHint: "<question>"
+    },
+    "search-engine": {
+      description: "\u5207\u6362\u7F51\u7EDC\u641C\u7D22\u540E\u7AEF \u2014 mojeek\uFF08\u9ED8\u8BA4\uFF0C\u65E0\u4F9D\u8D56\uFF09\u6216 searxng\uFF08\u81EA\u6258\u7BA1\uFF09",
+      argsHint: "<mojeek|searxng> [<endpoint>]"
     }
   },
   wizard: {
@@ -2710,9 +2799,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 +2830,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",
@@ -2809,6 +2910,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",
@@ -3153,7 +3255,8 @@ var zhCN = {
     mb: " MB",
     evt: " \u4E8B\u4EF6",
     editsLabel: "\u7F16\u8F91:",
-    mcpLoading: "MCP"
+    mcpLoading: "MCP",
+    ctx: "\u4E0A\u4E0B\u6587"
   },
   editMode: {
     plan: "\u8BA1\u5212",
@@ -3460,7 +3563,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"
@@ -3525,7 +3629,9 @@ var zhCN = {
     reconnect: "\u91CD\u8FDE\u4E2D\u2026",
     initDetail: "\u521D\u59CB\u5316 \u2192 tools/list \u2192 resources/list",
     reconnectDetail: "\u65AD\u5F00\u65E7\u8FDE\u63A5 \xB7 \u91CD\u65B0\u63E1\u624B \xB7 \u5217\u51FA\u5DE5\u5177",
-    disabledDetail: "\u901A\u8FC7 /mcp disable {name}"
+    disabledDetail: "\u901A\u8FC7 /mcp disable {name}",
+    failedSetupHint: "\u2192 \u8FD0\u884C `reasonix setup` \u79FB\u9664\u6B64\u6761\u76EE\uFF0C\u6216\u4FEE\u590D\u5E95\u5C42\u95EE\u9898\uFF08\u7F3A\u5C11 npm \u5305\u3001\u7F51\u7EDC\u7B49\uFF09\u3002",
+    failedSetupConfigHint: "\u2192 \u8FD0\u884C `reasonix setup` \u4ECE\u5DF2\u4FDD\u5B58\u914D\u7F6E\u4E2D\u79FB\u9664\u635F\u574F\u7684\u6761\u76EE\u3002"
   },
   checkpointPicker: {
     title: "\u6062\u590D\u68C0\u67E5\u70B9 \u2014 {workspace}",
@@ -4509,7 +4615,7 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join4, posix as posixPath, win32 as win32Path } from "path";
 function sessionsDir() {
   return join4(homedir3(), ".reasonix", "sessions");
 }
@@ -4796,6 +4902,23 @@ var HISTORY_FOLD_MIN_SAVINGS_FRACTION = 0.3;
 var FORCE_SUMMARY_THRESHOLD = 0.8;
 var PREFLIGHT_EMERGENCY_THRESHOLD = 0.95;
 var HISTORY_FOLD_MARKER = "[CONVERSATION HISTORY SUMMARY \u2014 earlier turns folded for context efficiency]\n\n";
+var SKILL_PIN_MEMO_HEADER = "[Active skill memos \u2014 preserved verbatim across the fold:]";
+var SKILL_PIN_REGEX = /<skill-pin name="([^"]+)">\n[\s\S]*?\n<\/skill-pin>/g;
+function extractPinnedSkills(head) {
+  const pinned = /* @__PURE__ */ new Map();
+  const stubbedHead = head.map((msg) => {
+    if (typeof msg.content !== "string") return msg;
+    let hit = false;
+    const next = msg.content.replace(SKILL_PIN_REGEX, (full, name) => {
+      pinned.delete(name);
+      pinned.set(name, full);
+      hit = true;
+      return `[skill ${JSON.stringify(name)} memo \u2014 preserved separately, do not summarize.]`;
+    });
+    return hit ? { ...msg, content: next } : msg;
+  });
+  return { stubbedHead, pinnedBodies: [...pinned.values()] };
+}
 var ContextManager = class {
   constructor(deps) {
     this.deps = deps;
@@ -4865,11 +4988,17 @@ var ContextManager = class {
     const tail = all.slice(boundary);
     const headTokens = totalTokens - cumTokens;
     if (headTokens < totalTokens * HISTORY_FOLD_MIN_SAVINGS_FRACTION) return noop;
-    const summary = await this.summarizeForFold(head);
+    const { stubbedHead, pinnedBodies } = extractPinnedSkills(head);
+    const summary = await this.summarizeForFold(stubbedHead);
     if (!summary) return noop;
+    const memoTail = pinnedBodies.length > 0 ? `
+
+${SKILL_PIN_MEMO_HEADER}
+
+${pinnedBodies.join("\n\n")}` : "";
     const summaryMsg = {
       role: "assistant",
-      content: HISTORY_FOLD_MARKER + summary
+      content: HISTORY_FOLD_MARKER + summary + memoTail
     };
     const replacement = [summaryMsg, ...tail];
     this.deps.log.compactInPlace(replacement);
@@ -5094,6 +5223,8 @@ function buildSyntheticAssistantMessage(content, fallbackModel) {
 }
 
 // src/loop/force-summary.ts
+var PAUSE_SUMMARY_MODEL = "deepseek-v4-flash";
+var PAUSE_SUMMARY_EFFORT = "high";
 async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
   try {
     yield { turn: ctx.turn, role: "status", content: t("summary.status") };
@@ -5139,6 +5270,28 @@ ${summary}`;
     yield { turn: ctx.turn, role: "done", content: "" };
   }
 }
+async function summarizePartialProgress(ctx) {
+  try {
+    const messages = ctx.buildMessages();
+    messages.push({
+      role: "user",
+      content: "You're being paused at a checkpoint, not stopped. In 3-6 sentences of plain prose, tell the parent agent: (1) what you accomplished so far, (2) what's still left, (3) any blockers or open questions. Be concrete \u2014 mention specific files / functions / tool results \u2014 so the parent can decide whether to resume you or take over. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+    });
+    const resp = await ctx.client.chat({
+      model: PAUSE_SUMMARY_MODEL,
+      messages,
+      signal: ctx.signal,
+      thinking: thinkingModeForModel(PAUSE_SUMMARY_MODEL),
+      reasoningEffort: PAUSE_SUMMARY_EFFORT
+    });
+    const cleaned = stripHallucinatedToolMarkup(resp.content?.trim() ?? "");
+    if (!cleaned) return null;
+    const stats = ctx.recordStats(PAUSE_SUMMARY_MODEL, resp.usage ?? new Usage());
+    return { summary: cleaned, stats };
+  } catch {
+    return null;
+  }
+}
 
 // src/loop/shrink.ts
 function looksLikeCompleteJson(s) {
@@ -5184,6 +5337,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 +5348,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 +5365,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 {
@@ -5310,17 +5468,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;
   }
@@ -5745,12 +5911,14 @@ var CacheFirstLoop = class {
   /** One-shot 80% warning latch — cleared by setBudget so a bump re-arms at the new boundary. */
   _budgetWarned = false;
   sessionName;
+  onIterBudgetExhausted;
   hooks;
   hookCwd;
   /** PauseGate bridge — defaults to singleton, injectable for tests. */
   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. */
@@ -5783,33 +5951,15 @@ var CacheFirstLoop = class {
       resolveFailureThreshold(opts.failureThreshold, FAILURE_ESCALATION_THRESHOLD)
     );
     this.maxToolIters = opts.maxToolIters ?? 64;
+    this.onIterBudgetExhausted = opts.onIterBudgetExhausted ?? "summarize";
     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 +5967,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 +6060,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 +6074,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 +6127,27 @@ var CacheFirstLoop = class {
     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 ?? "{}";
@@ -6207,6 +6385,15 @@ ${reason}`
             thinking: thinkingModeForModel(callModel),
             reasoningEffort: this.reasoningEffort
           })) {
+            if (chunk.reasoningDelta) {
+              reasoningContent += chunk.reasoningDelta;
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: "",
+                reasoningDelta: chunk.reasoningDelta
+              };
+            }
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
               if (bufferForEscalation && !escalationBufFlushed) {
@@ -6231,15 +6418,6 @@ ${reason}`
                 };
               }
             }
-            if (chunk.reasoningDelta) {
-              reasoningContent += chunk.reasoningDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: "",
-                reasoningDelta: chunk.reasoningDelta
-              };
-            }
             if (chunk.toolCallDelta) {
               const d = chunk.toolCallDelta;
               const cur = callBuf.get(d.index) ?? {
@@ -6527,6 +6705,19 @@ ${reason}`
         }
       }
     }
+    if (this.onIterBudgetExhausted === "pause") {
+      const partial = await summarizePartialProgress(this.summaryContext());
+      yield {
+        turn: this._turn,
+        role: "paused",
+        content: "",
+        sessionName: this.sessionName ?? void 0,
+        pausedAtIter: this.maxToolIters,
+        partialSummary: partial?.summary
+      };
+      yield { turn: this._turn, role: "done", content: "" };
+      return;
+    }
     yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "budget" });
   }
   summaryContext() {
@@ -6844,7 +7035,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 +7121,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);
@@ -7219,6 +7410,12 @@ function parseAllowedTools(raw) {
   const names = raw.split(",").map((s) => s.trim()).filter(Boolean);
   return names.length > 0 ? Object.freeze(names) : void 0;
 }
+function parseMaxToolIters(raw) {
+  if (raw === void 0) return void 0;
+  const n = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(n) || n < 1) return void 0;
+  return n;
+}
 var SkillStore = class {
   homeDir;
   projectRoot;
@@ -7349,7 +7546,8 @@ var SkillStore = class {
       path: path2,
       allowedTools: parseAllowedTools(data["allowed-tools"]),
       runAs: parseRunAs(data.runAs),
-      model: data.model?.startsWith("deepseek-") ? data.model : void 0
+      model: data.model?.startsWith("deepseek-") ? data.model : void 0,
+      maxToolIters: parseMaxToolIters(data["max-iters"])
     };
   }
 };
@@ -7370,6 +7568,7 @@ Tips:
 - Reference tools by name (run_command, edit_file, search_content, ...)
 - Add \`runAs: subagent\` to frontmatter to spawn an isolated subagent loop
 - Add \`allowed-tools: read_file, search_content\` to scope a subagent's tools
+- Add \`max-iters: N\` to change the subagent's pause cadence (default 16). This isn't a budget \u2014 the parent resumes on pause, so N is how often the parent gets a checkpoint, not how much total work the subagent gets.
 `;
 }
 function skillIndexLine(s) {
@@ -7620,16 +7819,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 +7898,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 +7906,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 +7953,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 +8038,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 +8103,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 +8325,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 +8491,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 +8570,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 +8671,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 +8694,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 +8719,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 +8747,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 +8757,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 +8779,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 +8847,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 +8955,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 +9115,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 +9201,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 +9269,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 +9281,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 +9299,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 +9317,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 +9343,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 [
@@ -9584,9 +9940,7 @@ ${NEGATIVE_CLAIM_RULE}
 
 ${TUI_FORMATTING_RULES}`;
 var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
-var DEFAULT_MAX_ITERS = 16;
-var MIN_MAX_ITERS = 1;
-var MAX_MAX_ITERS = 32;
+var DEFAULT_PAUSE_EVERY = 16;
 var BUDGET_WARN_THRESHOLD = 3;
 function budgetParagraph(maxToolIters) {
   return `Tool budget: you have ${maxToolIters} tool call${maxToolIters === 1 ? "" : "s"} for this task. The cap is enforced from outside \u2014 the call after #${maxToolIters} is refused. Pace yourself: if you can't fully resolve the task within the budget, stop early and return what you have plus what's missing, rather than burning the budget on one branch.`;
@@ -9609,12 +9963,13 @@ function subagentBudgetHint(spawnCount, totalTokens) {
 }
 async function spawnSubagent(opts) {
   const model = opts.model ?? DEFAULT_SUBAGENT_MODEL;
-  const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
+  const maxToolIters = opts.maxToolIters ?? DEFAULT_PAUSE_EVERY;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
   const skillName = opts.skillName;
-  const startedAt = Date.now();
   const runId = nextRunId();
+  const sessionName = opts.resumeSession ?? `subagent-${runId}-${timestampSuffix()}`;
+  const startedAt = Date.now();
   const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
   sink?.current?.({
     kind: "start",
@@ -9694,10 +10049,9 @@ ${budgetParagraph(maxToolIters)}`,
     reasoningEffort: DEFAULT_SUBAGENT_EFFORT,
     maxToolIters,
     hooks: [],
-    // Streaming on so the parent UI can flip the "summarising" phase the
-    // moment the model starts emitting the final answer (first assistant_delta
-    // after the last tool result, before assistant_final lands).
-    stream: true
+    stream: true,
+    session: sessionName,
+    onIterBudgetExhausted: "pause"
   });
   const onParentAbort = () => childLoop.abort();
   if (opts.parentSignal?.aborted) {
@@ -9709,8 +10063,13 @@ ${budgetParagraph(maxToolIters)}`,
   let errorMessage;
   let toolIter = 0;
   let summarisingEmitted = false;
+  let paused = false;
+  let partialSummary;
+  const taskForLoop = opts.resumeSession ? `[Resume: your tool-call budget has been refreshed with ${maxToolIters} new calls. Earlier "wrap up" / "finalize NOW" budget hints in this conversation referred to the previous window \u2014 they no longer apply. Continue the work you were given.]
+
+${opts.task}` : opts.task;
   try {
-    for await (const ev of childLoop.step(opts.task)) {
+    for await (const ev of childLoop.step(taskForLoop)) {
       sink?.current?.({ kind: "inner", runId, task: taskPreview, skillName, model, inner: ev });
       if (ev.role === "tool") {
         toolIter++;
@@ -9748,13 +10107,17 @@ ${budgetParagraph(maxToolIters)}`,
       if (ev.role === "error") {
         errorMessage = ev.error ?? "subagent error";
       }
+      if (ev.role === "paused") {
+        paused = true;
+        if (ev.partialSummary) partialSummary = ev.partialSummary;
+      }
     }
   } catch (err) {
     errorMessage = err.message;
   } finally {
     opts.parentSignal?.removeEventListener("abort", onParentAbort);
   }
-  if (!errorMessage && !final) {
+  if (!errorMessage && !final && !paused) {
     errorMessage = opts.parentSignal?.aborted ? "subagent aborted before producing an answer" : "subagent ended without producing an answer";
   }
   const elapsedMs = Date.now() - startedAt;
@@ -9788,7 +10151,10 @@ ${budgetParagraph(maxToolIters)}`,
     costUsd: costUsd2,
     model,
     skillName,
-    usage
+    usage,
+    paused: paused || void 0,
+    pausedSession: paused ? sessionName : void 0,
+    partialSummary: paused ? partialSummary : void 0
   };
 }
 function aggregateChildUsage(loop) {
@@ -9803,6 +10169,18 @@ function aggregateChildUsage(loop) {
   return agg;
 }
 function formatSubagentResult(r) {
+  if (r.paused) {
+    return JSON.stringify({
+      success: false,
+      paused: true,
+      resume_session: r.pausedSession,
+      tool_iters: r.toolIters,
+      elapsed_ms: r.elapsedMs,
+      cost_usd: r.costUsd,
+      partial_summary: r.partialSummary,
+      note: `Subagent reached its pause-every interval (${r.toolIters} tool calls) without producing a final answer. Read partial_summary above to see what was done / left / blocked, then decide: resume by calling spawn_subagent again with resume_session="${r.pausedSession}" (the task arg becomes a continuation nudge \u2014 e.g. "finish what you started"), or accept the partial work and proceed with what you already know.`
+    });
+  }
   if (!r.success) {
     return JSON.stringify({
       success: false,
@@ -9825,7 +10203,7 @@ function registerSubagentTool(parentRegistry, opts) {
   const baseSystem = opts.defaultSystem ?? SUBAGENT_BASE_SYSTEM;
   const defaultSystemBase = opts.projectRoot ? applyProjectMemory(baseSystem, opts.projectRoot) : baseSystem;
   const defaultModel = opts.defaultModel ?? DEFAULT_SUBAGENT_MODEL;
-  const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
+  const maxToolIters = opts.maxToolIters ?? DEFAULT_PAUSE_EVERY;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
   let sessionSpawnCount = 0;
@@ -9833,17 +10211,17 @@ function registerSubagentTool(parentRegistry, opts) {
   parentRegistry.register({
     name: SUBAGENT_TOOL_NAME,
     parallelSafe: true,
-    description: "Spawn an isolated subagent to handle a self-contained subtask in a fresh context, returning only its final answer. **Prefer direct tools.** Spawn primarily for parallel fan-out (2+ independent investigations issued in one tool batch) or when the work would otherwise need >10 file reads/searches whose trail you don't need to keep. Single greps, 1-3 file cross-references, and 'keep my context clean for one question' are NOT good reasons to spawn \u2014 direct tools are cheaper and let you reference the evidence later. Each spawn pays a fresh prefix-cache miss plus a full child loop. The subagent inherits your tools but runs in its own isolated message log; only the final assistant message comes back. Keep tasks focused; the subagent has a stricter iter budget than you do.",
+    description: "Spawn an isolated subagent to handle a self-contained subtask in a fresh context, returning only its final answer. **Prefer direct tools.** Spawn primarily for parallel fan-out (2+ independent investigations issued in one tool batch) or when the work would otherwise need >10 file reads/searches whose trail you don't need to keep. Single greps, 1-3 file cross-references, and 'keep my context clean for one question' are NOT good reasons to spawn \u2014 direct tools are cheaper and let you reference the evidence later. Each fresh spawn pays a prefix-cache miss plus a full child loop. The subagent inherits your tools but runs in its own isolated message log; only the final assistant message comes back. **Pause/resume**: subagents yield back to you every `max_iters` tool calls. A paused result returns `{ paused: true, resume_session: \"...\" }` \u2014 you can either accept the partial state, or call spawn_subagent again with `resume_session` set to continue where it left off (cheap: the prior prefix is cached). Tasks expected to run much longer than 16 tool calls don't need a huge `max_iters` \u2014 just resume.",
     parameters: {
       type: "object",
       properties: {
         task: {
           type: "string",
-          description: "The subtask the subagent should perform. Be specific and self-contained \u2014 the subagent has none of your conversation context, only what you write here."
+          description: 'The subtask the subagent should perform. Be specific and self-contained \u2014 the subagent has none of your conversation context, only what you write here. When resuming via `resume_session`, this becomes a continuation nudge (e.g. "finish what you started" or a delta instruction).'
         },
         system: {
           type: "string",
-          description: "Optional override for the subagent's system prompt. The default tells it to stay focused and return a concise answer; override only when the subtask needs a specialized persona."
+          description: "Optional override for the subagent's system prompt. The default tells it to stay focused and return a concise answer; override only when the subtask needs a specialized persona. Ignored on resume \u2014 the prior session keeps its original system prompt for cache stability."
         },
         model: {
           type: "string",
@@ -9852,9 +10230,11 @@ function registerSubagentTool(parentRegistry, opts) {
         },
         max_iters: {
           type: "integer",
-          minimum: MIN_MAX_ITERS,
-          maximum: MAX_MAX_ITERS,
-          description: `Cap on the subagent's tool-call iterations. Default 16 (or the type's default when 'type' is set). Hard range: ${MIN_MAX_ITERS}-${MAX_MAX_ITERS}; out-of-range values are clamped to the nearest end.`
+          description: "How many tool calls the subagent runs before pausing back to you for a checkpoint. Default 16. This is checkpoint cadence, not a budget \u2014 work continues across pauses via `resume_session`. Pick what feels natural for the granularity of decisions you want to make: small (4-8) when you want frequent control, larger (32-64) when the subagent should mostly run autonomously."
+        },
+        resume_session: {
+          type: "string",
+          description: "Provide the `resume_session` value returned by a previous paused spawn to continue that subagent. When set, prior messages are loaded from disk and the original system prompt is reused (cache-friendly). `task` becomes a continuation nudge."
         },
         type: {
           type: "string",
@@ -9876,7 +10256,8 @@ function registerSubagentTool(parentRegistry, opts) {
       const system = typeof args.system === "string" && args.system.trim().length > 0 ? args.system.trim() : typeSpec?.system ?? `${defaultSystemBase}
 
 ${escalationContract(model)}`;
-      const callerIters = clampMaxIters(args.max_iters);
+      const callerIters = parseMaxIters(args.max_iters);
+      const resumeSession = typeof args.resume_session === "string" && args.resume_session.trim().length > 0 ? args.resume_session.trim() : void 0;
       const result = await spawnSubagent({
         client: opts.client,
         parentRegistry,
@@ -9886,7 +10267,8 @@ ${escalationContract(model)}`;
         maxToolIters: callerIters ?? typeSpec?.maxToolIters ?? maxToolIters,
         maxResultChars,
         sink,
-        parentSignal: ctx?.signal
+        parentSignal: ctx?.signal,
+        resumeSession
       });
       sessionSpawnCount++;
       sessionSpawnTokens += result.usage.totalTokens;
@@ -9898,12 +10280,10 @@ ${hint}` : formatted;
   });
   return parentRegistry;
 }
-function clampMaxIters(raw) {
+function parseMaxIters(raw) {
   if (typeof raw !== "number" || !Number.isFinite(raw)) return void 0;
   const n = Math.floor(raw);
-  if (n < MIN_MAX_ITERS) return MIN_MAX_ITERS;
-  if (n > MAX_MAX_ITERS) return MAX_MAX_ITERS;
-  return n;
+  return n >= 1 ? n : void 0;
 }
 function forkRegistryExcluding(parent, exclude) {
   const child = new ToolRegistry();
@@ -9932,11 +10312,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 +10376,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 +10489,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 +10554,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 +10607,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 +10644,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 +10680,13 @@ 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 { devNull } from "os";
+import * as pathMod7 from "path";
 var UnsupportedSyntaxError = class extends Error {
   constructor(detail) {
     super(`run_command: ${detail}`);
@@ -10546,6 +10945,12 @@ async function runChain(chain, opts) {
 [\u2026 truncated ${output.length - opts.maxOutputChars} chars \u2026]` : output;
   return { exitCode: lastExit, output: truncated, timedOut };
 }
+function isNullDeviceAlias(target) {
+  const lower = target.toLowerCase();
+  if (lower === "/dev/null") return true;
+  if (process.platform === "win32" && lower === "nul") return true;
+  return false;
+}
 function openRedirects(redirects, cwd) {
   let stdinFd = null;
   let stdoutFd = null;
@@ -10554,7 +10959,7 @@ function openRedirects(redirects, cwd) {
   let bothFd = null;
   const toClose = [];
   const open = (target, flags) => {
-    const resolved = pathMod6.resolve(cwd, target);
+    const resolved = isNullDeviceAlias(target) ? devNull : pathMod7.resolve(cwd, target);
     const fd = openSync(resolved, flags);
     toClose.push(fd);
     return fd;
@@ -11051,16 +11456,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 +11581,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 +11603,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 +11669,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 +11742,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 +11752,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 +12971,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 +13919,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.