moflo 4.10.25 → 4.10.27

package/bin/simplify-classify.cjs

@@ -7,17 +7,28 @@
  * deterministic and unit-testable instead of a prose decision Claude makes
  * over and over per run.
  *
- * Rule: default to single-agent Sonnet review. Only escalate to a 3-agent
- * fan-out when diff signals genuinely warrant it. Opus is never selected —
- * the existing skill already documents that.
+ * Rule: default to single-agent Sonnet review. Escalate to a 3-agent Sonnet
+ * fan-out (NORMAL) when diff signals warrant it, and to a 3-agent Opus fan-out
+ * (DEEP) only for genuinely architectural diffs — ordinary review is
+ * breadth-bound (Sonnet wins), but architectural review is depth-bound (Opus
+ * earns its cost). The most extreme diffs additionally suggest handing off to
+ * Claude Code's built-in /simplify via escalate.suggested. (#1222 follow-up)
+ *
+ * Opus escalation is gated on genuine new-logic evidence, NEVER raw volume:
+ * TS/JS uses net-new declarations; other languages use net-new lines
+ * (added − deleted, aggregate → relocation/churn cancels out). Noise
+ * (lockfiles, snapshots, generated/vendored) and docs/data never count toward
+ * the opus bar. So a lockfile bump, a reformatting sweep, or a big rename can
+ * never reach Opus.
  *
  * Outputs JSON:
  *   {
- *     "tier": "TRIVIAL" | "SMALL" | "NORMAL",
- *     "model": "sonnet",
+ *     "tier": "TRIVIAL" | "SMALL" | "NORMAL" | "DEEP",
+ *     "model": "sonnet" | "haiku" | "opus",
  *     "agentCount": 0 | 1 | 3,
+ *     "escalate": { suggested: bool, target: "builtin-simplify"|null, reason: string|null },
  *     "reasoning": [string, ...],
- *     "stats": { added, deleted, fileCount, declAdded, declRemoved, ... }
+ *     "stats": { added, deleted, fileCount, declAdded, declRemoved, tsjsLOC, tsjsNetDecls, otherNetAdded, ... }
  *   }
  *
  * Usage:
@@ -45,6 +56,48 @@ const SECURITY_PATHS = [
   /(?:^|[\\\/])\.claude[\\\/]helpers[\\\/]gate/i,
 ];
 
+// ── File-family classification for the opus-escalation gate (#1222) ───────────
+// Opus is gated on genuine new-logic evidence, never raw volume — so generated
+// noise and docs/data are stripped before measuring, and TS/JS (where the decl
+// parser is accurate) is measured by net-new declarations while other languages
+// fall back to net-new lines.
+
+// Generated / vendored noise — inflates LOC without adding reviewable logic.
+const NOISE_FILE = [
+  /(?:^|[\\\/])(?:package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|composer\.lock|Cargo\.lock|poetry\.lock|Gemfile\.lock|go\.sum)$/i,
+  /\.snap$/i,
+  /(?:^|[\\\/])__snapshots__[\\\/]/i,
+  /(?:^|[\\\/])(?:dist|build|out|coverage|node_modules)[\\\/]/i,
+  /\.min\.(?:js|css)$/i,
+  /\.(?:map|bundle\.js)$/i,
+  /(?:^|[\\\/])vendor[\\\/]/i,
+];
+
+// Docs / data — reviewed at normal tiers, but never counted toward the opus bar.
+const DOCDATA_FILE = /\.(?:md|mdx|markdown|txt|rst|json|json5|ya?ml|toml|ini|cfg|conf|xml|csv|tsv|svg|properties|env)$/i;
+
+// TS/JS source — the declaration parser is accurate here, so the opus gate uses
+// net-new declarations for these files.
+const TSJS_FILE = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts)$/i;
+
+/**
+ * Bucket a file path into the family the opus-escalation gate cares about:
+ * 'noise' / 'docdata' (both excluded from the opus bar), 'tsjs' (decl-gated),
+ * or 'othercode' (net-line-gated). Pure function over the path string.
+ */
+function fileFamily(filename) {
+  if (NOISE_FILE.some((rx) => rx.test(filename))) return 'noise';
+  if (TSJS_FILE.test(filename)) return 'tsjs';
+  if (DOCDATA_FILE.test(filename)) return 'docdata';
+  return 'othercode';
+}
+
+// Default "no escalation" marker attached to every non-DEEP decision so the
+// output shape (decision.escalate) is stable for every consumer.
+function noEscalate() {
+  return { suggested: false, target: null, reason: null };
+}
+
 function safeExec(cmd, opts) {
   try {
     return execSync(cmd, {
@@ -146,6 +199,11 @@ function parseDiff(diff) {
   let added = 0, deleted = 0, declAdded = 0, declRemoved = 0;
   let newFiles = 0, renamedFiles = 0;
   let securityHit = false;
+  // Family-segregated signals for the opus-escalation gate (#1222). Noise +
+  // docs/data still contribute to the global totals (so existing
+  // TRIVIAL/SMALL/NORMAL routing is unchanged) but never to the opus bar.
+  let tsjsAdded = 0, tsjsDeleted = 0, tsjsDeclAdded = 0, tsjsDeclRemoved = 0;
+  let otherAdded = 0, otherDeleted = 0;
   for (const f of files.values()) {
     added += f.added;
     deleted += f.deleted;
@@ -154,6 +212,14 @@ function parseDiff(diff) {
     if (f.isNew) newFiles++;
     if (f.isRenamed) renamedFiles++;
     if (SECURITY_PATHS.some(rx => rx.test(f.filename))) securityHit = true;
+
+    const fam = fileFamily(f.filename);
+    if (fam === 'tsjs') {
+      tsjsAdded += f.added; tsjsDeleted += f.deleted;
+      tsjsDeclAdded += f.declAdded; tsjsDeclRemoved += f.declRemoved;
+    } else if (fam === 'othercode') {
+      otherAdded += f.added; otherDeleted += f.deleted;
+    }
   }
 
   return {
@@ -162,6 +228,13 @@ function parseDiff(diff) {
     fileCount: files.size,
     newFiles, renamedFiles,
     securityHit,
+    // Opus-gate signals (#1222): net-new declarations for TS/JS, net-new lines
+    // for other code. Aggregate net → relocation/churn cancels to ~0.
+    tsjsLOC: tsjsAdded + tsjsDeleted,
+    tsjsNetDecls: tsjsDeclAdded - tsjsDeclRemoved,
+    tsjsDeclAdded,
+    otherNetAdded: otherAdded - otherDeleted,
+    otherLOC: otherAdded + otherDeleted,
     files: [...files.keys()],
   };
 }
@@ -175,13 +248,13 @@ function decide(stats) {
   const totalChange = stats.added + stats.deleted;
 
   if (totalChange === 0) {
-    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, reasoning: ['empty diff — nothing to review'], stats };
+    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, escalate: noEscalate(), reasoning: ['empty diff — nothing to review'], stats };
   }
 
   // TRIVIAL: tiny diff, no declarations changed
   if (totalChange <= 10 && stats.fileCount <= 1 && stats.netDecls === 0 && stats.declAdded === 0 && stats.declRemoved === 0) {
     reasoning.push(`≤10 LOC in 1 file with no declaration changes`);
-    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, reasoning, stats };
+    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, escalate: noEscalate(), reasoning, stats };
   }
 
   // Mechanical relocation detection — the #906 case.
@@ -203,11 +276,60 @@ function decide(stats) {
     // Haiku is sufficient for mechanical moves: code already existed and worked,
     // so review reduces to copy-paste-divergence / dead-after-move pattern checks
     // — exactly haiku's strength. ~5x cheaper than sonnet on relocation-shape diffs.
-    return { tier: 'SMALL', model: 'haiku', agentCount: 1, reasoning, stats };
+    return { tier: 'SMALL', model: 'haiku', agentCount: 1, escalate: noEscalate(), reasoning, stats };
+  }
+
+  // ── Architectural escalation to Opus (#1222) ────────────────────────────────
+  // Two rungs above NORMAL, BOTH gated on genuine new-logic evidence so volume
+  // alone never escalates: TS/JS by net-new declarations, other languages by
+  // net-new lines. The relocation guard above already returned SMALL, so
+  // mechanical moves never reach here, and noise/docs/data were stripped from
+  // these signals in parseDiff.
+  //
+  //   • DEEP            → runs a 3-agent Opus pass automatically (depth-bound
+  //                       architectural review; ordinary review stays Sonnet).
+  //   • DEEP + handoff  → also suggests Claude Code's built-in /simplify for the
+  //                       most extreme diffs (escalate.suggested = true). The
+  //                       Opus pass still runs as the floor; the handoff is a
+  //                       prompt, not an auto-switch.
+  const tsjsLOC = stats.tsjsLOC || 0;
+  const tsjsNetDecls = stats.tsjsNetDecls || 0;
+  const tsjsDeclAdded = stats.tsjsDeclAdded || 0;
+  const otherNetAdded = stats.otherNetAdded || 0;
+
+  // The new-subsystem triggers count TS/JS declarations only (tsjs-scoped, not
+  // global) so a docs/data file with a fenced `export function` code sample
+  // can't leak into the opus gate — consistent with the net-new-logic contract.
+  const handoffTriggers = [];
+  if (tsjsLOC > 4000 && tsjsNetDecls >= 25) handoffTriggers.push(`${tsjsLOC} LOC of TS/JS with ${tsjsNetDecls} net-new declarations`);
+  if (otherNetAdded > 3000) handoffTriggers.push(`${otherNetAdded} net-new lines of non-TS/JS source`);
+  if (stats.newFiles >= 10 && tsjsDeclAdded >= 30 && tsjsNetDecls >= 20) handoffTriggers.push(`${stats.newFiles} new files with ${tsjsDeclAdded} new TS/JS declarations`);
+
+  if (handoffTriggers.length > 0) {
+    return {
+      tier: 'DEEP', model: 'opus', agentCount: 3,
+      escalate: { suggested: true, target: 'builtin-simplify', reason: handoffTriggers.join('; ') },
+      reasoning: handoffTriggers, stats,
+    };
+  }
+
+  const deepTriggers = [];
+  if (tsjsLOC > 1500 && tsjsNetDecls >= 10) deepTriggers.push(`${tsjsLOC} LOC of TS/JS with ${tsjsNetDecls} net-new declarations`);
+  if (otherNetAdded > 1200) deepTriggers.push(`${otherNetAdded} net-new lines of non-TS/JS source`);
+  if (stats.newFiles >= 5 && tsjsDeclAdded >= 15 && tsjsNetDecls >= 10) deepTriggers.push(`${stats.newFiles} new files with ${tsjsDeclAdded} new TS/JS declarations`);
+  if (stats.securityHit && stats.netDecls >= 8) deepTriggers.push(`security-sensitive path with ${stats.netDecls} net-new declarations`);
+
+  if (deepTriggers.length > 0) {
+    return {
+      tier: 'DEEP', model: 'opus', agentCount: 3,
+      escalate: noEscalate(),
+      reasoning: deepTriggers, stats,
+    };
   }
 
   // Escalation triggers — any one trips NORMAL (3 agents).
-  // Always Sonnet — Opus is never the right model for /simplify per skill rule.
+  // Sonnet — ordinary cross-cutting review is breadth-bound, so 3 Sonnet agents
+  // are the right tool; Opus is reserved for the DEEP (architectural) tier above.
   const triggers = [];
   if (totalChange > 500) triggers.push(`>500 LOC changed (${totalChange})`);
   if (stats.fileCount >= 5 && stats.netDecls >= 3) triggers.push(`${stats.fileCount} files with ${stats.netDecls} net new declarations`);
@@ -215,12 +337,12 @@ function decide(stats) {
   if (stats.newFiles >= 3 && stats.declAdded >= 5) triggers.push(`${stats.newFiles} new files with ${stats.declAdded} new declarations`);
 
   if (triggers.length > 0) {
-    return { tier: 'NORMAL', model: 'sonnet', agentCount: 3, reasoning: triggers, stats };
+    return { tier: 'NORMAL', model: 'sonnet', agentCount: 3, escalate: noEscalate(), reasoning: triggers, stats };
   }
 
   // Default: SMALL — single sonnet agent
   reasoning.push(`small/medium diff: ${totalChange} LOC across ${stats.fileCount} file(s), +${stats.declAdded}/-${stats.declRemoved} decls`);
-  return { tier: 'SMALL', model: 'sonnet', agentCount: 1, reasoning, stats };
+  return { tier: 'SMALL', model: 'sonnet', agentCount: 1, escalate: noEscalate(), reasoning, stats };
 }
 
 function classifyDiff(diffText) {

package/dist/src/cli/commands/doctor-checks-deep.js

@@ -667,7 +667,7 @@ export async function checkHookBlockDrift() {
         name: 'Hook Block Drift',
         status: 'warn',
         message: parts.join(', '),
-        fix: 'set auto_update.hook_block_drift: regenerate in moflo.yaml, or moflo.hooks.locked: true to suppress',
+        fix: 'session-start auto-regenerates by default (#1227); next Claude Code start should heal this. If it persists, ensure `auto_update.hook_block_drift` is not set to `warn`/`off` in moflo.yaml, or set `moflo.hooks.locked: true` to suppress.',
     };
 }
 // ============================================================================

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

@@ -19,6 +19,9 @@ import { generateClaudeMd as generateMofloSection } from './claudemd-generator.j
 import { applyInjectionReplacement } from '../services/claudemd-injection.js';
 import { loadShippedScripts } from './shipped-scripts.js';
 import { DEFAULT_INIT_OPTIONS } from './types.js';
+import { generateSettings } from './settings-generator.js';
+import { applyWholesaleRegeneration, computeHookBlockDrift, isHookBlockLocked, } from '../services/hook-block-hash.js';
+import { rewriteIncorrectHookWiring } from '../services/hook-wiring.js';
 export { discoverTestDirs };
 // ============================================================================
 // Init
@@ -180,176 +183,107 @@ function generateConfig(root, force, answers) {
 // ============================================================================
 // Step 2: .claude/settings.json hooks
 // ============================================================================
-function generateHooks(root, force, answers) {
+// #1227 — `flo init` was the surgical patcher that silently nuked user-owned
+// hooks (project-analysis-gate.cjs, e2e-gate.cjs) AND moflo entries in legacy
+// slots (swarm_init/hive-mind_init in PreToolUse, auto-memory-hook in SessionEnd).
+// The old generateHooks had three structural defects:
+//   (1) Its "already configured" guard scanned for the literal substring
+//       `'flo gate'` / `'moflo gate'` — modern moflo commands are
+//       `node ".../helpers/gate.cjs ..."` so the substring NEVER matched and
+//       the guard always fell through to the wipe path.
+//   (2) `existing.hooks = hooks` was a wholesale overwrite — the comment claimed
+//       "preserve existing non-MoFlo hooks" but the code did the opposite.
+//   (3) Its inlined canonical block had drifted from settings-generator.ts /
+//       hook-block-hash.ts (no swarm_init, no hive-mind_init, no Stop
+//       auto-memory-hook, SessionStart launcher timeout 3000 not 5000).
+//
+// New shape: one canonical source. For missing settings.json, write
+// generateSettings(DEFAULT_INIT_OPTIONS). For existing, run the same wholesale
+// regen the session-start launcher uses — applyWholesaleRegeneration preserves
+// user-owned entries via the #1180 basename guard AND relocates moflo entries
+// from legacy slots (SessionEnd → Stop, PreToolUse swarm_init → PostToolUse,
+// etc.). rewriteIncorrectHookWiring runs first so command-string rewrites
+// (#879 / #931) are healed before the structural pass hashes the block.
+function generateHooks(root, force, _answers) {
     const settingsPath = path.join(root, '.claude', 'settings.json');
     const settingsDir = path.dirname(settingsPath);
     if (!fs.existsSync(settingsDir)) {
         fs.mkdirSync(settingsDir, { recursive: true });
     }
-    let existing = {};
-    if (fs.existsSync(settingsPath)) {
-        try {
-            existing = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        }
-        catch { /* start fresh */ }
-        // Check if MoFlo hooks already set up
-        const settingsStr = JSON.stringify(existing);
-        const hasGateHooks = settingsStr.includes('flo gate') || settingsStr.includes('moflo gate');
-        if (hasGateHooks && !force) {
-            return { name: '.claude/settings.json', status: 'skipped', detail: 'MoFlo hooks already configured' };
+    // No settings.json yet — write the canonical default and return.
+    if (!fs.existsSync(settingsPath)) {
+        const fresh = generateSettings({ ...DEFAULT_INIT_OPTIONS, targetDir: root, force: true });
+        fs.writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), 'utf-8');
+        return { name: '.claude/settings.json', status: 'created', detail: 'canonical hooks block written' };
+    }
+    let existing;
+    try {
+        existing = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        // Corrupt — rewrite from canonical (force-overwrites; user can revert).
+        const fresh = generateSettings({ ...DEFAULT_INIT_OPTIONS, targetDir: root, force: true });
+        fs.writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), 'utf-8');
+        return { name: '.claude/settings.json', status: 'updated', detail: 'rewrote unparseable settings.json from canonical' };
+    }
+    // Respect the explicit opt-out — same sentinel the launcher honours.
+    if (isHookBlockLocked(existing) && !force) {
+        return { name: '.claude/settings.json', status: 'skipped', detail: 'moflo.hooks.locked=true (explicit opt-out)' };
+    }
+    // Pass 1: in-place command + matcher rewrites (#879, #929, #931, #1171,
+    // auto-meditate rebrand). These never delete anything; they fix commands
+    // that exist but point at the wrong helper/subcommand.
+    const { rewrites } = rewriteIncorrectHookWiring(existing);
+    const rewroteCommands = rewrites.reduce((n, r) => n + r.count, 0);
+    // Pass 2: structural wholesale regen. Preserves user-owned entries via the
+    // #1180 basename guard (any command not pointing at a moflo-shipped helper
+    // is grafted back in); relocates moflo entries from legacy event/matcher
+    // slots to the current canonical shape.
+    const report = computeHookBlockDrift((existing.hooks ?? {}));
+    let added = 0;
+    let removed = 0;
+    let preserved = 0;
+    if (report.drifted) {
+        const extraCount = report.extra.length;
+        const result = applyWholesaleRegeneration(existing, report);
+        added = result.added;
+        removed = result.removed;
+        // applyWholesaleRegeneration computes `removed = extra - customisations`,
+        // so `preserved` is the complement — the number of user-owned entries
+        // grafted back into the fresh tree.
+        preserved = extraCount - removed;
+    }
+    // Ensure statusLine + permissions/env/attribution scaffold is present —
+    // mirrors the existing moflo-init.ts UX but no longer overwrites user
+    // values that are already set.
+    const canonical = generateSettings({ ...DEFAULT_INIT_OPTIONS, targetDir: root, force: true });
+    const scaffoldKeys = ['statusLine', 'permissions', 'env', 'attribution'];
+    const scaffoldAdded = [];
+    for (const key of scaffoldKeys) {
+        if (existing[key] == null && canonical[key] != null) {
+            existing[key] = canonical[key];
+            scaffoldAdded.push(key);
         }
     }
-    // Build hooks config — all on by default (opinionated pit-of-success)
-    // Uses direct node invocation via helper scripts (gate.cjs, gate-hook.mjs,
-    // hook-handler.cjs) instead of `npx flo` to avoid 2-5s cold-start per hook.
-    const gateHook = (sub) => `node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" ${sub}`;
-    const gate = (sub) => `node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" ${sub}`;
-    const handler = (sub) => `node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" ${sub}`;
-    const hooks = {
-        "PreToolUse": [
-            {
-                "matcher": "^(Write|Edit|MultiEdit)$",
-                "hooks": [{ "type": "command", "command": handler('post-edit'), "timeout": 5000 }]
-            },
-            {
-                "matcher": "^(Glob|Grep)$",
-                "hooks": [{ "type": "command", "command": gateHook('check-before-scan'), "timeout": 3000 }]
-            },
-            {
-                "matcher": "^Read$",
-                "hooks": [{ "type": "command", "command": gateHook('check-before-read'), "timeout": 3000 }]
-            },
-            {
-                // #1171 — widened to cover the dedicated `PowerShell` tool.
-                "matcher": "^(Bash|PowerShell)$",
-                "hooks": [
-                    { "type": "command", "command": gateHook('check-dangerous-command'), "timeout": 2000 },
-                    { "type": "command", "command": gateHook('check-before-pr'), "timeout": 2000 }
-                ]
-            },
-            {
-                // #931 — Advisory only; never blocks. TaskCreate REMINDER and the
-                // namespace hint moved here from UserPromptSubmit so they emit only
-                // when Claude is about to spawn an Agent — saves ~90 tokens × every
-                // prompt × every consumer. Routed via gate-hook.mjs so Claude Code's
-                // session_id is forwarded as HOOK_SESSION_ID, enabling per-actor
-                // single-shot emission (mirror of #879's record-memory-searched fix).
-                "matcher": "^Agent$",
-                "hooks": [{ "type": "command", "command": gateHook('check-before-agent'), "timeout": 2000 }]
-            }
-        ],
-        "PostToolUse": [
-            {
-                "matcher": "^(Write|Edit|MultiEdit)$",
-                "hooks": [
-                    { "type": "command", "command": handler('post-edit'), "timeout": 5000 },
-                    { "type": "command", "command": gateHook('reset-edit-gates'), "timeout": 2000 }
-                ]
-            },
-            {
-                "matcher": "^Agent$",
-                "hooks": [{ "type": "command", "command": handler('post-task'), "timeout": 5000 }]
-            },
-            {
-                "matcher": "^TaskCreate$",
-                "hooks": [{ "type": "command", "command": gate('record-task-created'), "timeout": 2000 }]
-            },
-            {
-                // #1171 — widened to cover the dedicated `PowerShell` tool.
-                "matcher": "^(Bash|PowerShell)$",
-                "hooks": [
-                    { "type": "command", "command": gateHook('check-bash-memory'), "timeout": 2000 },
-                    { "type": "command", "command": gateHook('record-test-run'), "timeout": 2000 }
-                ]
-            },
-            {
-                "matcher": "^Skill$",
-                "hooks": [{ "type": "command", "command": gateHook('record-skill-run'), "timeout": 2000 }]
-            },
-            {
-                // Anchored alternation — Claude Code anchors hook matchers (`^…$` semantics),
-                // so a bare `mcp__moflo__memory_` never matches any real MCP tool name and the
-                // hook silently no-ops (#929 regression). The explicit suffix list keeps the
-                // matcher narrow while catching every memory_* tool we ship.
-                // Use gateHook (not gate) so the wrapper forwards Claude Code's session_id as
-                // HOOK_SESSION_ID — record-memory-searched needs this to mark the per-actor map
-                // (memorySearchedBy[sid]) that check-before-read consults under #838's per-actor gating.
-                // Without it, the legacy boolean is set but the per-actor map stays empty, and the gate
-                // blocks every Read forever within the turn (issue #879).
-                "matcher": "^mcp__moflo__memory_(search|retrieve|list|stats|store)$",
-                "hooks": [{ "type": "command", "command": gateHook('record-memory-searched'), "timeout": 3000 }]
-            },
-            {
-                "matcher": "^mcp__moflo__memory_store$",
-                "hooks": [{ "type": "command", "command": gate('record-learnings-stored'), "timeout": 2000 }]
-            }
-        ],
-        "UserPromptSubmit": [
-            {
-                "hooks": [
-                    { "type": "command", "command": `node "$CLAUDE_PROJECT_DIR/.claude/helpers/prompt-hook.mjs"`, "timeout": 3000 }
-                ]
-            },
-            {
-                // prompt-state-reset is REQUIRED to reset memorySearched/memorySearchedBy on
-                // each new prompt and reclassify memoryRequired. Without it, gate state leaks
-                // across prompts. Separate hook entry so a prompt-hook.mjs exception doesn't
-                // skip the reset. Idempotent state reset only — no emission, no
-                // interactionCount increment (#931 dedupe).
-                "hooks": [
-                    { "type": "command", "command": gateHook('prompt-state-reset'), "timeout": 3000 }
-                ]
-            }
-        ],
-        "SubagentStart": [
-            {
-                "hooks": [{
-                        "type": "command",
-                        "command": "node \"$CLAUDE_PROJECT_DIR/.claude/helpers/subagent-start.cjs\"",
-                        "timeout": 2000
-                    }]
-            }
-        ],
-        "SessionStart": [
-            {
-                "hooks": [
-                    {
-                        "type": "command",
-                        "command": "node \"$CLAUDE_PROJECT_DIR/.claude/scripts/session-start-launcher.mjs\"",
-                        "timeout": 3000
-                    }
-                ]
-            }
-        ],
-        "Stop": [
-            {
-                "hooks": [{ "type": "command", "command": handler('session-end'), "timeout": 5000 }]
-            }
-        ],
-        "PreCompact": [
-            {
-                "hooks": [{ "type": "command", "command": gate('compact-guidance'), "timeout": 3000 }]
-            }
-        ],
-        "Notification": [
-            {
-                "hooks": [{ "type": "command", "command": handler('notification'), "timeout": 3000 }]
-            }
-        ]
-    };
-    // Merge: preserve existing non-MoFlo hooks, add MoFlo hooks
-    existing.hooks = hooks;
-    // Ensure statusLine is always present (required for dashboard display).
-    // The executor.ts / settings-generator.ts code path adds this, but
-    // moflo-init.ts uses its own generateHooks() which was missing it.
-    if (!existing.statusLine) {
-        existing.statusLine = {
-            type: 'command',
-            command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs"',
-        };
+    const dirty = rewroteCommands > 0 || added > 0 || removed > 0 || scaffoldAdded.length > 0;
+    if (!dirty) {
+        return { name: '.claude/settings.json', status: 'skipped', detail: 'already at canonical reference' };
     }
     fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), 'utf-8');
-    return { name: '.claude/settings.json', status: existing.hooks ? 'updated' : 'created', detail: '14 hooks configured (gates, lifecycle, routing, session)' };
+    // Surface deletions, preserved customisations, and rewrites so nothing is
+    // silent — direct response to #1227's "no notice was printed" complaint.
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added} canonical`);
+    if (removed > 0)
+        parts.push(`-${removed} stale moflo`);
+    if (preserved > 0)
+        parts.push(`✓${preserved} preserved`);
+    if (rewroteCommands > 0)
+        parts.push(`↻${rewroteCommands} rewrites`);
+    if (scaffoldAdded.length > 0)
+        parts.push(`+scaffold (${scaffoldAdded.join(',')})`);
+    return { name: '.claude/settings.json', status: 'updated', detail: parts.join(', ') };
 }
 // ============================================================================
 // Step 3: .claude/skills/flo/ skill (with /fl alias)

package/dist/src/cli/memory/entries-write.js

@@ -50,7 +50,17 @@ export async function storeEntry(options) {
     if (options.namespace === 'learnings') {
         const tags = options.tags ?? [];
         if (!tags.some((t) => typeof t === 'string' && t.startsWith('source:'))) {
-            options = { ...options, tags: [...tags, 'source:manual'] };
+            // Default provenance is `source:manual`, but a writer running in a known
+            // context can declare its own origin deterministically via the
+            // MOFLO_LEARNINGS_SOURCE env (the auto-meditate distill sets it to
+            // `auto-meditate`) so attribution never depends on a headless model
+            // remembering to pass the tag. Validated to a bare slug so a stray env
+            // value can't inject arbitrary tag text. (#1203 follow-up)
+            const envSource = process.env.MOFLO_LEARNINGS_SOURCE;
+            const source = envSource && /^[a-z0-9][a-z0-9-]*$/i.test(envSource)
+                ? `source:${envSource}`
+                : 'source:manual';
+            options = { ...options, tags: [...tags, source] };
         }
     }
     // #981 — single-writer routing. When an external daemon is reachable AND

package/dist/src/cli/services/daemon-lock.js

@@ -65,7 +65,16 @@ export function readOwnMofloVersion() {
  * @returns `{ acquired: true }` on success,
  *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
  */
-export function acquireDaemonLock(projectRoot, pid = process.pid) {
+export function acquireDaemonLock(projectRoot, pid = process.pid, 
+/**
+ * Pre-computed project-daemon PIDs for the pre-acquire reap. When supplied,
+ * the reap skips the OS process scan (`findProjectDaemonPids`) and operates
+ * on exactly these PIDs. A caller that already enumerated project daemons
+ * passes them here to avoid a redundant scan; tests use it to make the reap
+ * deterministic instead of depending on the contention-sensitive cold-shell
+ * scan (mirrors the `pidsHint` seam on `reapSameProjectOrphans`).
+ */
+opts = {}) {
     const lock = lockPath(projectRoot);
     const stateDir = join(projectRoot, '.moflo');
     // Ensure state directory exists
@@ -79,7 +88,7 @@ export function acquireDaemonLock(projectRoot, pid = process.pid) {
     //     the failure mode that produced two-daemons-per-project in #1145's
     //     waxstack audit.
     const lockHolderPid = readLockPayload(lock)?.pid;
-    reapSameProjectOrphans(projectRoot, pid, lockHolderPid);
+    reapSameProjectOrphans(projectRoot, pid, lockHolderPid, opts.pidsHint);
     const payload = {
         pid,
         startedAt: Date.now(),
@@ -655,13 +664,21 @@ function terminateOrphan(pid) {
     }
     if (!isProcessAlive(pid))
         return true;
-    // Escalate to SIGKILL on POSIX (Windows already used /F)
-    if (process.platform !== 'win32') {
-        try {
-            process.kill(pid, 'SIGKILL');
-        }
-        catch { /* already dead */ }
+    // Escalate. The first kill can fail to land when spawning the OS helper is
+    // starved under heavy fork contention — a cold `taskkill.exe` load on Windows
+    // exceeding its exec timeout leaves the process alive with no second attempt.
+    // Escalate with an IN-PROCESS kill that spawns nothing and is therefore immune
+    // to that contention:
+    //   - POSIX:   SIGKILL.
+    //   - Windows: process.kill maps to TerminateProcess (libuv) for any same-user
+    //     PID — no subprocess, unlike taskkill. The earlier taskkill /T already
+    //     best-effort-killed the process tree; this guarantees the main PID dies.
+    // (Production value: a transiently-failed reap is the exact #1150 failure mode
+    // — a surviving orphan a fresh daemon then spawns alongside.)
+    try {
+        process.kill(pid, 'SIGKILL');
     }
+    catch { /* already dead */ }
     const killDeadline = Date.now() + 1000;
     while (Date.now() < killDeadline && isProcessAlive(pid)) {
         sleepSyncMs(100);

package/dist/src/cli/spells/commands/composite-command.js

@@ -217,13 +217,24 @@ function interpolateCommandString(command, config) {
 }
 /**
  * Run a shell command and capture output.
- * Uses platform-aware shell selection.
+ *
+ * On POSIX we deliberately use `/bin/sh` (NOT `process.env.SHELL`). The
+ * interpolation pipeline uses POSIX single-quote escaping (`shellEscapeValue`),
+ * which is safe under sh/bash but breaks under zsh: zsh's stricter globbing
+ * treats unmatched `[...]` patterns as a hard error ("zsh:1: no matches found"),
+ * whereas POSIX sh and bash leave unmatched globs literal. Honouring the user's
+ * interactive `$SHELL` made CI (Ubuntu, /bin/bash) pass while macOS/Linux dev
+ * machines on zsh silently failed every composite step containing bracket
+ * characters in interpolated values.
+ *
+ * On Windows we use ComSpec (cmd.exe) — POSIX shell quoting is meaningless
+ * there; the rest of the pipeline already special-cases Windows shell-out.
  */
 function runShellCommand(command, context) {
     const timeout = 30000;
     const shell = process.platform === 'win32'
         ? (process.env.ComSpec || 'cmd.exe')
-        : (process.env.SHELL || 'bash');
+        : '/bin/sh';
     return new Promise((resolve) => {
         const child = exec(command, { timeout, shell }, (error, stdout, stderr) => {
             context.abortSignal?.removeEventListener('abort', onAbort);

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.10.25",
+  "version": "4.10.27",
   "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",
@@ -95,7 +95,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.10.25-rc.1",
+    "moflo": "^4.10.26",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"