@soleri/core 9.14.0 → 9.15.0

package/src/planning/planner.test.ts

@@ -74,6 +74,26 @@ describe('Planner', () => {
       const planner2 = new Planner(join(tempDir, 'plans.json'));
       expect(planner2.list()).toHaveLength(1);
     });
+
+    it('should make newly created plans visible to other planner instances', () => {
+      const planner2 = new Planner(join(tempDir, 'plans.json'));
+      const plan = planner.create({ objective: 'Shared plan', scope: 'sync' });
+
+      expect(planner2.get(plan.id)?.objective).toBe('Shared plan');
+    });
+
+    it('should merge plans created by multiple planner instances', () => {
+      const planner2 = new Planner(join(tempDir, 'plans.json'));
+      const planA = planner.create({ objective: 'Plan A', scope: 'sync-a' });
+      const planB = planner2.create({ objective: 'Plan B', scope: 'sync-b' });
+
+      const reloaded = new Planner(join(tempDir, 'plans.json'));
+      const ids = reloaded.list().map((plan) => plan.id);
+
+      expect(ids).toContain(planA.id);
+      expect(ids).toContain(planB.id);
+      expect(ids).toHaveLength(2);
+    });
   });
 
   describe('get', () => {
@@ -120,26 +140,36 @@ describe('Planner', () => {
 
     it('should approve a plan with A+ grade', () => {
       const plan = planner.create({
-        objective: 'Well-graded plan',
-        scope: 'test',
+        objective: 'Implement a Redis caching layer for the API to reduce DB load by 50%',
+        scope: 'Backend API services only. Does not include frontend caching or CDN.',
         tasks: [
-          { title: 'Task 1', description: 'A well-described task for implementation' },
-          { title: 'Task 2', description: 'Another well-described task for testing' },
+          {
+            title: 'Set up Redis client',
+            description: 'Install and configure Redis connection pool',
+          },
+          {
+            title: 'Add cache middleware',
+            description: 'Express middleware for transparent caching',
+          },
+          {
+            title: 'Add invalidation logic',
+            description: 'Purge cache on write operations to ensure consistency',
+          },
+          {
+            title: 'Write integration tests',
+            description: 'Test cache hit/miss scenarios with Redis',
+          },
+          { title: 'Add monitoring', description: 'Track and verify cache hit rate metrics' },
         ],
-        decisions: ['Use TypeScript for type safety'],
-      });
-      // Grade the plan — set an A+ grade check
-      const p = planner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test-aplus',
-        planId: plan.id,
-        grade: 'A+',
-        score: 98,
-        gaps: [],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+        decisions: [
+          'Use Redis because it provides sub-millisecond latency and supports TTL natively',
+          'Set TTL to 5 minutes since average data freshness requirement is 10 minutes',
+        ],
+        alternatives: TWO_ALTERNATIVES,
+      });
+      const check = planner.grade(plan.id);
+      expect(check.score).toBeGreaterThanOrEqual(95);
+      expect(check.grade).toMatch(/^A/);
       const approved = planner.approve(plan.id);
       expect(approved.status).toBe('approved');
     });
@@ -149,27 +179,8 @@ describe('Planner', () => {
         objective: 'Bad plan',
         scope: 'test',
       });
-      // Manually set a B grade check on the plan
-      const p = planner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test',
-        planId: plan.id,
-        grade: 'B',
-        score: 82,
-        gaps: [
-          {
-            id: 'gap-1',
-            severity: 'major',
-            category: 'completeness',
-            description: 'Missing tasks',
-            recommendation: 'Add tasks',
-            location: 'tasks',
-          },
-        ],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+      const check = planner.grade(plan.id);
+      expect(check.score).toBeLessThan(90);
       expect(() => planner.approve(plan.id)).toThrow(PlanGradeRejectionError);
     });
 
@@ -184,68 +195,52 @@ describe('Planner', () => {
       const lenientPlanner = new Planner(join(tempDir, 'lenient-plans.json'), {
         minGradeForApproval: 'B',
       });
-      const plan = lenientPlanner.create({ objective: 'B-grade plan', scope: 'test' });
-      // Set a B grade check
-      const p = lenientPlanner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test-b',
-        planId: plan.id,
-        grade: 'B',
-        score: 82,
-        gaps: [],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
-      // B grade should pass with B threshold
+      const plan = lenientPlanner.create({
+        objective: 'B-grade plan with enough detail',
+        scope: 'Test scope with clear boundary',
+        decisions: ['Use TypeScript for compile-time safety'],
+        tasks: [
+          { title: 'Task 1', description: 'Implement the first part of the change' },
+          { title: 'Task 2', description: 'Validate the second part of the change' },
+        ],
+      });
+      const check = lenientPlanner.grade(plan.id);
+      expect(check.grade).toBe('B');
       const approved = lenientPlanner.approve(plan.id);
       expect(approved.status).toBe('approved');
     });
 
     it('should reject with PlanGradeRejectionError containing gap details', () => {
-      const plan = planner.create({ objective: 'Gap details', scope: 'test' });
-      const p = planner.get(plan.id)!;
-      const testGaps = [
-        {
-          id: 'gap-crit',
-          severity: 'critical' as const,
-          category: 'structure',
-          description: 'Missing critical structure',
-          recommendation: 'Fix structure',
-          location: 'tasks',
-        },
-        {
-          id: 'gap-maj',
-          severity: 'major' as const,
-          category: 'completeness',
-          description: 'Incomplete scope',
-          recommendation: 'Add scope details',
-          location: 'scope',
-        },
-      ];
-      p.latestCheck = {
-        checkId: 'chk-test-gaps',
-        planId: plan.id,
-        grade: 'C',
-        score: 65,
-        gaps: testGaps,
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+      const plan = planner.create({ objective: '', scope: '' });
+      const check = planner.grade(plan.id);
       try {
         planner.approve(plan.id);
         expect.unreachable('Should have thrown');
       } catch (err) {
         expect(err).toBeInstanceOf(PlanGradeRejectionError);
         const rejection = err as PlanGradeRejectionError;
-        expect(rejection.grade).toBe('C');
-        expect(rejection.score).toBe(65);
+        expect(rejection.grade).toBe(check.grade);
+        expect(rejection.score).toBe(check.score);
         expect(rejection.minGrade).toBe('A');
-        expect(rejection.gaps).toHaveLength(2);
+        expect(rejection.gaps).toEqual(check.gaps);
         expect(rejection.message).toContain('below the minimum required grade A');
       }
     });
+
+    it('should respect grading performed by another planner instance', () => {
+      const strictPlanner = new Planner(join(tempDir, 'shared-plans.json'), {
+        minGradeForApproval: 'A',
+      });
+      const gradingPlanner = new Planner(join(tempDir, 'shared-plans.json'), {
+        minGradeForApproval: 'A',
+      });
+      const plan = strictPlanner.create({ objective: '', scope: '' });
+
+      const check = gradingPlanner.grade(plan.id);
+
+      expect(check.grade).toBe('F');
+      expect(() => strictPlanner.approve(plan.id)).toThrow(PlanGradeRejectionError);
+    });
   });
 
   describe('startExecution', () => {
@@ -592,10 +587,11 @@ describe('Planner', () => {
           { title: 'Task C', description: 'Third task (not in cycle)' },
         ],
       });
-      // Manually create circular deps
-      const p = planner.get(plan.id)!;
-      p.tasks[0].dependsOn = ['task-2'];
-      p.tasks[1].dependsOn = ['task-1'];
+      planner.splitTasks(plan.id, [
+        { title: 'Task A', description: 'First task in the cycle', dependsOn: ['task-2'] },
+        { title: 'Task B', description: 'Second task in the cycle', dependsOn: ['task-1'] },
+        { title: 'Task C', description: 'Third task (not in cycle)' },
+      ]);
       const check = planner.grade(plan.id);
       const circGap = check.gaps.find((g) => g.description.includes('Circular'));
       expect(circGap).toBeDefined();

package/src/planning/planner.ts

@@ -77,8 +77,38 @@ export class Planner {
     }
   }
 
-  private save(): void {
+  private refresh(): void {
+    this.store = this.load();
+  }
+
+  private mergeLatestStore(deletedPlanIds: string[] = []): void {
+    const deleted = new Set(deletedPlanIds);
+    const latest = this.load();
+    const merged = new Map<string, Plan>();
+
+    for (const plan of latest.plans) {
+      if (!deleted.has(plan.id)) {
+        merged.set(plan.id, plan);
+      }
+    }
+
+    for (const plan of this.store.plans) {
+      if (deleted.has(plan.id)) continue;
+      const existing = merged.get(plan.id);
+      if (!existing || plan.updatedAt >= existing.updatedAt) {
+        merged.set(plan.id, plan);
+      }
+    }
+
+    this.store = {
+      version: latest.version ?? this.store.version ?? '1.0',
+      plans: [...merged.values()],
+    };
+  }
+
+  private save(deletedPlanIds: string[] = []): void {
     mkdirSync(dirname(this.filePath), { recursive: true });
+    this.mergeLatestStore(deletedPlanIds);
     writeFileSync(this.filePath, JSON.stringify(this.store, null, 2), 'utf-8');
   }
 
@@ -88,8 +118,13 @@ export class Planner {
     plan.updatedAt = r.updatedAt;
   }
 
+  private findPlan(planId: string): Plan | null {
+    return this.store.plans.find((p) => p.id === planId) ?? null;
+  }
+
   private requirePlan(planId: string): Plan {
-    const plan = this.get(planId);
+    this.refresh();
+    const plan = this.findPlan(planId);
     if (!plan) throw new Error(`Plan not found: ${planId}`);
     return plan;
   }
@@ -101,6 +136,7 @@ export class Planner {
   }
 
   create(params: Parameters<typeof createPlanObject>[0]): Plan {
+    this.refresh();
     const plan = createPlanObject(params);
     this.store.plans.push(plan);
     this.save();
@@ -108,18 +144,21 @@ export class Planner {
   }
 
   get(planId: string): Plan | null {
-    return this.store.plans.find((p) => p.id === planId) ?? null;
+    this.refresh();
+    return this.findPlan(planId);
   }
 
   list(): Plan[] {
+    this.refresh();
     return [...this.store.plans];
   }
 
   remove(planId: string): boolean {
+    this.refresh();
     const idx = this.store.plans.findIndex((p) => p.id === planId);
     if (idx < 0) return false;
     this.store.plans.splice(idx, 1);
-    this.save();
+    this.save([planId]);
     return true;
   }
 
@@ -220,10 +259,12 @@ export class Planner {
   }
 
   getExecuting(): Plan[] {
+    this.refresh();
     return this.store.plans.filter((p) => p.status === 'executing' || p.status === 'validating');
   }
 
   getActive(): Plan[] {
+    this.refresh();
     return this.store.plans.filter(
       (p) =>
         p.status === 'brainstorming' ||
@@ -435,6 +476,7 @@ export class Planner {
   }
 
   archive(olderThanDays?: number): Plan[] {
+    this.refresh();
     const cutoff =
       olderThanDays !== undefined
         ? Date.now() - olderThanDays * 24 * 60 * 60 * 1000
@@ -460,6 +502,7 @@ export class Planner {
     closedIds: string[];
     closedPlans: Array<{ id: string; previousStatus: string; reason: string }>;
   } {
+    this.refresh();
     const now = Date.now();
     const forceAll = olderThanMs === 0;
     const defaultTtl = forceAll ? 0 : 30 * 60 * 1000; // 30 minutes for draft/approved
@@ -522,6 +565,7 @@ export class Planner {
     totalTasks: number;
     tasksByStatus: Record<TaskStatus, number>;
   } {
+    this.refresh();
     const plans = this.store.plans;
     const byStatus = {
       brainstorming: 0,

package/src/runtime/admin-setup-ops.test.ts

@@ -46,6 +46,11 @@ vi.mock('./claude-md-helpers.js', () => ({
   injectEngineRulesBlock: vi.fn((content: string) => content),
 }));
 
+vi.mock('../paths.js', () => ({
+  agentPlansPath: vi.fn(() => '/mock-home/.soleri/test-agent/plans.json'),
+  agentVaultPath: vi.fn(() => '/mock-home/.soleri/test-agent/vault.db'),
+}));
+
 vi.mock('../skills/sync-skills.js', () => ({
   discoverSkills: vi.fn(() => [{ name: 'skill-1', path: '/mock/skills/skill-1' }]),
   syncSkillsToClaudeCode: vi.fn(() => ({
@@ -330,5 +335,44 @@ describe('createAdminSetupOps', () => {
       expect(activePlans[0].status).toBe('executing');
       expect(result.recommendation).toContain('need attention');
     });
+
+    it('uses configured or resolved .soleri plan paths and understands planner stores', async () => {
+      runtime = {
+        ...createMockRuntime(),
+        config: {
+          agentId: 'test-agent',
+          dataDir: '/mock/agent-data',
+          agentDir: '/mock/agent-dir',
+        },
+      } as unknown as AgentRuntime;
+      ops = createAdminSetupOps(runtime);
+
+      mockDirs.add('/mock-home/.soleri/test-agent');
+      mockFs['/mock-home/.soleri/test-agent/vault.db'] = 'binary';
+      mockFs['/mock-home/.soleri/test-agent/plans.json'] = JSON.stringify({
+        version: '1.0',
+        plans: [
+          { id: 'plan-1', status: 'executing' },
+          { id: 'plan-2', status: 'completed' },
+        ],
+      });
+
+      const result = (await findOp(ops, 'admin_check_persistence').handler({})) as Record<
+        string,
+        unknown
+      >;
+
+      expect((result.storageDirectory as Record<string, unknown>).path).toBe(
+        '/mock-home/.soleri/test-agent',
+      );
+      expect(
+        ((result.files as Record<string, unknown>).plans as Record<string, unknown>).path,
+      ).toBe('/mock-home/.soleri/test-agent/plans.json');
+      expect(
+        ((result.files as Record<string, unknown>).plans as Record<string, unknown>).items,
+      ).toBe(2);
+      expect(result.status).toBe('PERSISTENCE_ACTIVE');
+      expect(result.activePlans).toEqual([{ id: 'plan-1', status: 'executing' }]);
+    });
   });
 });

package/src/runtime/admin-setup-ops.ts

@@ -27,6 +27,10 @@ import { join, resolve, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
+import {
+  agentPlansPath as getAgentPlansPath,
+  agentVaultPath as getAgentVaultPath,
+} from '../paths.js';
 import {
   hasSections,
   removeSections,
@@ -74,19 +78,63 @@ function getFileInfo(path: string): { exists: boolean; size: number; items: numb
   try {
     const stat = statSync(path);
     const content = JSON.parse(readFileSync(path, 'utf-8'));
-    const items = content.items
-      ? Object.keys(content.items).length
-      : content.contexts
-        ? content.contexts.length
-        : Array.isArray(content)
-          ? content.length
-          : 0;
+    const items = countPersistedItems(content);
     return { exists: true, size: stat.size, items };
   } catch {
     return { exists: true, size: 0, items: -1 };
   }
 }
 
+function countPersistedItems(content: unknown): number {
+  if (Array.isArray(content)) return content.length;
+  if (!content || typeof content !== 'object') return 0;
+
+  const data = content as Record<string, unknown>;
+  if (Array.isArray(data.plans)) return data.plans.length;
+  if (data.items && typeof data.items === 'object') return Object.keys(data.items).length;
+  if (Array.isArray(data.contexts)) return data.contexts.length;
+  return 0;
+}
+
+function extractActivePlans(content: unknown): Array<{ id: string; status: string }> {
+  if (!content || typeof content !== 'object') return [];
+
+  const plans = Array.isArray((content as Record<string, unknown>).plans)
+    ? ((content as Record<string, unknown>).plans as unknown[])
+    : null;
+  if (plans) {
+    return plans.flatMap((plan) => {
+      if (!plan || typeof plan !== 'object') return [];
+      const p = plan as Record<string, unknown>;
+      const id = typeof p.id === 'string' ? p.id : null;
+      const lifecycle =
+        typeof p.lifecycleStatus === 'string'
+          ? p.lifecycleStatus
+          : typeof p.status === 'string'
+            ? p.status
+            : null;
+      if (!id || (lifecycle !== 'executing' && lifecycle !== 'reconciling')) return [];
+      return [{ id, status: lifecycle }];
+    });
+  }
+
+  const items = (content as Record<string, unknown>).items;
+  if (!items || typeof items !== 'object') return [];
+
+  return Object.entries(items).flatMap(([id, plan]) => {
+    if (!plan || typeof plan !== 'object') return [];
+    const p = plan as Record<string, unknown>;
+    const lifecycle =
+      typeof p.lifecycleStatus === 'string'
+        ? p.lifecycleStatus
+        : typeof p.status === 'string'
+          ? p.status
+          : null;
+    if (lifecycle !== 'executing' && lifecycle !== 'reconciling') return [];
+    return [{ id, status: lifecycle }];
+  });
+}
+
 /** Discover hookify rule files in a directory */
 function discoverHookifyFiles(dir: string): Array<{ name: string; path: string }> {
   if (!existsSync(dir)) return [];
@@ -621,15 +669,15 @@ export function createAdminSetupOps(runtime: AgentRuntime): OpDefinition[] {
       auth: 'read',
       handler: async () => {
         const { agentId, plansPath, vaultPath } = config;
-        const storageDir = join(homedir(), `.${agentId}`);
+        const plansFile = plansPath ?? getAgentPlansPath(agentId);
+        const vaultFile = vaultPath ?? getAgentVaultPath(agentId);
+        const storageDir = dirname(plansFile);
         const storageDirExists = existsSync(storageDir);
 
         // Check plan storage
-        const plansFile = plansPath ?? join(storageDir, 'plans.json');
         const plansInfo = getFileInfo(plansFile);
 
         // Check vault
-        const vaultFile = vaultPath ?? join(storageDir, 'vault.db');
         const vaultExists = existsSync(vaultFile);
         let vaultSize = 0;
         if (vaultExists) {
@@ -655,16 +703,7 @@ export function createAdminSetupOps(runtime: AgentRuntime): OpDefinition[] {
         if (plansInfo.exists) {
           try {
             const plansData = JSON.parse(readFileSync(plansFile, 'utf-8'));
-            const items = plansData.items ?? plansData;
-            if (typeof items === 'object' && items !== null) {
-              for (const [id, plan] of Object.entries(items)) {
-                const p = plan as Record<string, unknown>;
-                const lifecycle = (p.lifecycleStatus ?? p.status) as string | undefined;
-                if (lifecycle === 'executing' || lifecycle === 'reconciling') {
-                  activePlans.push({ id, status: lifecycle });
-                }
-              }
-            }
+            activePlans.push(...extractActivePlans(plansData));
           } catch {
             // Parse error — not critical
           }

package/src/runtime/facades/orchestrate-facade.ts

@@ -24,7 +24,7 @@ import {
 import type { SkillStep, EvidenceType } from '../../skills/step-tracker.js';
 
 export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, governance, projectRegistry } = runtime;
+  const { vault, governance, projectRegistry, brainIntelligence } = runtime;
 
   return [
     // ─── Session Start (inline from core-ops.ts) ─────────────────────
@@ -150,6 +150,31 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
           vaultStats: stats,
         });
 
+        // Auto-close orphaned brain sessions (endedAt IS NULL, startedAt < now - 2h)
+        let orphansClosed = 0;
+        try {
+          const TWO_HOURS_MS = 2 * 60 * 60 * 1000;
+          const cutoff = new Date(Date.now() - TWO_HOURS_MS);
+          const activeSessions = brainIntelligence.listSessions({ active: true, limit: 1000 });
+          for (const s of activeSessions) {
+            if (new Date(s.startedAt) < cutoff) {
+              try {
+                brainIntelligence.lifecycle({
+                  action: 'end',
+                  sessionId: s.id,
+                  planOutcome: 'abandoned',
+                  context: 'auto-closed: orphan from previous conversation',
+                });
+                orphansClosed++;
+              } catch {
+                // Best-effort per session — never let one failure abort the rest
+              }
+            }
+          }
+        } catch {
+          // Non-critical — don't fail session start over orphan cleanup
+        }
+
         return {
           project,
           is_new: isNew,
@@ -167,6 +192,7 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
             expiredThisSession: expired,
           },
           preflight,
+          orphansClosed,
           ...(stagingWarning ? { stagingWarning } : {}),
           ...(dreamInfo ? { dream: dreamInfo } : {}),
         };

package/src/runtime/runtime.ts

@@ -148,6 +148,15 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   // Pass embeddingProvider for hybrid FTS5+vector search when available
   const brain = new Brain(vault, vaultManager, embeddingProvider);
 
+  // Wire canonical tag config if provided
+  if (config.canonicalTags && config.canonicalTags.length > 0) {
+    brain.setCanonicalTagConfig({
+      canonicalTags: config.canonicalTags,
+      tagConstraintMode: config.tagConstraintMode ?? 'suggest',
+      metadataTagPrefixes: config.metadataTagPrefixes ?? ['source:'],
+    });
+  }
+
   // Brain Intelligence — pattern strengths, session knowledge, intelligence pipeline
   const brainIntelligence = new BrainIntelligence(vault, brain);
 
@@ -199,6 +208,15 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const intakePipeline = new IntakePipeline(vault.getProvider(), vault, llmClient);
   const textIngester = new TextIngester(vault, llmClient);
 
+  // Wire canonical tag config into TextIngester if provided
+  if (config.canonicalTags && config.canonicalTags.length > 0) {
+    textIngester.setCanonicalTagConfig({
+      canonicalTags: config.canonicalTags,
+      tagConstraintMode: config.tagConstraintMode ?? 'suggest',
+      metadataTagPrefixes: config.metadataTagPrefixes ?? ['source:'],
+    });
+  }
+
   // Playbook Executor — in-memory step-by-step workflow sessions
   const playbookExecutor = new PlaybookExecutor();
 

package/src/runtime/types.ts

@@ -79,6 +79,25 @@ export interface AgentRuntimeConfig {
   persona?: Partial<import('../persona/types.js').PersonaConfig>;
   /** Embedding provider configuration. If omitted, embeddings are disabled. */
   embedding?: EmbeddingConfig;
+  /**
+   * Canonical tag taxonomy configuration.
+   * When set, tags are normalized against this list during capture and ingestion.
+   */
+  canonicalTags?: string[];
+  /**
+   * Tag constraint mode.
+   * - 'enforce': tags not matching canonical list are dropped (unless within edit-distance 3).
+   * - 'suggest': tags are mapped to nearest canonical if within edit-distance 2 (default).
+   * - 'off': no normalization — behavior unchanged from pre-taxonomy.
+   * Default: 'suggest'
+   */
+  tagConstraintMode?: 'enforce' | 'suggest' | 'off';
+  /**
+   * Metadata tag prefixes — tags with these prefixes (e.g. 'source:') are treated as metadata
+   * and are exempt from canonical normalization.
+   * Default: ['source:']
+   */
+  metadataTagPrefixes?: string[];
 }
 
 /**

package/src/skills/sync-skills.ts

@@ -257,20 +257,26 @@ export function syncSkillsToClaudeCode(
 }
 
 /**
- * Remove existing `{agent}-soleri-*` entries from ~/.claude/skills/
+ * Remove ALL `{agent}-soleri-*` entries from ~/.claude/skills/
  * to clean up duplicates left by the old global-install behavior.
+ *
+ * Cleans entries from ALL agents, not just the current one — any
+ * `*-soleri-*` entry in the global dir is a stale copy from a previous
+ * global install. Canonical skills now live in project-local .claude/skills/.
  */
 function cleanStaleGlobalSkills(agentName: string, result: SyncResult): void {
   const globalSkillsDir = join(homedir(), '.claude', 'skills');
   if (!existsSync(globalSkillsDir)) return;
 
-  const prefix = `${agentName.toLowerCase().replace(/\s+/g, '-')}-soleri-`;
+  // Match any agent-prefixed soleri skill: <anything>-soleri-<skillname>
+  // Canonical project-local names look like "soleri-*" (no agent prefix).
+  const stalePattern = /^.+-soleri-.+$/;
 
   try {
     const entries = readdirSync(globalSkillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      if (!entry.name.startsWith(prefix)) continue;
+      if (!stalePattern.test(entry.name)) continue;
 
       const staleDir = join(globalSkillsDir, entry.name);
       try {