@soleri/core 9.3.1 → 9.5.0

package/src/brain/intelligence.ts

@@ -38,7 +38,6 @@ const SPREAD_MAX = 5;
 const RECENCY_DECAY_DAYS = 30;
 const EXTRACTION_TOOL_THRESHOLD = 3;
 const EXTRACTION_FILE_THRESHOLD = 3;
-const EXTRACTION_LONG_SESSION_MINUTES = 30;
 const EXTRACTION_HIGH_FEEDBACK_RATIO = 0.8;
 const AUTO_PROMOTE_THRESHOLD = 0.8;
 const AUTO_PROMOTE_PENDING_MIN = 0.4;
@@ -500,7 +499,7 @@ export class BrainIntelligence {
   // ─── Strength Scoring ─────────────────────────────────────────────
 
   computeStrengths(): PatternStrength[] {
-    // Gather feedback data grouped by entry_id
+    // Gather feedback data grouped by entry_id, JOIN with entries to avoid N+1 vault.get() calls
     const feedbackRows = this.provider.all<{
       entry_id: string;
       total: number;
@@ -509,16 +508,21 @@ export class BrainIntelligence {
       modified: number;
       failed: number;
       last_used: string;
+      entry_title: string | null;
+      entry_domain: string | null;
     }>(
-      `SELECT entry_id,
+      `SELECT bf.entry_id,
               COUNT(*) as total,
-              SUM(CASE WHEN action = 'accepted' THEN 1 ELSE 0 END) as accepted,
-              SUM(CASE WHEN action = 'dismissed' THEN 1 ELSE 0 END) as dismissed,
-              SUM(CASE WHEN action = 'modified' THEN 1 ELSE 0 END) as modified,
-              SUM(CASE WHEN action = 'failed' THEN 1 ELSE 0 END) as failed,
-              MAX(created_at) as last_used
-       FROM brain_feedback
-       GROUP BY entry_id`,
+              SUM(CASE WHEN bf.action = 'accepted' THEN 1 ELSE 0 END) as accepted,
+              SUM(CASE WHEN bf.action = 'dismissed' THEN 1 ELSE 0 END) as dismissed,
+              SUM(CASE WHEN bf.action = 'modified' THEN 1 ELSE 0 END) as modified,
+              SUM(CASE WHEN bf.action = 'failed' THEN 1 ELSE 0 END) as failed,
+              MAX(bf.created_at) as last_used,
+              e.title as entry_title,
+              e.domain as entry_domain
+       FROM brain_feedback bf
+       LEFT JOIN entries e ON e.id = bf.entry_id
+       GROUP BY bf.entry_id`,
     );
 
     // Count unique session domains as spread proxy
@@ -531,10 +535,9 @@ export class BrainIntelligence {
     const strengths: PatternStrength[] = [];
 
     for (const row of feedbackRows) {
-      // Look up vault entry for domain info
-      const entry = this.vault.get(row.entry_id);
-      const domain = entry?.domain ?? 'unknown';
-      const pattern = entry?.title ?? row.entry_id;
+      // Use JOINed entry data — no per-row vault.get() needed
+      const domain = row.entry_domain ?? 'unknown';
+      const pattern = row.entry_title ?? row.entry_id;
 
       // Usage score: min(25, (count / USAGE_MAX) * 25)
       const usageScore = Math.min(25, (row.total / USAGE_MAX) * 25);
@@ -572,29 +575,33 @@ export class BrainIntelligence {
       };
 
       strengths.push(ps);
-
-      // Persist
-      this.provider.run(
-        `INSERT OR REPLACE INTO brain_strengths
-         (pattern, domain, strength, usage_score, spread_score, success_score, recency_score,
-          usage_count, unique_contexts, success_rate, last_used, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`,
-        [
-          ps.pattern,
-          ps.domain,
-          ps.strength,
-          ps.usageScore,
-          ps.spreadScore,
-          ps.successScore,
-          ps.recencyScore,
-          ps.usageCount,
-          ps.uniqueContexts,
-          ps.successRate,
-          ps.lastUsed,
-        ],
-      );
     }
 
+    // Persist all strengths in a single transaction to avoid N fsync calls
+    this.provider.transaction(() => {
+      for (const ps of strengths) {
+        this.provider.run(
+          `INSERT OR REPLACE INTO brain_strengths
+           (pattern, domain, strength, usage_score, spread_score, success_score, recency_score,
+            usage_count, unique_contexts, success_rate, last_used, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`,
+          [
+            ps.pattern,
+            ps.domain,
+            ps.strength,
+            ps.usageScore,
+            ps.spreadScore,
+            ps.successScore,
+            ps.recencyScore,
+            ps.usageCount,
+            ps.uniqueContexts,
+            ps.successRate,
+            ps.lastUsed,
+          ],
+        );
+      }
+    });
+
     return strengths;
   }
 
@@ -739,10 +746,18 @@ export class BrainIntelligence {
     for (const [tool, count] of toolCounts) {
       if (count >= EXTRACTION_TOOL_THRESHOLD) {
         rulesApplied.push('repeated_tool_usage');
+        const ctx = session.context ?? '';
+        const objective = this.extractObjective(ctx);
+        const toolTitle = objective
+          ? `Tool pattern: ${tool} (${count}x) during ${objective.slice(0, 60)}`
+          : `Frequent use of ${tool} (${count}x)`;
+        const toolDescription = objective
+          ? `Tool ${tool} used ${count} times while working on: ${objective}. This tool-task pairing may indicate a reusable workflow.`
+          : `Tool ${tool} was used ${count} times in session. Consider automating or abstracting this workflow.`;
         proposals.push(
           this.createProposal(sessionId, 'repeated_tool_usage', 'pattern', {
-            title: `Frequent use of ${tool}`,
-            description: `Tool ${tool} was used ${count} times in session. Consider automating or abstracting this workflow.`,
+            title: toolTitle,
+            description: toolDescription,
             confidence: Math.min(0.9, 0.5 + count * 0.1),
           }),
         );
@@ -766,57 +781,107 @@ export class BrainIntelligence {
       if (significantDirs.length > 0) {
         const [topDir, topFiles] = significantDirs.sort((a, b) => b[1].length - a[1].length)[0];
         rulesApplied.push('multi_file_edit');
+        const ctx = session.context ?? '';
+        const objective = this.extractObjective(ctx);
+        const isRefactor = /refactor|rename|move|extract|consolidat/i.test(ctx);
+        const isFeature = /feat|add|implement|create|new/i.test(ctx);
+        const inferredPattern = isRefactor
+          ? 'Refactoring'
+          : isFeature
+            ? 'Feature'
+            : 'Cross-cutting change';
+        const mfeTitle = objective
+          ? `${inferredPattern}: ${objective.slice(0, 70)}`
+          : `${inferredPattern} in ${topDir} (${topFiles.length} files)`;
+        const mfeDescription = objective
+          ? `${inferredPattern} across ${topFiles.length} files in ${topDir}: ${objective}`
+          : `Session modified ${topFiles.length} files in ${topDir}: ${topFiles.slice(0, 5).join(', ')}${topFiles.length > 5 ? '...' : ''}.`;
         proposals.push(
           this.createProposal(sessionId, 'multi_file_edit', 'pattern', {
-            title: `Multi-file change pattern in ${topDir} (${topFiles.length} files)`,
-            description: `Session modified ${topFiles.length} files in ${topDir}: ${topFiles.slice(0, 5).join(', ')}${topFiles.length > 5 ? '...' : ''}. This may indicate an architectural pattern.`,
+            title: mfeTitle,
+            description: mfeDescription,
             confidence: Math.min(0.8, 0.4 + topFiles.length * 0.05),
           }),
         );
       }
     }
 
-    // Rule 3: Long session (>30min) — neutral observation, not anti-pattern
-    if (session.endedAt && session.startedAt) {
-      const durationMs =
-        new Date(session.endedAt).getTime() - new Date(session.startedAt).getTime();
-      const durationMin = durationMs / 60000;
-      if (durationMin > EXTRACTION_LONG_SESSION_MINUTES) {
-        rulesApplied.push('long_session');
-        proposals.push(
-          this.createProposal(sessionId, 'long_session', 'pattern', {
-            title: `Long session (${Math.round(durationMin)} minutes)`,
-            description: `Session lasted ${Math.round(durationMin)} minutes. Deep work session — review if this duration was productive or indicates a need for better tooling.`,
-            confidence: 0.3,
-          }),
-        );
-      }
-    }
-
-    // Rule 4: Plan completed — moderate confidence to avoid auto-promoting generic entries
+    // Rule 3: Plan completed — parse session.context for actionable title + dynamic confidence
     if (session.planId && session.planOutcome === 'completed') {
       rulesApplied.push('plan_completed');
+      const ctx = session.context ?? '';
+      const objective = this.extractObjective(ctx);
+      const hasScope = /scope|included|excluded/i.test(ctx);
+      const hasCriteria = /criteria|acceptance|verification/i.test(ctx);
+      const confidence =
+        ctx.length > 0
+          ? hasScope && hasCriteria
+            ? 0.85
+            : hasScope || hasCriteria
+              ? 0.8
+              : 0.75
+          : 0.5;
+      const title = objective
+        ? `Workflow: ${objective.slice(0, 80)}`
+        : `Successful plan: ${session.planId}`;
+      const description = objective
+        ? `Completed: ${objective}${hasScope ? '. Scope and constraints documented in session context.' : ''}`
+        : `Plan ${session.planId} completed successfully. This workflow can be reused for similar tasks.`;
       proposals.push(
         this.createProposal(sessionId, 'plan_completed', 'workflow', {
-          title: `Successful plan: ${session.planId}`,
-          description: `Plan ${session.planId} completed successfully. This workflow can be reused for similar tasks.`,
-          confidence: 0.65,
+          title,
+          description,
+          confidence,
         }),
       );
     }
 
-    // Rule 5: Plan abandoned
+    // Rule 4: Plan abandoned — parse context for failure reason
     if (session.planId && session.planOutcome === 'abandoned') {
       rulesApplied.push('plan_abandoned');
+      const ctx = session.context ?? '';
+      const objective = this.extractObjective(ctx);
+      const hasFailureReason = /blocked|failed|wrong|mistake|abandoned|reverted|conflict/i.test(
+        ctx,
+      );
+      const confidence = ctx.length > 0 ? (hasFailureReason ? 0.85 : 0.75) : 0.5;
+      const title = objective
+        ? `Anti-pattern: ${objective.slice(0, 80)}`
+        : `Abandoned plan: ${session.planId}`;
+      const description = objective
+        ? `Abandoned: ${objective}${hasFailureReason ? '. Failure indicators found in session context — review for root cause.' : '. Review what went wrong to avoid repeating.'}`
+        : `Plan ${session.planId} was abandoned. Review what went wrong to avoid repeating in future sessions.`;
       proposals.push(
         this.createProposal(sessionId, 'plan_abandoned', 'anti-pattern', {
-          title: `Abandoned plan: ${session.planId}`,
-          description: `Plan ${session.planId} was abandoned. Review what went wrong to avoid repeating in future sessions.`,
-          confidence: 0.7,
+          title,
+          description,
+          confidence,
         }),
       );
     }
 
+    // Rule 5: Drift detected — fires when plan completed but context contains drift indicators
+    if (session.planId && session.planOutcome === 'completed' && session.context) {
+      const driftPattern =
+        /drift|skipped|added.*unplanned|changed scope|out of scope|deviat|unplanned/i;
+      if (driftPattern.test(session.context)) {
+        rulesApplied.push('drift_detected');
+        const objective = this.extractObjective(session.context);
+        const driftMatch =
+          session.context.match(/drift[:\s]+(.{1,120})/i) ??
+          session.context.match(/skipped[:\s]+(.{1,120})/i) ??
+          session.context.match(/unplanned[:\s]+(.{1,120})/i);
+        const driftDetail = driftMatch ? driftMatch[1].trim() : 'scope changed during execution';
+        proposals.push(
+          this.createProposal(sessionId, 'drift_detected', 'anti-pattern', {
+            title: `Plan drift: ${objective ? objective.slice(0, 60) : session.planId} — ${driftDetail.slice(0, 40)}`,
+            description: `Plan ${objective ?? session.planId} completed with drift: ${driftDetail}. Review scope controls for future planning.`,
+            confidence: 0.8,
+          }),
+        );
+      }
+    }
+
     // Rule 6: High feedback ratio (>80% accept or dismiss)
     const feedbackRow = this.provider.get<{
       total: number;
@@ -1369,12 +1434,58 @@ export class BrainIntelligence {
     };
   }
 
+  /**
+   * Extract the objective from session context — first meaningful sentence or line.
+   * Returns empty string if context is empty or unparseable.
+   */
+  private extractObjective(context: string): string {
+    if (!context || context.trim().length === 0) return '';
+    // Try to find an "Objective:" line
+    const objMatch = context.match(/objective[:\s]+(.+)/i);
+    if (objMatch) return objMatch[1].trim().replace(/\s+/g, ' ');
+    // Fall back to first non-empty line
+    const firstLine = context
+      .split('\n')
+      .map((l) => l.trim())
+      .find((l) => l.length > 0);
+    return firstLine ? firstLine.replace(/\s+/g, ' ') : '';
+  }
+
   private createProposal(
     sessionId: string,
     rule: string,
     type: 'pattern' | 'anti-pattern' | 'workflow',
     data: { title: string; description: string; confidence: number },
   ): KnowledgeProposal {
+    // Dedup guard: skip if a proposal with the same rule + sessionId already exists
+    const existing = this.provider.get<{
+      id: string;
+      session_id: string;
+      rule: string;
+      type: string;
+      title: string;
+      description: string;
+      confidence: number;
+      promoted: number;
+      created_at: string;
+    }>('SELECT * FROM brain_proposals WHERE session_id = ? AND rule = ? LIMIT 1', [
+      sessionId,
+      rule,
+    ]);
+    if (existing) {
+      return {
+        id: existing.id,
+        sessionId: existing.session_id,
+        rule: existing.rule,
+        type: existing.type as 'pattern' | 'anti-pattern' | 'workflow',
+        title: existing.title,
+        description: existing.description,
+        confidence: existing.confidence,
+        promoted: existing.promoted === 1,
+        createdAt: existing.created_at,
+      };
+    }
+
     const id = randomUUID();
     this.provider.run(
       `INSERT INTO brain_proposals (id, session_id, rule, type, title, description, confidence)

package/src/brain/learning-radar.ts

@@ -229,14 +229,17 @@ export class LearningRadar {
   }
 
   /**
-   * Dismiss a pending candidate — mark it as not worth capturing.
+   * Dismiss one or more pending candidates — mark them as not worth capturing.
    */
-  dismiss(candidateId: number): { dismissed: boolean } {
+  dismiss(candidateIds: number | number[]): { dismissed: number } {
+    const ids = Array.isArray(candidateIds) ? candidateIds : [candidateIds];
+    if (ids.length === 0) return { dismissed: 0 };
+    const placeholders = ids.map(() => '?').join(',');
     const result = this.provider.run(
-      "UPDATE radar_candidates SET status = 'dismissed' WHERE id = ? AND status = 'pending'",
-      [candidateId],
+      `UPDATE radar_candidates SET status = 'dismissed' WHERE id IN (${placeholders}) AND status = 'pending'`,
+      ids,
     );
-    return { dismissed: result.changes > 0 };
+    return { dismissed: result.changes };
   }
 
   /**

package/src/brain/second-brain-features.test.ts

@@ -335,7 +335,7 @@ describe('Ambient learning radar (#208)', () => {
     const pending = candidates.find((c) => c.title.includes('stale cache'));
     expect(pending).toBeDefined();
     const result = learningRadar.dismiss(pending!.id);
-    expect(result.dismissed).toBe(true);
+    expect(result.dismissed).toBe(1);
   });
 
   it('getStats returns radar statistics', () => {

package/src/chat/agent-loop.ts

@@ -292,7 +292,7 @@ async function callAnthropic(params: AnthropicCallParams): Promise<AnthropicResp
       'anthropic-version': API_VERSION,
     },
     body: JSON.stringify(body),
-    signal: params.signal,
+    signal: params.signal ?? AbortSignal.timeout(120_000),
   });
 
   if (!response.ok) {

package/src/chat/notifications.ts

@@ -88,6 +88,10 @@ export class NotificationEngine {
     setTimeout(() => this.poll(), 10_000);
 
     this.timer = setInterval(() => this.poll(), this.intervalMs);
+    // Don't prevent process exit for background notification polling
+    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+      (this.timer as NodeJS.Timeout).unref();
+    }
   }
 
   /**

package/src/control/intent-router.test.ts

@@ -35,7 +35,7 @@ describe('IntentRouter', () => {
   describe('construction', () => {
     it('seeds 10 default modes on first creation', () => {
       const modes = router.getModes();
-      expect(modes.length).toBe(10);
+      expect(modes.length).toBe(11);
     });
 
     it('starts in GENERAL-MODE', () => {
@@ -44,7 +44,7 @@ describe('IntentRouter', () => {
 
     it('is idempotent — second instance does not duplicate modes', () => {
       const router2 = new IntentRouter(vault);
-      expect(router2.getModes().length).toBe(10);
+      expect(router2.getModes().length).toBe(11);
     });
   });
 
@@ -199,7 +199,7 @@ describe('IntentRouter', () => {
     it('adds a new mode to the database', () => {
       router.registerMode(customMode);
       const modes = router.getModes();
-      expect(modes.length).toBe(11);
+      expect(modes.length).toBe(12);
       const found = modes.find((m) => m.mode === 'CUSTOM-MODE');
       expect(found).toBeDefined();
       expect(found!.keywords).toEqual(['custom', 'special']);
@@ -338,6 +338,76 @@ describe('IntentRouter', () => {
     });
   });
 
+  // ─── YOLO-MODE ───────────────────────────────────────────────
+
+  describe('YOLO-MODE', () => {
+    it('route_intent with "yolo" returns YOLO-MODE', () => {
+      const result = router.routeIntent('go yolo on this task');
+      expect(result.intent).toBe('yolo');
+      expect(result.mode).toBe('YOLO-MODE');
+      expect(result.matchedKeywords).toContain('yolo');
+    });
+
+    it('morph to YOLO-MODE succeeds when hook pack is installed', () => {
+      const result = router.morph('YOLO-MODE', { hookPackInstalled: true });
+      expect(result.previousMode).toBe('GENERAL-MODE');
+      expect(result.currentMode).toBe('YOLO-MODE');
+      expect(result.behaviorRules.length).toBe(5);
+      expect(result.blocked).toBeUndefined();
+      expect(result.error).toBeUndefined();
+    });
+
+    it('morph to YOLO-MODE fails when hook pack is missing', () => {
+      const result = router.morph('YOLO-MODE');
+      expect(result.blocked).toBe(true);
+      expect(result.error).toContain('yolo-safety hook pack');
+      expect(result.error).toContain('soleri hooks add-pack yolo-safety');
+      expect(result.currentMode).toBe('GENERAL-MODE'); // unchanged
+      expect(router.getCurrentMode()).toBe('GENERAL-MODE'); // not switched
+    });
+
+    it('morph to YOLO-MODE fails when hookPackInstalled is explicitly false', () => {
+      const result = router.morph('YOLO-MODE', { hookPackInstalled: false });
+      expect(result.blocked).toBe(true);
+      expect(result.error).toContain('yolo-safety hook pack');
+      expect(router.getCurrentMode()).toBe('GENERAL-MODE');
+    });
+
+    it('morph to other modes is unaffected by the gate', () => {
+      const result = router.morph('BUILD-MODE');
+      expect(result.currentMode).toBe('BUILD-MODE');
+      expect(result.blocked).toBeUndefined();
+      expect(result.error).toBeUndefined();
+      expect(router.getCurrentMode()).toBe('BUILD-MODE');
+    });
+
+    it('get_behavior_rules returns 5 rules', () => {
+      const rules = router.getBehaviorRules('YOLO-MODE');
+      expect(rules).toHaveLength(5);
+      expect(rules[0]).toContain('Skip plan approval gates');
+      expect(rules[1]).toContain('orchestrate_complete');
+      expect(rules[2]).toContain('vault gather-before-execute');
+      expect(rules[3]).toContain('Hook pack must be installed');
+      expect(rules[4]).toContain('exit YOLO');
+    });
+
+    it('all keywords route to YOLO-MODE', () => {
+      const keywords = [
+        'yolo',
+        'autonomous',
+        'fire-and-forget',
+        'hands-off',
+        'no-approval',
+        'skip-gates',
+        'full-auto',
+      ];
+      for (const kw of keywords) {
+        const result = router.routeIntent(kw);
+        expect(result.mode).toBe('YOLO-MODE');
+      }
+    });
+  });
+
   // ─── getModes ─────────────────────────────────────────────────
 
   describe('getModes', () => {

package/src/control/intent-router.ts

@@ -15,6 +15,7 @@ import type {
   OperationalMode,
   IntentClassification,
   ModeConfig,
+  MorphOptions,
   MorphResult,
   RoutingAccuracyReport,
 } from './types.js';
@@ -132,6 +133,27 @@ const DEFAULT_MODES: ModeConfig[] = [
     behaviorRules: ['Be helpful', 'Ask clarifying questions when needed'],
     keywords: [],
   },
+  {
+    mode: 'YOLO-MODE',
+    intent: 'yolo',
+    description: 'Autonomous execution — skip approval gates, execute directly',
+    behaviorRules: [
+      'Skip plan approval gates — execute tasks directly',
+      'Still run orchestrate_complete — knowledge capture is non-negotiable',
+      'Still run vault gather-before-execute — decisions must be informed',
+      'Hook pack must be installed — refuse to activate without yolo-safety hooks',
+      'User can exit with "exit YOLO" or session end',
+    ],
+    keywords: [
+      'yolo',
+      'autonomous',
+      'fire-and-forget',
+      'hands-off',
+      'no-approval',
+      'skip-gates',
+      'full-auto',
+    ],
+  },
 ];
 
 // ─── Class ──────────────────────────────────────────────────────────
@@ -140,6 +162,7 @@ export class IntentRouter {
   private vault: Vault;
   private provider: PersistenceProvider;
   private currentMode: OperationalMode = 'GENERAL-MODE';
+  private modesCache: ModeConfig[] | null = null;
 
   constructor(vault: Vault) {
     this.vault = vault;
@@ -267,7 +290,7 @@ export class IntentRouter {
 
   // ─── Mode Management ───────────────────────────────────────────────
 
-  morph(mode: OperationalMode): MorphResult {
+  morph(mode: OperationalMode, options?: MorphOptions): MorphResult {
     // Handle "reset" as a built-in alias for GENERAL-MODE
     const resolvedMode: OperationalMode = (mode as string) === 'reset' ? 'GENERAL-MODE' : mode;
 
@@ -283,8 +306,24 @@ export class IntentRouter {
       throw new Error(`Unknown mode: ${mode}. Available: ${available}`);
     }
 
+    // ─── YOLO-MODE activation gate ────────────────────────────────
+    // YOLO-MODE requires the yolo-safety hook pack to be installed.
+    // The CLI/facade layer provides hookPackInstalled based on filesystem check.
+    if (resolvedMode === 'YOLO-MODE' && !options?.hookPackInstalled) {
+      return {
+        previousMode: this.currentMode,
+        currentMode: this.currentMode, // unchanged — mode switch blocked
+        behaviorRules: this.getBehaviorRules(),
+        blocked: true,
+        error:
+          'YOLO-MODE requires the yolo-safety hook pack. ' +
+          'Install it with: soleri hooks add-pack yolo-safety',
+      };
+    }
+
     const previousMode = this.currentMode;
     this.currentMode = resolvedMode;
+    this.modesCache = null; // Invalidate cache on mode change
     const behaviorRules = JSON.parse(row.behavior_rules) as string[];
 
     return { previousMode, currentMode: resolvedMode, behaviorRules };
@@ -296,18 +335,16 @@ export class IntentRouter {
 
   getBehaviorRules(mode?: OperationalMode): string[] {
     const target = mode ?? this.currentMode;
-    const row = this.provider.get<{ behavior_rules: string }>(
-      'SELECT behavior_rules FROM agent_modes WHERE mode = ?',
-      [target],
-    );
-
-    if (!row) return [];
-    return JSON.parse(row.behavior_rules) as string[];
+    const modes = this.getModes();
+    const found = modes.find((m) => m.mode === target);
+    return found ? found.behaviorRules : [];
   }
 
   getModes(): ModeConfig[] {
+    if (this.modesCache) return this.modesCache;
     const rows = this.provider.all<ModeRow>('SELECT * FROM agent_modes ORDER BY mode');
-    return rows.map(rowToModeConfig);
+    this.modesCache = rows.map(rowToModeConfig);
+    return this.modesCache;
   }
 
   registerMode(config: ModeConfig): void {
@@ -322,6 +359,7 @@ export class IntentRouter {
         JSON.stringify(config.keywords),
       ],
     );
+    this.modesCache = null;
   }
 
   updateModeRules(mode: OperationalMode, rules: string[]): void {
@@ -332,6 +370,7 @@ export class IntentRouter {
     if (result.changes === 0) {
       throw new Error(`Unknown mode: ${mode}`);
     }
+    this.modesCache = null;
   }
 
   // ─── Routing Feedback ─────────────────────────────────────────────

package/src/control/types.ts

@@ -65,7 +65,8 @@ export type IntentType =
   | 'explore'
   | 'plan'
   | 'review'
-  | 'general';
+  | 'general'
+  | 'yolo';
 
 export type OperationalMode =
   | 'BUILD-MODE'
@@ -77,7 +78,8 @@ export type OperationalMode =
   | 'EXPLORE-MODE'
   | 'PLAN-MODE'
   | 'REVIEW-MODE'
-  | 'GENERAL-MODE';
+  | 'GENERAL-MODE'
+  | 'YOLO-MODE';
 
 export interface IntentClassification {
   intent: IntentType;
@@ -95,10 +97,19 @@ export interface ModeConfig {
   keywords: string[];
 }
 
+export interface MorphOptions {
+  /** Whether the yolo-safety hook pack is installed. Required for YOLO-MODE activation. */
+  hookPackInstalled?: boolean;
+}
+
 export interface MorphResult {
   previousMode: OperationalMode;
   currentMode: OperationalMode;
   behaviorRules: string[];
+  /** Present when activation is refused (e.g. missing hook pack). */
+  error?: string;
+  /** When true, the mode switch was blocked. */
+  blocked?: boolean;
 }
 
 export interface RoutingAccuracyReport {