moflo 4.12.3 → 4.12.4-rc.2

package/dist/src/cli/index.js

@@ -2,7 +2,7 @@
  * V3 CLI Main Entry Point
  * MoFlo V4 CLI
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { commandParser } from './parser.js';
 import { output } from './output.js';
@@ -105,8 +105,45 @@ export class CLI {
             // Parse arguments
             let parseResult = this.parser.parse(args);
             let { command: commandPath, flags, positional } = parseResult;
-            // Handle global flags
-            if (flags.version || flags.V) {
+            // Handle lazy-loaded commands that weren't recognized by the parser.
+            // If commandPath is empty but positional has a command name, check if
+            // it's lazy-loadable.
+            if (commandPath.length === 0 && positional.length > 0 && !positional[0].startsWith('-')) {
+                const potentialCommand = positional[0];
+                if (hasCommand(potentialCommand)) {
+                    // This is a lazy-loaded command, treat it as the command
+                    commandPath.push(potentialCommand);
+                    positional.shift();
+                }
+            }
+            // Resolve the command BEFORE the global-flag handling below, so those
+            // checks see flags parsed against the command's own option tree.
+            // The first parse happens without knowledge of a lazily-loaded command's
+            // options, so `plugins install pkg --version 1.2.3` parsed `--version`
+            // under the GLOBAL boolean rule, came out as `version: true`, and hit the
+            // version handler below — printing "flo v4.12.4-rc.1" and returning
+            // without installing anything. Re-parsing here makes flags authoritative.
+            let command = commandPath[0]
+                ? this.parser.getCommand(commandPath[0]) || getCommand(commandPath[0])
+                : undefined;
+            if (!command && commandPath[0] && hasCommand(commandPath[0])) {
+                command = await getCommandAsync(commandPath[0]);
+                if (command) {
+                    // Registering the newly-loaded command also restores scoped
+                    // short-flag aliases for its nested subcommand options, which the
+                    // first parse could not apply.
+                    this.parser.registerCommand(command);
+                    parseResult = this.parser.parse(args);
+                    ({ command: commandPath, flags, positional } = parseResult);
+                }
+            }
+            // Strict `=== true`: the global `--version` is a boolean, so a genuine
+            // global usage always yields exactly `true`. Commands that redefine
+            // `--version` as a value-taking option (plugins install/upgrade,
+            // deployment deploy/rollback) yield a string — or '' when the value is
+            // omitted — and those must NOT be hijacked into printing the moflo
+            // version and returning.
+            if (flags.version === true || flags.V === true) {
                 this.showVersion();
                 return;
             }
@@ -136,16 +173,6 @@ export class CLI {
             if (commandPath[0] !== 'daemon') {
                 this.maybeAutoStartDaemon().catch(() => { });
             }
-            // Handle lazy-loaded commands that weren't recognized by the parser
-            // If commandPath is empty but positional has a command name, check if it's lazy-loadable
-            if (commandPath.length === 0 && positional.length > 0 && !positional[0].startsWith('-')) {
-                const potentialCommand = positional[0];
-                if (hasCommand(potentialCommand)) {
-                    // This is a lazy-loaded command, treat it as the command
-                    commandPath.push(potentialCommand);
-                    positional.shift();
-                }
-            }
             // No command - show help or suggest correction
             if (commandPath.length === 0 || flags.help || flags.h) {
                 if (commandPath.length > 0) {
@@ -166,26 +193,9 @@ export class CLI {
                 }
                 return;
             }
-            // Find and execute command
+            // Find and execute command. Resolution + any lazy load already happened
+            // above, before global-flag handling — see the note there.
             const commandName = commandPath[0];
-            // First check the parser's registry (for dynamically registered commands)
-            // Then fall back to the static registry, then try lazy loading
-            let command = this.parser.getCommand(commandName) || getCommand(commandName);
-            // If not found in sync registry, try lazy loading
-            if (!command && hasCommand(commandName)) {
-                command = await getCommandAsync(commandName);
-                if (command) {
-                    // The first parse happened without knowledge of this command's
-                    // subcommand tree, so scoped short-flag aliases for any nested
-                    // subcommand options weren't applied — and a globally-registered
-                    // command's `-x` would have hijacked the value. Register the
-                    // newly-loaded command and re-parse so flags reflect the leaf
-                    // command's options.
-                    this.parser.registerCommand(command);
-                    parseResult = this.parser.parse(args);
-                    ({ command: commandPath, flags, positional } = parseResult);
-                }
-            }
             if (!command) {
                 this.output.printError(`Unknown command: ${commandName}`);
                 // Smart suggestions - include lazy-loadable commands in suggestions
@@ -378,7 +388,7 @@ export class CLI {
         this.output.writeln();
         this.output.writeln(this.output.dim(`Run "${this.name} <command> --help" for command help`));
         this.output.writeln();
-        this.output.writeln(this.output.dim('Created with ❤️ by motailz.com'));
+        this.output.writeln(this.output.dim('Created with ❤️ by cielolimitada.com'));
         this.output.writeln();
     }
     /**

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

@@ -35,10 +35,10 @@ Your first tool call MUST be \`mcp__moflo__memory_search\` — before any Glob/G
 
 Search results carry a compact \`navigation\` crumb (parentDoc, prev/next, chunkTitle). For adjacent/sibling/hierarchical context use \`mcp__moflo__memory_get_neighbors\`; for full chunk content use \`mcp__moflo__memory_retrieve\`; \`Read\` the source doc only via \`parentPath\` when truly needed. Full protocol + worked examples per namespace: \`.claude/guidance/moflo-memory-protocol.md\`.
 
-### Auto-enforced gates
+### Gates
 
-- **TaskCreate-first**: Call \`TaskCreate\` before spawning the Agent tool
-- **Task Icons**: \`TaskCreate\` entries MUST use ICON+[Role] format — see \`.claude/guidance/moflo-task-icons.md\`
+- **Blocking** (hook exits non-zero): memory search before Glob/Grep/guidance Read; tests + \`/flo-simplify\` + learnings + \`/verify\` before \`gh pr create\`; \`swarm_init\`/\`hive-mind_init\` before Agent under \`/fl -s|-h\`.
+- **Advisory** (reminder only): \`TaskCreate\` before spawning the Agent tool, entries in ICON+[Role] format — see \`.claude/guidance/moflo-task-icons.md\`.
 
 ### Tools
 

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

@@ -325,6 +325,9 @@ var EXEMPT = ['.claude/', '.claude\\\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-sta
 // bin/gate.cjs GATE_ORIGIN_NOTE / GATE_DISABLE_NOTE.
 var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule — allow-rules cannot override it.';
 var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
+// #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';
 // #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
@@ -546,9 +549,58 @@ function applyPromptStateReset(state, promptText) {
   state.activeSddSlug = null;
 }
 var TEST_RUNNER_RE = /(?:^|[^a-z])(?:npm|yarn|pnpm|bun)\\s+(?:run\\s+)?(?:test|t)(?:[:\\s]|$)|\\b(?:npx|pnpx)\\s+(?:vitest|jest|mocha|ava|tap|jasmine|pytest)\\b|(?:^|;|&&|\\|\\|)\\s*(?:vitest|jest|pytest|mocha|jasmine|tap|ava)\\s|\\b(?:cargo|go|deno|dotnet|mvn)\\s+test\\b|\\bgradle\\w*\\s+test\\b/i;
+// #1322 — failure markers in a test runner's own OUTPUT.
+//
+// This is deliberately not an exit-code check: Claude Code's PostToolUse payload
+// carries no exit status, and PostToolUse does not fire at all when a command
+// exits non-zero — so an unmasked red suite already leaves testsRun false, by
+// accident of the hook lifecycle rather than by design. What DOES defeat the
+// gate is a masked exit (\`npm test | tail -20\`, \`npm test || true\`,
+// \`npm test 2>&1 | grep -i fail\`): the pipeline exits 0, PostToolUse fires with
+// a clean-looking response, and a red suite credits the gate. Output is the only
+// signal left, and it is genuinely weaker than a status — see the ticket.
+//
+// Every arm matches a SUMMARY shape a runner emits, never a bare "fail", which
+// occurs constantly in ordinary passing test names ("returns null when the
+// lookup failed"). The count arm excludes an explicit zero so jest's
+// \`0 failed, 12 passed\` cannot self-block.
+//
+// The count arm's trailing lookahead is what keeps a GREEN run from blocking
+// itself. Mocha's default spec reporter prints every passing test name, so
+// \`npm test | tail -20\` on a green suite legitimately contains lines like
+// \`✓ handles 2 failed retries\`. A real summary is followed by a delimiter or a
+// line end (\`3 failed | 40 passed\`, \`1 failed, 2 passed\`, \`1 failing\`), never by
+// more prose — so a lowercase word after the count means it is a sentence, not a
+// tally. \`tests\`/\`test\` is exempted because \`2 failed tests\` is a real summary.
+// Same-line whitespace only: at a line end there is nothing to disqualify.
+var TEST_FAILURE_RE = new RegExp([
+  '\\\\b(?!0\\\\b)\\\\d+\\\\s+(?:tests?\\\\s+)?(?:failed|failing|failures?)\\\\b(?![^\\\\S\\\\n]+(?!tests?\\\\b)[a-z])', // vitest/jest/pytest/mocha counts
+  '^\\\\s*(?:FAIL|FAILED)\\\\b',                                          // vitest + jest per-file, pytest FAILED
+  '^\\\\s*---\\\\s*FAIL:',                                                // go test
+  '\\\\btest result:\\\\s*FAILED\\\\b',                                     // cargo
+  '^npm ERR!',                                                        // npm wrapper around any of the above
+].join('|'), 'im');
+
+/**
+ * #1322 — why a just-fired record-test-run must NOT be credited, or null.
+ *
+ * Absent output is not evidence of failure: a quiet green \`npm test > /dev/null\`
+ * and a silently-masked red one are indistinguishable, and treating the pair as
+ * failures would block every consumer who redirects test output. Absent means
+ * unknown, and unknown keeps the pre-#1322 behaviour.
+ */
+function detectTestFailure() {
+  if (process.env.TOOL_RESPONSE_interrupted === 'true') return 'the run was interrupted';
+  var out = (process.env.TOOL_RESPONSE_stdout || '') + '\\n' + (process.env.TOOL_RESPONSE_stderr || '');
+  if (!out.trim()) return null;
+  var hit = out.match(TEST_FAILURE_RE);
+  return hit ? 'output reports "' + hit[0].trim().slice(0, 40) + '"' : null;
+}
 var EDIT_RESET_SKIP_BOTH_RE = /\\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\\\\/])(CHANGELOG(?:\\.md)?|\\.env\\.example|package-lock\\.json|pnpm-lock\\.yaml|yarn\\.lock|bun\\.lockb)$/i;
 // #1297 — path-inert dirs (.github/workflows etc.); SYNC: mirrors bin/gate.cjs EDIT_RESET_SKIP_PATH_RE.
-var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\\\\/])\\.github[\\\\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\\\\/.]|$)/i;
+// #1348 — plus \`.moflo/\`, moflo's own gitignored state dir: nothing written
+// there can reach the branch diff, so it must not invalidate a gate.
+var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\\\\/])\\.github[\\\\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\\\\/.]|$)|(?:^|[\\\\\\/])\\.moflo[\\\\\\/]/i;
 // Test files: invalidate testsRun but preserve simplifyRun (#908) — /simplify
 // already reviewed the production code, touching tests/fixtures doesn't expose
 // new untested surface for code review.
@@ -556,14 +608,17 @@ var EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE = /(?:^|[\\\\\\/])(__tests__|__mocks__|test
 
 switch (command) {
   case 'check-before-agent': {
-    // Advisory only — agent spawning is never blocked.
-    // Memory-first enforcement happens at the scan/read gate layer.
+    // Mostly advisory. The TaskCreate + memory reminders below go to stdout and
+    // never block — their wording must not claim otherwise (#1326). The one
+    // exception is the #952 swarm/hive check at the bottom of this case, which
+    // writes to stderr and exits 2.
+    // Memory-first enforcement otherwise happens at the scan/read gate layer.
     // SubagentStart hook injects guidance directive into subagent context.
     // #931 — TaskCreate REMINDER + namespace hint moved here from
     // prompt-reminder so they emit only when Claude is about to spawn an Agent.
     var s = readState();
     if (config.task_create_first && !s.tasksCreated) {
-      process.stdout.write('REMINDER: Use TaskCreate before spawning agents. Task tool is blocked until then.\\n');
+      process.stdout.write('REMINDER: Use TaskCreate before spawning agents.\\n');
     }
     if (config.memory_first && s.memoryRequired && !s.memorySearched) {
       process.stdout.write('REMINDER: Search memory (mcp__moflo__memory_search) before spawning agents.\\n');
@@ -703,8 +758,14 @@ switch (command) {
   case 'record-test-run': {
     var cmd = process.env.TOOL_INPUT_command || '';
     if (TEST_RUNNER_RE.test(cmd)) {
+      // #1322 — a red run is evidence AGAINST the gate, so it also clears a
+      // flag an earlier green run earned.
+      var failure = detectTestFailure();
       var s = readState();
-      if (!s.testsRun) {
+      if (failure) {
+        if (s.testsRun) { s.testsRun = false; writeState(s); }
+        process.stderr.write('gate: record-test-run not credited — ' + failure + '\\n');
+      } else if (!s.testsRun) {
         s.testsRun = true;
         writeState(s);
       }
@@ -730,25 +791,58 @@ switch (command) {
     // end-to-end verification (see fl/sdd.md).
     if (vName === 'verify') {
       var s = readState();
-      if (!s.verifyRun) { s.verifyRun = true; writeState(s); }
+      // #1332: starting a verification clears any prior verdict, so the run
+      // in progress cannot inherit a previous issue's PASS.
+      if (!s.verifyRun || s.verifyOutcome) {
+        s.verifyRun = true;
+        s.verifyOutcome = null;
+        writeState(s);
+      }
     }
     break;
   }
+  case 'record-verify-outcome': {
+    // #1332 — record HOW the verification ended, from the structured record
+    // #1328 has /verify write to memory_store's \`metadata\`. Never parsed out
+    // of the prose \`value\`; gate-hook.mjs forwards the object as JSON.
+    var mKey = process.env.TOOL_INPUT_key || '';
+    if (mKey.indexOf('verify:') !== 0) break;
+    var rawMeta = process.env.TOOL_INPUT_metadata || '';
+    if (!rawMeta) break;
+    var parsedMeta = null;
+    try { parsedMeta = JSON.parse(rawMeta); } catch (e) { parsedMeta = null; }
+    if (!parsedMeta || typeof parsedMeta !== 'object' || parsedMeta.type !== 'verify-record') break;
+    var overall = typeof parsedMeta.overall === 'string' ? parsedMeta.overall.toUpperCase() : '';
+    if (overall !== 'PASS' && overall !== 'FAIL' && overall !== 'UNVERIFIED') overall = 'UNVERIFIED';
+    var vs = readState();
+    // #1348 — a verdict that arrives after a code edit cleared verifyRun
+    // describes pre-edit code; recording it leaves state self-contradictory.
+    if (!vs.verifyRun) break;
+    vs.verifyOutcome = overall;
+    writeState(vs);
+    break;
+  }
   case 'reset-edit-gates': {
     var fp = process.env.TOOL_INPUT_file_path || '';
-    // Inert files (markdown, lockfiles, CHANGELOG, .env.example): no gate reset.
-    if (fp && EDIT_RESET_SKIP_BOTH_RE.test(fp)) break;
+    // Inert files (markdown, lockfiles, CHANGELOG, .env.example) and inert paths
+    // (.github meta dirs, .moflo state): no gate reset.
+    if (fp && (EDIT_RESET_SKIP_BOTH_RE.test(fp) || EDIT_RESET_SKIP_PATH_RE.test(fp))) break;
+    // #1348 — a scratchpad write under the OS temp dir is transient tool I/O,
+    // never a code edit, so it must not reset tests/simplify/verify. SYNC:
+    // mirrors bin/gate.cjs, which carries the full rationale.
+    if (isEphemeralPath(fp)) break;
     var s = readState();
     // Test-only edits invalidate testsRun but preserve simplifyRun (#908).
     var isTestOnly = fp && EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE.test(fp);
     var resetTests = s.testsRun;
     // A code edit invalidates a prior verification (Story #1274), like tests.
-    var resetVerify = s.verifyRun;
+    // #1332: also fires on a lingering verdict, so no stale PASS survives.
+    var resetVerify = s.verifyRun || !!s.verifyOutcome;
     var resetSimplify = s.simplifyRun && !isTestOnly;
     if (!resetTests && !resetSimplify && !resetVerify) break;
     var gates = [];
     if (resetTests) { s.testsRun = false; gates.push('tests'); }
-    if (resetVerify) { s.verifyRun = false; gates.push('verify'); }
+    if (resetVerify) { s.verifyRun = false; s.verifyOutcome = null; gates.push('verify'); }
     if (resetSimplify) { s.simplifyRun = false; gates.push('simplify'); }
     if (fp) {
       s.lastResetBy = { file: fp, at: new Date().toISOString(), gates: gates };
@@ -789,7 +883,7 @@ switch (command) {
     if (!/(?:^|&&\\s*|\\|\\|\\s*|;\\s*)\\s*(?:[A-Z_][A-Z0-9_]*=\\S+\\s+)*gh\\s+pr\\s+create\\b/.test(cmd)) break;
     var s = readState();
     var missing = [];
-    if (config.testing_gate && !s.testsRun) missing.push('tests have not run since the last code edit (run npm test, vitest, jest, pytest, or similar)');
+    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, #1322)');
     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 (missing.length === 0) break;
@@ -800,6 +894,7 @@ switch (command) {
     if (s.lastResetBy && s.lastResetBy.file) {
       process.stderr.write('Last gate reset: ' + s.lastResetBy.file + ' (' + (s.lastResetBy.gates || []).join(', ') + ')\\n');
     }
+    process.stderr.write(ORDER_HINT);
     process.stderr.write('Disable per-gate via moflo.yaml:\\n');
     process.stderr.write('  gates:\\n    testing_gate: false\\n    simplify_gate: false\\n    learnings_gate: false\\n');
     process.exit(2);
@@ -815,9 +910,21 @@ switch (command) {
     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;
     var s = readState();
-    if (s.verifyRun) break;
+    // #1332 — gate on the OUTCOME, not on attendance: a /verify returning FAIL
+    // is still a successful tool invocation, so verifyRun alone let it through.
+    if (s.verifyRun && s.verifyOutcome === 'PASS') break;
     process.stderr.write('BLOCKED: gh pr create requires verification before done:\\n');
-    process.stderr.write('  - the change has not been verified since the last code edit (run /verify)\\n');
+    if (!s.verifyRun) {
+      process.stderr.write('  - the change has not been verified since the last code edit (run /verify)\\n');
+    } else if (s.verifyOutcome === 'FAIL' || s.verifyOutcome === 'UNVERIFIED') {
+      process.stderr.write('  - /verify ran and returned ' + s.verifyOutcome + ' — fix the failing criteria, then re-run /verify\\n');
+    } else {
+      process.stderr.write('  - /verify ran but recorded no verdict — re-run it so it stores a structured result\\n');
+      // #1348 — re-invoking /verify clears the prior verdict by design (#1332),
+      // so the obvious recovery lands back here unless Step 5 completes.
+      process.stderr.write('    Re-invoking /verify clears the prior verdict, so a re-run that skips Step 5 lands here again.\\n');
+    }
+    process.stderr.write(ORDER_HINT);
     process.stderr.write('Disable via moflo.yaml:\\n');
     process.stderr.write('  gates:\\n    verify_before_done: false\\n');
     process.exit(2);
@@ -906,15 +1013,24 @@ switch (command) {
 }
 /**
  * Generate gate-hook.mjs — ESM wrapper that reads Claude Code stdin JSON
- * and passes tool_name + tool_input to gate.cjs via environment variables.
+ * and passes tool_name + tool_input + tool_response to gate.cjs via env vars.
  *
  * Claude Code hooks receive context as JSON on stdin but don't set env vars
  * for tool input. This script bridges that gap. It also translates exit code 1
  * from gate.cjs into exit code 2 (which Claude Code requires to block tools).
+ *
+ * **This must stay byte-identical to `bin/gate-hook.mjs`** — the launcher syncs
+ * that file into the same `.claude/helpers/gate-hook.mjs` this generator writes,
+ * so any divergence means `flo init` emits one bridge and the next session start
+ * silently swaps in another. It had drifted exactly that way before #1322: the
+ * generated copy never received #1332's structured-input forwarding and still
+ * shelled out via `execSync` string concatenation. Parity is pinned by
+ * `tests/guards/gate-hook-parity-guard.test.ts` — when you change one, copy the
+ * whole file across; do not hand-merge.
  */
 export function generateGateHookScript() {
     return `#!/usr/bin/env node
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { resolve } from 'path';
 
 var command = process.argv[2];
@@ -941,24 +1057,91 @@ try { if (stdinData.trim()) hookContext = JSON.parse(stdinData); } catch (e) {}
 var env = Object.assign({}, process.env);
 if (hookContext.tool_name) env.TOOL_NAME = hookContext.tool_name;
 // Forward Claude Code's session_id so gate.cjs can enforce memory-first
-// per-actor (#838) — each spawned subagent has its own session_id.
+// per-actor (#838) — each spawned subagent gets its own session_id, so a
+// shared workflow-state.json no longer lets one subagent's directive be
+// silently satisfied by the parent's earlier search.
 if (typeof hookContext.session_id === 'string' && hookContext.session_id) {
   env.HOOK_SESSION_ID = hookContext.session_id;
 }
+// #1332: structured tool inputs are forwarded as JSON, not dropped.
+//
+// This previously forwarded ONLY string values, so any object-valued input was
+// invisible to gate.cjs. That blocked the verify-before-done gate from reading
+// \`/verify\`'s per-criterion verdict, which #1328 stores in memory_store's
+// \`metadata\` — an object. Parsing the verdict out of the prose \`value\` string
+// instead would re-create exactly the free-text dependency #1328 removed.
+//
+// Cross-platform (Rule #1): Windows caps a single environment variable at
+// ~32KB and the whole block at ~32K wide chars, and exceeding it fails the
+// spawn rather than truncating. Newly-forwarded values are therefore skipped
+// when oversized, not clipped — a truncated JSON blob would parse as malformed
+// on the far side and read as a corrupt record rather than an absent one.
+// \`metadata\` is capped at 64KB by memory_store, so a real verdict never nears
+// this. STRING values keep their previous uncapped behaviour byte-for-byte:
+// gate.cjs reads TOOL_INPUT_command, and dropping an oversized heredoc command
+// would silently stop check-dangerous-command from firing on the exact inputs
+// most worth checking.
+var MAX_STRUCTURED_LEN = 16384;
 if (hookContext.tool_input && typeof hookContext.tool_input === 'object') {
   Object.keys(hookContext.tool_input).forEach(function(key) {
-    if (typeof hookContext.tool_input[key] === 'string') {
-      env['TOOL_INPUT_' + key] = hookContext.tool_input[key];
+    var raw = hookContext.tool_input[key];
+    if (typeof raw === 'string') {
+      env['TOOL_INPUT_' + key] = raw;
+      return;
     }
+    var val;
+    if (typeof raw === 'number' || typeof raw === 'boolean') {
+      val = String(raw);
+    } else if (raw && typeof raw === 'object') {
+      try { val = JSON.stringify(raw); } catch (e) { return; }
+    } else {
+      return; // null/undefined/function — nothing meaningful to forward
+    }
+    if (val.length > MAX_STRUCTURED_LEN) return;
+    env['TOOL_INPUT_' + key] = val;
   });
 }
 
+// #1322: forward the parts of tool_response that actually exist, so a gate can
+// observe an OUTCOME rather than only the intent it was handed.
+//
+// Claude Code's PostToolUse payload carries NO exit status — probed on v2.1.220,
+// tool_response for a Bash call is {stdout, stderr, interrupted, isImage,
+// noOutputExpected}. PostToolUse also does not fire at all when the command
+// exits non-zero, so the only case a gate can still be fooled by is an exit code
+// MASKED by a pipe or \`|| true\`, where the response looks clean. The runner's
+// own output is the sole remaining signal; record-test-run reads it in gate.cjs.
+//
+// Tail, not head. Every test runner prints its pass/fail summary LAST, so
+// clipping the front of a long log would discard the exact lines this exists to
+// read. Bounds are deliberately tight — Windows caps the whole environment
+// block at ~32K wide chars and fails the spawn rather than truncating, and
+// TOOL_INPUT_command is already forwarded uncapped alongside these.
+var MAX_RESPONSE_STDOUT = 4096;
+var MAX_RESPONSE_STDERR = 2048;
+function tailOf(value, max) {
+  return value.length > max ? value.slice(value.length - max) : value;
+}
+if (hookContext.tool_response && typeof hookContext.tool_response === 'object') {
+  var resp = hookContext.tool_response;
+  if (typeof resp.stdout === 'string' && resp.stdout) {
+    env.TOOL_RESPONSE_stdout = tailOf(resp.stdout, MAX_RESPONSE_STDOUT);
+  }
+  if (typeof resp.stderr === 'string' && resp.stderr) {
+    env.TOOL_RESPONSE_stderr = tailOf(resp.stderr, MAX_RESPONSE_STDERR);
+  }
+  // Boolean — the string-typed forwarding above would drop it silently.
+  if (typeof resp.interrupted === 'boolean') {
+    env.TOOL_RESPONSE_interrupted = String(resp.interrupted);
+  }
+}
+
 // 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');
 try {
-  var output = execSync('node "' + gateScript + '" ' + command, {
-    env: env, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
+  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);
   process.exit(0);

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

@@ -22,8 +22,14 @@ const WALK_SKIP_DIRS = new Set([
     'node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.reports',
     '.swarm', '.moflo', 'packages',
 ]);
+// `.mjs`/`.cjs` are first-class JS sources, not build artifacts — moflo's own
+// hook/gate/launcher runtime is written in them. Omitting them here made every
+// consumer's generated `code_map.extensions` exclude them, so an explicit list
+// from `flo init` shadowed the indexer defaults and left that code unsearchable
+// (#1337).
 const SOURCE_EXTENSIONS = [
-    '.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.rb', '.cs',
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.go', '.rs', '.java', '.kt', '.swift', '.rb', '.cs',
 ];
 /**
  * Top-level candidates for source directories. Same list `flo init` uses; the
@@ -127,7 +133,9 @@ function scanExtensions(dir, extensions, depth, maxDepth) {
             scanExtensions(path.join(dir, entry.name), extensions, depth + 1, maxDepth);
         }
         else if (entry.isFile()) {
-            const ext = path.extname(entry.name);
+            // Lowercase before matching: NTFS/APFS are case-insensitive, so a file
+            // committed as `Foo.MJS` yields `.MJS` and would miss an exact compare.
+            const ext = path.extname(entry.name).toLowerCase();
             if (SOURCE_EXTENSIONS.includes(ext))
                 extensions.add(ext);
         }
@@ -144,7 +152,7 @@ export function detectExtensions(root, srcDirs) {
             catch { /* skip */ }
         }
     }
-    return extensions.size > 0 ? [...extensions].sort() : ['.ts', '.tsx', '.js', '.jsx'];
+    return extensions.size > 0 ? [...extensions].sort() : ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
 }
 export function defaultMofloYamlConfig(root) {
     const guidanceDirs = discoverGuidanceDirs(root);

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

@@ -39,7 +39,7 @@ export function generateSettings(options) {
     };
     // Add claude-flow attribution for git commits and PRs
     settings.attribution = {
-        commit: 'Co-Authored-By: moflo <noreply@motailz.com>',
+        commit: 'Co-Authored-By: moflo <noreply@cielolimitada.com>',
         pr: '🤖 Generated with [moflo](https://github.com/eric-cielo/moflo)',
     };
     // Note: Claude Code expects 'model' to be a string, not an object
@@ -339,7 +339,15 @@ function generateHooksConfig(config) {
             },
             {
                 matcher: '^mcp__moflo__memory_store$',
-                hooks: [{ type: 'command', command: gateCmd('record-learnings-stored'), timeout: 2000 }],
+                hooks: [
+                    { type: 'command', command: gateCmd('record-learnings-stored'), timeout: 2000 },
+                    // #1332 — capture /verify's structured verdict so check-before-done
+                    // can gate on the outcome rather than on attendance. Must route via
+                    // gateHookCmd, not gateCmd: the TOOL_INPUT_* env vars this reads are
+                    // built by gate-hook.mjs from the hook's stdin payload, so a direct
+                    // gate.cjs invocation would see no key and no metadata.
+                    { type: 'command', command: gateHookCmd('record-verify-outcome'), timeout: 2000 },
+                ],
             },
             {
                 // #952 — when /fl is invoked with -s/--swarm, the gate blocks Agent

package/dist/src/cli/mcp-client.js

@@ -20,9 +20,16 @@ import { securityTools } from './mcp-tools/security-tools.js';
 import { systemTools } from './mcp-tools/system-tools.js';
 import { neuralTools } from './mcp-tools/neural-tools.js';
 import { performanceTools } from './mcp-tools/performance-tools.js';
-import { githubTools } from './mcp-tools/github-tools.js';
+// #1353 — `github-tools.ts` is gone. Its four tools made no GitHub API call;
+// they wrote local JSON and returned `Math.random()` counts, so a `merged: true`
+// described nothing that happened. Use the `gh` CLI or a GitHub MCP server.
 import { coordinationTools } from './mcp-tools/coordination-tools.js';
 import { moflodbTools } from './mcp-tools/moflodb-tools.js';
+// #1349 — handlers for tool names shipped CLI commands were already calling.
+import { progressTools } from './mcp-tools/progress-tools.js';
+import { coverageTools } from './mcp-tools/coverage-tools.js';
+import { memoryAdminTools } from './mcp-tools/memory-admin-tools.js';
+import { analysisTools } from './mcp-tools/analysis-tools.js';
 import { errorDetail } from './shared/utils/error-detail.js';
 /**
  * MCP Tool Registry
@@ -49,9 +56,12 @@ registerTools([
     ...systemTools,
     ...neuralTools,
     ...performanceTools,
-    ...githubTools,
     ...coordinationTools,
     ...moflodbTools,
+    ...progressTools,
+    ...coverageTools,
+    ...memoryAdminTools,
+    ...analysisTools,
 ]);
 /**
  * MCP Client Error

package/dist/src/cli/mcp-server.js

@@ -25,6 +25,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { errorDetail } from './shared/utils/error-detail.js';
 import { findProjectRoot } from './services/project-root.js';
+import { getMofloVersion } from './services/moflo-version.js';
 import { readMofloEnv } from './services/env-compat.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -269,28 +270,7 @@ export class MCPServerManager extends EventEmitter {
         // Import the tool registry
         const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
         // Read version dynamically from root moflo package.json
-        let VERSION = '4.6.3';
-        try {
-            const { readFileSync } = await import('fs');
-            const { dirname: _d, join: _j } = await import('path');
-            const { fileURLToPath: _f } = await import('url');
-            let _dir = _d(_f(import.meta.url));
-            for (;;) {
-                try {
-                    const _pkg = JSON.parse(readFileSync(_j(_dir, 'package.json'), 'utf8'));
-                    if (_pkg.name === 'moflo' && _pkg.version) {
-                        VERSION = _pkg.version;
-                        break;
-                    }
-                }
-                catch { }
-                const _p = _d(_dir);
-                if (_p === _dir)
-                    break;
-                _dir = _p;
-            }
-        }
-        catch { }
+        const VERSION = getMofloVersion();
         const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
         // Log to stderr to not corrupt stdout
         console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`);
@@ -445,7 +425,9 @@ export class MCPServerManager extends EventEmitter {
                         id: message.id,
                         result: {
                             protocolVersion: '2024-11-05',
-                            serverInfo: { name: 'moflo', version: '3.0.0' },
+                            // The `initialize` reply is where a client learns the server
+                            // version; this reported 3.0.0 from a 4.x package (#1325).
+                            serverInfo: { name: 'moflo', version: getMofloVersion() },
                             capabilities: {
                                 tools: { listChanged: true },
                                 resources: { subscribe: true, listChanged: true },