moflo 4.12.1 → 4.12.2

package/.claude/agents/base-template-generator.md

@@ -1,6 +1,6 @@
 ---
 name: base-template-generator
-description: Use this agent when you need to create foundational templates, boilerplate code, or starter configurations for new projects, components, or features. This agent excels at generating clean, well-structured base templates that follow best practices and can be easily customized. Examples: <example>Context: User needs to start a new React component and wants a solid foundation. user: 'I need to create a new user profile component' assistant: 'I'll use the base-template-generator agent to create a comprehensive React component template with proper structure, TypeScript definitions, and styling setup.' <commentary>Since the user needs a foundational template for a new component, use the base-template-generator agent to create a well-structured starting point.</commentary></example> <example>Context: User is setting up a new API endpoint and needs a template. user: 'Can you help me set up a new REST API endpoint for user management?' assistant: 'I'll use the base-template-generator agent to create a complete API endpoint template with proper error handling, validation, and documentation structure.' <commentary>The user needs a foundational template for an API endpoint, so use the base-template-generator agent to provide a comprehensive starting point.</commentary></example>
+description: Create foundational templates, boilerplate code, and starter configurations for new projects, components, or features. Use for scaffolding a new component, API endpoint, model, config, or test suite from scratch.
 color: orange
 ---
 
@@ -19,6 +19,26 @@ On chunk hits where `navigation` is non-null, traverse via `mcp__moflo__memory_g
 
 You are a Base Template Generator, an expert architect specializing in creating clean, well-structured foundational templates and boilerplate code. Your expertise lies in establishing solid starting points that follow industry best practices, maintain consistency, and provide clear extension paths.
 
+## When you get dispatched
+
+Worked examples of the requests that route here — these live in the body, not the
+frontmatter `description`, because the description is always-resident routing
+context while this body only loads on dispatch.
+
+<example>
+Context: User needs to start a new React component and wants a solid foundation.
+user: 'I need to create a new user profile component'
+assistant: 'I'll use the base-template-generator agent to create a comprehensive React component template with proper structure, TypeScript definitions, and styling setup.'
+<commentary>Since the user needs a foundational template for a new component, use the base-template-generator agent to create a well-structured starting point.</commentary>
+</example>
+
+<example>
+Context: User is setting up a new API endpoint and needs a template.
+user: 'Can you help me set up a new REST API endpoint for user management?'
+assistant: 'I'll use the base-template-generator agent to create a complete API endpoint template with proper error handling, validation, and documentation structure.'
+<commentary>The user needs a foundational template for an API endpoint, so use the base-template-generator agent to provide a comprehensive starting point.</commentary>
+</example>
+
 Your core responsibilities:
 - Generate comprehensive base templates for components, modules, APIs, configurations, and project structures
 - Ensure all templates follow established coding standards and best practices from the project's CLAUDE.md guidelines

package/.claude/guidance/shipped/moflo-yaml-reference.md

@@ -123,14 +123,54 @@ auto_update:
   helpers: true                          # Sync .claude/helpers/ from moflo source
   hook_block_drift: regenerate           # warn | regenerate | off (default: regenerate since #1227)
   claudemd_injection_drift: regenerate   # warn | regenerate | off
+
+# Which skill categories to install (OPTIONAL — omit to get every skill)
+skills:
+  categories: [core, memory, spells]     # core | memory | spells
 ```
 
 If your `moflo.yaml` predates the `sandbox:` or `auto_update:` blocks, they are auto-appended on the next session start — you never need to re-run `moflo init` after a version bump.
 
+### Narrowing Installed Skills with `skills.categories`
+
+**Omit the `skills:` block entirely to receive every moflo skill — that is the default and the recommended setting.** Add `skills.categories` only when you want a smaller always-resident skill listing, and expect to lose the commands in the categories you drop.
+
+Every installed skill's name and description sit in Claude's context in every session, so a project that will never author a spell can reclaim that space. The cost is real but small — the full set is roughly 2,000 tokens.
+
+| Category | Skills | Drop it when |
+|----------|--------|--------------|
+| `core` | `/fl`, `/healer`, `/verify`, `/flo-simplify`, `/eldar`, `/quicken`, `/ward`, `/divine`, `/meditate`, `/guidance`, `/commune`, `/luminarium` | Never — these are the everyday commands |
+| `memory` | `/memory-patterns`, `/vector-search`, `/memory-optimization`, `/memory-team`, `/memory-worktree` | You are not building on moflo's memory stack and have finished any team/worktree sharing setup |
+| `spells` | `/spell-builder`, `/spell-schedule`, `/connector-builder` | You do not author or schedule spells in this project |
+
+Both YAML list styles work:
+
+```yaml
+skills:
+  categories: [core, memory]
+```
+
+```yaml
+skills:
+  categories:
+    - core
+    - memory
+```
+
+**Key behaviors:**
+
+- **Omitting `skills:` means no restriction.** Every shipped skill syncs on every session start, exactly as before this option existed.
+- **`/flo` and `/fl` are never gated.** The ticket spell is the primary entry point and installs regardless of selection.
+- **An unknown category name is ignored, not fatal.** A typo narrows nothing rather than silently stripping your skills.
+- **Narrowing stops future syncing; it does not delete.** Skills already on disk stay until you remove them — moflo will not re-add them once excluded, so delete the directories under `.claude/skills/` to reclaim the context.
+- **Re-widening is instant.** Add the category back and the next session start restores its skills.
+
 ### Key Behaviors
 
 | Config | Effect |
 |--------|--------|
+| `skills.categories` omitted | Install every skill (default) |
+| `skills.categories: [core]` | Install only core skills; `memory` + `spells` stop syncing |
 | `auto_index.guidance: false` | Skip guidance indexing on session start |
 | `auto_index.code_map: false` | Skip code map generation on session start |
 | `auto_meditate.enabled: false` | Opt out of automatic session-lesson distillation (`/meditate` still works manually) |

package/.claude/helpers/gate.cjs

@@ -134,6 +134,13 @@ var command = process.argv[2];
 
 var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules', 'moflo.yaml'];
 
+// Appended to every memory-first denial. Without it, a context audit of Claude
+// Code's denial telemetry reads moflo's gate enforcements as permission-setup
+// 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.';
+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
 // (background-task output/transcripts, agent scratchpads) are transient tool
 // I/O and never carry indexable project knowledge, so they must not trip the
@@ -713,7 +720,7 @@ switch (command) {
     var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
     if (isEphemeralPath(process.env.TOOL_INPUT_path)) break;
     if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
-    process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before exploring files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' + GATE_ORIGIN_NOTE + '\n' + GATE_DISABLE_NOTE + '\n');
     process.exit(2);
   }
   case 'check-before-read': {
@@ -726,7 +733,7 @@ switch (command) {
     if (isEphemeralPath(fp)) break;
     var isGuidance = fp.indexOf('.claude/guidance/') >= 0 || fp.indexOf('.claude\\guidance\\') >= 0;
     if (!isGuidance && EXEMPT.some(function(p) { return fp.indexOf(p) >= 0; })) break;
-    process.stderr.write('BLOCKED: Search memory before reading files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before reading files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' + GATE_ORIGIN_NOTE + '\n' + GATE_DISABLE_NOTE + '\n');
     process.exit(2);
   }
   case 'record-task-created': {
@@ -775,11 +782,12 @@ switch (command) {
     // "Memory namespace hint: ..." sentence so the BLOCK message stays uniform.
     var hint = s2.lastNamespaceHint || classifyBashNamespaceHint(cmd) || '';
     process.stderr.write(
-      'BLOCKED: Search memory before reading files via Bash.\n' +
+      'BLOCKED [moflo memory_first gate]: Search memory before reading files via Bash.\n' +
       'Example: mcp__moflo__memory_search { query: "<topic>", namespace: "<one of: guidance | code-map | patterns | learnings | tests>" }\n' +
       (hint ? hint + '\n' : '') +
       'On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' +
-      'Disable per-gate via moflo.yaml: gates: memory_first: false\n'
+      GATE_ORIGIN_NOTE + '\n' +
+      GATE_DISABLE_NOTE + '\n'
     );
     process.exit(2);
     break;

package/.claude/skills/distill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: distill
-description: Alias for /flo-simplify. Review changed code for reuse, quality, and efficiency, then fix any issues found — effort scales to the diff size.
+description: Alias for /flo-simplify — see that skill's description.
 ---
 
 # /distill is an alias for /flo-simplify

package/.claude/skills/perf-audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: perf-audit
-description: Alias for /quicken. Ad-hoc performance audit — reveals N+1 queries, needless re-renders, missing caching, memory leaks, and redundant computation in your diff (or a named path), and prescribes the fix inline.
+description: Alias for /quicken — see that skill's description.
 arguments: "[path or area | --all]"
 ---
 

package/.claude/skills/test-gaps/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: test-gaps
-description: Alias for /ward. Ad-hoc test-gap audit — reveals untested functions, uncovered edge cases, and missing error-handling/integration tests in your diff (or a named path), and conjures ready-to-paste test skeletons inline.
+description: Alias for /ward — see that skill's description.
 arguments: "[path or area | --all]"
 ---
 

package/bin/gate.cjs

@@ -134,6 +134,13 @@ var command = process.argv[2];
 
 var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules', 'moflo.yaml'];
 
+// Appended to every memory-first denial. Without it, a context audit of Claude
+// Code's denial telemetry reads moflo's gate enforcements as permission-setup
+// 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.';
+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
 // (background-task output/transcripts, agent scratchpads) are transient tool
 // I/O and never carry indexable project knowledge, so they must not trip the
@@ -713,7 +720,7 @@ switch (command) {
     var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
     if (isEphemeralPath(process.env.TOOL_INPUT_path)) break;
     if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
-    process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before exploring files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' + GATE_ORIGIN_NOTE + '\n' + GATE_DISABLE_NOTE + '\n');
     process.exit(2);
   }
   case 'check-before-read': {
@@ -726,7 +733,7 @@ switch (command) {
     if (isEphemeralPath(fp)) break;
     var isGuidance = fp.indexOf('.claude/guidance/') >= 0 || fp.indexOf('.claude\\guidance\\') >= 0;
     if (!isGuidance && EXEMPT.some(function(p) { return fp.indexOf(p) >= 0; })) break;
-    process.stderr.write('BLOCKED: Search memory before reading files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before reading files. Use mcp__moflo__memory_search. On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' + GATE_ORIGIN_NOTE + '\n' + GATE_DISABLE_NOTE + '\n');
     process.exit(2);
   }
   case 'record-task-created': {
@@ -775,11 +782,12 @@ switch (command) {
     // "Memory namespace hint: ..." sentence so the BLOCK message stays uniform.
     var hint = s2.lastNamespaceHint || classifyBashNamespaceHint(cmd) || '';
     process.stderr.write(
-      'BLOCKED: Search memory before reading files via Bash.\n' +
+      'BLOCKED [moflo memory_first gate]: Search memory before reading files via Bash.\n' +
       'Example: mcp__moflo__memory_search { query: "<topic>", namespace: "<one of: guidance | code-map | patterns | learnings | tests>" }\n' +
       (hint ? hint + '\n' : '') +
       'On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\n' +
-      'Disable per-gate via moflo.yaml: gates: memory_first: false\n'
+      GATE_ORIGIN_NOTE + '\n' +
+      GATE_DISABLE_NOTE + '\n'
     );
     process.exit(2);
     break;

package/bin/lib/retired-files.mjs

@@ -33,10 +33,17 @@
  * @module bin/lib/retired-files
  */
 
-import { existsSync, readFileSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
 import { createHash } from 'crypto';
 
+/**
+ * Consumer-relative path of the retained-files record written by
+ * `writeRetainedRecord`. Exported so tests and `flo healer` resolve the same
+ * location instead of re-deriving the string.
+ */
+export const RETAINED_RECORD_REL = join('.moflo', 'retired-retained.json');
+
 /**
  * Compute sha256 of file content. Returns null on read errors so the caller
  * can decide what to do — we never want a transient stat/read failure to
@@ -156,17 +163,29 @@ export function classifyRetiredFile(projectRoot, entry) {
  * Failures are non-fatal — a single un-deletable file (Windows AV hold,
  * EBUSY) must not stop pruning the rest. The caller surfaces the report.
  *
+ * `preserved` is the flat path list the launcher banner samples from;
+ * `preservedDetails` carries the same set with the manifest's retirement
+ * provenance attached, for the machine-readable record (#1307 finding 3).
+ *
  * @param {string} projectRoot
  * @param {string} manifestPath
- * @returns {{ pruned: string[], preserved: string[], unknown: string[], failed: Array<{path:string, message:string}> }}
+ * @returns {{ pruned: string[], preserved: string[], preservedDetails: Array<{path:string, retiredIn?:string, retiredBy?:string}>, unknown: string[], failed: Array<{path:string, message:string}> }}
  */
 export function applyRetiredPrune(projectRoot, manifestPath) {
   const { entries } = loadRetiredManifest(manifestPath);
-  const report = { pruned: [], preserved: [], unknown: [], failed: [] };
+  const report = { pruned: [], preserved: [], preservedDetails: [], unknown: [], failed: [] };
   for (const entry of entries) {
     const { action } = classifyRetiredFile(projectRoot, entry);
     if (action === 'absent') continue;
-    if (action === 'preserve') { report.preserved.push(entry.path); continue; }
+    if (action === 'preserve') {
+      report.preserved.push(entry.path);
+      report.preservedDetails.push({
+        path: entry.path,
+        ...(entry.retiredIn ? { retiredIn: entry.retiredIn } : {}),
+        ...(entry.retiredBy ? { retiredBy: entry.retiredBy } : {}),
+      });
+      continue;
+    }
     if (action === 'unknown') { report.unknown.push(entry.path); continue; }
     // action === 'prune'
     try {
@@ -181,3 +200,104 @@ export function applyRetiredPrune(projectRoot, manifestPath) {
   }
   return report;
 }
+
+/**
+ * Reconcile an existing retained record against what is actually on disk.
+ *
+ * `writeRetainedRecord` only runs inside the launcher's UPGRADE branch (that
+ * is where `applyRetiredPrune` lives), so on its own it cannot keep the record
+ * honest: a user who reads the record and deletes the files would keep a
+ * record naming those files until their next moflo upgrade — the record would
+ * outlive what it describes, which is the same "not actionable" complaint
+ * #1307 raised about the truncated banner.
+ *
+ * This runs on EVERY session start instead, and is written to cost nothing in
+ * the common case: one `existsSync` when no record is present (overwhelmingly
+ * the norm), and only then a stat per retained entry.
+ *
+ * Never throws — advisory bookkeeping must not break session start.
+ *
+ * @param {string} projectRoot
+ * @returns {{ changed: boolean, removed: string[], remaining: number }}
+ */
+export function reconcileRetainedRecord(projectRoot) {
+  const result = { changed: false, removed: [], remaining: 0 };
+  const abs = resolve(projectRoot, RETAINED_RECORD_REL);
+  try {
+    if (!existsSync(abs)) return result;               // fast path — no record
+    // Corrupt/hand-edited record: drop it rather than reason about it. Parsed
+    // in its own try so a JSON error lands here and the bad file is actually
+    // removed, instead of falling to the outer catch and lingering forever.
+    let parsed = null;
+    try {
+      parsed = JSON.parse(readFileSync(abs, 'utf-8'));
+    } catch { /* handled below */ }
+    if (!parsed || !Array.isArray(parsed.retained)) {
+      unlinkSync(abs);
+      result.changed = true;
+      return result;
+    }
+    const stillPresent = [];
+    for (const entry of parsed.retained) {
+      if (entry && typeof entry.path === 'string' && existsSync(resolve(projectRoot, entry.path))) {
+        stillPresent.push(entry);
+      } else if (entry && typeof entry.path === 'string') {
+        result.removed.push(entry.path);
+      }
+    }
+    result.remaining = stillPresent.length;
+    if (result.removed.length === 0) return result;    // nothing to do
+    result.changed = true;
+    if (stillPresent.length === 0) {
+      unlinkSync(abs);
+      return result;
+    }
+    writeFileSync(abs, JSON.stringify({ ...parsed, retained: stillPresent }, null, 2) + '\n', 'utf-8');
+    return result;
+  } catch {
+    return result;
+  }
+}
+
+/**
+ * Persist the retained (customized-and-therefore-preserved) retired files to
+ * `.moflo/retired-retained.json` (#1307 finding 3).
+ *
+ * Before this, the only place the retained set appeared was a launcher stdout
+ * banner truncated to 5 entries — so "delete manually if unwanted" was not
+ * actionable for the remainder, and nothing on disk let you reconstruct the
+ * set (`installed-files.json` doesn't track pre-#948 agents/skills).
+ *
+ * The record is advisory state, not a manifest: it is rewritten from scratch
+ * on every launcher run, and deleted when nothing is retained so a stale file
+ * never claims paths the consumer has since removed.
+ *
+ * Never throws — a failure to write an advisory record must not break session
+ * start on any consumer. Returns the absolute path written, or null.
+ *
+ * @param {string} projectRoot
+ * @param {Array<{path:string, retiredIn?:string, retiredBy?:string}>} preservedDetails
+ * @param {string} [mofloVersion] - version that produced this record, if known
+ * @returns {string|null} absolute path written, or null if nothing was written
+ */
+export function writeRetainedRecord(projectRoot, preservedDetails, mofloVersion) {
+  const abs = resolve(projectRoot, RETAINED_RECORD_REL);
+  try {
+    if (!Array.isArray(preservedDetails) || preservedDetails.length === 0) {
+      // Nothing retained — drop any record from a previous run.
+      if (existsSync(abs)) unlinkSync(abs);
+      return null;
+    }
+    mkdirSync(dirname(abs), { recursive: true });
+    const payload = {
+      version: 1,
+      note: 'Retired moflo files preserved because they were customized locally. Safe to delete manually if unwanted; moflo will not remove them.',
+      ...(mofloVersion ? { mofloVersion } : {}),
+      retained: preservedDetails,
+    };
+    writeFileSync(abs, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
+    return abs;
+  } catch {
+    return null;
+  }
+}

package/bin/lib/skill-categories.mjs

@@ -0,0 +1,158 @@
+/**
+ * Skill-category selection for the session-start launcher (#1308).
+ *
+ * ## Why this leaf exists
+ *
+ * The launcher syncs every shipped skill into the consumer on each run
+ * (`syncDirRecursive` in `file-sync.mjs`). Before #1308 that sync was
+ * unconditional except for `INTERNAL_SKILLS`, which meant a consumer could not
+ * narrow their installed skill set: whatever `flo init` selected, the next
+ * session start put everything back. The category structure in `SKILLS_MAP` was
+ * therefore dead config.
+ *
+ * To honour a selection the launcher has to know which skill belongs to which
+ * category. The canonical map is `SKILLS_MAP` in `src/cli/init/executor.ts`,
+ * but the launcher is a plain `.mjs` and cannot import that TS const across the
+ * dist/source depth boundary — so this leaf mirrors it, exactly as
+ * `internal-skills.mjs` mirrors `INTERNAL_SKILLS`.
+ * `tests/bin/skill-categories-parity.test.ts` asserts the two never drift.
+ *
+ * ## Default is "everything"
+ *
+ * A consumer with no `skills:` block in `moflo.yaml` must keep getting every
+ * skill — anything else would silently delete capability on upgrade for every
+ * existing install (Rule #2). `parseSkillCategories` returns `null` for
+ * "unconfigured", and `computeExcludedSkills(null, …)` excludes nothing beyond
+ * the internal skills.
+ *
+ * @module bin/lib/skill-categories
+ */
+
+/**
+ * Mirror of `SKILLS_MAP` in `src/cli/init/executor.ts`. Keep in sync — the
+ * parity test fails otherwise.
+ */
+export const SKILL_CATEGORIES_MAP = {
+  core: [
+    'commune',
+    'eldar',
+    'guidance',
+    'healer',
+    'flo-simplify',
+    'distill',
+    'luminarium',
+    'reasoningbank-intelligence',
+    'meditate',
+    'divine',
+    'quicken',
+    'perf-audit',
+    'ward',
+    'test-gaps',
+    'verify',
+  ],
+  memory: [
+    'memory-patterns',
+    'memory-optimization',
+    'vector-search',
+    'memory-worktree',
+    'memory-team',
+  ],
+  spells: [
+    'spell-builder',
+    'spell-schedule',
+    'connector-builder',
+  ],
+};
+
+/** Every category name, in declaration order. */
+export const SKILL_CATEGORY_NAMES = Object.keys(SKILL_CATEGORIES_MAP);
+
+/**
+ * Skills installed by `moflo-init.ts` outside `SKILLS_MAP` (the `/flo` + `/fl`
+ * ticket spell). They are the primary entry point and are never category-gated
+ * — excluding them would break the headline workflow.
+ */
+export const ALWAYS_INSTALLED_SKILLS = ['flo', 'fl'];
+
+/**
+ * Extract the selected skill categories from raw `moflo.yaml` text.
+ *
+ * Regex-based on purpose: the launcher deliberately avoids a YAML dependency
+ * (see the `auto_update` parsing it sits beside). Both YAML list styles are
+ * accepted because either is what a hand-editing consumer will write:
+ *
+ *     skills:
+ *       categories: [core, memory]
+ *
+ *     skills:
+ *       categories:
+ *         - core
+ *         - memory
+ *
+ * @param {string} yamlContent
+ * @returns {string[]|null} selected categories, or null when unconfigured
+ *   (meaning "no restriction" — sync everything).
+ *
+ *   An explicitly empty list returns `[]`, which is a REAL selection and is not
+ *   the same as `null`: it excludes every category, leaving only
+ *   {@link ALWAYS_INSTALLED_SKILLS} (`/flo` + `/fl`). That is a legitimate
+ *   "bare minimum" choice, but it is a much stronger statement than omitting
+ *   the block, so the two must never be conflated.
+ */
+export function parseSkillCategories(yamlContent) {
+  if (typeof yamlContent !== 'string' || yamlContent.length === 0) return null;
+
+  // Flow style: categories: [a, b]
+  const flow = yamlContent.match(/^[ \t]*skills:[ \t]*\r?\n(?:[ \t]+[^\r\n]*\r?\n)*?[ \t]+categories:[ \t]*\[([^\]]*)\]/m);
+  if (flow) {
+    return flow[1]
+      .split(',')
+      .map((s) => s.trim().replace(/^['"]|['"]$/g, ''))
+      .filter((s) => s.length > 0);
+  }
+
+  // Block style: categories:\n  - a\n  - b
+  const block = yamlContent.match(/^[ \t]*skills:[ \t]*\r?\n(?:[ \t]+[^\r\n]*\r?\n)*?[ \t]+categories:[ \t]*\r?\n((?:[ \t]*-[ \t]*[^\r\n]+\r?\n?)+)/m);
+  if (block) {
+    return block[1]
+      .split(/\r?\n/)
+      .map((line) => line.match(/^[ \t]*-[ \t]*(.+?)[ \t]*$/))
+      .filter(Boolean)
+      .map((m) => m[1].replace(/^['"]|['"]$/g, '').trim())
+      .filter((s) => s.length > 0);
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the set of top-level skill directory names the launcher must NOT
+ * sync, given a selection.
+ *
+ * Unknown category names in the selection are ignored rather than treated as
+ * "select nothing" — a typo in `moflo.yaml` should not silently strip a
+ * consumer's skills. Skills that belong to no category at all are always kept
+ * for the same reason: this function can only ever exclude a skill it can
+ * positively attribute to an UNSELECTED category.
+ *
+ * @param {string[]|null} selected - from `parseSkillCategories`
+ * @param {string[]} internalSkills - INTERNAL_SKILLS (never installed)
+ * @returns {Set<string>} top-level names to exclude from the sync
+ */
+export function computeExcludedSkills(selected, internalSkills = []) {
+  const excluded = new Set(internalSkills);
+  if (!Array.isArray(selected)) return excluded; // unconfigured → no restriction
+
+  const keep = new Set(ALWAYS_INSTALLED_SKILLS);
+  for (const category of selected) {
+    for (const skill of SKILL_CATEGORIES_MAP[category] || []) keep.add(skill);
+  }
+
+  for (const [category, skills] of Object.entries(SKILL_CATEGORIES_MAP)) {
+    if (selected.includes(category)) continue;
+    for (const skill of skills) {
+      if (!keep.has(skill)) excluded.add(skill);
+    }
+  }
+  return excluded;
+}

package/bin/session-start-launcher.mjs

@@ -14,9 +14,10 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { mofloDir, findProjectRoot, findAncestorMofloRoot, COMMON_WALK_SKIP_NAMES } from './lib/moflo-paths.mjs';
 import { repairMemoryDbIfCorrupt } from './lib/db-repair.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
-import { applyRetiredPrune } from './lib/retired-files.mjs';
+import { applyRetiredPrune, writeRetainedRecord, reconcileRetainedRecord, RETAINED_RECORD_REL } from './lib/retired-files.mjs';
 import { makeSyncer, contentEqual, syncDirRecursive } from './lib/file-sync.mjs';
 import { INTERNAL_SKILLS } from './lib/internal-skills.mjs';
+import { parseSkillCategories, computeExcludedSkills } from './lib/skill-categories.mjs';
 import { loadShippedScripts } from './lib/shipped-scripts.mjs';
 import {
   readContinuityConfig,
@@ -839,6 +840,9 @@ let autoUpdateConfig = {
   // refresh CLAUDE.md on their own — there is no other auto-refresh path.
   claudemdInjectionDrift: 'regenerate',
 };
+// #1308 — skill categories the consumer opted into via moflo.yaml. `null` =
+// unconfigured = no restriction (every shipped skill syncs, as before).
+let selectedSkillCategories = null;
 try {
   const mofloYaml = resolve(projectRoot, 'moflo.yaml');
   if (existsSync(mofloYaml)) {
@@ -859,6 +863,10 @@ try {
     if (helpersMatch) autoUpdateConfig.helpers = helpersMatch[1] === 'true';
     if (driftMatch) autoUpdateConfig.hookBlockDrift = driftMatch[1];
     if (claudemdMatch) autoUpdateConfig.claudemdInjectionDrift = claudemdMatch[1];
+    // #1308 — optional `skills: categories: [...]` selection. null means
+    // unconfigured, which must keep meaning "sync everything" so no existing
+    // consumer loses skills on upgrade.
+    selectedSkillCategories = parseSkillCategories(yamlContent);
   }
 } catch (err) {
   // Defaults (all true) keep the upgrade flow alive but the user should
@@ -1216,10 +1224,24 @@ try {
         '.claude/agents',
         { projectRoot, syncFile, onWarn: emitWarning },
       );
+      // #1308 — excludeTopLevel is INTERNAL_SKILLS plus, when the consumer has
+      // opted into a `skills: categories: [...]` selection in moflo.yaml, every
+      // skill belonging to an unselected category. With no selection the set is
+      // just INTERNAL_SKILLS, i.e. byte-for-byte the pre-#1308 behaviour — a
+      // silent narrowing on upgrade would strip capability from every existing
+      // consumer (Rule #2), so "unconfigured" must always mean "everything".
+      const excludedSkills = computeExcludedSkills(selectedSkillCategories, INTERNAL_SKILLS);
+      if (selectedSkillCategories) {
+        emitMutation(
+          'applied skills selection',
+          `categories [${selectedSkillCategories.join(', ')}] — ` +
+          `${plural(excludedSkills.size - INTERNAL_SKILLS.length, 'skill')} not synced`,
+        );
+      }
       await syncDirRecursive(
         resolve(projectRoot, 'node_modules/moflo/.claude/skills'),
         '.claude/skills',
-        { projectRoot, syncFile, excludeTopLevel: new Set(INTERNAL_SKILLS), onWarn: emitWarning },
+        { projectRoot, syncFile, excludeTopLevel: excludedSkills, onWarn: emitWarning },
       );
 
       // Sync all shipped guidance files from node_modules/moflo/.claude/guidance/shipped/
@@ -1292,17 +1314,51 @@ try {
             `${plural(report.pruned.length, 'file')} matching known-shipped content removed`,
           );
         }
+        // Always reconcile the retained record — including writing none when
+        // nothing is retained, so a record from a previous run doesn't outlive
+        // the files it names (#1307 finding 3).
+        //
+        // The version is only read when there is actually something to record.
+        // Nothing-retained is the overwhelmingly common case, and this runs on
+        // every session start in every consumer — an unconditional read +
+        // JSON.parse here would be pure hot-path waste.
+        //
+        // Read locally rather than reusing §2's `installedVersion`: that
+        // binding is scoped to the auto-update branch, and an out-of-scope
+        // reference would be swallowed by the surrounding catch as a bogus
+        // "prune skipped" warning.
+        let recordVersion;
+        if (report.preservedDetails.length > 0) {
+          try {
+            recordVersion = JSON.parse(readFileSync(
+              resolve(projectRoot, 'node_modules/moflo/package.json'), 'utf-8',
+            )).version;
+          } catch { /* record just omits the version */ }
+        }
+        const retainedRecordPath = writeRetainedRecord(
+          projectRoot,
+          report.preservedDetails,
+          recordVersion,
+        );
         if (report.preserved.length > 0) {
           // stdout (not stderr) so Claude sees this in `additionalContext`
           // and can surface to the user — these aren't failures, just
           // consumer-customized files we deliberately left alone.
+          //
+          // The banner samples; the full list goes to the record file. Before
+          // the record existed the truncated banner was the ONLY place these
+          // paths appeared, and it scrolls away — so "delete manually" wasn't
+          // actionable past the 5th entry.
           const sample = report.preserved.slice(0, 5).map((p) => `  - ${p}`).join('\n');
           const more = report.preserved.length > 5
             ? `\n  …and ${report.preserved.length - 5} more`
             : '';
+          const where = retainedRecordPath
+            ? `\n  full list: ${RETAINED_RECORD_REL}`
+            : '';
           try {
             process.stdout.write(
-              `moflo: retained ${plural(report.preserved.length, 'customized retired file')} (delete manually if unwanted):\n${sample}${more}\n`,
+              `moflo: retained ${plural(report.preserved.length, 'customized retired file')} (delete manually if unwanted):\n${sample}${more}${where}\n`,
             );
           } catch { /* non-fatal */ }
         }
@@ -2390,6 +2446,26 @@ if (upgradeNoticeContext) {
 // preserved because that commit is gated on sync success; every stage after the
 // sync block runs unconditionally + idempotently each session.
 
+// ── 3g-1307. Keep the retained-retired record honest every session ──────────
+// The record is WRITTEN in §3's upgrade branch (that is where the retired-file
+// prune runs), but it must not survive the files it names — a user who reads
+// it and deletes those files would otherwise keep a record listing them until
+// their next moflo upgrade. Reconciling here, unconditionally, closes that.
+// Costs one existsSync when no record is present, which is the normal state.
+try {
+  const rec = reconcileRetainedRecord(projectRoot);
+  if (rec.changed) {
+    emitMutation(
+      'reconciled retained-retired record',
+      rec.remaining === 0
+        ? 'all retained files removed by the user — record dropped'
+        : `${plural(rec.removed.length, 'entry')} dropped, ${rec.remaining} still retained`,
+    );
+  }
+} catch (err) {
+  emitWarning(`retained-record reconcile skipped (${errMessage(err)})`);
+}
+
 // ── 3h. Clear bootstrap sentinel if section-3 sync resolved it (#975) ───────
 // Section 3 above re-attempts the same file copies the bootstrap was supposed
 // to do, with the launcher's own retry logic. If after section 3 every file

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

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { findAncestorMofloRoot } from '../services/project-root.js';
-import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
+import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, SKILL_CATEGORIES, } from '../init/index.js';
 // Check if project is already initialized
 function isInitialized(cwd) {
     const claudePath = path.join(cwd, '.claude', 'settings.json');
@@ -366,17 +366,35 @@ const wizardCommand = {
                 options.components.statusline = components.includes('statusline');
                 options.components.mcp = components.includes('mcp');
                 options.components.runtime = components.includes('runtime');
-                // Skills selection
+                // Skills selection.
+                //
+                // #1308: this used to offer 'Core' and 'GitHub'. 'GitHub' mapped to
+                // `options.skills.github`, which has no matching SKILLS_MAP category —
+                // so ticking it did nothing at all, and the `memory` / `spells`
+                // categories were never offered. The options now mirror
+                // SKILL_CATEGORIES, so every choice here selects real skills.
                 if (options.components.skills) {
                     const skillSets = await multiSelect({
                         message: 'Select skill sets:',
                         options: [
-                            { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC, ReasoningBank skills', selected: true },
-                            { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
+                            { value: 'core', label: 'Core', hint: '/fl, /healer, /verify, /flo-simplify, /eldar …', selected: true },
+                            { value: 'memory', label: 'Memory', hint: 'Memory patterns, vector search, team/worktree sharing', selected: true },
+                            { value: 'spells', label: 'Spells', hint: 'Spell authoring, scheduling, connectors', selected: true },
                         ],
                     });
-                    options.skills.core = skillSets.includes('core');
-                    options.skills.github = skillSets.includes('github');
+                    for (const category of SKILL_CATEGORIES) {
+                        options.skills[category] = skillSets.includes(category);
+                    }
+                    // A selection made here governs what init COPIES, but the
+                    // session-start launcher re-syncs shipped skills on every run and
+                    // reads its own selection from moflo.yaml. Without that block the
+                    // narrowing silently reverts on the next session — the #1308 trap.
+                    // Say so rather than let the user discover it.
+                    const narrowed = SKILL_CATEGORIES.filter((c) => !skillSets.includes(c));
+                    if (narrowed.length > 0) {
+                        output.printInfo(`To keep ${narrowed.join(' + ')} skills from returning on the next session, add to moflo.yaml:\n` +
+                            `  skills:\n    categories: [${skillSets.join(', ')}]`);
+                    }
                 }
                 // Hooks selection
                 if (options.components.settings) {
@@ -581,10 +599,13 @@ const checkCommand = {
 const skillsCommand = {
     name: 'skills',
     description: 'Initialize only skills',
+    // Flags mirror SKILL_CATEGORIES. `--github` used to be offered here and
+    // installed nothing — there is no GitHub skill category (#1308).
     options: [
-        { name: 'all', description: 'Install all skills', type: 'boolean', default: false },
-        { name: 'core', description: 'Install core skills', type: 'boolean', default: true },
-        { name: 'github', description: 'Install GitHub skills', type: 'boolean', default: false },
+        { name: 'all', description: 'Install every skill category', type: 'boolean', default: false },
+        { name: 'core', description: 'Install core skills (/fl, /healer, /verify, …)', type: 'boolean', default: true },
+        { name: 'memory', description: 'Install memory skills (patterns, vector search, sharing)', type: 'boolean', default: false },
+        { name: 'spells', description: 'Install spell skills (authoring, scheduling, connectors)', type: 'boolean', default: false },
     ],
     action: async (ctx) => {
         const options = {
@@ -606,8 +627,8 @@ const skillsCommand = {
             skills: {
                 all: ctx.flags.all,
                 core: ctx.flags.core,
-                github: ctx.flags.github,
-                browser: false,
+                memory: ctx.flags.memory,
+                spells: ctx.flags.spells,
             },
         };
         const spinner = output.createSpinner({ text: 'Installing skills...' });

package/dist/src/cli/index.js

@@ -464,6 +464,21 @@ export class CLI {
      * Non-blocking — fires and forgets. Errors are silently swallowed.
      */
     async maybeAutoStartDaemon() {
+        // Test-only kill switch. A test that shells the CLI into a throwaway tmp
+        // project gets `daemon.auto_start: true` from DEFAULT_CONFIG (no moflo.yaml
+        // there to say otherwise), so EVERY such invocation spawned a detached,
+        // unref'd daemon. When the test then removed its tmp dir, the daemon
+        // survived holding a deleted cwd — no lockfile left to contend for, no
+        // project root to match, so nothing ever reclaimed it. One full suite run
+        // leaked several; they accumulated across runs into dozens of ~87MB
+        // processes that only `doctor --fix` could reap.
+        //
+        // Set in vitest.setup.ts alongside MOFLO_TEST_TRUST_DAEMON_PID and
+        // MOFLO_TEST_SKIP_ORPHAN_SCAN. Subprocesses inherit it, which is what makes
+        // it reach the spawned CLI. Production never sets it; a test that genuinely
+        // wants autostart can delete it in its own beforeEach, same as the others.
+        if (process.env.MOFLO_TEST_SKIP_DAEMON_AUTOSTART === '1')
+            return;
         const config = loadMofloConfig(process.cwd());
         if (!config.daemon.auto_start)
             return;

package/dist/src/cli/init/executor.js

@@ -11,7 +11,7 @@ import { dirname } from 'path';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
+import { detectPlatform, DEFAULT_INIT_OPTIONS, SKILL_CATEGORIES } from './types.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
 import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, generateGateScript, generateGateHookScript, generatePromptHookScript, generateHookHandlerScript, } from './helpers-generator.js';
@@ -31,6 +31,8 @@ import { readMofloEnv } from '../services/env-compat.js';
 // cruft). New additions MUST pass the same audit, otherwise the drift-guard
 // test (skills-classification-drift.test.ts) fails. See INTERNAL_SKILLS for
 // skills that ship in the tarball but are deliberately NOT installed.
+// Typed by SkillCategory (not `string`) so this map and `SkillsConfig` cannot
+// drift apart again — see SKILL_CATEGORIES in types.ts for what that drift cost.
 export const SKILLS_MAP = {
     core: [
         'commune',
@@ -915,9 +917,14 @@ async function copySkills(targetDir, options, result) {
         Object.values(SKILLS_MAP).forEach(skills => skillsToCopy.push(...skills));
     }
     else {
-        for (const [key, skills] of Object.entries(SKILLS_MAP)) {
-            if (skillsConfig[key])
-                skillsToCopy.push(...skills);
+        // Iterate SKILL_CATEGORIES rather than Object.entries + a cast. The cast
+        // was what let `SKILLS_MAP`'s keys drift away from `SkillsConfig`'s without
+        // a type error, silently disabling the `memory` and `spells` categories
+        // (#1308). Indexing a typed Record by the category union needs no cast, so
+        // the compiler now enforces that every category is selectable.
+        for (const category of SKILL_CATEGORIES) {
+            if (skillsConfig[category])
+                skillsToCopy.push(...SKILLS_MAP[category]);
         }
     }
     // Find source skills directory

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

@@ -319,6 +319,12 @@ var mergeConf = loadMergeConfig();
 var command = process.argv[2];
 
 var EXEMPT = ['.claude/', '.claude\\\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules', 'moflo.yaml'];
+
+// Appended to every memory-first denial so a context audit doesn't read gate
+// enforcement as permission misconfiguration (#1307 finding 5). SYNC: mirrors
+// bin/gate.cjs GATE_ORIGIN_NOTE / GATE_DISABLE_NOTE.
+var GATE_ORIGIN_NOTE = 'This is a moflo hook, not a Claude Code permission rule — allow-rules cannot override it.';
+var GATE_DISABLE_NOTE = 'Disable per-gate via moflo.yaml: gates: memory_first: false';
 // #1294 Finding 3 — exempt ephemeral reads/scans under the OS temp dir
 // (background-task output, scratchpads) from the memory-first gate. Mirrors
 // bin/gate.cjs isEphemeralPath. Cross-platform via os.tmpdir(); normalizes a
@@ -628,7 +634,7 @@ switch (command) {
     var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
     if (isEphemeralPath(process.env.TOOL_INPUT_path)) break;
     if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
-    process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search.\\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before exploring files. Use mcp__moflo__memory_search.\\n' + GATE_ORIGIN_NOTE + '\\n' + GATE_DISABLE_NOTE + '\\n');
     process.exit(2);
   }
   case 'check-before-read': {
@@ -638,7 +644,7 @@ switch (command) {
     var fp = process.env.TOOL_INPUT_file_path || '';
     if (isEphemeralPath(fp)) break;
     if (fp.indexOf('.claude/guidance/') < 0 && fp.indexOf('.claude\\\\guidance\\\\') < 0) break;
-    process.stderr.write('BLOCKED: Search memory before reading guidance files. Use mcp__moflo__memory_search.\\n');
+    process.stderr.write('BLOCKED [moflo memory_first gate]: Search memory before reading guidance files. Use mcp__moflo__memory_search.\\n' + GATE_ORIGIN_NOTE + '\\n' + GATE_DISABLE_NOTE + '\\n');
     process.exit(2);
   }
   case 'record-task-created': {
@@ -670,11 +676,12 @@ switch (command) {
     // See bin/gate.cjs check-bash-memory for full rationale.
     var hint = s2.lastNamespaceHint || classifyBashNamespaceHint(cmd) || '';
     process.stderr.write(
-      'BLOCKED: Search memory before reading files via Bash.\\n' +
+      'BLOCKED [moflo memory_first gate]: Search memory before reading files via Bash.\\n' +
       'Example: mcp__moflo__memory_search { query: "<topic>", namespace: "<one of: guidance | code-map | patterns | learnings | tests>" }\\n' +
       (hint ? hint + '\\n' : '') +
       'On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\\n' +
-      'Disable per-gate via moflo.yaml: gates: memory_first: false\\n'
+      GATE_ORIGIN_NOTE + '\\n' +
+      GATE_DISABLE_NOTE + '\\n'
     );
     process.exit(2);
     break;

package/dist/src/cli/init/index.js

@@ -3,7 +3,7 @@
  * Comprehensive initialization system for Claude Code integration
  */
 // Types
-export { DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+export { SKILL_CATEGORIES, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
 // Generators
 export { generateSettings, generateSettingsJson, } from './settings-generator.js';
 export { generateMCPConfig, generateMCPJson, generateMCPCommands, } from './mcp-generator.js';

package/dist/src/cli/init/types.js

@@ -4,6 +4,21 @@
  */
 import os from 'os';
 import path from 'path';
+/**
+ * The skill categories `SKILLS_MAP` partitions shipped skills into.
+ *
+ * This list is the single source of truth (#1308). `SkillsConfig` is DERIVED
+ * from it and `SKILLS_MAP` is TYPED by it, so the two can never drift again.
+ *
+ * They did drift, silently, and it disabled the whole selection mechanism:
+ * `SkillsConfig` declared `core`/`github`/`browser` while `SKILLS_MAP` keyed on
+ * `core`/`memory`/`spells`. `copySkills` joins them by key, so `memory` and
+ * `spells` resolved to `undefined` → falsy → never installed, while
+ * `github`/`browser` selected nothing at all. An `as keyof typeof` cast in the
+ * lookup suppressed the type error that would otherwise have caught it. Adding
+ * a category to one side without the other is now a compile error.
+ */
+export const SKILL_CATEGORIES = ['core', 'memory', 'spells'];
 /**
  * Detect current platform
  */
@@ -69,10 +84,15 @@ export const DEFAULT_INIT_OPTIONS = {
         timeout: 5000,
         continueOnError: true,
     },
+    // Every category. This is not a behaviour change: the session-start launcher
+    // syncs all shipped skills on every run regardless of what init selected, so
+    // consumers already end up with all of them. Pre-#1308 this said
+    // `core/github/browser`, which resolved to core-only — meaning `flo init` and
+    // the launcher disagreed, and init's answer simply lost. Now they agree.
     skills: {
         core: true,
-        github: true,
-        browser: true,
+        memory: true,
+        spells: true,
         all: false,
     },
     commands: {
@@ -159,10 +179,11 @@ export const MINIMAL_INIT_OPTIONS = {
         stop: false,
         notification: false,
     },
+    // Minimal deliberately stays core-only — that is the point of the preset.
     skills: {
         core: true,
-        github: false,
-        browser: false,
+        memory: false,
+        spells: false,
         all: false,
     },
     agents: {
@@ -217,8 +238,8 @@ export const FULL_INIT_OPTIONS = {
     },
     skills: {
         core: true,
-        github: true,
-        browser: true,
+        memory: true,
+        spells: true,
         all: true,
     },
     commands: {

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.12.1';
+export const VERSION = '4.12.2';
 //# sourceMappingURL=version.js.map

package/package.json

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