moflo 4.10.25-rc.1 → 4.10.26

package/.claude/helpers/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,34 +56,97 @@ const SECURITY_PATHS = [
   /(?:^|[\\\/])\.claude[\\\/]helpers[\\\/]gate/i,
 ];
 
-function safeExec(cmd) {
-  try { return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }); }
-  catch { return ''; }
+// ── 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, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...(opts && opts.cwd ? { cwd: opts.cwd } : {}),
+    });
+  } catch { return ''; }
 }
 
 // Detect the consumer's default branch. Hardcoding 'main' silently miscalibrates
 // classification on repos that use 'master', 'develop', etc. — empty diff →
 // TRIVIAL → gate stamps clean without any real review.
 let _cachedDefaultBranch = null;
-function detectDefaultBranch() {
-  if (_cachedDefaultBranch !== null) return _cachedDefaultBranch;
+function detectDefaultBranch(cwd) {
+  // Cache by cwd so tests probing multiple repos in-process don't return a
+  // single stale value; CLI use passes no cwd and benefits from the cache.
+  if (cwd === undefined && _cachedDefaultBranch !== null) return _cachedDefaultBranch;
+  const opts = cwd ? { cwd } : undefined;
 
   // Preferred: origin/HEAD points to whatever the remote considers default.
-  const symbolic = safeExec('git symbolic-ref --short refs/remotes/origin/HEAD').trim();
-  if (symbolic.startsWith('origin/')) return (_cachedDefaultBranch = symbolic.slice('origin/'.length));
+  const symbolic = safeExec('git symbolic-ref --short refs/remotes/origin/HEAD', opts).trim();
+  if (symbolic.startsWith('origin/')) {
+    const v = symbolic.slice('origin/'.length);
+    if (cwd === undefined) _cachedDefaultBranch = v;
+    return v;
+  }
 
   // Fallback: local init.defaultBranch (set by `git init -b <name>` or config).
-  const configured = safeExec('git config --get init.defaultBranch').trim();
-  if (configured) return (_cachedDefaultBranch = configured);
+  const configured = safeExec('git config --get init.defaultBranch', opts).trim();
+  if (configured) {
+    if (cwd === undefined) _cachedDefaultBranch = configured;
+    return configured;
+  }
 
   // Last resort: 'main' (most common modern default).
-  return (_cachedDefaultBranch = 'main');
+  if (cwd === undefined) _cachedDefaultBranch = 'main';
+  return 'main';
+}
+
+function _resetCacheForTest() {
+  _cachedDefaultBranch = null;
 }
 
-function readDiffFromGit(base) {
+function readDiffFromGit(base, cwd) {
+  const opts = cwd ? { cwd } : undefined;
   // Combined diff: committed-since-base + working-tree
-  const committed = safeExec(`git diff ${base}...HEAD`);
-  const working = safeExec('git diff HEAD');
+  const committed = safeExec(`git diff ${base}...HEAD`, opts);
+  const working = safeExec('git diff HEAD', opts);
   return committed + (working ? '\n' + working : '');
 }
 
@@ -125,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;
@@ -133,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 {
@@ -141,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()],
   };
 }
@@ -154,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.
@@ -182,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`);
@@ -194,21 +337,21 @@ 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) {
   return decide(parseDiff(diffText));
 }
 
-function classifyFromGit(base) {
-  const resolved = base || detectDefaultBranch();
-  return classifyDiff(readDiffFromGit(resolved));
+function classifyFromGit(base, cwd) {
+  const resolved = base || detectDefaultBranch(cwd);
+  return classifyDiff(readDiffFromGit(resolved, cwd));
 }
 
 if (require.main === module) {
@@ -232,4 +375,4 @@ if (require.main === module) {
   }
 }
 
-module.exports = { parseDiff, decide, classifyDiff, classifyFromGit, detectDefaultBranch };
+module.exports = { parseDiff, decide, classifyDiff, classifyFromGit, detectDefaultBranch, _resetCacheForTest };

package/.claude/skills/flo-simplify/SKILL.md

@@ -28,11 +28,12 @@ The classifier auto-detects the repo's default branch (origin/HEAD, then `init.d
 Output:
 ```json
 {
-  "tier": "TRIVIAL" | "SMALL" | "NORMAL",
-  "model": "sonnet",
+  "tier": "TRIVIAL" | "SMALL" | "NORMAL" | "DEEP",
+  "model": "sonnet" | "haiku" | "opus",
   "agentCount": 0 | 1 | 3,
+  "escalate": { "suggested": false, "target": null, "reason": null },
   "reasoning": ["..."],
-  "stats": { "added": ..., "deleted": ..., "declAdded": ..., "declRemoved": ..., "netDecls": ..., "fileCount": ..., "securityHit": ... }
+  "stats": { "added": ..., "deleted": ..., "declAdded": ..., "declRemoved": ..., "netDecls": ..., "fileCount": ..., "securityHit": ..., "tsjsLOC": ..., "tsjsNetDecls": ..., "otherNetAdded": ... }
 }
 ```
 
@@ -69,6 +70,17 @@ Reserved for **genuinely cross-cutting** changes that single-agent review can't
 
 Three agents exist to cover orthogonal axes (Reuse / Quality / Efficiency) when the change is broad enough that one agent's tool-call budget can't survey it all. For single-file edits, one focused agent always covers all three axes — three is duplication, not coverage.
 
+### DEEP — three parallel Opus agents (architectural, rare)
+The top rung, for genuinely **architectural** change where *depth* of reasoning — not just breadth — earns Opus's cost (judging whether a large refactor picked the right abstractions is reasoning, not surveying). The classifier escalates to DEEP only on real new-logic evidence, **never raw volume** — any of:
+- `>1500 LOC of TS/JS AND ≥10 net-new declarations`
+- `>1200 net-new lines of non-TS/JS source` (other languages are gated on net lines because the declaration parser is TS/JS-shaped)
+- `5+ new files AND ≥15 new declarations AND ≥10 net` (a real new subsystem)
+- `security-sensitive path AND ≥8 net-new declarations`
+
+DEEP runs **automatically — no prompt.** Noise (lockfiles, snapshots, generated/vendored) and docs/data are stripped before measuring, and the signal is *net of churn* (TS/JS by net-new declarations, other code by net-new lines), so a lockfile bump, a reformatting sweep, or a large rename/relocation can never reach Opus — they cancel to ~0 and stay SMALL/NORMAL.
+
+For the most **extreme** diffs (`>4000 LOC TS/JS + ≥25 net decls`, `>3000 net-new non-TS/JS lines`, or `10+ new files + ≥30 decls + ≥20 net`), the classifier also sets `escalate.suggested = true` with `target: "builtin-simplify"`. The Opus pass still runs as the floor; you then **offer** the user a handoff to Claude Code's built-in `/simplify` (Phase 3) — a suggestion, not an auto-switch.
+
 ## Phase 2.5: Validation pass (re-run after fixes)
 
 If `/flo-simplify` already ran on this branch in this session AND the only edits since are fixes driven by the prior pass's findings, default to **self-review tier** regardless of LOC count. The fan-out already happened; the fix is small relative to the diff that was already reviewed.
@@ -79,7 +91,7 @@ Escalate one tier (self-review → SMALL agent) only if the fix introduced any o
 - A new dependency or import from a previously-untouched module
 - A change to control flow not covered in the original findings
 
-Do **not** escalate to NORMAL on a validation pass. If the fix is so structural that NORMAL is warranted, treat it as a fresh diff and start over from Phase 1.
+Do **not** escalate to NORMAL or DEEP on a validation pass. If the fix is so structural that NORMAL/DEEP is warranted, treat it as a fresh diff and start over from Phase 1.
 
 ## Phase 2.7: Model selection
 
@@ -87,7 +99,7 @@ Do **not** escalate to NORMAL on a validation pass. If the fix is so structural
 
 - `sonnet` (default) — real logic changes, single agent or three-agent fan-out.
 - `haiku` — mostly-relocation diffs (mechanical moves where pattern-matching beats deep reasoning, ~5x cheaper).
-- `opus` — never. Code review is breadth-bound, not depth-bound; the three-agent fan-out at sonnet is the high-effort tier.
+- `opus` — the **DEEP** tier only. Architectural review is depth-bound (judging whether a large refactor picked the right abstractions is reasoning, not surveying), so the classifier returns opus when — and only when — the diff clears the DEEP bar. Never pick opus yourself for SMALL/NORMAL; ordinary review is breadth-bound and three sonnet agents are the right tool.
 
 If you fell back to prose rules in Phase 2 (no classifier available), use `sonnet` unconditionally. Pass the classifier's `model` field verbatim to Agent's `model` parameter.
 
@@ -123,6 +135,15 @@ Launch three agents in a single message — Reuse, Quality, Efficiency — passi
 
 **Efficiency**: unnecessary work, missed concurrency, hot-path bloat, recurring no-op updates, TOCTOU existence checks, unbounded structures, over-broad reads.
 
+### DEEP: three parallel Opus agents (architectural) — and maybe a handoff
+Same three-agent fan-out as NORMAL (Reuse / Quality / Efficiency in one message), but pass `model: "opus"` to each — the classifier already decided depth is warranted. **Print one line first** so the heavier cost is never silent, e.g. `distill: DEEP — 1,800 LOC of new logic, ran opus depth pass`.
+
+If the classifier set `escalate.suggested = true`, then **after** the Opus pass finishes, surface a handoff suggestion to the user — never switch automatically:
+
+> This change is large enough (`<escalate.reason>`) that Claude Code's built-in `/simplify` — a deeper, heavier multi-agent pass — may add value beyond this review. Want to run it? It costs more tokens, so it's your call.
+
+Then stop and let the user decide. Do **not** invoke the built-in `/simplify` yourself — the handoff is the user's choice, and the Opus pass you just ran already covers the diff.
+
 ## Phase 4: Fix or skip
 
 Aggregate findings. Fix each one directly. False positives or not-worth-fixing — note and skip without arguing. If self-review found nothing, just confirm clean and exit.

package/.claude/skills/meditate/SKILL.md

@@ -87,11 +87,11 @@ mcp__moflo__memory_store {
   namespace: "learnings",
   key: "<stable descriptive slug, e.g. pattern:daemon-port-resolver or gotcha:windows-spell-path>",
   value: "<the lesson> — Why: <why it matters>. How to apply: <what to do next time>.",
-  tags: ["<topic>", "<area>"]
+  tags: ["<topic>", "<area>", "source:meditate-manual"]
 }
 ```
 
-Keep keys stable and descriptive so the next `/meditate` updates rather than re-adds. In `--preview` mode, **stop here** — print the candidates and their would-be keys/dedup verdicts, write nothing.
+Always include the `source:meditate-manual` tag — it lets the Luminarium "Learnings" panel attribute each lesson to `/meditate` vs the automatic auto-meditate distill. Keep keys stable and descriptive so the next `/meditate` updates rather than re-adds. In `--preview` mode, **stop here** — print the candidates and their would-be keys/dedup verdicts, write nothing.
 
 ## Step 4 — Report
 

package/bin/lib/meditate.mjs

@@ -39,11 +39,12 @@ import { randomBytes } from 'crypto';
 // ── Tunables (exported for tests) ───────────────────────────────────────────
 /** Model used for the bounded distillation pass (cheap; Haiku is a formatter). */
 export const HAIKU_MODEL_ID = 'claude-haiku-4-5-20251001';
-/** Min gap between in-session capture directives, so a chatty correction streak
- *  can't spam the model. */
-export const INJECT_WINDOW_MS = 8 * 60_000;
+/** Min gap between in-session capture directives — a debounce so a burst of
+ *  signals in quick succession injects the directive at most once per window.
+ *  Shorter window = more capture opportunities (and more injected context). */
+export const INJECT_WINDOW_MS = 5 * 60_000;
 /** Hard cap on directives per session (belt-and-braces over the time window). */
-export const INJECT_MAX_PER_SESSION = 6;
+export const INJECT_MAX_PER_SESSION = 10;
 /** Ledger size cap — distilled entries are pruned first, then oldest. */
 export const MAX_LEDGER_ENTRIES = 200;
 /** Keep this many already-distilled entries for idempotency/debug before pruning. */
@@ -148,8 +149,23 @@ const DECISION_PATTERNS = [
   /\b(decided|decision)\b/i,
   /\bgoing with\b/i,
   /\bthe plan is\b/i,
+  /\bthe approach is\b/i,
   /\bwe should (use|go with|do)\b/i,
   /\bi'?ll go with\b/i,
+  // Selection / preference / finalization phrasing.
+  /\bgo with (option|approach|the|that|a)\b/i,
+  /\bi'?d rather\b/i,
+  /\b(we'?ll|let'?s) keep\b/i,
+  /\bfinal (decision|answer|call)\b/i,
+  // Approval ATTACHED to a concrete action/decision — "go ahead and ship the
+  // fix", "ok, use the daemon", "proceed with option B". Bare approval alone
+  // ("ok"/"yes"/"go ahead"/"sounds good") deliberately does NOT fire: it must
+  // carry an action to count as a decision moment, else it would trip on nearly
+  // every agreeing turn and burn the per-session injection budget. The live
+  // model's "append nothing" remains the final precision filter.
+  /\bgo ahead (and|with)\b/i,
+  /\bproceed with\b/i,
+  /\b(yes|yeah|yep|sure|ok|okay|sounds good|lgtm)[\s,!.]+(go with|use|ship|build|implement|add|proceed)\b/i,
 ];
 
 // Tight, low-false-positive markers only — tool output mentions "error" benignly
@@ -162,6 +178,32 @@ const ERROR_PATTERNS = [
   /\b[1-9]\d* (failed|failing)\b/i,
 ];
 
+// Bare approval that, on its own, looks like mere assent ("yes", "ok", "go
+// ahead") — but confirms a real decision when the PRIOR assistant turn proposed
+// one. Anchored at the start of the user's message so it matches a reply that
+// LEADS with approval. Paired with PROPOSAL_PATTERNS below as the precision gate.
+const APPROVAL_PATTERNS = [
+  /^\s*(y(es|ep|eah|up)?|sure|ok(ay)?|kk?|roger|agreed?|perfect|great|nice|sounds good|lgtm|do it|go ahead|proceed|approved?|let'?s do it|make it so|ship it)\b/i,
+];
+
+// Proposal / recommendation / options language the assistant uses when it asks
+// the user to choose or approve. Scanned against the recent transcript tail; a
+// match here means a bare approval in the prompt is confirming a real decision,
+// so "yes" after "I recommend we use the daemon" fires, but "ok thanks" after a
+// plain status report does not. Recall-biased — the live model still filters.
+const PROPOSAL_PATTERNS = [
+  /\bi (propose|recommend|suggest|advise)\b/i,
+  /\bi'?(d|ll) (recommend|suggest|propose|go with|use|implement|add|build|refactor)\b/i,
+  /\bwe (could|should|can|might) (use|go with|implement|refactor|add|switch|split)\b/i,
+  /\b(option|approach|plan|choice) (a|b|c|1|2|3|one|two)\b/i,
+  /\b(two|three|several|a few) (options|approaches|choices|ways)\b/i,
+  /\bshould i (proceed|go ahead|use|implement|start|continue|create|add)\b/i,
+  /\b(would|do) you (like|want) me to\b/i,
+  /\bhere'?s (the|my|a) (plan|approach|proposal|recommendation)\b/i,
+  /\brecommendation\b/i,
+  /\bpropos(e|ed|al)\b/i,
+];
+
 function anyMatch(patterns, text) {
   if (!text) return false;
   for (const re of patterns) if (re.test(text)) return true;
@@ -182,6 +224,12 @@ export function detectSignal(prompt, transcriptTail = '') {
   const t = typeof transcriptTail === 'string' ? transcriptTail : '';
   if (anyMatch(CORRECTION_PATTERNS, p)) return { hit: true, kind: 'correction' };
   if (anyMatch(DECISION_PATTERNS, p) || anyMatch(DECISION_PATTERNS, t)) return { hit: true, kind: 'decision' };
+  // Bare approval in the prompt that confirms a proposal/recommendation the
+  // assistant made in the immediately prior turn — "yes"/"go ahead" answering
+  // "I recommend we use the daemon". The prior-turn proposal (in transcriptTail)
+  // is the precision gate: a contextless "ok thanks" with nothing proposed above
+  // it does NOT fire.
+  if (anyMatch(APPROVAL_PATTERNS, p) && anyMatch(PROPOSAL_PATTERNS, t)) return { hit: true, kind: 'decision' };
   if (anyMatch(ERROR_PATTERNS, t)) return { hit: true, kind: 'error_fix' };
   return { hit: false, kind: null };
 }
@@ -241,11 +289,11 @@ export function buildCaptureDirective(kind) {
   return [
     `[auto-meditate] A ${label} just occurred this session.`,
     `FIRST: fully address the user's request as you normally would — do NOT let this note change your answer.`,
-    `THEN, only if a durable, reusable lesson emerged, append exactly ONE final line of the form:`,
+    `THEN, if a reusable lesson emerged, append exactly ONE final line of the form:`,
     `<meditate-capture>LESSON</meditate-capture>`,
     `where LESSON is a single concise sentence (a pattern, gotcha, or decision+rationale).`,
     DURABILITY_BAR,
-    `If nothing clears that bar, append nothing — silence is the correct, common outcome. Never emit more than one such line.`,
+    `When in doubt, capture it — a borderline lesson is cheap and the distill dedups; append nothing only for pure session state or git history. Never emit more than one such line.`,
   ].join('\n');
 }
 
@@ -488,6 +536,7 @@ export function buildDistillPrompt(entries) {
     `1. For EACH candidate, call mcp__moflo__memory_search { namespace: "learnings", query: <bare keywords>, threshold: 0.6, limit: 5 }.`,
     `2. If the top hit is the SAME fact at similarity >= 0.80, call mcp__moflo__memory_store with that SAME key (upsert), merging any new nuance — do NOT create a near-duplicate.`,
     `3. Otherwise call mcp__moflo__memory_store { namespace: "learnings", key: <stable descriptive slug>, value: "<lesson> — Why: <why it matters>. How to apply: <what to do next time>.", tags: [<topic>, <area>] }.`,
+    `   PROVENANCE (#1203): every memory_store you make — both the step-2 upsert and the step-3 new write — MUST include the tag "source:auto-meditate" in its tags array, so the Luminarium "Learnings" panel can attribute these to the automatic distill pass.`,
     `4. Skip any candidate that does not clear the durability bar below, or that merely restates an existing entry.`,
     ``,
     DURABILITY_BAR,

package/bin/meditate-distill.mjs

@@ -69,6 +69,10 @@ function runHeadless(projectRoot, prompt) {
       ...process.env,
       CLAUDE_CODE_HEADLESS: 'true',     // mark the child so its own hooks no-op (#860)
       ANTHROPIC_MODEL: HAIKU_MODEL_ID,  // cheap formatter model
+      // Deterministic provenance: the write path stamps source:auto-meditate on
+      // these learnings writes even if Haiku omits the tag it's asked to add
+      // (#1203 follow-up). Honoured by storeEntry in memory/entries-write.ts.
+      MOFLO_LEARNINGS_SOURCE: 'auto-meditate',
     };
 
     let child;