moflo 4.12.5 → 4.12.7

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/services/project-root.js

@@ -60,6 +60,22 @@ import { resolve, dirname, parse, join, basename } from 'node:path';
  *
  * Algorithmic twin of `bin/lib/moflo-paths.mjs:findAncestorMofloRoot()`.
  */
+/**
+ * Does `dir` carry moflo state that makes it a project root?
+ *
+ * The single source of truth for Pass A's marker set, exported so callers that
+ * must agree with the resolver cannot drift from it. #1431 is exactly that
+ * drift: `doctor-fixes.ts` guarded its daemon reaps by looking for
+ * `.moflo/moflo.db` alone, went blind to a nested checkout carrying only the
+ * legacy `.swarm/memory.db`, and allowed the parent project's daemons to be
+ * killed. Any new marker belongs here and nowhere else.
+ *
+ * (`bin/lib/moflo-paths.mjs` holds a plain-JS twin for the launcher, which
+ * cannot import TypeScript — keep the two in step.)
+ */
+export function hasMofloStateMarker(dir) {
+    return existsSync(join(dir, '.moflo', 'moflo.db')) || existsSync(join(dir, '.swarm', 'memory.db'));
+}
 export function findAncestorMofloRoot(dir) {
     const start = resolve(dir);
     const fsRoot = parse(start).root;
@@ -201,7 +217,7 @@ export function findProjectRoot(opts) {
             dir = dirname(dir);
             continue;
         }
-        if (existsSync(join(dir, '.moflo', 'moflo.db')) || existsSync(join(dir, '.swarm', 'memory.db'))) {
+        if (hasMofloStateMarker(dir)) {
             topmostMemoryMarker = dir;
         }
         const parent = dirname(dir);

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.5';
+export const VERSION = '4.12.7';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.12.5",
+  "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.4",
+    "moflo": "^4.12.6",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"