moflo 4.12.0 → 4.12.2

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...' });