synabun 2026.7.32 → 2026.9.5

package/CHANGELOG.md

@@ -1,3 +1,79 @@
+# SynaBun v.2026.09.05
+
+A Claude Code model release: the model picker stops quietly serving a stale built-in list, sidepanel sessions run the model the picker actually offered, and Fable 5.1 is priced correctly.
+
+## 🛠 Fixed
+
+- **The Claude model picker silently served a static fallback list** — Model discovery spawns the Claude Code CLI to read its live model table, and that spawn goes through a shell whenever the resolved binary is a bare command name rather than a full path. A shell concatenates its arguments instead of passing them through, so the empty string in `--setting-sources ''` vanished, the CLI exited with `option '--setting-sources <sources>' argument missing`, and discovery came back empty. The flag is now a single `--setting-sources=` token, which survives both spawn paths. The failure was invisible by design: an empty result falls back to a four-entry list of unversioned aliases with no Fable entry at all, so the picker looked merely out of date rather than broken.
+- **Discovery missed a Claude CLI installed outside the login shell's `PATH`** — SynaBun is routinely started from Finder or launchd with a minimal environment, where a CLI in `~/.local/bin`, Homebrew, Bun, or an npm global prefix is invisible. The same `PATH` augmentation the rest of the server already used is now applied to the model-discovery and version probes, so those installations are found.
+- **The sidepanel offered Fable 5.1 but ran Fable 5** — The picker reads the CLI you have installed, while sidepanel chats run the CLI bundled inside `@anthropic-ai/claude-agent-sdk`. The two had drifted apart, and the older bundle's model table knows only `claude-fable-5` — so choosing Fable 5.1, or the `fable`/`best` aliases, quietly launched Fable 5 with no symptom beyond the model naming a different version of itself. The SDK is bumped `0.3.220` → `0.3.258` to close the gap. The guard test that exists to catch exactly this had been passing vacuously, because it probed for a CLI under the un-augmented `PATH` and skipped whenever it could not find one; it now runs on the machines it was written to protect.
+- **Fable 5.1 sessions reported the wrong cost** — With no pricing row of its own, `claude-fable-5-1` fell through to the Sonnet fallback and understated input and output by roughly 3.3x. It now carries its own rates, which are deliberately not a copy of the Fable 5 row: same input and output pricing, cheaper cache reads.
+
+---
+
+# SynaBun v.2026.09.01
+
+A Codex and memory-hooks release: Codex sidepanels no longer strand `already has an active writer` errors across tab switches, thread history moves off Codex's deprecated hydration path, and the Claude Code memory hooks stop re-issuing a block they were never able to clear.
+
+## 🛠 Fixed
+
+- **The "Unstored file edits" block never cleared** — A `remember` call without a `category` reset nothing, because the entire pending-remember reset was gated behind a branch that Claude Code rarely reaches: it routinely sends `remember` with `{ content }` alone. The flag was never cleared, so the Stop hook re-issued the identical block on every turn for the rest of the session — confirmed against a real session flag showing `rememberCount: 0` after four successful `remember` calls. The reset is now unconditional for any successful `remember` or `reflect`. Failure detection fails open by design: only an explicit `isError` / `success: false` / `status: "error"` counts as a failure, so a future payload change cannot silently reintroduce a block that never clears. A new `MAX_TASK_BLOCKS` session ceiling bounds the worst case.
+- **Edit nudges never reached the model** — Every PostToolUse nudge was written as a bare top-level `{ additionalContext }`, but PostToolUse only reads `hookSpecificOutput: { hookEventName, additionalContext }`. The output was valid JSON, so it failed silently rather than erroring, and no "N file edits — remember to store this work" message was ever delivered. Fixed in `post-remember.mjs`, and in the five emission sites in `post-plan.mjs` that had the same bug — all now routed through one shared helper.
+- **`reflect` was excluded by the hook matcher** — `post-remember.mjs` already handled `reflect`, but the registered PostToolUse matcher ended at `remember`, making that code unreachable: `reflect` calls never reached the hook. The matcher now covers both, anchored so it still never fires for `recall`, `memories`, or `forget`, and matches both Claude Code's `mcp__SynaBun__remember` and OpenCode's `SynaBun_remember` spelling.
+- **Every hook invocation stalled about two seconds** — `readStdin()` resolved promptly, but its 2000 ms fallback timer stayed pending afterwards and held the event loop open, so each hook lingered for the full timeout before exiting — measured at 2.05 s against a configured 3 s hook timeout. Clearing and unref-ing the guard brings it to 0.02 s across every hook.
+- **Memories were filed under the wrong project** — The MCP server read `claude-code-projects.json` from a data directory that has never existed, so registered project labels were silently ignored and every project fell back to a raw directory basename — `/Apps/EllaCred` was stored as `ellacred` rather than the registered label `elacred`. Over the HTTP transport `process.cwd()` is the Neural Interface's own directory, which labeled every HTTP-sourced memory `neural-interface` regardless of the caller; that case now resolves to `global`, a recoverable mislabel rather than one indistinguishable from a real project.
+- **Codex sidepanels stranded "already has an active writer"** — A tab's intentional socket close was invisible to the server, so it orphaned an idle Codex app-server for the full 30-minute grace period and the next `thread/resume` collided with SynaBun's own abandoned writer. Ownership is now handed back through a release handshake before the socket closes, retirement waits for observed process exit rather than a kill flag, and only connections with genuinely reattachable work — active turns, pending approvals, in-flight RPCs — keep the grace period. Rapid tab switching can no longer strand or resurrect a hidden writer, and a genuinely external writer still reports an actionable error instead of requiring a restart.
+- **Codex thread history rode a deprecated hydration path** — Full history was requested through `thread/read` and `thread/resume`. SynaBun now rebuilds the same client shape by paging `thread/turns/list` and `thread/items/list` in chronological order, and falls back to paginated turns with `itemsView: "full"` when a store reports that item pagination is unsupported. Repeated cursors, invalid pages, duplicate ids, and items with no matching turn are rejected before they can loop or poison a transcript; timeouts and unrelated protocol failures still surface rather than being misread as compatibility gaps.
+- **The Codex Resume dropdown blocked on a full account scan** — It now serves from the cached session catalog when rows exist and refreshes in the background, falling back to a full multi-account walk only when the cache is cold; the same cached catalog backs Codex search metadata. Windows path matching resolves with `path.win32` and compares case-insensitively, so drive-letter case and slash direction no longer drop valid sessions from project grouping. Cache warmup also starts earlier at boot, so the dropdown is usually warm by the time it is opened.
+- **Agent-selected MCP profiles did not expose their tools** — Profile state was module-global even though the HTTP transport hosts multiple stateful MCP sessions in one process, so a profile switch could mutate the most recently registered server instead of the caller's. Each stdio process and HTTP client session now owns an isolated profile runtime. The `tools/list_changed` notification is also no longer emitted synchronously from inside `profile set` — where OpenCode could abort or discard the in-flight roundtrip — but delayed and coalesced until after the tool result returns, so newly enabled tools are usable within the same agent turn.
+- **Codex could not call newly enabled tools mid-turn** — Codex snapshots deferred MCP tools when a turn starts, so a successful refresh updated the app-server inventory without making anything callable by the running agent. Canonical Codex registrations now start SynaBun with the full deferred catalog, while per-sidepanel and automation profiles remain isolated focus selections. Profile changes no longer trigger a global `config/mcpServer/reload` that restarted unrelated MCP servers and reported success before startup had finished, and repeating a valid `profile.set` now re-reports the runtime and emits a fresh notification so a strictly profiled host can heal a stale catalog.
+
+## ⚙️ Changed
+
+- **`remember` now requires `category` and `project`** — Both were declared optional in the tool schema, and the `category` description merely noted that "if omitted, a project default is used." Hosts took the hint and sent `{ content }` alone — which is exactly what left the Stop hook blocked. A JSON Schema `required` entry is enforcement; a description is advice, and the advice was already being ignored. `importance` stays optional, since nothing downstream depends on it. Category names that are present but misspelled are still remapped rather than lost.
+- **The memory ruleset now states this accurately** — The shipped `CLAUDE.md` template claimed no recall-and-reflect was needed afterwards, without mentioning that omitting `category` misfiles the memory and leaves the stop hook blocked. Corrected across all six template sites, the README, and the `/synabun` skill modules. The ruleset version is now `1.2.0`, so existing installs are offered the update.
+- **Installed hook matchers repair themselves at startup** — A matcher change previously reached fresh installs but left every existing `.claude/settings.json` on the old value indefinitely, because the startup sweep compared only the command string and short-circuited. It now compares the matcher too, counts repairs, reports them on the startup `Hooks:` line, and is idempotent — so a stale matcher cannot keep a hook unreachable across upgrades.
+
+---
+
+# SynaBun v.2026.07.34
+
+A reliability release: the Claude sidepanel no longer dies with a misleading "does not match this system's libc" error, and every bundled native binary is checked and repaired at startup.
+
+## 🛠 Fixed
+
+- **"Native binary exists but failed to launch"** — The Claude sidepanel could fail every turn with *"Claude Code native binary at `…/claude` exists but failed to launch. This usually means the binary does not match this system's libc…"*. On macOS and Windows that explanation is never right: the real cause is almost always a missing execute bit. npm does not preserve the execute bit for files a package ships without a `bin` entry, which is exactly how the Claude Agent SDK and Codex deliver their native payloads, so a perfectly good binary can land as mode `0644` and fail to spawn. SynaBun now stats the binary the SDK is about to launch, restores the execute bit when it is missing, and retries — and when it cannot repair it, it says what is actually wrong: a permission problem on macOS and Linux, Gatekeeper quarantine (with the `xattr -d com.apple.quarantine` command) on macOS, a genuine libc mismatch only on Linux, and an unlaunchable `.cmd`/`.bat`/`.ps1` shim on Windows.
+- **Only the current machine's binaries were repaired** — The startup repair looked at one directory, `prebuilds/<your platform>-<your arch>`, so a checkout carrying several platform builds left the others broken — including `darwin-x64`, which is what an Intel Mac needs for terminals. Startup and postinstall now sweep every vendored binary that is present (Claude Agent SDK, Codex, `node-pty`) by walking the tree instead of consulting a hardcoded list, so new platform directories are covered automatically.
+- **The postinstall repair had stopped doing anything** — `scripts/rebuild-pty.js` was still fixing permissions on `node_modules/.bin/claude` and `@anthropic-ai/claude-code/cli.js`, neither of which has existed since that package was replaced by the Agent SDK. Its prebuild list named Linux directories that are not shipped while missing ones that are. It now runs the shared sweep, and runs it *before* the "node-pty not found, skipping" guard — previously an install without node-pty skipped the Claude and Codex repair entirely.
+- **A `.cjs` executable override was launched the wrong way** — A custom Claude executable ending in `.cjs` was treated as a script to run through Node, but the SDK spawns it directly, so it needed the execute bit and did not get it.
+
+## ✨ New
+
+- **Runtime notices in the Claude sidepanel** — A new amber notice sits between grey status text and a red fatal error: something went wrong, was worked around, and the session is continuing in a degraded state. You will see it when the bundled binary is repaired and retried, and when a session falls back to your globally installed Claude CLI. It appears in both the sidepanel and the standalone chat page.
+- **Fallback to your installed Claude CLI** — If the bundled runtime cannot be launched or repaired, sessions and unattended automation loops now fall back to the Claude CLI you have installed rather than failing the turn. Because model aliases and effort levels resolve per-binary, a version difference between your CLI and the bundled runtime is reported alongside the fallback instead of silently changing which model runs.
+
+## ⚙️ Changed
+
+- **A custom Claude executable path is now validated before use** — The `claude-skin` → `sdkExecutable` override was passed straight through to the SDK, which uses it verbatim with no checks of its own. It is now vetted first, and a bare command name such as `claude` is rejected with an explanation: the SDK spawns without a shell and cannot resolve a name from `PATH`, so handing one over produces a worse and more confusing failure than the one being recovered from. Overrides may be either a script entrypoint or a native binary path, and the same rule now applies to automation loops, which previously accepted anything.
+
+---
+
+# SynaBun v.2026.07.33
+
+A Windows release: Codex schedules and sidepanels now find a globally installed Codex runtime instead of failing at launch.
+
+## 🛠 Fixed
+
+- **Codex could not be found on Windows even with the global CLI installed** — SynaBun located the Codex runtime by looking it up on the inherited `PATH`, and the PATH it built for that lookup only added POSIX directories (`~/.local/bin`, `/usr/local/bin`, `~/.npm-global/bin`) that do not exist on Windows. Started from anywhere whose environment did not already carry the npm global bin — a shortcut, a service, a fresh terminal after an install — Codex was invisible and every Codex schedule failed. Discovery no longer depends on `PATH` at all: `@openai/codex` is now located under `npm root -g`, `%APPDATA%\npm\node_modules`, an `npm_config_prefix` override, the `node_modules` directory that contains SynaBun itself, and Node's own install directory. The Windows PATH augmentation also picks up `%APPDATA%\npm`, the configured npm prefix, and Node's directory, deduplicated, so the shell-aware launch paths improve too.
+- **The native Codex executable was missed under current npm layouts** — The resolver looked in exactly one place, `vendor/<target>/codex/codex.exe` inside the platform package resolved through `require.resolve`. Current Codex releases ship the executable at `vendor/<target>/bin/`, and depending on the npm version the platform package sits either beside `@openai/codex` or nested inside its own `node_modules` — and package `exports` can block the resolve entirely. Both vendor layouts and all three package locations are now checked directly, so hoisting differences no longer read as "Codex is not installed".
+- **Windows launched npm's shell shim instead of the real launcher** — `npm install -g` writes both an extensionless `codex` sh shim and a `codex.cmd`, and `where codex` lists the shim first, which Windows cannot spawn. The sidepanel launch path now prefers a `.cmd`, `.exe`, `.bat`, or `.ps1` launcher and keeps the first result only as a fallback for non-npm installations.
+
+## ⚙️ Improved
+
+- **A missing Codex runtime says which problem it is** — The failure notice now distinguishes "the global Codex package is installed but its Windows runtime is missing" from "Codex is not installed globally", and both point at `npm install -g @openai/codex@latest --include=optional`. The platform executable ships as an optional dependency, so an install that skipped optional packages leaves a Codex that looks present and cannot run. Successful resolution logs which layout it came from, and failures log the candidate paths that were checked.
+
+---
+
 # SynaBun v.2026.07.32
 
 A follow-up to 2026.07.31 that makes updating fast again on a large data home.

package/README.md

@@ -797,7 +797,7 @@ Also available: profile (runtime tool-group toggle), browser automation (40 tool
 - Session-ending context: remember ongoing work as conversation
 
 ### Memory Tool Quirks
-- `remember` accepts `tags` and `importance` directly and returns the full UUID.
+- `remember` requires `category` and `project` on every call, accepts `tags` and `importance` directly, and returns the full UUID.
 - `forget` is a soft delete — use `restore` to undo.
 - The `reflect` tool's ID parameter is `memory_id` (not `id`). It requires the FULL UUID format.
 - Make memory MCP calls sequentially, not in parallel — one failure cascades to all sibling calls in the batch.

package/hooks/claude-code/post-plan.mjs

@@ -19,7 +19,8 @@
  *   { session_id, tool_name, tool_input, tool_response, cwd }
  *
  * Output (stdout JSON):
- *   { additionalContext: "..." } on success, or {} on skip/error
+ *   { hookSpecificOutput: { hookEventName, additionalContext } } on success,
+ *   or {} on skip/error. See emitContext().
  */
 
 import { readFileSync, writeFileSync, appendFileSync, readdirSync, statSync, existsSync, mkdirSync, renameSync, unlinkSync } from 'node:fs';
@@ -35,6 +36,17 @@ process.on('unhandledRejection', () => { try { process.stdout.write('{}'); } cat
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Emit additionalContext in the shape PostToolUse actually reads. A bare
+ * top-level { additionalContext } is accepted as valid JSON and then silently
+ * discarded, so every message written that way never reaches the model.
+ */
+function emitContext(text) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: text },
+  }));
+}
+
 // Debug log (append-only, survives across invocations)
 const DEBUG_LOG_PATH = join(DATA_DIR, 'plan-debug.log');
 function debugLog(msg) {
@@ -456,9 +468,7 @@ async function main() {
   if (toolName === 'EnterPlanMode') {
     debugLog('EnterPlanMode fired — injecting AskUserQuestion reminder');
     const todayDir = getTodayPlanDir();
-    process.stdout.write(JSON.stringify({
-      additionalContext: `SynaBun: You are now in plan mode.\n\n**CRITICAL CONSTRAINT**: Do NOT make code changes (Edit, Write, NotebookEdit). Plan mode is RESEARCH AND PLANNING ONLY. Investigate, read files, search code — then present your plan. Do NOT implement anything until the user explicitly approves the plan and you exit plan mode.\n\nWhen you have questions or need clarification, you MUST use the \`AskUserQuestion\` tool — do NOT write questions as plain text. Load it via \`ToolSearch\` if its schema is not yet available. Use \`ExitPlanMode\` for final plan approval.\n\n**Plan file location**: Write plan files to \`${todayDir}/your-plan-slug.md\` — use a short descriptive slug derived from the plan title (e.g., \`fix-session-crosstalk.md\`, \`opencode-sidepanel.md\`). Do NOT create \`PLAN.md\` at the project root. Do NOT write to \`~/.claude/plans/\`.`,
-    }));
+    emitContext(`SynaBun: You are now in plan mode.\n\n**CRITICAL CONSTRAINT**: Do NOT make code changes (Edit, Write, NotebookEdit). Plan mode is RESEARCH AND PLANNING ONLY. Investigate, read files, search code — then present your plan. Do NOT implement anything until the user explicitly approves the plan and you exit plan mode.\n\nWhen you have questions or need clarification, you MUST use the \`AskUserQuestion\` tool — do NOT write questions as plain text. Load it via \`ToolSearch\` if its schema is not yet available. Use \`ExitPlanMode\` for final plan approval.\n\n**Plan file location**: Write plan files to \`${todayDir}/your-plan-slug.md\` — use a short descriptive slug derived from the plan title (e.g., \`fix-session-crosstalk.md\`, \`opencode-sidepanel.md\`). Do NOT create \`PLAN.md\` at the project root. Do NOT write to \`~/.claude/plans/\`.`);
     return;
   }
 
@@ -516,9 +526,7 @@ async function main() {
     const stored = loadStoredPlans();
     if (stored[base]) {
       debugLog(`ExitPlanMode: ${base} already stored — skipping`);
-      process.stdout.write(JSON.stringify({
-        additionalContext: `SynaBun: Plan already stored (${base}).`,
-      }));
+      emitContext(`SynaBun: Plan already stored (${base}).`);
       return;
     }
     try {
@@ -575,9 +583,7 @@ async function main() {
   }
 
   if (!planFile) {
-    process.stdout.write(JSON.stringify({
-      additionalContext: 'SynaBun: No plan file found and no plan content in tool_input — UI capture and hook authoring both failed.',
-    }));
+    emitContext('SynaBun: No plan file found and no plan content in tool_input — UI capture and hook authoring both failed.');
     return;
   }
 
@@ -624,14 +630,10 @@ async function main() {
   const shortTitle = planTitle.length > 60 ? planTitle.slice(0, 60) + '...' : planTitle;
   const matchInfo = planFile.method || 'unknown';
   debugLog(`Stored plan: ${planFile.path} [${matchInfo}] → memory ${id} (project: ${project})`);
-  process.stdout.write(JSON.stringify({
-    additionalContext: `SynaBun: Plan stored in memory [${id}] — "${shortTitle}" (category: ${categoryName}, project: ${project}). Plan file: ${planFile.path} [matched: ${matchInfo}]`,
-  }));
+  emitContext(`SynaBun: Plan stored in memory [${id}] — "${shortTitle}" (category: ${categoryName}, project: ${project}). Plan file: ${planFile.path} [matched: ${matchInfo}]`);
 }
 
 main().catch((err) => {
   // On error, still output valid JSON so Claude Code doesn't break
-  process.stdout.write(JSON.stringify({
-    additionalContext: `SynaBun: Plan storage failed — ${err.message}. The plan file is still saved at ${PLANS_DIR}.`,
-  }));
+  emitContext(`SynaBun: Plan storage failed — ${err.message}. The plan file is still saved at ${PLANS_DIR}.`);
 });

package/hooks/claude-code/post-remember.mjs

@@ -3,24 +3,31 @@
 /**
  * SynaBun PostToolUse Hook for Claude Code (unified handler)
  *
- * Matches: ^Edit$|^Write$|^NotebookEdit$|mcp__SynaBun__remember
+ * Matches: ^Edit$|^Write$|^NotebookEdit$|Syna[Bb]un_+(remember|reflect)
  *
  * Two responsibilities:
  *
  * 1. EDIT TRACKING — When Claude uses Edit, Write, or NotebookEdit,
- *    increments a pending-remember counter. If Claude finishes responding
- *    with 3+ unremembered edits, the Stop hook will block it.
+ *    increments a pending-remember counter. Once EDIT_THRESHOLD edits are
+ *    unremembered, the Stop hook blocks until a memory is stored.
  *
- * 2. FLAG MANAGEMENT — When Claude calls `remember`:
- *    - category "conversations" → clears pending-compact flag (compaction enforcement)
- *    - any other category       → resets pending-remember flag (editCount→0,
- *      keeps rememberCount/totalEdits so subsequent edits start a fresh segment)
+ * 2. FLAG MANAGEMENT — When Claude calls `remember` or `reflect`:
+ *    - ALWAYS resets the pending-remember flag (editCount→0, retries→0,
+ *      files→[]), keeping rememberCount/totalEdits so subsequent edits start
+ *      a fresh segment. This is deliberately NOT conditional on `category`.
+ *    - category "conversations" ALSO clears pending-compact (compaction).
+ *
+ *    History: this used to be `else if (category)`, so a `remember` call that
+ *    omitted `category` — which is what Claude Code actually sends when the
+ *    schema lets it — cleared nothing, and the Stop hook blocked forever.
+ *    Never re-gate the reset on a field the caller may legitimately omit.
  *
  * Input (stdin JSON):
  *   { session_id, tool_name, tool_input: { ... }, tool_response: { ... } }
  *
  * Output (stdout JSON):
- *   - On edit at threshold multiples (3, 6, 9...): { additionalContext: "..." }
+ *   - On an edit that hits the threshold:
+ *     { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } }
  *   - Otherwise: {} (side effects only)
  */
 
@@ -45,14 +52,38 @@ for (const dir of [PENDING_COMPACT_DIR, PENDING_REMEMBER_DIR]) {
 const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
 const EDIT_THRESHOLD = 1;
 
+/**
+ * Explicit-failure detection ONLY — everything ambiguous counts as SUCCESS.
+ *
+ * MCP tools return a CallToolResult: { content: [{type:'text',text}], isError? }.
+ * Claude Code passes it through and snake_cases some fields depending on version,
+ * so accept both spellings. A missing tool_response, a plain string, or an object
+ * of unknown shape MUST fail open: a format change on the Claude Code side can
+ * never be allowed to reintroduce the never-clears bug this hook exists to avoid.
+ *
+ * A schema rejection (InvalidParams) doesn't fire PostToolUse at all, which is
+ * also correct — nothing was stored, so nothing should clear.
+ */
+function toolCallFailed(resp) {
+  if (!resp || typeof resp !== 'object' || Array.isArray(resp)) return false;
+  if (resp.isError === true || resp.is_error === true) return true;
+  if (resp.success === false) return true;
+  if (typeof resp.status === 'string' && resp.status.toLowerCase() === 'error') return true;
+  return false;
+}
+
 function readStdin() {
   return new Promise((resolve) => {
     if (process.stdin.isTTY) return resolve('{}');
     let data = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-    setTimeout(() => resolve(data || '{}'), 2000);
+    process.stdin.on('end', () => { clearTimeout(guard); resolve(data); });
+    // unref + clearTimeout: without both, this timer keeps the event loop alive
+    // for its full duration AFTER 'end' already resolved, so every hook
+    // invocation stalled ~2s against a 3s configured timeout.
+    const guard = setTimeout(() => resolve(data || '{}'), 2000);
+    guard.unref?.();
   });
 }
 
@@ -85,6 +116,12 @@ async function main() {
       } catch { /* start fresh */ }
     }
 
+    // A new edit segment starts a fresh obligation. `retries` is per-segment
+    // backoff, not a session budget — without this reset, MAX_RETRIES blocks
+    // permanently disable task-memory enforcement for the rest of the session
+    // (the only other reset paths require editCount to already be 0).
+    if ((flag.editCount || 0) === 0) flag.retries = 0;
+
     // Increment edit counters
     flag.editCount = (flag.editCount || 0) + 1;
     flag.totalEdits = (flag.totalEdits || 0) + 1;
@@ -101,7 +138,7 @@ async function main() {
       writeFileSync(flagPath, JSON.stringify(flag));
     } catch { /* ok */ }
 
-    // Proactive nudge at every multiple of threshold (3, 6, 9, ...)
+    // Proactive nudge at every multiple of EDIT_THRESHOLD
     if (flag.editCount > 0 && flag.editCount % EDIT_THRESHOLD === 0) {
       let nudgeText;
       if (flag.editCount <= EDIT_THRESHOLD) {
@@ -124,7 +161,12 @@ async function main() {
         } catch { /* category tree optional — nudge still works without it */ }
       }
 
-      process.stdout.write(JSON.stringify({ additionalContext: nudgeText }));
+      // PostToolUse reads additionalContext from hookSpecificOutput. A bare
+      // top-level { additionalContext } is silently discarded — which is why
+      // these nudges never reached the model.
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: nudgeText },
+      }));
     } else {
       process.stdout.write(JSON.stringify({}));
     }
@@ -152,13 +194,18 @@ async function main() {
     }
   }
 
-  // ─── REMEMBER FLAG CLEARING ───
-  // Both remember and reflect count as storing work — clear edit tracking for either.
-  if (toolName.includes('remember') || toolName.includes('reflect')) {
-    const category = toolInput.category || '';
+  // ─── MEMORY-STORED CLEARING ───
+  // ANY successful remember/reflect resets edit tracking, regardless of category.
+  // Claude Code routinely calls remember with { content } only, and reflect rarely
+  // carries a category — gating this reset on category truthiness is what made the
+  // Stop hook block forever. Category only decides the EXTRA compaction clear below.
+  const storedMemory = (toolName.includes('remember') || toolName.includes('reflect'))
+    && !toolCallFailed(input.tool_response);
 
-    if (category === 'conversations') {
-      // Clear ALL pending-compact flags (session ID may differ after compaction)
+  if (storedMemory) {
+    // A "conversations" memory ALSO satisfies the compaction obligation.
+    // Clear every pending-compact flag — the session ID changes after compaction.
+    if ((toolInput.category || '') === 'conversations') {
       try {
         if (existsSync(PENDING_COMPACT_DIR)) {
           for (const f of readdirSync(PENDING_COMPACT_DIR).filter(f => f.endsWith('.json'))) {
@@ -166,58 +213,44 @@ async function main() {
           }
         }
       } catch { /* ok */ }
-      // Also reset pending-remember flag (conversations remember counts too)
-      const rememberFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
-      if (existsSync(rememberFlagPath)) {
-        try {
-          let flag = {};
-          try { flag = JSON.parse(readFileSync(rememberFlagPath, 'utf-8')); } catch { /* fresh */ }
-          flag.editCount = 0;
-          flag.messageCount = 0;
-          flag.retries = 0;
-          flag.files = [];
-          flag.firstEditAt = null;
-          flag.lastEditAt = null;
-          flag.rememberCount = (flag.rememberCount || 0) + 1;
-          flag.lastRememberedAt = new Date().toISOString();
-          writeFileSync(rememberFlagPath, JSON.stringify(flag));
-        } catch { /* ok */ }
-      }
-    } else if (category) {
-      // Reset pending-remember flag (keep file, zero counters for next task segment)
-      const rememberFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
-      if (existsSync(rememberFlagPath)) {
-        try {
-          let flag = {};
-          try { flag = JSON.parse(readFileSync(rememberFlagPath, 'utf-8')); } catch { /* start fresh */ }
-
-          const prevTotal = flag.totalEdits || flag.editCount || 0;
-          const prevRememberCount = flag.rememberCount || 0;
-
-          // Reset edit + message tracking but keep session-level stats
-          flag.editCount = 0;
-          flag.messageCount = 0;
-          flag.retries = 0;
-          flag.files = [];
-          flag.firstEditAt = null;
-          flag.lastEditAt = null;
-          flag.firstMessageAt = null;
-          flag.lastMessageAt = null;
-          flag.lastRememberedAt = new Date().toISOString();
-          flag.rememberCount = prevRememberCount + 1;
-          flag.totalEdits = prevTotal;
-
-          writeFileSync(rememberFlagPath, JSON.stringify(flag));
-        } catch {
-          // If reset fails, fall back to deleting
-          try { unlinkSync(rememberFlagPath); } catch { /* ok */ }
-        }
+    }
+
+    // Reset pending-remember (keep the file, zero counters for the next segment).
+    // Never create it here — prompt-submit.mjs owns creation, and manufacturing a
+    // flag for a session that never edited would resurrect stale-file buildup.
+    const rememberFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
+    if (existsSync(rememberFlagPath)) {
+      try {
+        let flag = {};
+        try { flag = JSON.parse(readFileSync(rememberFlagPath, 'utf-8')); } catch { /* start fresh */ }
+
+        // Preserve session-level stats before zeroing the segment counters.
+        flag.totalEdits = flag.totalEdits || flag.editCount || 0;
+        flag.rememberCount = (flag.rememberCount || 0) + 1;
+        flag.lastRememberedAt = new Date().toISOString();
+
+        flag.editCount = 0;
+        flag.messageCount = 0;
+        flag.retries = 0;
+        flag.taskBlockTotal = 0;
+        flag.files = [];
+        flag.firstEditAt = null;
+        flag.lastEditAt = null;
+        flag.firstMessageAt = null;
+        flag.lastMessageAt = null;
+        // categoryTreeInjected is intentionally NOT reset — the category tree is
+        // injected once per session, not once per task segment.
+
+        writeFileSync(rememberFlagPath, JSON.stringify(flag));
+      } catch {
+        // If reset fails, fall back to deleting
+        try { unlinkSync(rememberFlagPath); } catch { /* ok */ }
       }
     }
   }
 
-  // Update loop memory tracking when remember is called during an active loop
-  if (toolName.includes('remember')) {
+  // Update loop memory tracking when a memory is stored during an active loop
+  if (storedMemory) {
     const LOOP_DIR = join(DATA_DIR, 'loop');
     const loopPath = join(LOOP_DIR, `${sessionId}.json`);
     if (existsSync(loopPath)) {

package/hooks/claude-code/prompt-submit.mjs

@@ -197,8 +197,12 @@ function readStdin() {
     let data = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-    setTimeout(() => resolve(data || '{}'), 2000);
+    process.stdin.on('end', () => { clearTimeout(guard); resolve(data); });
+    // unref + clearTimeout: without both, this timer keeps the event loop alive
+    // for its full duration AFTER 'end' already resolved, so every hook
+    // invocation stalled ~2s against a 3s configured timeout.
+    const guard = setTimeout(() => resolve(data || '{}'), 2000);
+    guard.unref?.();
   });
 }
 

package/hooks/claude-code/session-start.mjs

@@ -99,8 +99,12 @@ function readStdin() {
     let data = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-    setTimeout(() => resolve(data || '{}'), 2000);
+    process.stdin.on('end', () => { clearTimeout(guard); resolve(data); });
+    // unref + clearTimeout: without both, this timer keeps the event loop alive
+    // for its full duration AFTER 'end' already resolved, so every hook
+    // invocation stalled ~2s against a 3s configured timeout.
+    const guard = setTimeout(() => resolve(data || '{}'), 2000);
+    guard.unref?.();
   });
 }
 
@@ -185,9 +189,9 @@ async function main() {
   // Sweep pending-remember flags from long-dead sessions (never deleted otherwise).
   cleanupStalePendingRemember();
   const LOOP_STALE_MS = 10 * 60 * 1000;
-  const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
-  let isLoopSession = false;
-  let isNativeLoopSession = false;
+  const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
+  let isLoopSession = false;
+  let isNativeLoopSession = false;
   try {
     if (existsSync(LOOP_DIR)) {
       const now = Date.now();
@@ -210,10 +214,10 @@ async function main() {
               if (data.terminalSessionId !== terminalSessionEnv) continue;
             } else {
               if (data.terminalSessionId) continue;
-            }
-            isLoopSession = true;
-            isNativeLoopSession = data.driverType === 'native';
-            break;
+            }
+            isLoopSession = true;
+            isNativeLoopSession = data.driverType === 'native';
+            break;
           }
         } catch { /* skip */ }
       }
@@ -227,9 +231,9 @@ async function main() {
       ``,
       `SynaBun memory is active. CLAUDE.md contains the memory rules. Follow them throughout this session.`,
       ``,
-      isNativeLoopSession
-        ? `**This is a native autonomous loop session.** Do NOT output any greeting or call recall at startup. The server sends the complete iteration task directly; execute it immediately.`
-        : `**This is an autonomous loop session.** Do NOT output any greeting. Do NOT call recall at startup. Wait for the loop task injection from the UserPromptSubmit hook, then execute immediately.`,
+      isNativeLoopSession
+        ? `**This is a native autonomous loop session.** Do NOT output any greeting or call recall at startup. The server sends the complete iteration task directly; execute it immediately.`
+        : `**This is an autonomous loop session.** Do NOT output any greeting. Do NOT call recall at startup. Wait for the loop task injection from the UserPromptSubmit hook, then execute immediately.`,
       ``,
       `Current project: **${project}**`,
     );

package/hooks/claude-code/shared.mjs

@@ -100,8 +100,12 @@ export function readStdin() {
     let data = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-    setTimeout(() => resolve(data || '{}'), 2000);
+    process.stdin.on('end', () => { clearTimeout(guard); resolve(data); });
+    // unref + clearTimeout: without both, this timer keeps the event loop alive
+    // for its full duration AFTER 'end' already resolved, so every hook
+    // invocation stalled ~2s against a 3s configured timeout.
+    const guard = setTimeout(() => resolve(data || '{}'), 2000);
+    guard.unref?.();
   });
 }
 

package/hooks/claude-code/stop.mjs

@@ -62,6 +62,11 @@ const STORED_PLANS_PATH = join(DATA_DIR, 'stored-plans.json');
 const PLAN_DEBUG_LOG = join(DATA_DIR, 'plan-debug.log');
 const MAX_RETRIES = 3;
 const EDIT_THRESHOLD = 1;
+// Session ceiling on task-memory blocks. `retries` resets whenever a new edit
+// segment starts (post-remember.mjs), so it alone can no longer bound the
+// block↔respond cycle. `stop_hook_active` is not honored by this hook, so this
+// is the only backstop against an agent that edits-then-stops forever.
+const MAX_TASK_BLOCKS = 12;
 
 function planDebug(msg) {
   try { appendCapped(PLAN_DEBUG_LOG, `[${new Date().toISOString()}] ${msg}\n`); } catch { /* ok */ }
@@ -81,6 +86,7 @@ function softCleanupFlag(flagPath) {
     const cleaned = {
       editCount: 0,
       retries: 0,
+      taskBlockTotal: 0,
       files: [],
       messageCount: flag.messageCount || 0,
       totalSessionMessages: flag.totalSessionMessages || 0,
@@ -232,8 +238,12 @@ function readStdin() {
     let data = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-    setTimeout(() => resolve(data || '{}'), 2000);
+    process.stdin.on('end', () => { clearTimeout(guard); resolve(data); });
+    // unref + clearTimeout: without both, this timer keeps the event loop alive
+    // for its full duration AFTER 'end' already resolved, so every hook
+    // invocation stalled ~2s against a 3s configured timeout.
+    const guard = setTimeout(() => resolve(data || '{}'), 2000);
+    guard.unref?.();
   });
 }
 
@@ -391,31 +401,31 @@ async function main() {
         }
       }
     } catch { /* ok */ }
-  }
-
-  // ─── CHECK 1.5: Active loop ───
-  // Native loops keep their state at {runId}.json for the server-owned runtime.
-  // Return before the legacy /clear ownership scan can rename that file to the
-  // Claude session ID and make the runtime believe its state was deleted.
-  if (terminalSessionEnv) {
-    try {
-      const nativePath = join(LOOP_DIR, `${terminalSessionEnv}.json`);
-      if (existsSync(nativePath)) {
-        const nativeLoop = JSON.parse(readFileSync(nativePath, 'utf-8'));
-        if (nativeLoop?.active && nativeLoop.driverType === 'native'
-          && nativeLoop.terminalSessionId === terminalSessionEnv) {
-          appendLoopLog(terminalSessionEnv, 'stop:native', 'leaving iteration transition to native runtime', {
-            sessionId,
-            currentIteration: nativeLoop.currentIteration || 0,
-          });
-          process.stdout.write(JSON.stringify({}));
-          return;
-        }
-      }
-    } catch { /* fall through to legacy ownership scan */ }
-  }
-
-  // Deactivate stale loops first (session died, terminal closed, time expired)
+  }
+
+  // ─── CHECK 1.5: Active loop ───
+  // Native loops keep their state at {runId}.json for the server-owned runtime.
+  // Return before the legacy /clear ownership scan can rename that file to the
+  // Claude session ID and make the runtime believe its state was deleted.
+  if (terminalSessionEnv) {
+    try {
+      const nativePath = join(LOOP_DIR, `${terminalSessionEnv}.json`);
+      if (existsSync(nativePath)) {
+        const nativeLoop = JSON.parse(readFileSync(nativePath, 'utf-8'));
+        if (nativeLoop?.active && nativeLoop.driverType === 'native'
+          && nativeLoop.terminalSessionId === terminalSessionEnv) {
+          appendLoopLog(terminalSessionEnv, 'stop:native', 'leaving iteration transition to native runtime', {
+            sessionId,
+            currentIteration: nativeLoop.currentIteration || 0,
+          });
+          process.stdout.write(JSON.stringify({}));
+          return;
+        }
+      }
+    } catch { /* fall through to legacy ownership scan */ }
+  }
+
+  // Deactivate stale loops first (session died, terminal closed, time expired)
   cleanupStaleLoops(LOOP_DIR);
   // After /clear, session ID may change. Try exact match first, then scan for any active loop.
   let loopFlagPath = join(LOOP_DIR, `${sessionId}.json`);
@@ -494,8 +504,8 @@ async function main() {
     } catch { /* ok */ }
   }
 
-  // Skip server-driven exec/native loops. Their runtimes own iteration transitions.
-  if (loop?.active && (loop.driverType === 'exec' || loop.driverType === 'native')) {
+  // Skip server-driven exec/native loops. Their runtimes own iteration transitions.
+  if (loop?.active && (loop.driverType === 'exec' || loop.driverType === 'native')) {
     process.stdout.write(JSON.stringify({}));
     return;
   }
@@ -642,8 +652,10 @@ async function main() {
     // CHECK 2: Task remember (edits without memory entry)
     if (editCount >= EDIT_THRESHOLD) {
       const retries = flag.retries || 0;
-      if (retries < MAX_RETRIES) {
+      const taskBlockTotal = flag.taskBlockTotal || 0;
+      if (retries < MAX_RETRIES && taskBlockTotal < MAX_TASK_BLOCKS) {
         flag.retries = retries + 1;
+        flag.taskBlockTotal = taskBlockTotal + 1;
         const files = Array.isArray(flag.files) ? flag.files : [];
         const fileList = files.length > 0
           ? ` Files: ${files.slice(0, 5).join(', ')}${files.length > 5 ? ` (+${files.length - 5} more)` : ''}`