moflo 4.9.21 → 4.9.23

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

@@ -105,9 +105,11 @@ export function generateSettings(options) {
         daemon: {
             autoStart: true,
             // Note: this list is documentation for the user — the daemon's actual
-            // worker registry lives in src/cli/services/worker-daemon.ts DEFAULT_WORKERS.
-            // 'audit' is intentionally absent here because it's default-disabled
-            // pending the perf fix in #631.
+            // worker registry lives in src/cli/services/worker-daemon.ts
+            // DEFAULT_WORKERS. The `audit`/`predict`/`document` workers were
+            // removed in #970 (no surfacing layer for findings + dashboard
+            // pollution); restore them as opt-in `flo doctor` one-shots if their
+            // value is ever re-established.
             workers: [
                 'map', // Codebase mapping
                 'optimize', // Performance optimization (high priority)
@@ -115,15 +117,12 @@ export function generateSettings(options) {
                 'testgaps', // Test coverage gaps
                 'ultralearn', // Deep knowledge acquisition
                 'deepdive', // Deep code analysis
-                'document', // Auto-documentation for ADRs
                 'refactor', // Refactoring suggestions (DDD alignment)
                 'benchmark', // Performance benchmarking
             ],
             schedules: {
-                audit: { interval: '1h', priority: 'critical' },
                 optimize: { interval: '30m', priority: 'high' },
                 consolidate: { interval: '2h', priority: 'low' },
-                document: { interval: '1h', priority: 'normal', triggers: ['adr-update', 'api-change'] },
                 deepdive: { interval: '4h', priority: 'normal', triggers: ['complex-change'] },
                 ultralearn: { interval: '1h', priority: 'normal' },
             },
@@ -302,6 +301,18 @@ function generateHooksConfig(config) {
                 matcher: '^mcp__moflo__memory_store$',
                 hooks: [{ type: 'command', command: gateCmd('record-learnings-stored'), timeout: 2000 }],
             },
+            {
+                // #952 — when /fl is invoked with -s/--swarm, the gate blocks Agent
+                // spawns until mcp__moflo__swarm_init runs. Record the call here so
+                // the hard block in check-before-agent passes for legitimate /fl runs.
+                matcher: '^mcp__moflo__swarm_init$',
+                hooks: [{ type: 'command', command: gateCmd('record-swarm-init'), timeout: 2000 }],
+            },
+            {
+                // #952 — symmetric record for /fl -h/--hive runs.
+                matcher: '^mcp__moflo__hive-mind_init$',
+                hooks: [{ type: 'command', command: gateCmd('record-hive-init'), timeout: 2000 }],
+            },
         ];
     }
     // UserPromptSubmit — per-prompt state reset + Context warnings.

package/dist/src/cli/mcp-tools/agent-tools.js

@@ -27,33 +27,16 @@ const CANONICAL_AGENT_TYPES = [
 ];
 const ALLOWED_AGENT_TYPES = new Set([
     ...CANONICAL_AGENT_TYPES,
-    // Shipped Claude Code agent definitions (.claude/agents/**)
-    'adaptive-coordinator', 'adr-architect', 'aidefence-guardian',
+    // Claude Code built-ins
+    'claude-code-guide', 'general-purpose',
+    // Shipped Claude Code agent definitions (.claude/agents/**) — both the
+    // canonical `name:` slug and the file basename are accepted.
     'analyze-code-quality', 'api-docs', 'arch-system-design',
-    'backend-dev', 'base-template-generator', 'benchmark-suite',
-    'byzantine-coordinator', 'cicd-engineer', 'claims-authorizer',
-    'claude-code-guide', 'code-analyzer', 'code-goal-planner',
-    'code-review-swarm', 'collective-intelligence-coordinator',
-    'crdt-synchronizer', 'data-ml-model', 'ddd-domain-expert',
-    'dev-backend-api', 'docs-api-openapi', 'general-purpose',
-    'github-modes', 'goal-planner', 'gossip-coordinator',
-    'hierarchical-coordinator', 'injection-analyst', 'issue-tracker',
-    'load-balancer', 'memory-specialist', 'mesh-coordinator',
-    'ml-developer', 'mobile-dev', 'multi-repo-swarm',
-    'ops-cicd-github', 'performance-benchmarker', 'performance-engineer',
-    'performance-monitor', 'pii-detector', 'planner',
-    'pr-manager', 'production-validator', 'project-board-sync',
-    'pseudocode', 'quorum-manager', 'queen-coordinator',
-    'raft-manager', 'reasoningbank-learner', 'refinement',
-    'release-manager', 'release-swarm', 'repo-architect',
-    'resource-allocator', 'safla-neural', 'scout-explorer',
-    'security-architect', 'security-architect-aidefence',
-    'security-auditor', 'security-manager', 'sona-learning-optimizer',
-    'sparc-orchestrator', 'spec-mobile-react-native', 'specification',
-    'swarm-issue', 'swarm-memory-manager', 'swarm-pr',
-    'sync-coordinator', 'system-architect', 'tdd-london-swarm',
-    'test-long-runner', 'topology-optimizer', 'v3-integration-architect',
-    'workflow-automation', 'worker-specialist',
+    'backend-dev', 'base-template-generator', 'cicd-engineer',
+    'code-analyzer', 'database-dev', 'dev-backend-api',
+    'dev-database', 'dev-frontend', 'docs-api-openapi',
+    'frontend-dev', 'ops-cicd-github', 'planner',
+    'security-auditor', 'system-architect', 'test-long-runner',
 ]);
 const AGENT_TYPE_SLUG_RE = /^[a-z][a-z0-9-]*$/;
 export function toNonNegativeInt(value, fallback) {
@@ -78,7 +61,6 @@ export function validateAgentType(value) {
 const AGENT_TYPE_MODEL_DEFAULTS = {
     // Complex agents → opus
     'architect': 'opus',
-    'security-architect': 'opus',
     'system-architect': 'opus',
     'core-architect': 'opus',
     // Medium complexity → sonnet

package/dist/src/cli/mcp-tools/hooks-tools.js

@@ -211,7 +211,7 @@ function learnedPatternsFromOutcomes() {
 const TASK_PATTERNS = {
     'security-task': {
         keywords: ['authentication', 'security', 'auth', 'password', 'encryption', 'vulnerability', 'cve', 'audit'],
-        agents: ['security-architect', 'security-auditor', 'reviewer'],
+        agents: ['security-auditor', 'reviewer'],
     },
     'testing-task': {
         keywords: ['test', 'testing', 'spec', 'coverage', 'unit test', 'integration test', 'e2e'],
@@ -223,7 +223,7 @@ const TASK_PATTERNS = {
     },
     'performance-task': {
         keywords: ['performance', 'optimize', 'speed', 'memory', 'benchmark', 'profiling', 'bottleneck'],
-        agents: ['performance-engineer', 'coder', 'tester'],
+        agents: ['reviewer', 'coder', 'tester'],
     },
     'refactor-task': {
         keywords: ['refactor', 'restructure', 'clean', 'organize', 'modular', 'decouple'],
@@ -239,23 +239,25 @@ const TASK_PATTERNS = {
     },
     'database-task': {
         keywords: ['database', 'sql', 'query', 'schema', 'migration', 'orm'],
-        agents: ['architect', 'coder', 'tester'],
+        agents: ['database-dev', 'coder', 'tester'],
     },
     'frontend-task': {
-        keywords: ['frontend', 'ui', 'component', 'react', 'css', 'style', 'layout'],
-        agents: ['coder', 'reviewer', 'tester'],
+        keywords: ['frontend', 'ui', 'component', 'react', 'vue', 'svelte', 'css', 'tailwind', 'style', 'layout', 'accessibility'],
+        agents: ['frontend-dev', 'reviewer', 'tester'],
     },
     'devops-task': {
         keywords: ['deploy', 'ci', 'cd', 'pipeline', 'docker', 'kubernetes', 'infrastructure'],
-        agents: ['devops', 'coder', 'tester'],
+        agents: ['cicd-engineer', 'coder', 'tester'],
     },
+    // (github-task intent removed — github work routes to generic coder/reviewer
+    // with the gh CLI; specialized github-* agents were retired in #932)
     'swarm-task': {
         keywords: ['swarm', 'agent', 'coordinator', 'hive', 'mesh', 'topology'],
-        agents: ['swarm-specialist', 'coordinator', 'architect'],
+        agents: ['coordinator', 'architect'],
     },
     'memory-task': {
         keywords: ['memory', 'cache', 'store', 'vector', 'embedding', 'persistence'],
-        agents: ['memory-specialist', 'architect', 'coder'],
+        agents: ['researcher', 'architect', 'coder'],
     },
 };
 /**
@@ -436,30 +438,30 @@ const AGENT_PATTERNS = {
     '.yaml': ['coder', 'devops'],
     '.yml': ['coder', 'devops'],
     '.sh': ['devops', 'coder'],
-    '.py': ['coder', 'ml-developer', 'researcher'],
+    '.py': ['coder', 'researcher'],
     '.sql': ['coder', 'architect'],
     '.css': ['coder', 'designer'],
     '.scss': ['coder', 'designer'],
 };
 // Keyword patterns for fallback routing (when semantic routing doesn't match)
 const KEYWORD_PATTERNS = {
-    'authentication': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.9 },
-    'auth': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.85 },
+    'authentication': { agents: ['security-auditor', 'coder', 'tester'], confidence: 0.9 },
+    'auth': { agents: ['security-auditor', 'coder', 'tester'], confidence: 0.85 },
     'api': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
     'test': { agents: ['tester', 'reviewer'], confidence: 0.95 },
     'refactor': { agents: ['architect', 'coder', 'reviewer'], confidence: 0.9 },
-    'performance': { agents: ['performance-engineer', 'coder', 'tester'], confidence: 0.88 },
-    'security': { agents: ['security-architect', 'security-auditor', 'reviewer'], confidence: 0.92 },
-    'database': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
-    'frontend': { agents: ['coder', 'designer', 'tester'], confidence: 0.82 },
-    'backend': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
+    'performance': { agents: ['reviewer', 'coder', 'tester'], confidence: 0.88 },
+    'security': { agents: ['security-auditor', 'reviewer'], confidence: 0.92 },
+    'database': { agents: ['database-dev', 'coder', 'tester'], confidence: 0.9 },
+    'frontend': { agents: ['frontend-dev', 'reviewer', 'tester'], confidence: 0.9 },
+    'backend': { agents: ['backend-dev', 'architect', 'coder', 'tester'], confidence: 0.9 },
     'bug': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.88 },
     'fix': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.85 },
     'feature': { agents: ['architect', 'coder', 'tester'], confidence: 0.8 },
-    'swarm': { agents: ['swarm-specialist', 'coordinator', 'architect'], confidence: 0.9 },
-    'memory': { agents: ['memory-specialist', 'architect', 'coder'], confidence: 0.88 },
-    'deploy': { agents: ['devops', 'coder', 'tester'], confidence: 0.85 },
-    'ci/cd': { agents: ['devops', 'coder'], confidence: 0.9 },
+    'swarm': { agents: ['coordinator', 'architect'], confidence: 0.9 },
+    'memory': { agents: ['researcher', 'architect', 'coder'], confidence: 0.88 },
+    'deploy': { agents: ['cicd-engineer', 'coder', 'tester'], confidence: 0.85 },
+    'ci/cd': { agents: ['cicd-engineer', 'coder'], confidence: 0.9 },
 };
 function getFileExtension(filePath) {
     const match = filePath.match(/\.[a-zA-Z0-9]+$/);
@@ -1675,7 +1677,7 @@ export const hooksBuildAgents = {
             { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
             { type: 'architect', configFile: join(outputDir, `architect.${format}`), capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
             { type: 'tester', configFile: join(outputDir, `tester.${format}`), capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
-            { type: 'security-architect', configFile: join(outputDir, `security-architect.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
+            { type: 'security-auditor', configFile: join(outputDir, `security-auditor.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
             { type: 'reviewer', configFile: join(outputDir, `reviewer.${format}`), capabilities: ['code-review', 'quality-analysis', 'best-practices'], optimizations: ['incremental-analysis'] },
         ];
         const filteredAgents = focus === 'all' ? agents :

package/dist/src/cli/mcp-tools/memory-tools.js

@@ -154,7 +154,7 @@ async function ensureInitialized() {
 export const memoryTools = [
     {
         name: 'memory_store',
-        description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Use upsert=true to update existing keys.',
+        description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Upserts by default — pass upsert:false to fail on duplicate keys.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -168,7 +168,7 @@ export const memoryTools = [
                     description: 'Optional tags for filtering',
                 },
                 ttl: { type: 'number', description: 'Time-to-live in seconds (optional)' },
-                upsert: { type: 'boolean', description: 'If true, update existing key instead of failing (default: false)' },
+                upsert: { type: 'boolean', description: 'If false, fail on duplicate keys instead of replacing (default: true)' },
             },
             required: ['key', 'value'],
         },
@@ -180,7 +180,9 @@ export const memoryTools = [
             const value = typeof input.value === 'string' ? input.value : JSON.stringify(input.value);
             const tags = input.tags || [];
             const ttl = input.ttl;
-            const upsert = input.upsert || false;
+            // #962: default upsert=true — silent UNIQUE-constraint failures on update
+            // were dropping schedule cancels and similar updates on the floor.
+            const upsert = input.upsert === false ? false : true;
             validateMemoryInput(key, value);
             const startTime = performance.now();
             try {
@@ -364,12 +366,21 @@ export const memoryTools = [
             const namespace = input.namespace || 'default';
             try {
                 const result = await deleteEntry({ key, namespace });
+                // Issue #963: surface the underlying reason when delete fails.
+                // `result.success` reflects whether the call itself succeeded; we
+                // require `deleted === true` for the MCP-level success boolean,
+                // and pass `result.error` through whenever the delete didn't take.
+                const deleted = result.deleted === true;
+                const errorReason = !deleted
+                    ? (result.error ?? `No entry deleted (key='${key}', namespace='${namespace}'); reason not reported by storage layer`)
+                    : undefined;
                 return {
-                    success: result.deleted,
+                    success: result.success === true && deleted,
                     key,
                     namespace,
-                    deleted: result.deleted,
+                    deleted,
                     backend: 'sql.js + HNSW',
+                    ...(errorReason ? { error: errorReason } : {}),
                 };
             }
             catch (error) {

package/dist/src/cli/memory/bridge-embedder.js

@@ -44,11 +44,9 @@ export const EMBEDDING_MODEL_OPT_OUT = 'none';
  */
 export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
 /**
- * Namespaces that store internal moflo run-tracking, never user knowledge.
- * Writes here skip embedding generation entirely — both `embedding` and
- * `embedding_model` land as NULL, distinct from the opt-out path which still
- * tags rows with `'none'`. Existing rows in these namespaces are hard-deleted
- * on upgrade by `services/ephemeral-namespace-purge.ts`.
+ * Namespaces that skip embedding generation in the bridge write path. Rows
+ * land with both `embedding` and `embedding_model` NULL (distinct from the
+ * opt-out path which still tags rows with `'none'`).
  *
  * Members:
  * - `hive-mind`     — MCP broadcast traffic (msg:*, agent_join, consensus_propose)
@@ -56,7 +54,11 @@ export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
  * - `epic-state`    — Epic progress (epic-N, story-M) written by commands/epic.ts
  * - `test-bridge-fix` — Single 2026-04-23 row left over from a one-off test
  *
- * See story #729 for the source-trace and rationale.
+ * See story #729 for the source-trace and rationale. The session-start
+ * launcher only purges {@link PURGE_ON_SESSION_START_NAMESPACES} — a strict
+ * subset that *excludes* `tasklist`, because the dashboard's Flo Runs tab
+ * (`daemon-dashboard.ts handleSpells`) reads tasklist; purging it on every
+ * session would empty the tab between sessions (#968).
  */
 export const EPHEMERAL_NAMESPACES = new Set([
     'hive-mind',
@@ -64,6 +66,24 @@ export const EPHEMERAL_NAMESPACES = new Set([
     'epic-state',
     'test-bridge-fix',
 ]);
+/**
+ * Subset of {@link EPHEMERAL_NAMESPACES} that the session-start launcher
+ * hard-purges via `services/ephemeral-namespace-purge.ts`. Excludes
+ * `tasklist` — those rows back the dashboard's "Flo Runs" tab and are
+ * trimmed by row-count retention instead of bulk purge (#968).
+ */
+export const PURGE_ON_SESSION_START_NAMESPACES = new Set([
+    'hive-mind',
+    'epic-state',
+    'test-bridge-fix',
+]);
+/**
+ * Maximum number of `tasklist` rows kept across session restarts. The
+ * session-start retention pass deletes oldest rows beyond this cap, so the
+ * dashboard's "Flo Runs" tab shows recent history without unbounded growth
+ * (#968). Sized for ~2 weeks of /flo activity at typical use.
+ */
+export const TASKLIST_RETENTION_CAP = 200;
 let cachedEmbedder = null;
 let testOverride = null;
 class LazyFastembedBridgeEmbedder {

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

@@ -435,14 +435,30 @@ export async function bridgeGetEntry(options) {
     });
 }
 /**
- * Soft-delete an entry. Guarded, cache-invalidated, attested.
+ * Hard-delete an entry. Guarded, cache-invalidated, attested.
+ *
+ * Failure modes (issue #963): every non-success path now carries a
+ * human-readable `error` so MCP callers can surface the reason instead
+ * of seeing a silent `{ deleted: false }`.
  */
 export async function bridgeDeleteEntry(options) {
     return withDb(options.dbPath, async (ctx, registry) => {
         const { key, namespace = 'default' } = options;
+        const deleteFail = (error) => ({ success: false, deleted: false, key, namespace, remainingEntries: 0, error });
         const guardResult = await guardValidate(registry, 'delete', { key, namespace });
         if (!guardResult.allowed) {
-            return { success: false, deleted: false, key, namespace, remainingEntries: 0, error: `MutationGuard rejected: ${guardResult.reason}` };
+            return deleteFail(`MutationGuard rejected: ${guardResult.reason}`);
+        }
+        let existed = false;
+        try {
+            const existsRows = execRows(ctx.db, `SELECT 1 as found FROM memory_entries WHERE key = ? AND namespace = ? AND status = 'active' LIMIT 1`, [key, namespace]);
+            existed = existsRows.length > 0;
+        }
+        catch (err) {
+            return deleteFail(`DB read failed during delete pre-check: ${errorDetail(err)}`);
+        }
+        if (!existed) {
+            return deleteFail(`Key '${key}' not found in namespace '${namespace}'`);
         }
         let changes = 0;
         try {
@@ -454,28 +470,30 @@ export async function bridgeDeleteEntry(options) {
             // db.getRowsModified() to read the row count from the last statement.
             changes = ctx.db.getRowsModified?.() ?? 0;
         }
-        catch {
-            return null;
+        catch (err) {
+            return deleteFail(`DELETE failed: ${errorDetail(err)}`);
         }
-        if (changes > 0)
-            persistBridgeDb(ctx.db, options.dbPath);
-        await cacheInvalidate(registry, makeEntryCacheKey(namespace, key));
-        if (changes > 0) {
-            await logAttestation(registry, 'delete', key, { namespace });
+        if (changes === 0) {
+            // SELECT found the row but DELETE removed nothing. Most likely cause:
+            // bridge holds an in-memory snapshot that diverged from disk
+            // (sql.js writeback semantics — see feedback_sqljs_writeback_clobber.md).
+            return deleteFail(`Internal inconsistency: row matched SELECT but DELETE removed 0 rows (key='${key}', namespace='${namespace}'). Possible bridge cache staleness — restart the daemon and retry.`);
         }
+        persistBridgeDb(ctx.db, options.dbPath);
+        await cacheInvalidate(registry, makeEntryCacheKey(namespace, key));
+        await logAttestation(registry, 'delete', key, { namespace });
         let remaining = 0;
         try {
-            const result = ctx.db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
-            remaining = result[0]?.values?.[0]?.[0] ?? 0;
+            const countRows = execRows(ctx.db, `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+            remaining = Number(countRows[0]?.cnt ?? 0);
         }
         catch {
-            // Non-fatal
+            // Non-fatal — count is informational
         }
-        if (changes > 0)
-            refreshVectorStatsCache();
+        refreshVectorStatsCache();
         return {
             success: true,
-            deleted: changes > 0,
+            deleted: true,
             key,
             namespace,
             remainingEntries: remaining,

package/dist/src/cli/memory/controllers/semantic-router.js

@@ -27,43 +27,49 @@ const DEFAULT_INTENTS = [
         name: 'memory',
         category: 'storage',
         keywords: ['memory', 'store', 'retrieve', 'search', 'embedding', 'vector', 'recall', 'persist'],
-        agents: ['memory-specialist', 'swarm-memory-manager'],
+        agents: ['researcher', 'coder'],
+    },
+    {
+        name: 'frontend',
+        category: 'development',
+        keywords: ['frontend', 'ui', 'component', 'react', 'vue', 'svelte', 'css', 'tailwind', 'style', 'layout', 'accessibility', 'responsive'],
+        agents: ['frontend-dev', 'reviewer'],
+    },
+    {
+        name: 'database',
+        category: 'development',
+        keywords: ['database', 'sql', 'query', 'schema', 'migration', 'orm', 'index', 'postgres', 'mysql', 'sqlite', 'transaction'],
+        agents: ['database-dev', 'reviewer'],
     },
     {
         name: 'spell',
         category: 'workflow',
         keywords: ['spell', 'workflow', 'orchestrate', 'cast', 'pipeline', 'step'],
-        agents: ['planner', 'sparc-orchestrator'],
+        agents: ['planner'],
     },
     {
         name: 'hooks',
         category: 'automation',
         keywords: ['hook', 'pre-task', 'post-task', 'event', 'trigger', 'automation'],
-        agents: ['cicd-engineer', 'workflow-automation'],
+        agents: ['cicd-engineer', 'coder'],
     },
     {
         name: 'security',
         category: 'security',
         keywords: ['security', 'vulnerability', 'cve', 'audit', 'threat', 'permission', 'auth'],
-        agents: ['security-auditor', 'security-architect'],
-    },
-    {
-        name: 'neural',
-        category: 'ml',
-        keywords: ['neural', 'train', 'model', 'learning', 'reinforcement', 'sona', 'reasoningbank'],
-        agents: ['ml-developer', 'safla-neural'],
+        agents: ['security-auditor', 'reviewer'],
     },
     {
         name: 'test',
         category: 'quality',
         keywords: ['test', 'vitest', 'unit', 'integration', 'tdd', 'coverage', 'assertion'],
-        agents: ['tester', 'tdd-london-swarm'],
+        agents: ['tester'],
     },
     {
         name: 'github',
         category: 'integration',
         keywords: ['github', 'pr', 'pull request', 'issue', 'release', 'commit', 'branch'],
-        agents: ['pr-manager', 'github-modes', 'release-manager'],
+        agents: ['coder', 'reviewer'],
     },
 ];
 export class SemanticRouter {

package/dist/src/cli/memory/sona-optimizer.js

@@ -38,8 +38,8 @@ const AGENT_TYPES = [
     'optimizer',
     'debugger',
     'documenter',
-    'security-architect',
-    'performance-engineer',
+    'security-auditor',
+    'planner',
 ];
 /**
  * Task keywords for pattern extraction
@@ -77,13 +77,13 @@ const KEYWORD_CATEGORIES = {
         'document', 'docs', 'readme', 'comment', 'explain', 'guide',
         'tutorial', 'api-docs', 'specification', 'jsdoc',
     ],
-    'security-architect': [
+    'security-auditor': [
         'security', 'auth', 'authentication', 'authorization', 'encrypt',
         'vulnerability', 'cve', 'secure', 'permission', 'role',
     ],
-    'performance-engineer': [
-        'profiling', 'bottleneck', 'latency', 'throughput', 'cache',
-        'scale', 'load', 'stress', 'concurrent', 'parallel',
+    planner: [
+        'plan', 'breakdown', 'sequencing', 'estimate', 'milestone', 'roadmap',
+        'task', 'dependency', 'goal',
     ],
 };
 // ============================================================================

package/dist/src/cli/neural/domain/services/learning-service.js

@@ -118,9 +118,9 @@ export class LearningDomainService {
             review: 'reviewer',
             plan: 'planner',
             research: 'researcher',
-            security: 'security-architect',
-            performance: 'performance-engineer',
-            memory: 'memory-specialist',
+            security: 'security-auditor',
+            performance: 'reviewer',
+            memory: 'researcher',
         };
         for (const [keyword, role] of Object.entries(keywordMap)) {
             if (taskLower.includes(keyword)) {

package/dist/src/cli/services/agent-router.js

@@ -19,9 +19,7 @@ export const AGENT_CAPABILITIES = {
     'backend-dev': ['api', 'database', 'server', 'authentication'],
     'frontend-dev': ['ui', 'react', 'css', 'components'],
     devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],
-    'security-architect': ['security-design', 'threat-modeling', 'auth-flow'],
-    'security-auditor': ['vulnerability-scan', 'dependency-audit', 'compliance'],
-    'memory-specialist': ['memory-management', 'caching', 'persistence'],
+    'security-auditor': ['security-design', 'threat-modeling', 'auth-flow', 'vulnerability-scan', 'dependency-audit', 'compliance'],
     coordinator: ['task-distribution', 'orchestration', 'scheduling'],
     analyst: ['data-analysis', 'metrics', 'reporting', 'monitoring'],
     optimizer: ['performance', 'profiling', 'optimization', 'benchmarking'],
@@ -41,8 +39,7 @@ const TASK_PATTERNS = [
     { regex: /ui|frontend|component|react|css|style/i, agentType: 'frontend-dev' },
     { regex: /deploy|docker|ci|cd|pipeline|infrastructure/i, agentType: 'devops' },
     // Specialized patterns
-    { regex: /security|auth|permission|rbac|oauth/i, agentType: 'security-architect' },
-    { regex: /vulnerability|cve|dependency.*update|npm audit/i, agentType: 'security-auditor' },
+    { regex: /security|auth|permission|rbac|oauth|vulnerability|cve|dependency.*update|npm audit/i, agentType: 'security-auditor' },
     { regex: /performance|optimize|profile|benchmark|speed/i, agentType: 'optimizer' },
     { regex: /analyz|metric|report|monitor|dashboard/i, agentType: 'analyst' },
 ];

package/dist/src/cli/services/daemon-autostart-lifecycle.js

@@ -0,0 +1,62 @@
+/**
+ * Daemon Autostart Lifecycle
+ *
+ * Reconciles the OS-native daemon login service against the count of enabled
+ * scheduled spells. Replaces the old prompt-based flow in `daemon-readiness.ts`
+ * (which left users with stale autostart entries when their last schedule was
+ * cancelled — see #960, #961).
+ *
+ * Idempotent: callers invoke `reconcileDaemonAutostart` after every mutation
+ * to `scheduled-spells`. It installs once, uninstalls once, and is a no-op
+ * for every other transition.
+ */
+import { isDaemonInstalled as defaultIsDaemonInstalled, installDaemonService as defaultInstallDaemonService, uninstallDaemonService as defaultUninstallDaemonService, } from './daemon-service.js';
+const NOOP = { transition: 'noop', message: null, warning: null };
+/**
+ * Reconcile OS-native daemon autostart against schedule count.
+ *
+ * - count ≥ 1 + not installed → install
+ * - count = 0 + installed     → uninstall
+ * - all other states          → noop
+ *
+ * Never throws. Install/uninstall failures are returned as non-fatal warnings
+ * — the caller decides whether to print them. The schedule mutation itself is
+ * always considered the primary operation; autostart is best-effort.
+ */
+export function reconcileDaemonAutostart(options) {
+    if (options.skip)
+        return NOOP;
+    const isInstalled = (options.isDaemonInstalled ?? defaultIsDaemonInstalled)(options.projectRoot);
+    if (options.enabledScheduleCount >= 1 && !isInstalled) {
+        const result = (options.installDaemonService ?? defaultInstallDaemonService)(options.projectRoot);
+        if (result.success) {
+            return {
+                transition: 'installed',
+                message: 'Daemon registered as OS login service so this schedule survives reboot.',
+                warning: null,
+            };
+        }
+        return {
+            transition: 'noop',
+            message: null,
+            warning: `Could not register daemon as OS login service: ${result.message}`,
+        };
+    }
+    if (options.enabledScheduleCount === 0 && isInstalled) {
+        const result = (options.uninstallDaemonService ?? defaultUninstallDaemonService)(options.projectRoot);
+        if (result.success) {
+            return {
+                transition: 'uninstalled',
+                message: 'No enabled schedules remain — daemon unregistered from OS login services.',
+                warning: null,
+            };
+        }
+        return {
+            transition: 'noop',
+            message: null,
+            warning: `Could not unregister daemon from OS login services: ${result.message}`,
+        };
+    }
+    return NOOP;
+}
+//# sourceMappingURL=daemon-autostart-lifecycle.js.map