nodal-agents 0.9.1 → 0.9.2

package/cli.js

@@ -11425,8 +11425,8 @@ function postmasterHoldsDataDir(pid, dataDir) {
 function processStartedAtMs(pid) {
   if (process.platform !== "linux") return null;
   try {
-    const stat2 = readFileSync4(`/proc/${pid}/stat`, "utf-8");
-    const after = stat2.slice(stat2.lastIndexOf(")") + 2).split(" ");
+    const stat3 = readFileSync4(`/proc/${pid}/stat`, "utf-8");
+    const after = stat3.slice(stat3.lastIndexOf(")") + 2).split(" ");
     const ticksSinceBoot = Number.parseInt(after[19] ?? "", 10);
     if (!Number.isFinite(ticksSinceBoot)) return null;
     const uptimeSeconds = Number.parseFloat(
@@ -13704,17 +13704,6 @@ var init_model_catalog = __esm({
             cacheWritePerMillionUsd: 6.25
           }
         },
-        {
-          modelId: "anthropic/claude-opus-5-fast",
-          label: "Claude Opus 5 (fast)",
-          capabilities: {
-            tools: true,
-            forcedToolChoice: true,
-            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
-          },
-          contextWindow: 1e6,
-          pricing: { inputPerMillionUsd: 10, outputPerMillionUsd: 50 }
-        },
         {
           modelId: "anthropic/claude-sonnet-5",
           label: "Claude Sonnet 5",
@@ -13747,6 +13736,34 @@ var init_model_catalog = __esm({
             cacheWritePerMillionUsd: 12.5
           }
         },
+        {
+          // The newest of the family (2026-09-01), read off /api/v1/models on
+          // 2026-09-22: same window, prices and modalities as Fable 5 except the
+          // cache READ price, four times lower (0.25 vs 1). Its `reasoning` object
+          // says mandatory:true with efforts max/xhigh/high/medium/low, so Off is
+          // hidden here — the Fable 5 entry above predates that object and still
+          // offers it (#417). No always-on `reasoning` flag, as for every Claude
+          // route in this file: the flag would flip openrouter.ts's default
+          // injection, and a mandatory model thinks anyway.
+          modelId: "anthropic/claude-fable-5.1",
+          label: "Claude Fable 5.1",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "medium", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 1e6,
+          pricing: {
+            inputPerMillionUsd: 10,
+            outputPerMillionUsd: 50,
+            cacheReadPerMillionUsd: 0.25,
+            cacheWritePerMillionUsd: 12.5
+          }
+        },
         // ─── OpenAI ───────────────────────────────────────────────────────────────
         // OpenAI was absent from the OpenRouter list entirely — not a curation
         // choice, a gap: the native `openai` provider carried gpt-5 while anyone
@@ -13799,6 +13816,107 @@ var init_model_catalog = __esm({
             cacheWritePerMillionUsd: 2.5
           }
         },
+        // The rest of the 5.6 series and GPT-6 Astra, read off OpenRouter's
+        // /api/v1/models on 2026-09-22 — including its `reasoning` object
+        // ({mandatory, default_enabled, supported_efforts}), which is what the
+        // control below follows. Sol, Sol Pro and Terra: mandatory:false,
+        // supported_efforts max/xhigh/high/medium/low/none → the Luna posture
+        // (four levels, Off offered). Astra and Astra Pro: mandatory:true, no
+        // 'none' → the same four levels with Off hidden. Prices are the
+        // STANDARD OpenAI service tier, the one the list endpoint reports; the
+        // endpoints list also carries a flex tier at half and a priority tier at
+        // double, and an override above 272K prompt tokens — the flat catalogue
+        // price is the standard tier, as for Luna and Terra Pro above. Upstream
+        // copy: Sol is the 5.6 flagship, Terra the balanced tier between Sol and
+        // Luna, Astra "OpenAI's flagship model for demanding end-to-end work".
+        {
+          modelId: "openai/gpt-5.6-terra",
+          label: "GPT-5.6 Terra",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
+          },
+          contextWindow: 105e4,
+          pricing: {
+            inputPerMillionUsd: 2,
+            outputPerMillionUsd: 12,
+            cacheReadPerMillionUsd: 0.2,
+            cacheWritePerMillionUsd: 2.5
+          }
+        },
+        {
+          modelId: "openai/gpt-5.6-sol",
+          label: "GPT-5.6 Sol",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
+          },
+          contextWindow: 105e4,
+          pricing: {
+            inputPerMillionUsd: 2,
+            outputPerMillionUsd: 10,
+            cacheReadPerMillionUsd: 0.2,
+            cacheWritePerMillionUsd: 2.5
+          }
+        },
+        {
+          modelId: "openai/gpt-5.6-sol-pro",
+          label: "GPT-5.6 Sol Pro",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
+          },
+          contextWindow: 105e4,
+          pricing: {
+            inputPerMillionUsd: 2,
+            outputPerMillionUsd: 10,
+            cacheReadPerMillionUsd: 0.2,
+            cacheWritePerMillionUsd: 2.5
+          }
+        },
+        {
+          modelId: "openai/gpt-6-astra",
+          label: "GPT-6 Astra",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "medium", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 105e4,
+          pricing: {
+            inputPerMillionUsd: 10,
+            outputPerMillionUsd: 50,
+            cacheReadPerMillionUsd: 1,
+            cacheWritePerMillionUsd: 12.5
+          }
+        },
+        {
+          modelId: "openai/gpt-6-astra-pro",
+          label: "GPT-6 Astra Pro",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "medium", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 105e4,
+          pricing: {
+            inputPerMillionUsd: 10,
+            outputPerMillionUsd: 50,
+            cacheReadPerMillionUsd: 1,
+            cacheWritePerMillionUsd: 12.5
+          }
+        },
         // Anthropic — reasoningControl WITHOUT the `reasoning` flag, on purpose:
         // the flag would flip openrouter.ts's always-on default injection; here
         // thinking is engaged only when the agent explicitly sets an effort.
@@ -13835,17 +13953,6 @@ var init_model_catalog = __esm({
             cacheWritePerMillionUsd: 6.25
           }
         },
-        {
-          modelId: "anthropic/claude-opus-4.7-fast",
-          label: "Claude Opus 4.7 (fast)",
-          capabilities: {
-            tools: true,
-            forcedToolChoice: true,
-            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
-          },
-          contextWindow: 1e6,
-          pricing: { inputPerMillionUsd: 30, outputPerMillionUsd: 150 }
-        },
         {
           modelId: "anthropic/claude-opus-4.8",
           label: "Claude Opus 4.8",
@@ -13862,17 +13969,6 @@ var init_model_catalog = __esm({
             cacheWritePerMillionUsd: 6.25
           }
         },
-        {
-          modelId: "anthropic/claude-opus-4.8-fast",
-          label: "Claude Opus 4.8 (fast)",
-          capabilities: {
-            tools: true,
-            forcedToolChoice: true,
-            reasoningControl: { kind: "effort", levels: ["low", "medium", "high", "max"] }
-          },
-          contextWindow: 1e6,
-          pricing: { inputPerMillionUsd: 10, outputPerMillionUsd: 50 }
-        },
         {
           modelId: "anthropic/claude-sonnet-4.6",
           label: "Claude Sonnet 4.6",
@@ -13963,6 +14059,58 @@ var init_model_catalog = __esm({
             cacheReadPerMillionUsd: 0.064902
           }
         },
+        {
+          // "The GA release of DeepSeek V4 Pro" (upstream copy) — the dated
+          // successor of the undated alias above. Pricing (DeepSeek's own
+          // endpoint), context and supported_parameters read off /api/v1/models
+          // on 2026-09-22. The levels follow the list endpoint's `reasoning`
+          // object: supported_efforts max/high/low, mandatory:false — so no
+          // 'medium', unlike the older entries above that predate that field.
+          modelId: "deepseek/deepseek-v4-pro-0813",
+          label: "DeepSeek V4 Pro (0813)",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoning: true,
+            reasoningControl: { kind: "effort", levels: ["low", "high", "max"] }
+          },
+          contextWindow: 1048576,
+          providerOrder: ["deepseek"],
+          pricing: {
+            inputPerMillionUsd: 0.66,
+            outputPerMillionUsd: 1.98,
+            cacheReadPerMillionUsd: 0.022
+          }
+        },
+        {
+          // The newest Flash (2026-09-10), first on DeepSeek's Causal
+          // Encoder-Decoder architecture. One difference from every V4 Flash
+          // above: it takes IMAGE input (input_modalities: text, image), so it is
+          // in VISION_MODEL_IDS. Same reasoning caveat as its siblings; levels
+          // from the list endpoint's `reasoning` object (max/high/low,
+          // mandatory:false, default_enabled:true). forcedToolChoice:false —
+          // DeepSeek's own endpoint (the one providerOrder prefers) reports
+          // supports_tool_choice.required:false; some fallbacks (DeepInfra,
+          // Wafer) report true, and the runtime floor relaxes it anyway.
+          // 'max' → OpenRouter 'xhigh' and Auto → 'medium' are not in this
+          // model's supported_efforts; OpenRouter documents that it "will map
+          // your requested effort to the nearest supported level".
+          modelId: "deepseek/deepseek-v4.1-flash",
+          label: "DeepSeek V4.1 Flash",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: false,
+            reasoning: true,
+            reasoningControl: { kind: "effort", levels: ["low", "high", "max"] }
+          },
+          contextWindow: 1048576,
+          providerOrder: ["deepseek"],
+          pricing: {
+            inputPerMillionUsd: 0.15,
+            outputPerMillionUsd: 0.6,
+            cacheReadPerMillionUsd: 3e-3
+          }
+        },
         // Google — all three are thinking models on OpenRouter (supported_parameters
         // includes "reasoning", verified via openrouter.ai/google/… 2026-07-12).
         // reasoning:true makes the OpenRouter provider enable reasoning + round-trip
@@ -14214,6 +14362,93 @@ var init_model_catalog = __esm({
             cacheReadPerMillionUsd: 0.015
           }
         },
+        {
+          // "The high-speed variant of GLM-5.3-Flash ... up to 200 tokens/s"
+          // (upstream copy, 2026-09-18). Same model family as Flash: multimodal
+          // (text, image, video → VISION_MODEL_IDS), forcedToolChoice:false
+          // (supports_tool_choice.required:false on its endpoint). The control
+          // follows the list endpoint's `reasoning` object, read 2026-09-22:
+          // mandatory:true, supported_efforts max/high/low, default max — the
+          // full 5.3's posture, and the same object upstream now reports for
+          // Flash too (the Flash entry above predates that field). It differs
+          // from Flash on price (~5x) and context (1.05M, not 1.31M).
+          modelId: "z-ai/glm-5.3-flashx",
+          label: "GLM 5.3 FlashX",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: false,
+            reasoning: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 1048576,
+          pricing: {
+            inputPerMillionUsd: 0.37,
+            outputPerMillionUsd: 1.25,
+            cacheReadPerMillionUsd: 0.075
+          }
+        },
+        // Xiaomi MiMo-V2.6 — the three 2.6 models OpenRouter serves (2026-09-21),
+        // all read off /api/v1/models and /models/<id>/endpoints on 2026-09-22:
+        // 1.05M context, 131K max output, input_modalities text+image+video+audio
+        // (→ VISION_MODEL_IDS), supported_parameters tools, tool_choice,
+        // reasoning, include_reasoning — and NO reasoning_effort. The list
+        // endpoint's `reasoning` object says only {mandatory:false}: no
+        // supported_efforts, so thinking can be switched on or off and nothing
+        // else — kind 'onoff', not a made-up scale. No always-on `reasoning`
+        // flag: Auto keeps the provider's default. forcedToolChoice:true —
+        // every endpoint reports supports_tool_choice.required:true.
+        // Upstream copy: Flash = 309B MoE / 15B active; Pro = the >1T flagship;
+        // Pro-UltraSpeed = the same Pro checkpoint "roughly 10x" faster, 10x the
+        // price.
+        {
+          modelId: "xiaomi/mimo-v2.6-flash",
+          label: "MiMo V2.6 Flash",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "onoff" }
+          },
+          contextWindow: 1048576,
+          pricing: {
+            inputPerMillionUsd: 0.14,
+            outputPerMillionUsd: 0.28,
+            cacheReadPerMillionUsd: 28e-4
+          }
+        },
+        {
+          modelId: "xiaomi/mimo-v2.6-pro",
+          label: "MiMo V2.6 Pro",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "onoff" }
+          },
+          contextWindow: 1048576,
+          pricing: {
+            inputPerMillionUsd: 0.435,
+            outputPerMillionUsd: 0.87,
+            cacheReadPerMillionUsd: 36e-4
+          }
+        },
+        {
+          modelId: "xiaomi/mimo-v2.6-pro-ultraspeed",
+          label: "MiMo V2.6 Pro UltraSpeed",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoningControl: { kind: "onoff" }
+          },
+          contextWindow: 1048576,
+          pricing: {
+            inputPerMillionUsd: 4.35,
+            outputPerMillionUsd: 8.7,
+            cacheReadPerMillionUsd: 0.036
+          }
+        },
         // Moonshot (Kimi)
         {
           modelId: "moonshotai/kimi-k2.6",
@@ -14292,6 +14527,56 @@ var init_model_catalog = __esm({
             cacheReadPerMillionUsd: 0.3
           }
         },
+        // Grok 4.6 (2026-08-12) and 4.7 (2026-09-21, "succeeding Grok 4.6" per
+        // upstream copy): same 500K context, same text+image+file input
+        // (→ VISION_MODEL_IDS), same supported_parameters as 4.5 (tools,
+        // tool_choice, reasoning, reasoning_effort), read off /api/v1/models and
+        // /models/<id>/endpoints on 2026-09-22. The control follows the list
+        // endpoint's `reasoning` object: mandatory:true (no Off), and — unlike
+        // 4.5, whose object stops at high — supported_efforts xhigh/high/medium/
+        // low, so 'max' (→ xhigh) is offered. Pricing: 4.6 = 4.5; 4.7 is 20%
+        // cheaper. Both double above 200K prompt tokens (an override the flat
+        // price does not carry, same as 4.5).
+        {
+          modelId: "x-ai/grok-4.6",
+          label: "Grok 4.6",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoning: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "medium", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 5e5,
+          pricing: {
+            inputPerMillionUsd: 2,
+            outputPerMillionUsd: 6,
+            cacheReadPerMillionUsd: 0.5
+          }
+        },
+        {
+          modelId: "x-ai/grok-4.7",
+          label: "Grok 4.7",
+          capabilities: {
+            tools: true,
+            forcedToolChoice: true,
+            reasoning: true,
+            reasoningControl: {
+              kind: "effort",
+              levels: ["low", "medium", "high", "max"],
+              mandatory: true
+            }
+          },
+          contextWindow: 5e5,
+          pricing: {
+            inputPerMillionUsd: 1.6,
+            outputPerMillionUsd: 4.8,
+            cacheReadPerMillionUsd: 0.4
+          }
+        },
         // Qwen — both verified via OpenRouter /api/v1/models (2026-07-20): 1M
         // context, tools + tool_choice + reasoning params (no native
         // reasoning_effort — OpenRouter's unified param drives the hybrid
@@ -14374,13 +14659,12 @@ var init_model_catalog = __esm({
     VISION_MODEL_IDS = /* @__PURE__ */ new Set([
       // OpenRouter (verified via /api/v1/models)
       "anthropic/claude-fable-5",
+      // input_modalities ["text","image","file"] on /api/v1/models, 2026-09-22.
+      "anthropic/claude-fable-5.1",
       "anthropic/claude-haiku-4.5",
       "anthropic/claude-opus-4.7",
-      "anthropic/claude-opus-4.7-fast",
       "anthropic/claude-opus-4.8",
-      "anthropic/claude-opus-4.8-fast",
       "anthropic/claude-opus-5",
-      "anthropic/claude-opus-5-fast",
       "anthropic/claude-sonnet-4.6",
       "anthropic/claude-sonnet-5",
       "google/gemini-3.1-flash-lite-preview",
@@ -14396,14 +14680,35 @@ var init_model_catalog = __esm({
       "openai/gpt-5.6-luna",
       "openai/gpt-5.6-luna-pro",
       "openai/gpt-5.6-terra-pro",
+      // The rest of the 5.6 series and GPT-6 Astra: input_modalities
+      // ["file","image","text"] on /api/v1/models, 2026-09-22.
+      "openai/gpt-5.6-terra",
+      "openai/gpt-5.6-sol",
+      "openai/gpt-5.6-sol-pro",
+      "openai/gpt-6-astra",
+      "openai/gpt-6-astra-pro",
+      // deepseek/deepseek-v4.1-flash reports ["text","image"] (2026-09-22) — the
+      // first V4 Flash that does; v4-flash, v4-flash-0731 and both V4 Pro are
+      // text-only per the same source and deliberately NOT in this set.
+      "deepseek/deepseek-v4.1-flash",
       "qwen/qwen3.8-max",
       // Verified via OpenRouter /api/v1/models input_modalities on 2026-08-28:
       // z-ai/glm-5.3-flash reports ["text","image","video"]. The full z-ai/glm-5.3
       // reports ["text"] only and is deliberately NOT in this set.
       "z-ai/glm-5.3-flash",
+      // z-ai/glm-5.3-flashx reports the same ["text","image","video"] (2026-09-22).
+      "z-ai/glm-5.3-flashx",
+      // Xiaomi MiMo-V2.6: all three report ["text","image","video","audio"]
+      // (2026-09-22).
+      "xiaomi/mimo-v2.6-flash",
+      "xiaomi/mimo-v2.6-pro",
+      "xiaomi/mimo-v2.6-pro-ultraspeed",
       // Verified via OpenRouter /api/v1/models input_modalities (2026-07-20).
       // qwen/qwen3.7-max is deliberately absent — text-only per the same source.
       "x-ai/grok-4.5",
+      // 4.6 and 4.7 report the same ["text","image","file"] (2026-09-22).
+      "x-ai/grok-4.6",
+      "x-ai/grok-4.7",
       "qwen/qwen3.7-plus",
       // Native-provider forms
       "claude-fable-5",
@@ -14990,10 +15295,10 @@ var init_entities = __esm({
         updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
         lastCuratorRunAt: timestamp("last_curator_run_at", { withTimezone: true }),
         reflectionEnabled: boolean("reflection_enabled").notNull().default(false),
-        // Decoupled from reflection_enabled (which gates the skill-learning loop,
-        // opt-in). Gates the memory curator (Phase 2 LLM pass) — ON by default so
-        // memory curation runs even for entities that never opted into reflection.
-        memoryCurationEnabled: boolean("memory_curation_enabled").notNull().default(true),
+        // `memory_curation_enabled` lived here from 0.7.0 to migration 0122 (#411):
+        // a per-workspace gate on the memory curator that no screen ever exposed.
+        // Memory curation is now gated by the runner's MEMORY_CURATION_ENABLED
+        // kill-switch only; "do not touch this fact" is the pin on the fact.
         // Controls whether agent-authored skills are auto-assigned to the authoring
         // agent ('auto') or queued for the entity owner to approve ('approval').
         skillAssignmentMode: text("skill_assignment_mode").notNull().default("approval").$type(),
@@ -20984,8 +21289,45 @@ var init_logs = __esm({
   }
 });
 
+// ../../packages/shared/src/git-binary.ts
+import { stat } from "fs/promises";
+import { delimiter as PATH_DELIMITER } from "path";
+function enBarresObliques(chemin) {
+  return chemin.replace(/\\/g, "/");
+}
+async function estFichier(chemin) {
+  try {
+    return (await stat(chemin)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function resolveGitBinary() {
+  gitBinaire ??= (async () => {
+    const chemins = (process.env["PATH"] ?? "").split(PATH_DELIMITER).filter((d) => d !== "");
+    const windows = process.platform === "win32";
+    for (const dossier of chemins) {
+      const base = `${enBarresObliques(dossier)}/git`;
+      for (const ext of windows ? EXTENSIONS_WINDOWS : [""]) {
+        if (await estFichier(base + ext)) return base + ext;
+      }
+    }
+    console.warn("[git] GIT_NOT_ON_PATH");
+    return null;
+  })();
+  return gitBinaire;
+}
+var EXTENSIONS_WINDOWS, gitBinaire;
+var init_git_binary = __esm({
+  "../../packages/shared/src/git-binary.ts"() {
+    "use strict";
+    EXTENSIONS_WINDOWS = [".exe", ".com"];
+    gitBinaire = null;
+  }
+});
+
 // ../../packages/checkpoints/src/failure.ts
-import { readdir, stat } from "fs/promises";
+import { readdir, stat as stat2 } from "fs/promises";
 import { basename, join as join13 } from "path";
 function checkpointFailureCode(cause, operation) {
   if (cause === "git_missing") return "git_missing";
@@ -21030,7 +21372,7 @@ async function measureWorkspace(workspace, limits = {}) {
       }
       files++;
       try {
-        bytes += (await stat(join13(dir, entry.name))).size;
+        bytes += (await stat2(join13(dir, entry.name))).size;
       } catch {
       }
     }
@@ -21170,7 +21512,13 @@ function isTimeoutError(err) {
   const e = err;
   return e.killed === true || e.code === "ETIMEDOUT";
 }
+async function gitBinary() {
+  const binaire = await resolveGitBinary();
+  if (binaire === null) throw new GitBinaryMissingError();
+  return binaire;
+}
 function isGitMissingError(err) {
+  if (err instanceof GitBinaryMissingError) return true;
   if (typeof err !== "object" || err === null) return false;
   const e = err;
   return e.code === "ENOENT" && typeof e.syscall === "string" && e.syscall.startsWith("spawn");
@@ -21242,7 +21590,7 @@ function gitEnv(store, workspace, indexFile) {
   };
 }
 async function git(store, workspace, args, indexFile, timeoutMs = storeTimeoutMs()) {
-  const { stdout } = await run("git", args, {
+  const { stdout } = await run(await gitBinary(), args, {
     timeout: timeoutMs,
     windowsHide: true,
     env: gitEnv(store, workspace, indexFile)
@@ -21255,7 +21603,7 @@ async function ensureStore(store) {
   await writeFile(join14(store, "gitconfig"), "", { flag: "a" });
   if (!existsSync13(join14(gitDir, "HEAD"))) {
     await mkdir(gitDir, { recursive: true });
-    await run("git", ["init", "--bare", "--quiet", gitDir], {
+    await run(await gitBinary(), ["init", "--bare", "--quiet", gitDir], {
       timeout: GIT_TIMEOUT_MS,
       windowsHide: true
     });
@@ -21321,14 +21669,23 @@ async function restoreCheckpoint(store, workspace, sha) {
   await git(store, workspace, ["checkout", "-f", sha, "--", "."]);
   return { restored: sha, safety };
 }
-var run, GIT_TIMEOUT_MS, badTimeoutSaid, EXCLUDES, CHECKPOINT_COVERAGE_NOTE;
+var run, GIT_TIMEOUT_MS, badTimeoutSaid, GitBinaryMissingError, EXCLUDES, CHECKPOINT_COVERAGE_NOTE;
 var init_checkpoints = __esm({
   "../../packages/checkpoints/src/checkpoints.ts"() {
     "use strict";
+    init_git_binary();
     init_failure();
     run = promisify(execFile);
     GIT_TIMEOUT_MS = 3e4;
     badTimeoutSaid = false;
+    GitBinaryMissingError = class extends Error {
+      constructor() {
+        super(
+          "git is not on PATH: no checkpoint can be taken or read. Install git, or make it reachable from the process PATH."
+        );
+        this.name = "GitBinaryMissingError";
+      }
+    };
     EXCLUDES = [
       ...SKIPPED_DIRS.map((dir) => `${dir}/`),
       ...SKIPPED_FILE_SUFFIXES.map((suffixe) => `*${suffixe}`)

package/docs-index.json

@@ -118,7 +118,7 @@
       "pageTitle": "Memory",
       "heading": "Memory",
       "url": "/nodal-agents/docs/concepts/memory",
-      "text": "How agents store, recall, and automatically use persistent facts across jobs. Agents accumulate facts in a persistent agent_memory table. These facts survive across sessions, restarts, and model swaps — whenever a job runs, relevant memories are already waiting in the system prompt before the first LLM call."
+      "text": "How an agent remembers something for later, and how the fact comes back next time it works. Agents accumulate facts in a persistent agent_memory table. These facts survive across sessions, restarts, and model swaps — whenever a job runs, relevant memories are already waiting in the system prompt before the first LLM call. When you tell an agent to remember this, to keep something for later, or to do it this way next time, a memory is what you are asking for: the fact is written once, and read back on its own every time it is needed."
     },
     {
       "page": "concepts/memory",
@@ -130,8 +130,8 @@
     {
       "page": "concepts/memory",
       "pageTitle": "Memory",
-      "heading": "Auto-injection into every job",
-      "url": "/nodal-agents/docs/concepts/memory#auto-injection-into-every-job",
+      "heading": "Auto-injection into every job — the fact is there next time",
+      "url": "/nodal-agents/docs/concepts/memory#auto-injection-into-every-job--the-fact-is-there-next-time",
       "text": "Before a job starts, the runner selects memories from the entity-wide pool and injects them as a frozen block inside the agent's system prompt. No tool call is needed — the agent already has context. Selection works in two stages: Candidate fetch — up to 200 non-archived, non-expired memories for the entity (MAX_CANDIDATES in packages/memory/src/inject.ts). The ordering depends on the current job: Task-relevant ranking. When the job's task is tokenizable, candidates are ordered by ts_rank against the task text (full-text relevance), with importance and recency only as a tie-break. A fact relevant to this task can surface even if it sits outside the importance/recency top tier. Fallback ranking. When the task has no usable tokens, candidates are ordered by importance DESC, then last_accessed_at DESC. Budget pack — a greedy selector fits as many as possible under a character budget derived from agents.memoryTokenBudget. In the relevance path, the FTS order is authoritative and is not re-sorted by importance. A single oversized fact is skipped rather than truncated. Memory is entity-scoped, not agent-scoped — every agent in the same entity sees the same pool. This matches the query_memory tool's behaviour: knowledge follows the user across agents, not the individual agent."
     },
     {
@@ -151,9 +151,9 @@
     {
       "page": "concepts/memory",
       "pageTitle": "Memory",
-      "heading": "Writing memories",
-      "url": "/nodal-agents/docs/concepts/memory#writing-memories",
-      "text": "Agents write memories with save_memory. Duplicate detection runs on a normalized hash of the fact text — an identical (non-archived) fact already in the store is rejected before it reaches the DB, so the pool stays clean. Content is sanitized before storage to guard against injection payloads being embedded into the entity-wide pool."
+      "heading": "Writing memories — remember this, for later",
+      "url": "/nodal-agents/docs/concepts/memory#writing-memories--remember-this-for-later",
+      "text": "Agents write memories with save_memory — the tool behind \"remember that I prefer short answers\" and \"keep that for later\". Duplicate detection runs on a normalized hash of the fact text — an identical (non-archived) fact already in the store is rejected before it reaches the DB, so the pool stays clean. Content is sanitized before storage to guard against injection payloads being embedded into the entity-wide pool."
     },
     {
       "page": "concepts/memory",
@@ -914,9 +914,9 @@
     {
       "page": "guides/shell-commands",
       "pageTitle": "Shell commands",
-      "heading": "How approval works",
-      "url": "/nodal-agents/docs/guides/shell-commands#how-approval-works",
-      "text": "When the agent calls run_command, the runner creates an approval request and suspends the job. You see the exact command in the dashboard and approve or reject it. If you approve, the runner executes the command and the job resumes with the output. If you reject, the agent receives an error and can try a different approach. On a Telegram-bound agent, the agent gets a bounded number of turns to tell you via chat that it is waiting — so you are not left wondering why it went quiet."
+      "heading": "How approval works — you approve a command before it runs",
+      "url": "/nodal-agents/docs/guides/shell-commands#how-approval-works--you-approve-a-command-before-it-runs",
+      "text": "When the agent calls run_command, the runner creates an approval request and suspends the job. You see the exact command in the dashboard and approve or reject it. If you approve, the runner executes the command and the job resumes with the output. If you reject, the agent receives an error and can try a different approach. Where you approve a command: the Approvals page of the dashboard, which lists every command waiting for you. By default, nothing an agent proposes runs until you approve that call. Three things let commands through without that question: a Run without asking rule on run_command for that agent, optionally confined to one of its folders — the card's Approve for this project writes exactly that rule; the workspace's autonomy level set to Autonomous, gate destructive, under which an ordinary command runs unasked while a destructive or heavy one (deleting files, installing a package, killing a process, a disk operation) stays gated; and Yolo mode, which drops the gate for every command that agent runs. On a Telegram-bound agent, the agent gets a bounded number of turns to tell you via chat that it is waiting — so you are not left wondering why it went quiet."
     },
     {
       "page": "guides/shell-commands",
@@ -1264,9 +1264,9 @@
     {
       "page": "reference/dashboard",
       "pageTitle": "Dashboard reference",
-      "heading": "Approvals — /approvals",
-      "url": "/nodal-agents/docs/reference/dashboard#approvals--approvals",
-      "text": "Everything that needs your sign-off, and everything that got it. Tabs: pending, approved, rejected, expired, all. Each card shows the tool input, the agent's stated purpose and impact, and a link to the run that asked. Approve or reject, optionally with a note. ?show=<id> opens one request on its own, whatever its decision — it is what the sidebar's Recents rows link to. The list narrows to that card and the page says so in its subtitle. See the autonomy model in Agents."
+      "heading": "Approvals — approve or refuse a command, /approvals",
+      "url": "/nodal-agents/docs/reference/dashboard#approvals--approve-or-refuse-a-command-approvals",
+      "text": "Everything that needs your sign-off, and everything that got it. Tabs: pending, approved, rejected, expired, all. This is where you approve a command — or any other tool call an agent asked to make — and where you refuse one. Each card shows the tool input, the agent's stated purpose and impact, and a link to the run that asked. Approve or reject, optionally with a note. An approval covers that one call. To stop confirming every time, you allow the tool rather than the command: on the agent's Approvals tab, set run_command to Run without asking, for that agent, and — if you name one — only inside one of its folders. The card's Approve for this project writes that same rule for the folder the run is in. A rule never reads what the command says, so it cannot allow one command line and keep asking about another. Yolo, on the same tab, goes further: it drops the gate for every command that agent runs. A third way does not come from that tab at all: with the workspace's autonomy level set to Autonomous, gate destructive and no rule on the tool, an ordinary command runs unasked, while a destructive or heavy one (deleting files, installing a package, killing a process, a disk operation) stays gated. See Shell commands. ?show=<id> opens one request on its own, whatever its decision — it is what the sidebar's Recents rows link to. The list narrows to that card and the page says so in its subtitle. See the autonomy model in Agents."
     },
     {
       "page": "reference/dashboard",