moflo 4.12.4-rc.1 → 4.12.4-rc.2

package/.claude/agents/core/coder.md

@@ -236,10 +236,9 @@ mcp__moflo__performance_benchmark {
   iterations: 10
 }
 
-// Analyze bottlenecks
+// Read this process's CPU / memory / heap usage
 mcp__moflo__performance_report {
-  component: "api-endpoint",
-  metrics: ["response-time", "memory-usage"]
+  format: "detailed"
 }
 ```
 

package/.claude/agents/core/researcher.md

@@ -155,10 +155,9 @@ mcp__moflo__memory_search {
 
 ### Analysis Tools
 ```javascript
-// Analyze codebase
-mcp__moflo__github_repo_analyze {
-  repo: "current",
-  analysis_type: "code_quality"
+// Understand what a change touches and how risky it is
+mcp__moflo__analyze_diff {
+  ref: "main"
 }
 
 // Track research metrics

package/.claude/agents/core/reviewer.md

@@ -304,16 +304,14 @@ mcp__moflo__memory_retrieve {
 
 ### Code Analysis
 ```javascript
-// Analyze code quality
-mcp__moflo__github_repo_analyze {
-  repo: "current",
-  analysis_type: "code_quality"
+// Assess the risk and shape of the change under review
+mcp__moflo__analyze_diff {
+  ref: "main"
 }
 
-// Run security scan
-mcp__moflo__github_repo_analyze {
-  repo: "current",
-  analysis_type: "security"
+// Scan the diff for prompt-injection and unsafe content
+mcp__moflo__aidefence_scan {
+  content: "<the diff or file under review>"
 }
 ```
 

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

@@ -71,6 +71,40 @@ if (hookContext.tool_input && typeof hookContext.tool_input === 'object') {
   });
 }
 
+// #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');

package/.claude/helpers/gate.cjs

@@ -139,6 +139,14 @@ var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state
 // failures and "fixes" them with allow rules — which cannot override a hook
 // block at all (#1307 finding 5). Naming the gate makes the cause self-evident.
 var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule — allow-rules cannot override it.';
+
+// #1348 — the pre-PR gates are order-dependent and each block message named only
+// its own missing gate, so a caller could satisfy them one at a time forever:
+// /flo-simplify may edit code (which resets tests and verify), and /verify must
+// not, so simplify strictly precedes verify. Both blocking gates print this.
+// /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';
 var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
 
 // #1294 Finding 3 — reads/scans of EPHEMERAL files under the OS temp dir
@@ -498,6 +506,53 @@ function applyPromptStateReset(state, promptText) {
 // and language-native test commands. The bare-runner arm is anchored so that
 // `npm install jest`, `grep -r vitest src/`, and similar don't false-positive.
 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;
+}
 // Edits to these don't change runtime behaviour, so they don't invalidate prior test/simplify runs.
 // Lock files and .gitignore are tracked but inert; package.json/*.yaml ARE source — they reset.
 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;
@@ -508,7 +563,13 @@ var EDIT_RESET_SKIP_BOTH_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^
 // they shouldn't reset testsRun/simplifyRun the way a real source edit does.
 // Trailing terminator includes `.` so the single-file template form
 // `.github/PULL_REQUEST_TEMPLATE.md` matches alongside the directory form.
-var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\/])\.github[\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\/.]|$)/i;
+// #1348 — `.moflo/` joins them. It is moflo's own gitignored state directory
+// (daemon locks, memory db, SDD spec/plan artifacts), so nothing written there
+// can appear in the branch diff, and a spec edit invalidating the test run is
+// pure noise. Scoped to the reset only — deliberately NOT added to EXEMPT,
+// which would also un-gate reads of `.moflo/specs/**`, and those are indexed
+// guidance that memory-first should still route through a search.
+var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\/])\.github[\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\/.]|$)|(?:^|[\\\/])\.moflo[\\\/]/i;
 // Test files: invalidate the testing gate (tests are stale once test code changes)
 // but NOT the simplify gate — /simplify already reviewed the production code; touching
 // a test file or fixture doesn't expose new untested surface for code review (#908).
@@ -637,8 +698,11 @@ function getChangedFilesVsBase() {
 
 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 and the namespace hint moved here from
@@ -647,7 +711,7 @@ switch (command) {
     // consumer.
     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. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
@@ -809,8 +873,17 @@ 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. Without the reset, `npm test` (green)
+      // followed by an edit and `npm test | tail -20` (red) would leave the
+      // gate satisfied by the stale first run — the edit resets testsRun, but
+      // the masked red run would immediately set it back.
+      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);
       }
@@ -902,6 +975,17 @@ switch (command) {
       overall = 'UNVERIFIED';
     }
     var vs = readState();
+    // #1348 — refuse a verdict for a run that is no longer live. `verifyRun`
+    // false here means a code edit fired reset-edit-gates between the /verify
+    // invocation and this store, so the verdict describes pre-edit code.
+    // Recording it anyway produced the contradictory `verifyRun:false,
+    // verifyOutcome:'PASS'` state that check-before-done's four-way message
+    // chain has no branch for — it reports "a code edit invalidated the previous
+    // verification" while a PASS sits in state, which reads as a gate bug.
+    if (!vs.verifyRun) {
+      process.stderr.write('gate: record-verify-outcome — "' + mKey + '" arrived after a code edit invalidated the run; verdict not recorded (re-run /verify)\n');
+      break;
+    }
     vs.verifyOutcome = overall;
     writeState(vs);
     break;
@@ -912,6 +996,17 @@ switch (command) {
     // (.github/workflows/, .github/ISSUE_TEMPLATE/, .github/PULL_REQUEST_TEMPLATE/, #1176):
     // no gate reset — editing these doesn't expose new runtime surface.
     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 and
+    // can never reach the branch diff, but it used to reset tests + simplify +
+    // verify like any source change: a /verify run that jotted a probe cleared
+    // the /flo-simplify stamp, and the two gates invalidated each other with no
+    // ordering that satisfied both. Reuses the predicate the memory-first gate
+    // already trusts for these paths (#1294) rather than a second one.
+    // Scope: tmp-only, NOT project-root containment — so a project rooted under
+    // tmp has its own edits skipped too (pinned in the #1348 tests). Containment
+    // is the more general rule, but it fails OPEN when the root can't be
+    // resolved, and a gate that silently stops resetting is the worse failure.
+    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);
@@ -1018,7 +1113,7 @@ switch (command) {
       }
     }
     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;
@@ -1029,6 +1124,10 @@ switch (command) {
     if (s.lastResetBy && s.lastResetBy.file) {
       process.stderr.write('Last gate reset: ' + s.lastResetBy.file + ' (' + (s.lastResetBy.gates || []).join(', ') + ')\n');
     }
+    // #1348 — name the order, not just the missing gate. Satisfying one gate can
+    // invalidate another (/flo-simplify edits code, which resets tests + verify),
+    // so "what is missing" alone left callers rediscovering the sequence by trial.
+    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);
@@ -1079,7 +1178,12 @@ switch (command) {
       // recorded a structured outcome (interrupted, or it stored prose only).
       process.stderr.write('  - /verify ran but recorded no verdict — re-run it so it stores a structured result\n');
       process.stderr.write('    (Step 5 of the verify skill must pass metadata.overall to memory_store)\n');
+      // #1348 — the trap this state sets: re-invoking /verify CLEARS any prior
+      // verdict by design (#1332), so the obvious recovery lands right back here
+      // unless Step 5 completes. Say so, rather than letting it be rediscovered.
+      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);

package/bin/gate-hook.mjs

@@ -71,6 +71,40 @@ if (hookContext.tool_input && typeof hookContext.tool_input === 'object') {
   });
 }
 
+// #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');

package/bin/gate.cjs

@@ -139,6 +139,14 @@ var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state
 // failures and "fixes" them with allow rules — which cannot override a hook
 // block at all (#1307 finding 5). Naming the gate makes the cause self-evident.
 var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule — allow-rules cannot override it.';
+
+// #1348 — the pre-PR gates are order-dependent and each block message named only
+// its own missing gate, so a caller could satisfy them one at a time forever:
+// /flo-simplify may edit code (which resets tests and verify), and /verify must
+// not, so simplify strictly precedes verify. Both blocking gates print this.
+// /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';
 var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
 
 // #1294 Finding 3 — reads/scans of EPHEMERAL files under the OS temp dir
@@ -498,6 +506,53 @@ function applyPromptStateReset(state, promptText) {
 // and language-native test commands. The bare-runner arm is anchored so that
 // `npm install jest`, `grep -r vitest src/`, and similar don't false-positive.
 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;
+}
 // Edits to these don't change runtime behaviour, so they don't invalidate prior test/simplify runs.
 // Lock files and .gitignore are tracked but inert; package.json/*.yaml ARE source — they reset.
 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;
@@ -508,7 +563,13 @@ var EDIT_RESET_SKIP_BOTH_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^
 // they shouldn't reset testsRun/simplifyRun the way a real source edit does.
 // Trailing terminator includes `.` so the single-file template form
 // `.github/PULL_REQUEST_TEMPLATE.md` matches alongside the directory form.
-var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\/])\.github[\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\/.]|$)/i;
+// #1348 — `.moflo/` joins them. It is moflo's own gitignored state directory
+// (daemon locks, memory db, SDD spec/plan artifacts), so nothing written there
+// can appear in the branch diff, and a spec edit invalidating the test run is
+// pure noise. Scoped to the reset only — deliberately NOT added to EXEMPT,
+// which would also un-gate reads of `.moflo/specs/**`, and those are indexed
+// guidance that memory-first should still route through a search.
+var EDIT_RESET_SKIP_PATH_RE = /(?:^|[\\\/])\.github[\\\/](?:workflows|ISSUE_TEMPLATE|PULL_REQUEST_TEMPLATE)(?:[\\\/.]|$)|(?:^|[\\\/])\.moflo[\\\/]/i;
 // Test files: invalidate the testing gate (tests are stale once test code changes)
 // but NOT the simplify gate — /simplify already reviewed the production code; touching
 // a test file or fixture doesn't expose new untested surface for code review (#908).
@@ -637,8 +698,11 @@ function getChangedFilesVsBase() {
 
 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 and the namespace hint moved here from
@@ -647,7 +711,7 @@ switch (command) {
     // consumer.
     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. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
@@ -809,8 +873,17 @@ 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. Without the reset, `npm test` (green)
+      // followed by an edit and `npm test | tail -20` (red) would leave the
+      // gate satisfied by the stale first run — the edit resets testsRun, but
+      // the masked red run would immediately set it back.
+      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);
       }
@@ -902,6 +975,17 @@ switch (command) {
       overall = 'UNVERIFIED';
     }
     var vs = readState();
+    // #1348 — refuse a verdict for a run that is no longer live. `verifyRun`
+    // false here means a code edit fired reset-edit-gates between the /verify
+    // invocation and this store, so the verdict describes pre-edit code.
+    // Recording it anyway produced the contradictory `verifyRun:false,
+    // verifyOutcome:'PASS'` state that check-before-done's four-way message
+    // chain has no branch for — it reports "a code edit invalidated the previous
+    // verification" while a PASS sits in state, which reads as a gate bug.
+    if (!vs.verifyRun) {
+      process.stderr.write('gate: record-verify-outcome — "' + mKey + '" arrived after a code edit invalidated the run; verdict not recorded (re-run /verify)\n');
+      break;
+    }
     vs.verifyOutcome = overall;
     writeState(vs);
     break;
@@ -912,6 +996,17 @@ switch (command) {
     // (.github/workflows/, .github/ISSUE_TEMPLATE/, .github/PULL_REQUEST_TEMPLATE/, #1176):
     // no gate reset — editing these doesn't expose new runtime surface.
     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 and
+    // can never reach the branch diff, but it used to reset tests + simplify +
+    // verify like any source change: a /verify run that jotted a probe cleared
+    // the /flo-simplify stamp, and the two gates invalidated each other with no
+    // ordering that satisfied both. Reuses the predicate the memory-first gate
+    // already trusts for these paths (#1294) rather than a second one.
+    // Scope: tmp-only, NOT project-root containment — so a project rooted under
+    // tmp has its own edits skipped too (pinned in the #1348 tests). Containment
+    // is the more general rule, but it fails OPEN when the root can't be
+    // resolved, and a gate that silently stops resetting is the worse failure.
+    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);
@@ -1018,7 +1113,7 @@ switch (command) {
       }
     }
     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;
@@ -1029,6 +1124,10 @@ switch (command) {
     if (s.lastResetBy && s.lastResetBy.file) {
       process.stderr.write('Last gate reset: ' + s.lastResetBy.file + ' (' + (s.lastResetBy.gates || []).join(', ') + ')\n');
     }
+    // #1348 — name the order, not just the missing gate. Satisfying one gate can
+    // invalidate another (/flo-simplify edits code, which resets tests + verify),
+    // so "what is missing" alone left callers rediscovering the sequence by trial.
+    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);
@@ -1079,7 +1178,12 @@ switch (command) {
       // recorded a structured outcome (interrupted, or it stored prose only).
       process.stderr.write('  - /verify ran but recorded no verdict — re-run it so it stores a structured result\n');
       process.stderr.write('    (Step 5 of the verify skill must pass metadata.overall to memory_store)\n');
+      // #1348 — the trap this state sets: re-invoking /verify CLEARS any prior
+      // verdict by design (#1332), so the obvious recovery lands right back here
+      // unless Step 5 completes. Say so, rather than letting it be rediscovered.
+      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);

package/dist/src/cli/commands/agent.js

@@ -690,94 +690,6 @@ const healthCommand = {
         }
     }
 };
-// Agent logs subcommand
-const logsCommand = {
-    name: 'logs',
-    description: 'Show agent activity logs',
-    options: [
-        {
-            name: 'id',
-            short: 'i',
-            description: 'Agent ID',
-            type: 'string'
-        },
-        {
-            name: 'tail',
-            short: 'n',
-            description: 'Number of recent entries',
-            type: 'number',
-            default: 50
-        },
-        {
-            name: 'level',
-            short: 'l',
-            description: 'Minimum log level',
-            type: 'string',
-            choices: ['debug', 'info', 'warn', 'error'],
-            default: 'info'
-        },
-        {
-            name: 'follow',
-            short: 'f',
-            description: 'Follow log output',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'since',
-            description: 'Show logs since (e.g., "1h", "30m")',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'flo agent logs -i agent-001', description: 'Show agent logs' },
-        { command: 'flo agent logs -i agent-001 -f', description: 'Follow agent logs' },
-        { command: 'flo agent logs -l error --since 1h', description: 'Show errors from last hour' }
-    ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags.id;
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level;
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', {
-                agentId,
-                tail,
-                level,
-                since: ctx.flags.since,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                const levelStr = formatLogLevel(entry.level);
-                output.writeln(`${output.dim(time)} ${levelStr} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Logs error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 function formatLogLevel(level) {
     switch (level) {
         case 'debug':
@@ -796,7 +708,7 @@ function formatLogLevel(level) {
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand],
     options: [],
     examples: [
         { command: 'flo agent spawn -t coder', description: 'Spawn a coder agent' },