moflo 4.12.6 → 4.12.7

package/.claude/guidance/shipped/moflo-agent-rules.md

@@ -170,8 +170,23 @@ npx flo memory store --namespace patterns --key "brief-descriptive-key" --value
 | `patterns` | Solutions to tricky bugs, patterns that worked, gotchas, workarounds |
 | `learnings` | Architectural choices, user-stated decisions, post-mortem insights (`knowledge` is a deprecated alias — writes auto-redirect) |
 
+**Every entry must clear one bar: would it help a future session working on a *different* task?**
+If not, it does not go in memory. `memory_search` returns a **bounded** result set, so a non-durable
+entry does not merely waste space — it permanently displaces a reusable lesson from every future
+search.
+
+**Never store a summary of the run that just happened.** What you changed, which files you touched,
+which tests you ran, and what you decided for this one ticket are git history and belong in the
+commit or PR body. That content is applicable exactly once, so it can only ever crowd out something
+that is applicable repeatedly.
+
 **Skip** generic summaries of retrieved guidance, restated rules, and trivial file-location notes — those waste retrieval bandwidth on every future search.
 
+**A gate never justifies a write.** When a gate demands a memory write and the run produced nothing
+durable, declare that instead of inventing something — a mandatory write with nothing to say
+produces filler by construction. `/flo`'s learnings gate takes
+`node .claude/helpers/gate.cjs record-no-durable-lesson` for exactly this case.
+
 ---
 
 ## See Also

package/.claude/guidance/shipped/moflo-claude-swarm-cohesion.md

@@ -119,7 +119,15 @@ TaskList()  // Shows what's now unblocked
 TaskUpdate({ taskId: "2", status: "in_progress" })  // Next agent starts
 ```
 
-Close every task you open. moflo's PR gate reads the session transcript on `gh pr create` and prints `N tasks created this session, M still open` — an unclosed list reports as unfinished work on the PR. Mark tasks that no longer apply `status: "deleted"`; that closes the loop exactly like `completed`.
+**Close every task you open — `gh pr create` is blocked until you do.** moflo's PR gate reads the session transcript, counts the tasks this session opened against the ones it closed, and stops the PR while any remain open. A stale list reports work as not-started that is about to merge.
+
+| Situation | Action |
+|-----------|--------|
+| The work is done | `TaskUpdate({ taskId: "1", status: "completed" })` |
+| The task no longer applies | `TaskUpdate({ taskId: "1", status: "deleted" })` — closes the loop exactly like `completed` |
+| The work is deliberately deferred past this PR | Run the acknowledgement command the block message prints — it credits the gate and leaves the tasks open |
+
+Never mark a task `completed` to clear the gate. The acknowledgement path exists so the honest outcome costs one command; a false `completed` costs the user their only accurate view of what shipped. Set `gates: task_status_gate: warn` in `moflo.yaml` to report instead of block, or `off` to silence it.
 
 ---
 
@@ -132,7 +140,7 @@ Close every task you open. moflo's PR gate reads the session transcript on `gh p
 | 3 | Mark `completed` when results return |
 | 4 | Use `TaskList` to monitor what's unblocked |
 | 5 | Synthesize all agent outputs before proceeding |
-| 6 | Store learnings in memory after completion |
+| 6 | Store a learning after completion **only if** it would help a different future task — a run summary belongs in the PR body, not memory |
 
 ---
 

package/.claude/helpers/gate-hook.mjs

@@ -114,6 +114,34 @@ if (hookContext.tool_response && typeof hookContext.tool_response === 'object')
   }
 }
 
+// #1435 — deliver a PASSING gate's advisory to Claude, not only to the transcript.
+//
+// Claude Code shows a PreToolUse/PostToolUse hook's stdout to the user in
+// transcript mode and stops there; the model never sees it. So every advisory
+// the gates emit on the exit-0 path was invisible on exactly the runs it was
+// written for: #1374's open-task count, the pre-Agent TaskCreate reminder, the
+// namespace hint, the docs-only and simplify-auto-pass notes. They surfaced only
+// when some OTHER gate blocked, because the catch arm below re-routes err.stdout
+// to stderr — i.e. only once the PR had already been stopped for another reason.
+// A consumer shipped a PR over four untouched tasks with that reminder "working".
+//
+// `hookSpecificOutput.additionalContext` is the documented channel from a passing
+// tool hook into the model's context. Wrap there and nowhere else: SessionStart
+// and UserPromptSubmit already inject their stdout as context, so wrapping those
+// would rewrite a working path for nothing. An unknown or absent hook_event_name
+// falls back to raw stdout — byte-identical to the previous behaviour.
+var ADVISORY_EVENTS = { PreToolUse: true, PostToolUse: true };
+function emitAdvisory(text) {
+  var event = hookContext.hook_event_name;
+  if (!ADVISORY_EVENTS[event]) {
+    process.stdout.write(text);
+    return;
+  }
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: event, additionalContext: text },
+  }) + '\n');
+}
+
 // Run gate.cjs with the enriched environment
 var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
 var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
@@ -121,7 +149,7 @@ try {
   var output = execFileSync('node', [gateScript, command], {
     env: env, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true
   });
-  if (output.trim()) process.stdout.write(output);
+  if (output.trim()) emitAdvisory(output);
   process.exit(0);
 } catch (err) {
   // gate.cjs exit(2) = block, exit(1) = also block attempt — translate both to exit(2)

package/.claude/helpers/gate.cjs

@@ -13,7 +13,7 @@ var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 // the code it describes, so a change made outside Write/Edit/MultiEdit (a Bash
 // write, a branch switch, the next issue in the same session) invalidates it.
 // See creditFingerprint() for why the boolean flags alone cannot.
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, testsFingerprint: null, simplifyRun: false, simplifySnapshotSha: null, simplifyFingerprint: null, verifyRun: false, verifyOutcome: null, verifyFingerprint: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, tasksAcknowledged: false, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, testsFingerprint: null, simplifyRun: false, simplifySnapshotSha: null, simplifyFingerprint: null, verifyRun: false, verifyOutcome: null, verifyFingerprint: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
 
 // Per-actor memory-search tracking (#838). The legacy `memorySearched` boolean
 // is session-wide, so once the parent searches memory, every spawned subagent
@@ -70,9 +70,24 @@ function loadGateConfig() {
   // ships a real /verify skill and has /flo delegate to it, so leaving it off by
   // default would make the default /flo run silently skip the acceptance check.
   // Disable per-project with `verify_before_done: false` or per-run `--no-verify`.
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true };
+  // task_status_gate is a MODE, not a boolean: 'block' | 'warn' | 'off' (#1435).
+  // #1374 shipped the open-task count as a warn-only stdout line, and a consumer
+  // still shipped a PR over four untouched tasks — a reminder that survived ten
+  // consecutive ignores in one session is not a control. Blocking is the default
+  // because the honest "these stay open on purpose" outcome is one command away
+  // (record-tasks-acknowledged), so nothing here can deadlock a run.
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true, task_status_gate: 'block' };
   var content = MOFLO_YAML;
   if (content) {
+    // Boolean forms are accepted so this key reads like every other gate in the
+    // block: `false` is the same opt-out `testing_gate: false` is, `true` means
+    // enforce. Anything unrecognised falls through to the default rather than
+    // silently disabling the gate — a typo must not be a stealth opt-out.
+    var tsg = /task_status_gate:\s*['"]?(block|warn|off|false|true)['"]?/i.exec(content);
+    if (tsg) {
+      var mode = tsg[1].toLowerCase();
+      defaults.task_status_gate = mode === 'false' ? 'off' : mode === 'true' ? 'block' : mode;
+    }
     if (/memory_first:\s*false/i.test(content)) defaults.memory_first = false;
     if (/task_create_first:\s*false/i.test(content)) defaults.task_create_first = false;
     if (/context_tracking:\s*false/i.test(content)) defaults.context_tracking = false;
@@ -172,6 +187,25 @@ var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule
 // /verify's Step 5 memory_store carries the verdict AND stamps learnings, which
 // is why learnings has no separate step here.
 var ORDER_HINT = 'Order that satisfies all of them: tests green -> /flo-simplify (re-run tests if it edits) -> /verify -> its memory_store verdict -> gh pr create\n';
+// #1434 — the old text ('learnings have not been stored (call memory_store)')
+// named the mechanism but no quality bar, so the cheapest way past it was a
+// summary of the run — audit exhaust that displaces reusable lessons from every
+// future bounded search. Name the bar AND the no-write path here: an escape
+// hatch nobody can find is not an escape hatch (see #1332's gate deadlock).
+//
+// The escape command is built from __filename, not written as a relative path.
+// The caller is the model typing into a Bash tool, NOT a hook: $CLAUDE_PROJECT_DIR
+// is unset there (so the settings.json form would expand to "/.claude/..."), and a
+// bare `.claude/helpers/gate.cjs` breaks from any cwd but the project root. The
+// running script's own absolute path is correct on every OS and from any cwd;
+// double quotes carry Windows separators and spaces through the shell.
+var LEARNINGS_MISSING =
+  'no durable lesson recorded. A lesson qualifies only if it would help a future session ' +
+  'working on a DIFFERENT task — a reusable pattern, a trap, a decision + rationale. ' +
+  'Store one with mcp__moflo__memory_store (namespace "learnings"; use "patterns" for a ' +
+  'reusable code shape). What THIS run changed is git history — it belongs in the PR body, ' +
+  'not in memory. If this run taught nothing new, say so instead of inventing one: ' +
+  'node "' + __filename + '" record-no-durable-lesson';
 var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
 // #1338 — Claude Code spawns stdio MCP servers once at session start and never
 // respawns them, so a session can outlive its moflo MCP connection. Naming only
@@ -1355,6 +1389,41 @@ switch (command) {
     writeState(s);
     break;
   }
+  // #1435 — the escape from the task-status gate, for work deliberately left
+  // open. Session-scoped like `learningsStored`: it lives in STATE_DEFAULTS, so
+  // session-reset clears it, and neither applyPromptStateReset nor
+  // reset-edit-gates touches it — a decision the user made about the task list
+  // is not invalidated by the next prompt or the next source edit.
+  //
+  // A plain flag, not a count. The command is typed by the model into a Bash
+  // tool, where HOOK_TRANSCRIPT_PATH is unset (it is forwarded by gate-hook.mjs
+  // from the hook payload and exists only inside a hook), so this process cannot
+  // read the ledger to record WHICH tasks were acknowledged even if it wanted to.
+  case 'record-tasks-acknowledged': {
+    var s = readState();
+    if (!s.tasksAcknowledged) {
+      s.tasksAcknowledged = true;
+      writeState(s);
+    }
+    // writeState swallows its own errors by design — a gate must never crash the
+    // hook it runs in. That was harmless while every recorder was advisory. This
+    // one is the ONLY escape from a BLOCKING gate, so a lost write would report
+    // "satisfied" and then block the very next `gh pr create` with nothing said
+    // about why: #1332's deadlock shape exactly. Confirm it landed before
+    // claiming it did, and name the file and the way out when it did not.
+    if (!readState().tasksAcknowledged) {
+      process.stderr.write(
+        'Task-status gate NOT satisfied: the acknowledgement could not be persisted to\n' +
+        STATE_FILE + '\n' +
+        'Check that the file and its directory are writable, then run this again.\n' +
+        'To proceed without it: set gates: task_status_gate: off in moflo.yaml.\n');
+      process.exit(1);
+    }
+    process.stdout.write(
+      'Task-status gate satisfied: open tasks acknowledged as deliberately deferred.\n' +
+      'They stay visible in the task list — this records the decision, it does not close them.\n');
+    break;
+  }
   case 'record-memory-searched': {
     var s = readState();
     if (markMemorySearched(s)) writeState(s);
@@ -1417,12 +1486,48 @@ switch (command) {
     // Why it does nothing: see applyPromptStateReset().
     break;
   }
-  case 'record-learnings-stored': {
+  // #1434 — the gate demanded one memory_store per run whether or not the run
+  // produced a reusable lesson, and a mandatory write with nothing to say
+  // produces filler: a summary of this ticket, this commit, applicable never
+  // again. memory_search returns a bounded set, so each of those displaces a
+  // real lesson from every future search — the cost is retrieval quality, not
+  // disk. Declaring "nothing durable here" is the honest outcome of a run that
+  // learned nothing new, so it has to be reachable without a write; otherwise
+  // the cheapest way past the gate stays the filler write.
+  //
+  // Both credits set the same flag; they differ only in whether the run has
+  // something to say. Sharing the case body keeps that single write in one
+  // place across all three copies of this file.
+  case 'record-learnings-stored':
+  case 'record-no-durable-lesson': {
     var s = readState();
     if (!s.learningsStored) {
       s.learningsStored = true;
       writeState(s);
     }
+    if (command === 'record-no-durable-lesson') {
+      // Same reasoning as record-tasks-acknowledged above: writeState swallows
+      // its own errors so a gate never crashes the hook it runs in, and this is
+      // the ONLY escape from the BLOCKING learnings gate that does not require a
+      // memory_store. A lost write here would print "satisfied" and then block
+      // the next `gh pr create` with nothing said about why — #1332's deadlock.
+      // Verified only on this arm: record-learnings-stored is fired
+      // automatically by the PostToolUse hook on every memory_store, where a
+      // failed write leaves the gate closed but the run still has the ordinary
+      // way through, and a diagnostic on every store would be noise.
+      if (!readState().learningsStored) {
+        process.stderr.write(
+          'Learnings gate NOT satisfied: the declaration could not be persisted to\n' +
+          STATE_FILE + '\n' +
+          'Check that the file and its directory are writable, then run this again.\n' +
+          'To proceed without it: set gates: learnings_gate: false in moflo.yaml.\n');
+        process.exit(1);
+      }
+      process.stdout.write(
+        'Learnings gate satisfied: no durable lesson declared for this run.\n' +
+        'What this run did belongs in the PR body, not in memory.\n',
+      );
+    }
     break;
   }
   case 'record-test-run': {
@@ -1645,25 +1750,46 @@ switch (command) {
     // chained, piped, parenthesised, and multi-line shapes (#1410).
     var cmd = process.env.TOOL_INPUT_command || '';
     if (!isPrCreateCommand(cmd)) break;
-    // #1374 — close the loop the TaskCreate reminder opens. Advisory: stdout,
-    // no exit, and worded as a reminder, because a message may only claim to
-    // block when it blocks (#1326). An open task list is a reporting failure,
-    // not a quality failure — blocking the PR on it would be a new deadlock.
+    // #1374 opened this loop; #1435 closes it. The count itself is unchanged —
+    // what changed is that it now has teeth and, in warn mode, a delivery path.
     //
     // Deliberately ABOVE the no-source exemption below: a docs-only PR can
     // abandon a list exactly like a source PR can, and the exemption is about
     // testing/simplify/learnings, not about whether the run told the user what
-    // it did. Gated on the same `task_create_first` flag as the reminder itself
-    // so the two halves are always consistent — a project that turned the nag
-    // off is not then nagged about the other end of it.
-    if (config.task_create_first) {
+    // it did. It also exits on its own rather than joining `missing` below, for
+    // the same reason — `missing` is unreachable on an exempt diff.
+    //
+    // Gated on the same `task_create_first` flag as the reminder itself so the
+    // two halves are always consistent: a project that turned the nag off is
+    // not then blocked about the other end of it.
+    //
+    // Fail-open is load-bearing. readTaskLedger() returns null on a missing,
+    // oversized, or unreadable transcript and on a session with no TaskCreate at
+    // all, and null must never block — a gate that stops PRs because it could
+    // not read a file is worse than the reporting gap it is closing.
+    //
+    // State is read ONCE for the whole case, here — the pre-PR gate logic below
+    // reuses it and nothing writes in between. Reading it before the ledger also
+    // means an already-acknowledged run never pays for the transcript scan.
+    var s = readState();
+    if (config.task_create_first && config.task_status_gate !== 'off' && !s.tasksAcknowledged) {
       var ledger = readTaskLedger();
       if (ledger && ledger.open > 0) {
-        process.stdout.write(
-          'REMINDER: ' + ledger.created + ' task' + (ledger.created === 1 ? '' : 's') +
-          ' created this session, ' + ledger.open + ' still open. Close them with ' +
-          'TaskUpdate (status: completed), or delete the ones that no longer apply, ' +
-          'so the run does not report done over an unfinished list.\n');
+        var tally = ledger.created + ' task' + (ledger.created === 1 ? '' : 's') +
+          ' created this session, ' + ledger.open + ' still open.';
+        var closeIt = 'Close them with TaskUpdate (status: completed), or delete the ones ' +
+          'that no longer apply, so the run does not report done over an unfinished list.\n';
+        if (config.task_status_gate === 'warn') {
+          process.stdout.write('REMINDER: ' + tally + ' ' + closeIt);
+        } else {
+          process.stderr.write(
+            'BLOCKED: ' + tally + '\n' + closeIt +
+            'Deferring them on purpose is a legitimate outcome — declare it instead of\n' +
+            'closing tasks that are not done: node "' + __filename + '" record-tasks-acknowledged\n' +
+            GATE_ORIGIN_NOTE + '\n' +
+            'Report instead of blocking via moflo.yaml: gates: task_status_gate: warn   (or: off)\n');
+          process.exit(2);
+        }
       }
     }
     // No-source-files exemption (#1176, supersedes the original docs-only path).
@@ -1688,7 +1814,6 @@ switch (command) {
         break;
       }
     }
-    var s = readState();
     // Expire any credit whose fingerprint no longer matches the code before
     // reading the flags. This is what catches the mutations reset-edit-gates
     // structurally cannot see — Bash writes, git checkout/pull/merge, and the
@@ -1721,7 +1846,7 @@ switch (command) {
     var missing = [];
     if (config.testing_gate && !s.testsRun) missing.push('tests have not run green since the last code edit (run npm test, vitest, jest, pytest, or similar — a run whose output reports failures does not count)');
     if (config.simplify_gate && !s.simplifyRun) missing.push('/flo-simplify (or /distill) has not run since the last code edit');
-    if (config.learnings_gate && !s.learningsStored) missing.push('learnings have not been stored (call mcp__moflo__memory_store)');
+    if (config.learnings_gate && !s.learningsStored) missing.push(LEARNINGS_MISSING);
     if (missing.length === 0) break;
     process.stderr.write('BLOCKED: gh pr create requires the following before opening a PR:\n');
     for (var i = 0; i < missing.length; i++) {

package/.claude/skills/fl/SKILL.md

@@ -106,10 +106,12 @@ research → ticket → execute → tests → simplify → learnings → pr
 | Execute | Assign issue, create branch, implement |
 | Tests | Run unit + integration + E2E |
 | Simplify | Run `/flo-simplify` on changed code |
-| Learnings | Call `mcp__moflo__memory_store` with what was learned |
-| PR | Open the PR, update issue status |
+| Learnings | Store a **durable** lesson — one that helps a *different* future task — or declare there is none. A run summary belongs in the PR body, never in memory |
+| PR | Close every task this run opened, then open the PR and update issue status |
 
-The tests, simplify, and learnings steps are enforced by hooks. `gh pr create` is blocked by `check-before-pr` until each has run in the current session. Skill text describes the flow; the gates handle compliance.
+The tests, simplify, learnings, and task-closure steps are enforced by hooks. `gh pr create` is blocked by `check-before-pr` until each has run in the current session. Skill text describes the flow; the gates handle compliance.
+
+**Close the task list before the PR, and close it honestly.** `TaskUpdate` each task `completed`, or `deleted` if it no longer applies. Work deliberately left open is a legitimate outcome — the block message prints a one-command acknowledgement for it. Never mark a task `completed` just to clear the gate: the list is the user's only view of what actually shipped.
 
 ## Companion files
 
@@ -270,6 +272,6 @@ Full mode runs end-to-end without further prompts.
 6. Run `/flo-simplify` on changed code; rerun tests if it edits — `./phases.md` Phase 4.5
 7. Commit — `./phases.md` Phase 5.1
 8. **Verify — default, unless `--no-verify`** (`verifyMode`, always on under `sddMode`): delegate to the `/verify` skill — `Skill({ skill: "verify" })`. It checks the change against the acceptance criteria, reusing Phase 4's tests (no double verify) and recording its own outcome; invoking it satisfies the verify-before-done gate. Mechanics live in `.claude/skills/verify/SKILL.md`; trigger/flow in `./phases.md` Phase 5.1b.
-9. Store learnings via `mcp__moflo__memory_store` — `./phases.md` Phase 5.2
+9. Record a durable lesson via `mcp__moflo__memory_store`, or declare there is none — `./phases.md` Phase 5.2
 10. Open PR, update issue status — `./phases.md` Phases 5.3–5.4
 11. **If `mergeMode`:** await the PR's merge preconditions and merge it (native `--auto` preferred, else poll-then-merge) — `./phases.md` Phase 5.3b

package/.claude/skills/fl/phases.md

@@ -173,21 +173,73 @@ repository and their git history is permanent — moflo does not sign their comm
 
 **When it runs:** by default (`verify_before_done` now defaults true) and always under `--sdd`; `--no-verify` skips it for one run. See `./sdd.md` for triggers and `.claude/skills/verify/SKILL.md` for how verification is performed.
 
-### 5.2 Store learnings
-Before opening the PR, call `mcp__moflo__memory_store` with what was learned. The `check-before-pr` gate blocks `gh pr create` until this has run.
+### 5.2 Record a durable lesson — or declare there isn't one
+
+**A run summary is not a learning.** What this run changed — files touched, the fix applied,
+the decision taken for this ticket — is git history and belongs in the PR body. Writing it to
+memory instead is audit exhaust: one ticket, one commit, applicable never again. `memory_search`
+returns a **bounded** result set, so every such entry permanently displaces a reusable lesson
+from every future search. That cost is retrieval quality, not disk.
+
+Apply the **durability bar** — the same one `/meditate` uses:
+
+> *Would this help a future session working on a **different** task?*
+
+| Store it | Where | Skip it — it is not a lesson |
+|----------|-------|------------------------------|
+| A reusable pattern: "for X, do Y because Z" | `learnings` | "Fixed #<n> by editing `<file>`" → PR body |
+| A trap: "W silently fails when V" | `learnings` | "Added tests for Z" → the test records itself |
+| A decision + rationale future work must honor | `learnings` | "Ran tests, they passed" → the run records itself |
+| A reusable code shape this repo should copy | `patterns` | Restating an existing CLAUDE.md / guidance rule |
+
+Key the entry on the **symptom or rule**, not the ticket. A future session hits the symptom
+without knowing the issue number, so a ticket-shaped key is unfindable exactly when it is needed.
+(An incident narrative may carry the issue as provenance — `1145-daemon-port-collision-fix` — but
+the searchable words must still be the symptom.) A real entry from this repo, abridged:
 
 ```
 mcp__moflo__memory_store:
-  key: "pattern:<topic>"
-  namespace: "patterns"
-  value: "<files changed, patterns used, decisions made>"
-  tags: ["<relevant-tags>"]
+  key: "wal-defeats-db-mtime-as-change-signal"
+  namespace: "learnings"
+  value: "In WAL mode SQLite writes land in the -wal sidecar, so the .db file's mtime
+          stops advancing on write. Any cache or staleness check keyed on db mtime
+          silently never invalidates. Hash the schema+row count, or stat the -wal too."
+  tags: ["sqlite", "caching", "gotcha"]
 ```
 
-This step happens before `gh pr create`, not after.
+Note what makes it durable: it states a rule that holds beyond the ticket that discovered it,
+and a future session hitting a stale-cache symptom finds it without knowing the issue existed.
+
+**If this run taught nothing new, do not invent something.** Declare it and move on — the
+`check-before-pr` gate accepts the declaration in place of a write:
+
+```bash
+node .claude/helpers/gate.cjs record-no-durable-lesson    # from the project root
+```
+
+(When the gate has already blocked, it prints this command with an absolute path — use that
+verbatim and the cwd stops mattering.)
+
+Most runs land here, and that is the expected outcome: a routine fix in a well-understood area
+produces no transferable lesson. One real lesson beats five manufactured ones.
+
+Either path satisfies the gate, and either way it happens before `gh pr create`, not after.
+Note that when `/verify` ran (5.1b, the default), its verdict write has **already** satisfied
+this gate — so reach for `memory_store` here only when you genuinely have a lesson, never to
+unblock the PR.
 
 ### 5.3 Create the PR
 
+**Close the task list first.** `TaskUpdate` every task this run opened to `completed`, or to `deleted` where it no longer applies; `check-before-pr` blocks `gh pr create` while any stay open, because a list that still reads *pending* over merged work is the user's only view of what shipped.
+
+| Task state at PR time | Action |
+|-----------------------|--------|
+| Work finished | `TaskUpdate({ taskId: "<id>", status: "completed" })` |
+| No longer applies | `TaskUpdate({ taskId: "<id>", status: "deleted" })` |
+| Deliberately deferred past this PR | Run the acknowledgement command printed in the block message — it credits the gate and leaves the tasks open |
+
+Never mark a task `completed` to clear the gate. Declaring the deferral takes one command and keeps the list true.
+
 In epic mode (`--epic-branch` set): skip the PR. The commit from 5.1 (with `Closes #<issue-number>`) is enough; the epic orchestrator handles the consolidated PR and final push. Skip pushing too.
 
 Otherwise:

package/README.md

@@ -291,6 +291,7 @@ MoFlo installs Claude Code hooks that run on every tool call. Together, these ga
 |------|-----------------|------------------|----------------|
 | **Memory-first** | Claude must search the memory database before using Glob, Grep, or Read on guidance files | Before every Glob/Grep call, and before Read calls targeting `.claude/guidance/` | Prevents the AI from re-exploring files it (or a previous session) already indexed. Forces it to check what it knows first, saving tokens and context window. |
 | **TaskCreate-first** | Claude must call TaskCreate before spawning sub-agents via the Task tool | Before every Task (agent spawn) call | Ensures every piece of delegated work is tracked. Prevents runaway agent proliferation where Claude spawns agents without a clear plan. |
+| **Task-status** *(blocks by default)* | The task list Claude opened must reflect reality before the PR — every task closed, deleted, or explicitly acknowledged as deferred | Before `gh pr create`, whenever the session opened tasks and left some open | A stale task list is worse than none: it reports as not-started work that is about to merge. Every other step here is gated on an artifact; this is the one that gates what the *user is shown*. Deliberate deferrals stay legitimate — the block prints a one-command acknowledgement. Set `task_status_gate: warn` to report without blocking, or `off`; `task_create_first: false` disables both halves. |
 | **Context tracking** | Tracks conversation length and warns about context depletion | On every user prompt (UserPromptSubmit hook) | As conversations grow, AI quality degrades. MoFlo tracks interaction count and assigns a bracket (FRESH → MODERATE → DEPLETED → CRITICAL), advising Claude to checkpoint progress or start a fresh session before quality drops. |
 | **Routing** | Analyzes each prompt and recommends the optimal agent type and model tier | On every user prompt (UserPromptSubmit hook) | Saves cost by suggesting haiku for simple tasks, sonnet for moderate ones, opus for complex reasoning — without you having to think about model selection. |
 | **Verify-before-done** *(on by default)* | Claude must verify the change end-to-end (the `/verify` skill) before `gh pr create` | Before `gh pr create` (docs-only diffs exempt) | Enforces "prove it works before done." On by default since #1294 (`/flo` delegates to `/verify` and reuses its test run — no double verify). Opt out with `verify_before_done: false` or `--no-verify`. Pairs with the [Spec-Driven Development](#spec-driven-development-sdd) cycle, which gives verification its acceptance criteria. |
@@ -321,7 +322,8 @@ All gates are configurable in `moflo.yaml`:
 ```yaml
 gates:
   memory_first: true          # Set to false to disable memory-first enforcement
-  task_create_first: true     # Set to false to disable TaskCreate enforcement
+  task_create_first: true     # Set to false to disable TaskCreate enforcement (disables task_status_gate too)
+  task_status_gate: block     # Open tasks block `gh pr create`; warn → report only; off → silent
   context_tracking: true      # Set to false to disable context bracket warnings
   verify_before_done: true    # On by default (#1294); set false to skip /verify before `gh pr create`
 ```
@@ -916,6 +918,7 @@ tests:
 gates:
   memory_first: true                 # Must search memory before file exploration
   task_create_first: true            # Must TaskCreate before Agent tool
+  task_status_gate: block            # Open tasks block `gh pr create`; warn → report only; off → silent
   context_tracking: true             # Track context window depletion
   verify_before_done: true           # On by default (#1294); /verify before `gh pr create` (unless --no-verify). false to disable
 

package/bin/gate-hook.mjs

@@ -114,6 +114,34 @@ if (hookContext.tool_response && typeof hookContext.tool_response === 'object')
   }
 }
 
+// #1435 — deliver a PASSING gate's advisory to Claude, not only to the transcript.
+//
+// Claude Code shows a PreToolUse/PostToolUse hook's stdout to the user in
+// transcript mode and stops there; the model never sees it. So every advisory
+// the gates emit on the exit-0 path was invisible on exactly the runs it was
+// written for: #1374's open-task count, the pre-Agent TaskCreate reminder, the
+// namespace hint, the docs-only and simplify-auto-pass notes. They surfaced only
+// when some OTHER gate blocked, because the catch arm below re-routes err.stdout
+// to stderr — i.e. only once the PR had already been stopped for another reason.
+// A consumer shipped a PR over four untouched tasks with that reminder "working".
+//
+// `hookSpecificOutput.additionalContext` is the documented channel from a passing
+// tool hook into the model's context. Wrap there and nowhere else: SessionStart
+// and UserPromptSubmit already inject their stdout as context, so wrapping those
+// would rewrite a working path for nothing. An unknown or absent hook_event_name
+// falls back to raw stdout — byte-identical to the previous behaviour.
+var ADVISORY_EVENTS = { PreToolUse: true, PostToolUse: true };
+function emitAdvisory(text) {
+  var event = hookContext.hook_event_name;
+  if (!ADVISORY_EVENTS[event]) {
+    process.stdout.write(text);
+    return;
+  }
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: event, additionalContext: text },
+  }) + '\n');
+}
+
 // Run gate.cjs with the enriched environment
 var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
 var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
@@ -121,7 +149,7 @@ try {
   var output = execFileSync('node', [gateScript, command], {
     env: env, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true
   });
-  if (output.trim()) process.stdout.write(output);
+  if (output.trim()) emitAdvisory(output);
   process.exit(0);
 } catch (err) {
   // gate.cjs exit(2) = block, exit(1) = also block attempt — translate both to exit(2)

package/bin/gate.cjs

@@ -13,7 +13,7 @@ var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 // the code it describes, so a change made outside Write/Edit/MultiEdit (a Bash
 // write, a branch switch, the next issue in the same session) invalidates it.
 // See creditFingerprint() for why the boolean flags alone cannot.
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, testsFingerprint: null, simplifyRun: false, simplifySnapshotSha: null, simplifyFingerprint: null, verifyRun: false, verifyOutcome: null, verifyFingerprint: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, tasksAcknowledged: false, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, testsFingerprint: null, simplifyRun: false, simplifySnapshotSha: null, simplifyFingerprint: null, verifyRun: false, verifyOutcome: null, verifyFingerprint: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
 
 // Per-actor memory-search tracking (#838). The legacy `memorySearched` boolean
 // is session-wide, so once the parent searches memory, every spawned subagent
@@ -70,9 +70,24 @@ function loadGateConfig() {
   // ships a real /verify skill and has /flo delegate to it, so leaving it off by
   // default would make the default /flo run silently skip the acceptance check.
   // Disable per-project with `verify_before_done: false` or per-run `--no-verify`.
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true };
+  // task_status_gate is a MODE, not a boolean: 'block' | 'warn' | 'off' (#1435).
+  // #1374 shipped the open-task count as a warn-only stdout line, and a consumer
+  // still shipped a PR over four untouched tasks — a reminder that survived ten
+  // consecutive ignores in one session is not a control. Blocking is the default
+  // because the honest "these stay open on purpose" outcome is one command away
+  // (record-tasks-acknowledged), so nothing here can deadlock a run.
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true, task_status_gate: 'block' };
   var content = MOFLO_YAML;
   if (content) {
+    // Boolean forms are accepted so this key reads like every other gate in the
+    // block: `false` is the same opt-out `testing_gate: false` is, `true` means
+    // enforce. Anything unrecognised falls through to the default rather than
+    // silently disabling the gate — a typo must not be a stealth opt-out.
+    var tsg = /task_status_gate:\s*['"]?(block|warn|off|false|true)['"]?/i.exec(content);
+    if (tsg) {
+      var mode = tsg[1].toLowerCase();
+      defaults.task_status_gate = mode === 'false' ? 'off' : mode === 'true' ? 'block' : mode;
+    }
     if (/memory_first:\s*false/i.test(content)) defaults.memory_first = false;
     if (/task_create_first:\s*false/i.test(content)) defaults.task_create_first = false;
     if (/context_tracking:\s*false/i.test(content)) defaults.context_tracking = false;
@@ -172,6 +187,25 @@ var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule
 // /verify's Step 5 memory_store carries the verdict AND stamps learnings, which
 // is why learnings has no separate step here.
 var ORDER_HINT = 'Order that satisfies all of them: tests green -> /flo-simplify (re-run tests if it edits) -> /verify -> its memory_store verdict -> gh pr create\n';
+// #1434 — the old text ('learnings have not been stored (call memory_store)')
+// named the mechanism but no quality bar, so the cheapest way past it was a
+// summary of the run — audit exhaust that displaces reusable lessons from every
+// future bounded search. Name the bar AND the no-write path here: an escape
+// hatch nobody can find is not an escape hatch (see #1332's gate deadlock).
+//
+// The escape command is built from __filename, not written as a relative path.
+// The caller is the model typing into a Bash tool, NOT a hook: $CLAUDE_PROJECT_DIR
+// is unset there (so the settings.json form would expand to "/.claude/..."), and a
+// bare `.claude/helpers/gate.cjs` breaks from any cwd but the project root. The
+// running script's own absolute path is correct on every OS and from any cwd;
+// double quotes carry Windows separators and spaces through the shell.
+var LEARNINGS_MISSING =
+  'no durable lesson recorded. A lesson qualifies only if it would help a future session ' +
+  'working on a DIFFERENT task — a reusable pattern, a trap, a decision + rationale. ' +
+  'Store one with mcp__moflo__memory_store (namespace "learnings"; use "patterns" for a ' +
+  'reusable code shape). What THIS run changed is git history — it belongs in the PR body, ' +
+  'not in memory. If this run taught nothing new, say so instead of inventing one: ' +
+  'node "' + __filename + '" record-no-durable-lesson';
 var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
 // #1338 — Claude Code spawns stdio MCP servers once at session start and never
 // respawns them, so a session can outlive its moflo MCP connection. Naming only
@@ -1355,6 +1389,41 @@ switch (command) {
     writeState(s);
     break;
   }
+  // #1435 — the escape from the task-status gate, for work deliberately left
+  // open. Session-scoped like `learningsStored`: it lives in STATE_DEFAULTS, so
+  // session-reset clears it, and neither applyPromptStateReset nor
+  // reset-edit-gates touches it — a decision the user made about the task list
+  // is not invalidated by the next prompt or the next source edit.
+  //
+  // A plain flag, not a count. The command is typed by the model into a Bash
+  // tool, where HOOK_TRANSCRIPT_PATH is unset (it is forwarded by gate-hook.mjs
+  // from the hook payload and exists only inside a hook), so this process cannot
+  // read the ledger to record WHICH tasks were acknowledged even if it wanted to.
+  case 'record-tasks-acknowledged': {
+    var s = readState();
+    if (!s.tasksAcknowledged) {
+      s.tasksAcknowledged = true;
+      writeState(s);
+    }
+    // writeState swallows its own errors by design — a gate must never crash the
+    // hook it runs in. That was harmless while every recorder was advisory. This
+    // one is the ONLY escape from a BLOCKING gate, so a lost write would report
+    // "satisfied" and then block the very next `gh pr create` with nothing said
+    // about why: #1332's deadlock shape exactly. Confirm it landed before
+    // claiming it did, and name the file and the way out when it did not.
+    if (!readState().tasksAcknowledged) {
+      process.stderr.write(
+        'Task-status gate NOT satisfied: the acknowledgement could not be persisted to\n' +
+        STATE_FILE + '\n' +
+        'Check that the file and its directory are writable, then run this again.\n' +
+        'To proceed without it: set gates: task_status_gate: off in moflo.yaml.\n');
+      process.exit(1);
+    }
+    process.stdout.write(
+      'Task-status gate satisfied: open tasks acknowledged as deliberately deferred.\n' +
+      'They stay visible in the task list — this records the decision, it does not close them.\n');
+    break;
+  }
   case 'record-memory-searched': {
     var s = readState();
     if (markMemorySearched(s)) writeState(s);
@@ -1417,12 +1486,48 @@ switch (command) {
     // Why it does nothing: see applyPromptStateReset().
     break;
   }
-  case 'record-learnings-stored': {
+  // #1434 — the gate demanded one memory_store per run whether or not the run
+  // produced a reusable lesson, and a mandatory write with nothing to say
+  // produces filler: a summary of this ticket, this commit, applicable never
+  // again. memory_search returns a bounded set, so each of those displaces a
+  // real lesson from every future search — the cost is retrieval quality, not
+  // disk. Declaring "nothing durable here" is the honest outcome of a run that
+  // learned nothing new, so it has to be reachable without a write; otherwise
+  // the cheapest way past the gate stays the filler write.
+  //
+  // Both credits set the same flag; they differ only in whether the run has
+  // something to say. Sharing the case body keeps that single write in one
+  // place across all three copies of this file.
+  case 'record-learnings-stored':
+  case 'record-no-durable-lesson': {
     var s = readState();
     if (!s.learningsStored) {
       s.learningsStored = true;
       writeState(s);
     }
+    if (command === 'record-no-durable-lesson') {
+      // Same reasoning as record-tasks-acknowledged above: writeState swallows
+      // its own errors so a gate never crashes the hook it runs in, and this is
+      // the ONLY escape from the BLOCKING learnings gate that does not require a
+      // memory_store. A lost write here would print "satisfied" and then block
+      // the next `gh pr create` with nothing said about why — #1332's deadlock.
+      // Verified only on this arm: record-learnings-stored is fired
+      // automatically by the PostToolUse hook on every memory_store, where a
+      // failed write leaves the gate closed but the run still has the ordinary
+      // way through, and a diagnostic on every store would be noise.
+      if (!readState().learningsStored) {
+        process.stderr.write(
+          'Learnings gate NOT satisfied: the declaration could not be persisted to\n' +
+          STATE_FILE + '\n' +
+          'Check that the file and its directory are writable, then run this again.\n' +
+          'To proceed without it: set gates: learnings_gate: false in moflo.yaml.\n');
+        process.exit(1);
+      }
+      process.stdout.write(
+        'Learnings gate satisfied: no durable lesson declared for this run.\n' +
+        'What this run did belongs in the PR body, not in memory.\n',
+      );
+    }
     break;
   }
   case 'record-test-run': {
@@ -1645,25 +1750,46 @@ switch (command) {
     // chained, piped, parenthesised, and multi-line shapes (#1410).
     var cmd = process.env.TOOL_INPUT_command || '';
     if (!isPrCreateCommand(cmd)) break;
-    // #1374 — close the loop the TaskCreate reminder opens. Advisory: stdout,
-    // no exit, and worded as a reminder, because a message may only claim to
-    // block when it blocks (#1326). An open task list is a reporting failure,
-    // not a quality failure — blocking the PR on it would be a new deadlock.
+    // #1374 opened this loop; #1435 closes it. The count itself is unchanged —
+    // what changed is that it now has teeth and, in warn mode, a delivery path.
     //
     // Deliberately ABOVE the no-source exemption below: a docs-only PR can
     // abandon a list exactly like a source PR can, and the exemption is about
     // testing/simplify/learnings, not about whether the run told the user what
-    // it did. Gated on the same `task_create_first` flag as the reminder itself
-    // so the two halves are always consistent — a project that turned the nag
-    // off is not then nagged about the other end of it.
-    if (config.task_create_first) {
+    // it did. It also exits on its own rather than joining `missing` below, for
+    // the same reason — `missing` is unreachable on an exempt diff.
+    //
+    // Gated on the same `task_create_first` flag as the reminder itself so the
+    // two halves are always consistent: a project that turned the nag off is
+    // not then blocked about the other end of it.
+    //
+    // Fail-open is load-bearing. readTaskLedger() returns null on a missing,
+    // oversized, or unreadable transcript and on a session with no TaskCreate at
+    // all, and null must never block — a gate that stops PRs because it could
+    // not read a file is worse than the reporting gap it is closing.
+    //
+    // State is read ONCE for the whole case, here — the pre-PR gate logic below
+    // reuses it and nothing writes in between. Reading it before the ledger also
+    // means an already-acknowledged run never pays for the transcript scan.
+    var s = readState();
+    if (config.task_create_first && config.task_status_gate !== 'off' && !s.tasksAcknowledged) {
       var ledger = readTaskLedger();
       if (ledger && ledger.open > 0) {
-        process.stdout.write(
-          'REMINDER: ' + ledger.created + ' task' + (ledger.created === 1 ? '' : 's') +
-          ' created this session, ' + ledger.open + ' still open. Close them with ' +
-          'TaskUpdate (status: completed), or delete the ones that no longer apply, ' +
-          'so the run does not report done over an unfinished list.\n');
+        var tally = ledger.created + ' task' + (ledger.created === 1 ? '' : 's') +
+          ' created this session, ' + ledger.open + ' still open.';
+        var closeIt = 'Close them with TaskUpdate (status: completed), or delete the ones ' +
+          'that no longer apply, so the run does not report done over an unfinished list.\n';
+        if (config.task_status_gate === 'warn') {
+          process.stdout.write('REMINDER: ' + tally + ' ' + closeIt);
+        } else {
+          process.stderr.write(
+            'BLOCKED: ' + tally + '\n' + closeIt +
+            'Deferring them on purpose is a legitimate outcome — declare it instead of\n' +
+            'closing tasks that are not done: node "' + __filename + '" record-tasks-acknowledged\n' +
+            GATE_ORIGIN_NOTE + '\n' +
+            'Report instead of blocking via moflo.yaml: gates: task_status_gate: warn   (or: off)\n');
+          process.exit(2);
+        }
       }
     }
     // No-source-files exemption (#1176, supersedes the original docs-only path).
@@ -1688,7 +1814,6 @@ switch (command) {
         break;
       }
     }
-    var s = readState();
     // Expire any credit whose fingerprint no longer matches the code before
     // reading the flags. This is what catches the mutations reset-edit-gates
     // structurally cannot see — Bash writes, git checkout/pull/merge, and the
@@ -1721,7 +1846,7 @@ switch (command) {
     var missing = [];
     if (config.testing_gate && !s.testsRun) missing.push('tests have not run green since the last code edit (run npm test, vitest, jest, pytest, or similar — a run whose output reports failures does not count)');
     if (config.simplify_gate && !s.simplifyRun) missing.push('/flo-simplify (or /distill) has not run since the last code edit');
-    if (config.learnings_gate && !s.learningsStored) missing.push('learnings have not been stored (call mcp__moflo__memory_store)');
+    if (config.learnings_gate && !s.learningsStored) missing.push(LEARNINGS_MISSING);
     if (missing.length === 0) break;
     process.stderr.write('BLOCKED: gh pr create requires the following before opening a PR:\n');
     for (var i = 0; i < missing.length; i++) {

package/dist/src/cli/init/helpers-generator.js

@@ -208,7 +208,7 @@ var os = require('os');
 var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
 var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, verifyRun: false, verifyOutcome: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, tasksAcknowledged: false, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, verifyRun: false, verifyOutcome: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false, sddMode: false, activeSddSlug: null };
 
 function readState() {
   try {
@@ -256,9 +256,17 @@ function writeState(s) {
 
 // Load moflo.yaml gate config (defaults: all enabled)
 function loadGateConfig() {
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true };
+  // #1435 — task_status_gate is a MODE ('block' | 'warn' | 'off'), not a boolean;
+  // boolean forms are accepted so it reads like its neighbours. Unrecognised
+  // values keep the default: a typo must not become a stealth opt-out.
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true, verify_before_done: true, sdd_gate: true, task_status_gate: 'block' };
   var content = MOFLO_YAML;
   if (content) {
+    var tsg = /task_status_gate:\\s*['"]?(block|warn|off|false|true)['"]?/i.exec(content);
+    if (tsg) {
+      var tsgMode = tsg[1].toLowerCase();
+      defaults.task_status_gate = tsgMode === 'false' ? 'off' : tsgMode === 'true' ? 'block' : tsgMode;
+    }
     if (/memory_first:\\s*false/i.test(content)) defaults.memory_first = false;
     if (/task_create_first:\\s*false/i.test(content)) defaults.task_create_first = false;
     if (/context_tracking:\\s*false/i.test(content)) defaults.context_tracking = false;
@@ -345,6 +353,18 @@ var COORD_FALLBACK_NOTE = 'If mcp__moflo__* tools are unavailable this session (
 // #1348 — the pre-PR gates are order-dependent; naming only the missing one left
 // callers to rediscover the sequence by trial. SYNC: mirrors bin/gate.cjs.
 var ORDER_HINT = 'Order that satisfies all of them: tests green -> /flo-simplify (re-run tests if it edits) -> /verify -> its memory_store verdict -> gh pr create\\n';
+// #1434 — the old text named the mechanism but no quality bar, so the cheapest
+// way past the gate was a summary of the run. The escape command is built from
+// __filename: the caller is the model typing into Bash, where $CLAUDE_PROJECT_DIR
+// is unset and a relative path breaks from any cwd but the project root.
+// SYNC: mirrors bin/gate.cjs.
+var LEARNINGS_MISSING =
+  'no durable lesson recorded. A lesson qualifies only if it would help a future session ' +
+  'working on a DIFFERENT task — a reusable pattern, a trap, a decision + rationale. ' +
+  'Store one with mcp__moflo__memory_store (namespace "learnings"; use "patterns" for a ' +
+  'reusable code shape). What THIS run changed is git history — it belongs in the PR body, ' +
+  'not in memory. If this run taught nothing new, say so instead of inventing one: ' +
+  'node "' + __filename + '" record-no-durable-lesson';
 // #1294 Finding 3 — exempt ephemeral reads/scans under the OS temp dir
 // (background-task output, scratchpads) from the memory-first gate. Mirrors
 // bin/gate.cjs isEphemeralPath. Cross-platform via os.tmpdir(); normalizes a
@@ -691,6 +711,71 @@ var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\\\\/])\\.github[\\\\\\/](?:workflows|ISS
 // new untested surface for code review.
 var EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE = /(?:^|[\\\\\\/])(__tests__|__mocks__|tests?|spec|specs|cypress|e2e|fixtures?)[\\\\\\/]|\\.(test|spec)\\.[mc]?[jt]sx?$|\\.fixture\\.[mc]?[jt]sx?$/i;
 
+// #1374/#1435 — count TaskCreate calls against terminal TaskUpdate calls in the
+// session transcript. SYNC: mirrors bin/gate.cjs readTaskLedger (see there for
+// why the transcript, and not a TaskUpdate observer or Claude Code's task store).
+//
+// This template variant omits RELAXATIONS the synced bin/gate.cjs carries (the
+// docs-only exemption, fingerprint expiry) — omitting those only makes the
+// fallback stricter. An ENFORCEMENT gate is the opposite: leaving it out would
+// make the fallback silently permissive, which is the exact failure #1435 is
+// about. So it is mirrored in full.
+var TRANSCRIPT_MAX_BYTES = 16 * 1024 * 1024;
+function readTaskLedger() {
+  var tp = process.env.HOOK_TRANSCRIPT_PATH || '';
+  if (!tp) return null;
+  var raw;
+  try {
+    var tst = fs.statSync(tp);
+    if (!tst.isFile() || tst.size > TRANSCRIPT_MAX_BYTES) return null;
+    raw = fs.readFileSync(tp, 'utf-8');
+  } catch (e) { return null; }
+  var created = 0, createdIdCount = 0;
+  var pendingCreates = {}, createdIds = {}, latest = {};
+  var pos = 0;
+  while (pos <= raw.length) {
+    var nl = raw.indexOf('\\n', pos);
+    var line = nl < 0 ? raw.slice(pos) : raw.slice(pos, nl);
+    pos = nl < 0 ? raw.length + 1 : nl + 1;
+    if (line.indexOf('TaskCreate') < 0 && line.indexOf('TaskUpdate') < 0
+      && line.indexOf('created successfully') < 0) continue;
+    var entry;
+    try { entry = JSON.parse(line); } catch (e) { continue; }
+    var content = entry && entry.message && entry.message.content;
+    if (!Array.isArray(content)) continue;
+    for (var ci = 0; ci < content.length; ci++) {
+      var block = content[ci];
+      if (!block) continue;
+      if (block.type === 'tool_result') {
+        if (!pendingCreates[block.tool_use_id]) continue;
+        delete pendingCreates[block.tool_use_id];
+        var text = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+        var m = /Task #(\\S+) created successfully/.exec(text || '');
+        if (m && !createdIds[m[1]]) { createdIds[m[1]] = true; createdIdCount++; }
+        continue;
+      }
+      if (block.type !== 'tool_use') continue;
+      if (block.name === 'TaskCreate') {
+        created++;
+        if (block.id) pendingCreates[block.id] = true;
+        continue;
+      }
+      if (block.name !== 'TaskUpdate') continue;
+      var tinput = block.input || {};
+      var tid = tinput.taskId != null ? tinput.taskId : tinput.task_id;
+      if (tid == null || typeof tinput.status !== 'string' || !tinput.status) continue;
+      latest[String(tid)] = tinput.status;
+    }
+  }
+  if (created === 0) return null;
+  var open = created - createdIdCount;
+  Object.keys(createdIds).forEach(function(id) {
+    if (latest[id] !== 'completed' && latest[id] !== 'deleted') open++;
+  });
+  if (open > created) open = created;
+  return { created: created, closed: created - open, open: open };
+}
+
 switch (command) {
   case 'check-before-agent': {
     // Mostly advisory. The TaskCreate + memory reminders below go to stdout and
@@ -807,6 +892,28 @@ switch (command) {
     writeState(s);
     break;
   }
+  // #1435 — the escape from the task-status gate, for work deliberately left
+  // open. Session-scoped via STATE_DEFAULTS; no prompt or edit reset touches it.
+  case 'record-tasks-acknowledged': {
+    var s = readState();
+    if (!s.tasksAcknowledged) {
+      s.tasksAcknowledged = true;
+      writeState(s);
+    }
+    // writeState swallows its own errors so a gate never crashes its hook. This
+    // is the ONLY escape from a BLOCKING gate, so an unconfirmed write would
+    // report "satisfied" and block the next 'gh pr create' anyway — confirm it.
+    if (!readState().tasksAcknowledged) {
+      process.stderr.write('Task-status gate NOT satisfied: the acknowledgement could not be persisted to\\n' +
+        STATE_FILE + '\\n' +
+        'Check that the file and its directory are writable, then run this again.\\n' +
+        'To proceed without it: set gates: task_status_gate: off in moflo.yaml.\\n');
+      process.exit(1);
+    }
+    process.stdout.write('Task-status gate satisfied: open tasks acknowledged as deliberately deferred.\\n' +
+      'They stay visible in the task list — this records the decision, it does not close them.\\n');
+    break;
+  }
   case 'record-memory-searched': {
     var s = readState();
     if (markMemorySearched(s)) writeState(s);
@@ -847,12 +954,35 @@ switch (command) {
     // rather than per-task-transition.
     break;
   }
-  case 'record-learnings-stored': {
+  // #1434 — a mandatory write with nothing to say produces filler that displaces
+  // reusable lessons from every future bounded search. Both credits set the same
+  // flag and differ only in whether the run has something to say, so they share
+  // one case body. SYNC: mirrors bin/gate.cjs.
+  case 'record-learnings-stored':
+  case 'record-no-durable-lesson': {
     var s = readState();
     if (!s.learningsStored) {
       s.learningsStored = true;
       writeState(s);
     }
+    if (command === 'record-no-durable-lesson') {
+      // Same reasoning as record-tasks-acknowledged: this is the ONLY escape
+      // from the BLOCKING learnings gate that needs no memory_store, so an
+      // unconfirmed write would report "satisfied" and block anyway. Verified
+      // only on this arm — record-learnings-stored fires automatically on every
+      // memory_store, where a lost write still leaves the ordinary way through.
+      if (!readState().learningsStored) {
+        process.stderr.write('Learnings gate NOT satisfied: the declaration could not be persisted to\\n' +
+          STATE_FILE + '\\n' +
+          'Check that the file and its directory are writable, then run this again.\\n' +
+          'To proceed without it: set gates: learnings_gate: false in moflo.yaml.\\n');
+        process.exit(1);
+      }
+      process.stdout.write(
+        'Learnings gate satisfied: no durable lesson declared for this run.\\n' +
+        'What this run did belongs in the PR body, not in memory.\\n',
+      );
+    }
     break;
   }
   case 'record-test-run': {
@@ -981,11 +1111,34 @@ switch (command) {
   case 'check-before-pr': {
     var cmd = process.env.TOOL_INPUT_command || '';
     if (!/(?:^|&&\\s*|\\|\\|\\s*|;\\s*)\\s*(?:[A-Z_][A-Z0-9_]*=\\S+\\s+)*gh\\s+pr\\s+create\\b/.test(cmd)) break;
+    // #1435 — task-status gate. Subordinate to task_create_first so both halves
+    // of the task nag are on or off together; fail-open when the ledger is null.
+    // State is read once for the whole case and reused below; reading it before
+    // the ledger keeps an acknowledged run off the transcript scan entirely.
     var s = readState();
+    if (config.task_create_first && config.task_status_gate !== 'off' && !s.tasksAcknowledged) {
+      var ledger = readTaskLedger();
+      if (ledger && ledger.open > 0) {
+        var tally = ledger.created + ' task' + (ledger.created === 1 ? '' : 's') +
+          ' created this session, ' + ledger.open + ' still open.';
+        var closeIt = 'Close them with TaskUpdate (status: completed), or delete the ones ' +
+          'that no longer apply, so the run does not report done over an unfinished list.\\n';
+        if (config.task_status_gate === 'warn') {
+          process.stdout.write('REMINDER: ' + tally + ' ' + closeIt);
+        } else {
+          process.stderr.write('BLOCKED: ' + tally + '\\n' + closeIt +
+            'Deferring them on purpose is a legitimate outcome — declare it instead of\\n' +
+            'closing tasks that are not done: node "' + __filename + '" record-tasks-acknowledged\\n' +
+            GATE_ORIGIN_NOTE + '\\n' +
+            'Report instead of blocking via moflo.yaml: gates: task_status_gate: warn   (or: off)\\n');
+          process.exit(2);
+        }
+      }
+    }
     var missing = [];
     if (config.testing_gate && !s.testsRun) missing.push('tests have not run green since the last code edit (run npm test, vitest, jest, pytest, or similar — a run whose output reports failures does not count)');
     if (config.simplify_gate && !s.simplifyRun) missing.push('/flo-simplify (or /distill) has not run since the last code edit');
-    if (config.learnings_gate && !s.learningsStored) missing.push('learnings have not been stored (call mcp__moflo__memory_store)');
+    if (config.learnings_gate && !s.learningsStored) missing.push(LEARNINGS_MISSING);
     if (missing.length === 0) break;
     process.stderr.write('BLOCKED: gh pr create requires the following before opening a PR:\\n');
     for (var i = 0; i < missing.length; i++) {
@@ -1251,6 +1404,34 @@ if (hookContext.tool_response && typeof hookContext.tool_response === 'object')
   }
 }
 
+// #1435 — deliver a PASSING gate's advisory to Claude, not only to the transcript.
+//
+// Claude Code shows a PreToolUse/PostToolUse hook's stdout to the user in
+// transcript mode and stops there; the model never sees it. So every advisory
+// the gates emit on the exit-0 path was invisible on exactly the runs it was
+// written for: #1374's open-task count, the pre-Agent TaskCreate reminder, the
+// namespace hint, the docs-only and simplify-auto-pass notes. They surfaced only
+// when some OTHER gate blocked, because the catch arm below re-routes err.stdout
+// to stderr — i.e. only once the PR had already been stopped for another reason.
+// A consumer shipped a PR over four untouched tasks with that reminder "working".
+//
+// \`hookSpecificOutput.additionalContext\` is the documented channel from a passing
+// tool hook into the model's context. Wrap there and nowhere else: SessionStart
+// and UserPromptSubmit already inject their stdout as context, so wrapping those
+// would rewrite a working path for nothing. An unknown or absent hook_event_name
+// falls back to raw stdout — byte-identical to the previous behaviour.
+var ADVISORY_EVENTS = { PreToolUse: true, PostToolUse: true };
+function emitAdvisory(text) {
+  var event = hookContext.hook_event_name;
+  if (!ADVISORY_EVENTS[event]) {
+    process.stdout.write(text);
+    return;
+  }
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: event, additionalContext: text },
+  }) + '\\n');
+}
+
 // Run gate.cjs with the enriched environment
 var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
 var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
@@ -1258,7 +1439,7 @@ try {
   var output = execFileSync('node', [gateScript, command], {
     env: env, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true
   });
-  if (output.trim()) process.stdout.write(output);
+  if (output.trim()) emitAdvisory(output);
   process.exit(0);
 } catch (err) {
   // gate.cjs exit(2) = block, exit(1) = also block attempt — translate both to exit(2)

package/dist/src/cli/init/moflo-yaml-template.js

@@ -215,6 +215,7 @@ gates:
   task_create_first: ${gates}
   context_tracking: ${gates}
   verify_before_done: true    # Run /verify before 'gh pr create'. On by default; opt out with false or per-run --no-verify
+  task_status_gate: block     # Open tasks stop 'gh pr create'. warn → report only; off → silent
 
 # Auto-index on session start
 auto_index:

package/dist/src/cli/services/hook-wiring.js

@@ -77,7 +77,9 @@ export const REQUIRED_HOOK_WIRING = [
     // listing it here made repairHookWiring() graft the hook back into every
     // consumer on session start, undoing the removal.
     { event: 'PostToolUse', pattern: 'record-learnings-stored' },
-    { event: 'PostToolUse', pattern: 'check-bash-memory' },
+    // PreToolUse, not PostToolUse: #1132 moved it so its process.exit(2) actually
+    // prevents the read instead of reporting one that already happened.
+    { event: 'PreToolUse', pattern: 'check-bash-memory' },
     { event: 'PostToolUse', pattern: 'record-test-run' },
     // #1338 follow-up — CLI half of the #952 swarm/hive init recorders. Listed
     // here so an existing consumer picks it up via repairHookWiring on session
@@ -157,7 +159,9 @@ export const HOOK_ENTRY_MAP = {
     'record-learnings-stored': { event: 'PostToolUse', matcher: '^mcp__moflo__memory_store$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" record-learnings-stored', timeout: 2000 } },
     // #1171 — widened to ^(Bash|PowerShell)$ so PS reads / PS-invoked tests credit
     // the same gates as Bash. Name kept as `check-bash-memory` for backwards compat.
-    'check-bash-memory': { event: 'PostToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-bash-memory', timeout: 2000 } },
+    // PreToolUse since #1132: grafting it under PostToolUse — as this entry did —
+    // would repair a consumer into a gate that reports a read it can no longer stop.
+    'check-bash-memory': { event: 'PreToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-bash-memory', timeout: 2000 } },
     'record-test-run': { event: 'PostToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-test-run', timeout: 2000 } },
     // #1338 follow-up — same Bash/PowerShell PostToolUse block as record-test-run.
     'record-bash-swarm-init': { event: 'PostToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-bash-swarm-init', timeout: 2000 } },

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.12.6';
+export const VERSION = '4.12.7';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.12.6",
+  "version": "4.12.7",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -98,7 +98,7 @@
     "@typescript-eslint/parser": "^8.65.0",
     "eslint": "^10.8.0",
     "glob": "^11.1.0",
-    "moflo": "^4.12.5",
+    "moflo": "^4.12.6",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"