moflo 4.9.21 → 4.9.22

package/bin/gate.cjs

@@ -7,7 +7,7 @@ var cp = require('child_process');
 var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
 var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, simplifySnapshotSha: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {} };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, simplifySnapshotSha: null, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false };
 
 // Per-actor memory-search tracking (#838). The legacy `memorySearched` boolean
 // is session-wide, so once the parent searches memory, every spawned subagent
@@ -60,7 +60,7 @@ function writeState(s) {
 
 // Load moflo.yaml gate config (defaults: all enabled)
 function loadGateConfig() {
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true };
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true };
   try {
     var yamlPath = path.join(PROJECT_DIR, 'moflo.yaml');
     if (fs.existsSync(yamlPath)) {
@@ -71,6 +71,7 @@ function loadGateConfig() {
       if (/testing_gate:\s*false/i.test(content)) defaults.testing_gate = false;
       if (/simplify_gate:\s*false/i.test(content)) defaults.simplify_gate = false;
       if (/learnings_gate:\s*false/i.test(content)) defaults.learnings_gate = false;
+      if (/swarm_invocation_gate:\s*false/i.test(content)) defaults.swarm_invocation_gate = false;
     }
   } catch (e) { /* use defaults */ }
   return defaults;
@@ -111,6 +112,21 @@ var NS_NAV_RES = [
   /\b(class|function|method|component|service|entity|module)\b/,
 ];
 
+// Detect whether the current prompt invoked /fl or /flo with a swarm/hive flag (#952).
+// When set, check-before-agent BLOCKS the Agent spawn until the matching MCP init
+// (mcp__moflo__swarm_init or mcp__moflo__hive-mind_init) has been recorded — the user
+// explicitly opted in to the protected coordination surface, so falling back to
+// raw Agent dispatch silently regresses headline moflo product capability.
+//
+// SYNC: duplicated verbatim in src/cli/init/helpers-generator.ts.
+function detectFlMode(promptText) {
+  var p = promptText || '';
+  if (!/^\s*\/(?:fl|flo)\b/i.test(p)) return null;
+  if (/(?:^|\s)(?:-s|--swarm)\b/.test(p)) return 'swarm';
+  if (/(?:^|\s)(?:-h|--hive)\b/.test(p)) return 'hive';
+  return null;
+}
+
 function classifyNamespaceHint(promptText) {
   var lower = (promptText || '').toLowerCase();
   if (NS_TEST_RE.test(lower)) return 'Memory namespace hint: use "tests" for test inventory and coverage lookups.';
@@ -154,6 +170,12 @@ function applyPromptStateReset(state, promptText) {
   // subsequent agents (parent + subagents that spawn their own agents) all
   // see the new classification on their first check-before-agent.
   state.lastNamespaceHintEmittedBy = {};
+  // #952 — derive flMode from the user prompt, and reset the matching init
+  // flag. Each /fl invocation must call its protected MCP init; the previous
+  // prompt's swarm/hive registration does not satisfy this prompt's gate.
+  state.flMode = detectFlMode(promptText);
+  state.swarmInitialized = false;
+  state.hiveInitialized = false;
 }
 // Match npm/yarn/pnpm/bun test, npx vitest|jest|..., bare runners at command-start only,
 // and language-native test commands. The bare-runner arm is anchored so that
@@ -305,6 +327,47 @@ switch (command) {
         writeState(s);
       }
     }
+    // #952 — when /fl was invoked with -s/-h, the protected MCP init must run
+    // BEFORE any Agent spawn. Hard block: the user explicitly opted in to
+    // moflo's coordination surface, so silently dispatching `Agent` calls
+    // without `mcp__moflo__swarm_init` / `mcp__moflo__hive-mind_init` is the
+    // failure mode this gate exists to prevent (CLAUDE.md "⛔ Protected
+    // functionality — swarm + hive-mind"). Other Agent uses remain advisory.
+    if (config.swarm_invocation_gate) {
+      if (s.flMode === 'swarm' && !s.swarmInitialized) {
+        process.stderr.write('BLOCKED: /fl was invoked with -s/--swarm but mcp__moflo__swarm_init has not been called.\n');
+        process.stderr.write('Run mcp__moflo__swarm_init first, then mcp__moflo__agent_spawn for each role, then dispatch Agent.\n');
+        process.stderr.write('See .claude/skills/fl/execution-modes.md "SWARM mode" and CLAUDE.md "⛔ Protected functionality".\n');
+        process.stderr.write('Disable via moflo.yaml: gates: swarm_invocation_gate: false\n');
+        process.exit(2);
+      }
+      if (s.flMode === 'hive' && !s.hiveInitialized) {
+        process.stderr.write('BLOCKED: /fl was invoked with -h/--hive but mcp__moflo__hive-mind_init has not been called.\n');
+        process.stderr.write('Run mcp__moflo__hive-mind_init first, then dispatch Agent or hive-mind workers.\n');
+        process.stderr.write('See .claude/skills/fl/execution-modes.md "HIVE-MIND mode" and CLAUDE.md "⛔ Protected functionality".\n');
+        process.stderr.write('Disable via moflo.yaml: gates: swarm_invocation_gate: false\n');
+        process.exit(2);
+      }
+    }
+    break;
+  }
+  case 'record-swarm-init': {
+    // #952 — wired to mcp__moflo__swarm_init PostToolUse. Marks the gate
+    // satisfied so subsequent Agent spawns under /fl -s pass.
+    var s = readState();
+    if (!s.swarmInitialized) {
+      s.swarmInitialized = true;
+      writeState(s);
+    }
+    break;
+  }
+  case 'record-hive-init': {
+    // #952 — wired to mcp__moflo__hive-mind_init PostToolUse.
+    var s = readState();
+    if (!s.hiveInitialized) {
+      s.hiveInitialized = true;
+      writeState(s);
+    }
     break;
   }
   case 'check-before-scan': {
@@ -508,7 +571,11 @@ switch (command) {
     break;
   }
   case 'session-reset': {
-    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {} });
+    // Derive from STATE_DEFAULTS so adding a new state field requires only one
+    // edit (the defaults object) — the literal that used to live here drifted
+    // every time a field was added and is what motivated #952's audit of state
+    // shape consistency.
+    writeState(Object.assign({}, STATE_DEFAULTS, { sessionStart: new Date().toISOString() }));
     break;
   }
   default:

package/bin/lib/retired-files.mjs

@@ -0,0 +1,146 @@
+/**
+ * Retired-shipped-files prune helper (#948).
+ *
+ * Closes the gap that retired agents (#932) and retired skills (#945) leave
+ * in consumer projects: the manifest cleanup at section 3 of the launcher
+ * only knows about files moflo previously synced, but `.claude/agents/` and
+ * `.claude/skills/` were not in the manifest before #948. So files retired
+ * before #948 lands stay on disk forever — Claude Code keeps loading them as
+ * subagents on every prompt, paying the per-prompt roster tokens we just
+ * spent #932 fixing.
+ *
+ * This module reads `retired-files.json` (shipped at the moflo package
+ * root) and, for each entry, only prunes the consumer-side path when the
+ * file's sha256 matches one of `knownContentHashes` — i.e. the file matches
+ * a version moflo actually shipped, so the consumer didn't customize it.
+ * Customized files are preserved and a one-line notice is emitted so the
+ * user can act.
+ *
+ * Manifest format:
+ *
+ *   {
+ *     "version": 1,
+ *     "retired": [
+ *       {
+ *         "path": ".claude/agents/v3/performance-engineer.md",
+ *         "retiredIn": "4.9.22",
+ *         "retiredBy": "#932",
+ *         "knownContentHashes": ["sha256:abc...", "sha256:def..."]
+ *       }
+ *     ]
+ *   }
+ *
+ * @module bin/lib/retired-files
+ */
+
+import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { createHash } from 'crypto';
+
+/**
+ * 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
+ * trigger a prune of a file we couldn't actually verify.
+ *
+ * @param {string} absPath
+ * @returns {string|null} `sha256:<hex>` or null
+ */
+export function fileSha256(absPath) {
+  try {
+    const buf = readFileSync(absPath);
+    return 'sha256:' + createHash('sha256').update(buf).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load + validate the retired-files manifest. Returns `{ entries: [] }` for
+ * any failure mode (missing file, invalid JSON, wrong shape) — the launcher
+ * must never block on a corrupt manifest.
+ *
+ * @param {string} manifestPath - absolute path to retired-files.json
+ * @returns {{ entries: Array<{path:string, retiredIn?:string, retiredBy?:string, knownContentHashes:string[]}> }}
+ */
+export function loadRetiredManifest(manifestPath) {
+  if (!existsSync(manifestPath)) return { entries: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  } catch { return { entries: [] }; }
+  if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.retired)) {
+    return { entries: [] };
+  }
+  // Filter out malformed entries — guards against a hand-edited file
+  // dropping the wrong shape into a launcher that runs on N consumer
+  // machines. A skipped entry never auto-prunes (safest default).
+  const entries = parsed.retired.filter((entry) =>
+    entry &&
+    typeof entry.path === 'string' &&
+    entry.path.length > 0 &&
+    Array.isArray(entry.knownContentHashes) &&
+    entry.knownContentHashes.length > 0 &&
+    entry.knownContentHashes.every((h) => typeof h === 'string' && h.startsWith('sha256:'))
+  );
+  return { entries };
+}
+
+/**
+ * Decide what to do with a consumer-side path against a retirement entry:
+ *
+ *   - 'absent'     — path doesn't exist on disk; nothing to do
+ *   - 'prune'      — file exists and content hash matches a known-shipped
+ *                    value; safe to delete (consumer didn't customize)
+ *   - 'preserve'   — file exists but content differs from every known-shipped
+ *                    hash; consumer customized, leave alone
+ *   - 'unknown'    — file exists but its hash couldn't be read (transient
+ *                    error); leave alone, retry next session
+ *
+ * @param {string} projectRoot
+ * @param {{path:string, knownContentHashes:string[]}} entry
+ * @returns {{ action: 'absent'|'prune'|'preserve'|'unknown', actualHash: string|null }}
+ */
+export function classifyRetiredFile(projectRoot, entry) {
+  const abs = resolve(projectRoot, entry.path);
+  if (!existsSync(abs)) return { action: 'absent', actualHash: null };
+  const actualHash = fileSha256(abs);
+  if (!actualHash) return { action: 'unknown', actualHash: null };
+  if (entry.knownContentHashes.includes(actualHash)) {
+    return { action: 'prune', actualHash };
+  }
+  return { action: 'preserve', actualHash };
+}
+
+/**
+ * Walk the manifest and apply prune decisions. Returns a small report so
+ * the caller can emit one summary line (the launcher pattern) instead of
+ * forcing it to track per-entry state.
+ *
+ * Failures are non-fatal — a single un-deletable file (Windows AV hold,
+ * EBUSY) must not stop pruning the rest. The caller surfaces the report.
+ *
+ * @param {string} projectRoot
+ * @param {string} manifestPath
+ * @returns {{ pruned: string[], preserved: string[], unknown: string[], failed: Array<{path:string, message:string}> }}
+ */
+export function applyRetiredPrune(projectRoot, manifestPath) {
+  const { entries } = loadRetiredManifest(manifestPath);
+  const report = { pruned: [], preserved: [], 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 === 'unknown') { report.unknown.push(entry.path); continue; }
+    // action === 'prune'
+    try {
+      unlinkSync(resolve(projectRoot, entry.path));
+      report.pruned.push(entry.path);
+    } catch (err) {
+      report.failed.push({
+        path: entry.path,
+        message: err && err.message ? err.message : String(err),
+      });
+    }
+  }
+  return report;
+}

package/bin/session-start-launcher.mjs

@@ -14,6 +14,7 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { mofloDir } 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';
 
 // Headless skip (#860). The daemon's headless workers spawn `claude --print`
 // with CLAUDE_CODE_HEADLESS=true (see src/cli/services/headless-worker-
@@ -681,6 +682,56 @@ try {
         }
       }
 
+      // ── Sync .claude/agents/ + .claude/skills/ recursively (#948) ──────
+      // Pre-#948, agents and skills weren't manifest-tracked at all, so any
+      // file moflo retired (e.g. the 49 ruflo-aspirational agents in #932 or
+      // skill-builder in #945) would linger forever in consumer projects —
+      // Claude Code kept loading them on every prompt, paying the per-prompt
+      // roster tokens we just spent #932 fixing. Walking these dirs through
+      // syncFile() puts every shipped file in `currentManifest`, which lets
+      // the cleanup loop below auto-prune retired files going forward.
+      //
+      // Limitation: this only catches retirements that happen AFTER #948.
+      // For files retired BEFORE #948 (#932 + #945), see the retired-files.json
+      // hash-gated prune block further down — it ships a static list with
+      // content hashes so we only delete files the consumer didn't customize.
+      //
+      // User-authored files at custom paths (.claude/agents/custom/foo.md,
+      // .claude/skills/<custom>/SKILL.md) are NEVER passed through syncFile()
+      // because they don't exist in node_modules/moflo/, so they never enter
+      // the manifest and never get pruned — same proven safety story as
+      // scripts/helpers above.
+      async function syncDirRecursive(srcDir, destPrefix) {
+        if (!existsSync(srcDir)) return;
+        let entries;
+        try {
+          entries = readdirSync(srcDir, { recursive: true, withFileTypes: true });
+        } catch (err) {
+          emitWarning(`${destPrefix} readdir failed (${errMessage(err)})`);
+          return;
+        }
+        for (const entry of entries) {
+          if (!entry.isFile()) continue;
+          if (!entry.name.toLowerCase().endsWith('.md')) continue;
+          const parent = entry.parentPath || entry.path || srcDir;
+          const absSrc = resolve(parent, entry.name);
+          const rel = absSrc.slice(srcDir.length + 1).split(/[\\/]/).join('/');
+          const absDest = resolve(projectRoot, destPrefix, rel);
+          try { mkdirSync(dirname(absDest), { recursive: true }); } catch (err) {
+            emitWarning(`${destPrefix} subdir mkdir failed for ${rel} (${errMessage(err)})`);
+          }
+          await syncFile(absSrc, absDest, `${destPrefix}/${rel}`);
+        }
+      }
+      await syncDirRecursive(
+        resolve(projectRoot, 'node_modules/moflo/.claude/agents'),
+        '.claude/agents',
+      );
+      await syncDirRecursive(
+        resolve(projectRoot, 'node_modules/moflo/.claude/skills'),
+        '.claude/skills',
+      );
+
       // Sync all shipped guidance files from node_modules/moflo/.claude/guidance/shipped/
       const guidanceDir = resolve(projectRoot, '.claude/guidance');
       const shippedDir = resolve(projectRoot, 'node_modules/moflo/.claude/guidance/shipped');
@@ -725,6 +776,56 @@ try {
         emitMutation('cleaned up retired files', `${removedFiles} removed`);
       }
 
+      // ── Hash-gated prune of pre-#948 retirements (Mechanism B) ─────────
+      // The manifest cleanup above only knows about files moflo previously
+      // synced. Agents and skills retired BEFORE #948 (#932's 49 agents and
+      // #945's skill-builder, plus older retirements) were never in any
+      // manifest — they exist on disk in consumer projects only because
+      // earlier moflo versions shipped them via the npm tarball + flo init.
+      // `retired-files.json` is the explicit, reviewable static list that
+      // closes that gap. Each entry pairs a path with the sha256 hashes of
+      // every content version moflo previously shipped, so we only auto-
+      // prune when the consumer's file matches a known-shipped hash —
+      // customized files (different hash) get preserved with a one-line
+      // notice the user can act on.
+      try {
+        const retiredManifestPath = resolve(
+          projectRoot,
+          'node_modules/moflo/retired-files.json',
+        );
+        const report = applyRetiredPrune(projectRoot, retiredManifestPath);
+        if (report.pruned.length > 0) {
+          emitMutation(
+            'pruned retired shipped files',
+            `${plural(report.pruned.length, 'file')} matching known-shipped content removed`,
+          );
+        }
+        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.
+          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`
+            : '';
+          try {
+            process.stdout.write(
+              `moflo: retained ${plural(report.preserved.length, 'customized retired file')} (delete manually if unwanted):\n${sample}${more}\n`,
+            );
+          } catch { /* non-fatal */ }
+        }
+        if (report.failed.length > 0) {
+          const sample = report.failed.slice(0, 3)
+            .map((f) => `  - ${f.path}: ${f.message}`).join('\n');
+          emitWarning(`${plural(report.failed.length, 'retired file')} failed to prune:\n${sample}`);
+        }
+      } catch (err) {
+        // Non-fatal — the consumer just doesn't get the prune this session.
+        // Next session retries; manifest-cleanup above still works for
+        // future retirements regardless.
+        emitWarning(`retired-files prune skipped (${errMessage(err)})`);
+      }
+
       // The daemon was already stopped above so the lock file is gone and
       // there's no live PID to recycle here. Section 4's `hooks.mjs
       // session-start` will spawn a fresh daemon under the current moflo

package/dist/src/cli/appliance/rvfa-builder.js

@@ -20,7 +20,7 @@ const AES_TAG_LEN = 16;
 const AES_ALG = 'aes-256-gcm';
 // ── Catalog ──────────────────────────────────────────────────
 const RUFLO_COMMANDS = 'init agent swarm memory mcp task session config status start workflow hooks hive-mind daemon neural security performance providers plugins deployment embeddings claims migrate process doctor completions'.split(' ');
-const AGENT_TYPES = 'coder reviewer tester planner researcher security-architect security-auditor memory-specialist performance-engineer hierarchical-coordinator mesh-coordinator adaptive-coordinator collective-intelligence-coordinator swarm-memory-manager byzantine-coordinator raft-manager gossip-coordinator consensus-builder crdt-synchronizer quorum-manager security-manager perf-analyzer performance-benchmarker task-orchestrator memory-coordinator smart-agent github-modes pr-manager code-review-swarm issue-tracker release-manager workflow-automation project-board-sync repo-architect multi-repo-swarm sparc-coord sparc-coder specification pseudocode architecture refinement backend-dev mobile-dev ml-developer cicd-engineer api-docs system-architect code-analyzer base-template-generator tdd-london-swarm production-validator'.split(' ');
+const AGENT_TYPES = 'coder reviewer tester planner researcher security-auditor backend-dev frontend-dev database-dev cicd-engineer api-docs system-architect code-analyzer analyst base-template-generator test-long-runner'.split(' ');
 const HOOK_TYPES = 'pre-edit post-edit pre-command post-command pre-task post-task session-start session-end session-restore notify route explain pretrain build-agents transfer teammate-idle task-completed'.split(' ');
 const WORKER_TYPES = 'ultralearn optimize consolidate predict audit map preload deepdive document refactor benchmark testgaps'.split(' ');
 const OFFLINE_MODELS = [

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

@@ -68,13 +68,8 @@ const AGENT_TYPES = [
     { value: 'coordinator', label: 'Coordinator', hint: 'Multi-agent orchestration and spell management' },
     { value: 'analyst', label: 'Analyst', hint: 'Performance analysis and optimization' },
     { value: 'optimizer', label: 'Optimizer', hint: 'Performance optimization and bottleneck analysis' },
-    { value: 'security-architect', label: 'Security Architect', hint: 'Security architecture and threat modeling' },
     { value: 'security-auditor', label: 'Security Auditor', hint: 'CVE remediation and security testing' },
-    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'AgentDB unification (150x-12,500x faster)' },
-    { value: 'swarm-specialist', label: 'Swarm Specialist', hint: 'Unified coordination engine' },
-    { value: 'performance-engineer', label: 'Performance Engineer', hint: '2.49x-7.47x optimization targets' },
-    { value: 'core-architect', label: 'Core Architect', hint: 'Domain-driven design restructure' },
-    { value: 'test-architect', label: 'Test Architect', hint: 'TDD London School methodology' }
+    { value: 'planner', label: 'Planner', hint: 'Task planning and breakdown' },
 ];
 // Agent spawn subcommand
 const spawnCommand = {
@@ -844,9 +839,8 @@ function getAgentCapabilities(type) {
         reviewer: ['code-review', 'security-audit', 'quality-check', 'documentation'],
         architect: ['system-design', 'pattern-analysis', 'scalability', 'documentation'],
         coordinator: ['task-orchestration', 'agent-management', 'spell-control'],
-        'security-architect': ['threat-modeling', 'security-patterns', 'compliance', 'audit'],
-        'memory-specialist': ['vector-search', 'agentdb', 'caching', 'optimization'],
-        'performance-engineer': ['benchmarking', 'profiling', 'optimization', 'monitoring']
+        'security-auditor': ['threat-modeling', 'security-patterns', 'compliance', 'audit', 'vulnerability-scan'],
+        planner: ['task-breakdown', 'sequencing', 'estimation'],
     };
     return capabilities[type] || ['general'];
 }

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

@@ -21,9 +21,7 @@ const HOOK_TYPES = [
 // Agent routing options
 const AGENT_TYPES = [
     'coder', 'researcher', 'tester', 'reviewer', 'architect',
-    'security-architect', 'security-auditor', 'memory-specialist',
-    'swarm-specialist', 'performance-engineer', 'core-architect',
-    'test-architect', 'coordinator', 'analyst', 'optimizer'
+    'security-auditor', 'coordinator', 'analyst', 'optimizer', 'planner',
 ];
 // Pre-edit subcommand
 const preEditCommand = {

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

@@ -54,6 +54,8 @@ const commandLoaders = {
     issues: () => import('./issues.js'),
     // Auto-update System (ADR-025)
     update: () => import('./update.js'),
+    // Retired-files manifest helper (#948 — moflo dev only)
+    retire: () => import('./retire.js'),
     // Full integration diagnostics
     diagnose: () => import('./diagnose.js'),
     // Benchmark Suite (Pre-training, Neural, Memory)

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

@@ -0,0 +1,111 @@
+/**
+ * `flo retire <path>` — record a shipped file as retired (#948).
+ *
+ * Run this inside the moflo source repo whenever a retirement PR deletes a
+ * `.claude/agents/**` or `.claude/skills/**` file. It computes content
+ * hashes for the last few moflo-shipped versions of the file (from git
+ * history) and appends an entry to `retired-files.json`. The launcher then
+ * prunes the matching file from consumer projects on their next upgrade —
+ * but only when their on-disk content matches a known-shipped hash, so
+ * customized files stay put.
+ *
+ * Refuses to run outside moflo's own repo because the seed script and
+ * `retired-files.json` live at the moflo package root and don't ship to
+ * consumer projects.
+ *
+ * Created with motailz.com
+ */
+import { output } from '../output.js';
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+// dist/src/cli/commands/retire.js → repo root is up 5 dirs.
+// In dev (tsx) src/cli/commands/retire.ts → up 4 dirs. Walk to find package.json#name === 'moflo'.
+function findMofloRepoRoot(start) {
+    let dir = start;
+    const root = resolve(dir, '/');
+    while (dir !== root) {
+        const pkg = resolve(dir, 'package.json');
+        if (existsSync(pkg)) {
+            try {
+                const parsed = JSON.parse(readFileSync(pkg, 'utf-8'));
+                if (parsed?.name === 'moflo')
+                    return dir;
+            }
+            catch { /* keep walking */ }
+        }
+        dir = dirname(dir);
+    }
+    return null;
+}
+export const retireCommand = {
+    name: 'retire',
+    description: 'Record a retired shipped file in retired-files.json (moflo dev only) — usage: flo retire <path> [--retired-by #nnn]',
+    hidden: true,
+    options: [
+        {
+            name: 'retired-by',
+            description: 'GitHub PR/issue reference (e.g. #932)',
+            type: 'string',
+        },
+        {
+            name: 'retired-in',
+            description: 'moflo version that ships the retirement (defaults to current package.json version)',
+            type: 'string',
+        },
+        {
+            name: 'hashes',
+            description: 'Maximum number of historical content hashes to record (default 3)',
+            type: 'number',
+            default: 3,
+        },
+    ],
+    examples: [
+        { command: 'flo retire .claude/agents/v3/performance-engineer.md --retired-by #932', description: 'Record a retirement' },
+        { command: 'flo retire .claude/skills/skill-builder/SKILL.md --retired-by #945 --retired-in 4.9.21', description: 'Pin retiredIn' },
+    ],
+    action: async (ctx) => {
+        const repoRoot = findMofloRepoRoot(__filename) || findMofloRepoRoot(ctx.cwd);
+        if (!repoRoot) {
+            output.printError('flo retire must be run inside the moflo source repo');
+            output.printInfo('retired-files.json lives at the moflo package root and does not ship to consumer projects');
+            return { success: false, message: 'not in moflo repo', exitCode: 1 };
+        }
+        const path = ctx.args[0];
+        if (!path) {
+            output.printError('Missing required argument: <path>');
+            return { success: false, message: 'missing path', exitCode: 2 };
+        }
+        const scriptPath = resolve(repoRoot, 'scripts', 'build-retired-files.mjs');
+        if (!existsSync(scriptPath)) {
+            output.printError(`scripts/build-retired-files.mjs not found at ${scriptPath}`);
+            return { success: false, message: 'seed script missing', exitCode: 1 };
+        }
+        // Parser normalises kebab-case flag names to camelCase before storing
+        // (#787). Read as ctx.flags.<camelCase> — bracket-with-kebab is always
+        // undefined and ESLint blocks that pattern.
+        const args = ['--add', path];
+        if (ctx.flags.retiredBy)
+            args.push('--retired-by', String(ctx.flags.retiredBy));
+        if (ctx.flags.retiredIn)
+            args.push('--retired-in', String(ctx.flags.retiredIn));
+        if (ctx.flags.hashes)
+            args.push('--hashes', String(ctx.flags.hashes));
+        const result = spawnSync('node', [scriptPath, ...args], {
+            cwd: repoRoot,
+            stdio: 'inherit',
+        });
+        if (result.error) {
+            output.printError(`failed to invoke build-retired-files.mjs: ${result.error.message}`);
+            return { success: false, message: String(result.error), exitCode: 1 };
+        }
+        if (typeof result.status === 'number' && result.status !== 0) {
+            return { success: false, message: `exit ${result.status}`, exitCode: result.status };
+        }
+        return { success: true };
+    },
+};
+export default retireCommand;
+//# sourceMappingURL=retire.js.map

package/dist/src/cli/hooks/reasoningbank/index.js

@@ -33,15 +33,15 @@ const DEFAULT_CONFIG = {
     useMockEmbeddings: false,
 };
 /**
- * Agent mapping for routing
+ * Agent mapping for routing — keys must match agents shipped in .claude/agents/
+ * (or the canonical AgentType union).
  */
 const AGENT_PATTERNS = {
-    'security-architect': /security|auth|cve|vuln|encrypt|password|token/i,
-    'test-architect': /test|spec|mock|coverage|tdd|assert/i,
-    'performance-engineer': /perf|optim|fast|memory|cache|speed|slow/i,
-    'core-architect': /architect|design|ddd|domain|refactor|struct/i,
-    'swarm-specialist': /swarm|agent|coordinate|orchestrat|parallel/i,
-    'memory-specialist': /memory|agentdb|hnsw|vector|embedding/i,
+    'security-auditor': /security|auth|cve|vuln|encrypt|password|token/i,
+    'tester': /test|spec|mock|coverage|tdd|assert/i,
+    'architect': /architect|design|ddd|domain|refactor|struct|perf|optim|fast|memory|cache|speed|slow/i,
+    'coordinator': /swarm|agent|coordinate|orchestrat|parallel|hive/i,
+    'researcher': /memory|agentdb|hnsw|vector|embedding|recall|persist/i,
     'coder': /fix|bug|implement|create|add|build|error|code/i,
     'reviewer': /review|quality|lint|check|audit/i,
 };