@cleocode/core 2026.3.45 → 2026.3.46

package/src/scaffold.ts

@@ -523,7 +523,7 @@ export async function ensureProjectContext(
   try {
     const schemaPath = join(
       dirname(fileURLToPath(import.meta.url)),
-      '../../schemas/project-context.schema.json',
+      '../schemas/project-context.schema.json',
     );
     if (existsSync(schemaPath)) {
       const AjvModule = await import('ajv');
@@ -1037,8 +1037,16 @@ export function checkMemoryBridge(projectRoot: string): CheckResult {
  * Required subdirectories under the global ~/.cleo/ home.
  * These are infrastructure directories managed by CLEO itself,
  * not project-specific data.
+ *
+ * Truly global:
+ *   - logs      — global log output
+ *   - templates — CLEO-INJECTION.md symlink target
+ *
+ * Note: nexus.db lives directly in ~/.cleo/, not a subdir.
+ * Schemas are read at runtime from getPackageRoot()/schemas/ — no copy needed.
+ * Project-level dirs (adrs/, rcasd/, agent-outputs/, backups/) live in .cleo/ only.
  */
-export const REQUIRED_GLOBAL_SUBDIRS = ['schemas', 'templates'] as const;
+export const REQUIRED_GLOBAL_SUBDIRS = ['logs', 'templates'] as const;
 
 /**
  * Ensure the global ~/.cleo/ home directory and its required
@@ -1111,9 +1119,13 @@ export async function ensureGlobalTemplates(): Promise<ScaffoldResult> {
 }
 
 /**
- * Perform a complete global scaffold operation: ensure home, schemas,
- * and templates are all present and current. This is the single entry
- * point for global infrastructure scaffolding.
+ * Perform a complete global scaffold operation: ensure home and templates
+ * are all present and current. This is the single entry point for global
+ * infrastructure scaffolding.
+ *
+ * Schemas are NOT copied here — they are read at runtime from the npm
+ * package path (getPackageRoot() + '/schemas/'). Use ensureGlobalSchemas()
+ * explicitly from init or upgrade if a copy is needed for a specific workflow.
  *
  * Used by:
  *   - MCP startup (via startupHealthCheck in health.ts)
@@ -1122,17 +1134,12 @@ export async function ensureGlobalTemplates(): Promise<ScaffoldResult> {
  */
 export async function ensureGlobalScaffold(): Promise<{
   home: ScaffoldResult;
-  schemas: { installed: number; updated: number; total: number };
   templates: ScaffoldResult;
 }> {
-  // Lazy import to avoid circular dependency
-  const { ensureGlobalSchemas } = await import('./schema-management.js');
-
   const home = await ensureGlobalHome();
-  const schemas = ensureGlobalSchemas();
   const templates = await ensureGlobalTemplates();
 
-  return { home, schemas, templates };
+  return { home, templates };
 }
 
 // ── Global check* functions (read-only diagnostics) ──────────────────

package/src/skills/__tests__/routing-table.test.ts

@@ -3,44 +3,16 @@ import {
   getOperationsByChannel,
   getPreferredChannel,
   getRoutingForDomain,
-  ROUTING_TABLE,
 } from '../routing-table.js';
 
 describe('routing-table', () => {
-  describe('ROUTING_TABLE structure', () => {
-    it('has entries for all 10 canonical domains', () => {
-      const domains = new Set(ROUTING_TABLE.map((e) => e.domain));
-      expect(domains.has('memory')).toBe(true);
-      expect(domains.has('tasks')).toBe(true);
-      expect(domains.has('session')).toBe(true);
-      expect(domains.has('admin')).toBe(true);
-      expect(domains.has('tools')).toBe(true);
-      expect(domains.has('check')).toBe(true);
-      expect(domains.has('pipeline')).toBe(true);
-      expect(domains.has('orchestrate')).toBe(true);
-      expect(domains.has('nexus')).toBe(true);
-      expect(domains.has('sticky')).toBe(true);
-    });
-
-    it('every entry has required fields', () => {
-      for (const entry of ROUTING_TABLE) {
-        expect(entry.domain).toBeTruthy();
-        expect(entry.operation).toBeTruthy();
-        expect(['mcp', 'cli', 'either']).toContain(entry.preferredChannel);
-        expect(entry.reason).toBeTruthy();
-      }
+  describe('getPreferredChannel (via capability matrix)', () => {
+    it('returns mcp for memory.find', () => {
+      expect(getPreferredChannel('memory', 'find')).toBe('mcp');
     });
 
-    it('has no duplicate domain+operation pairs', () => {
-      const keys = ROUTING_TABLE.map((e) => `${e.domain}.${e.operation}`);
-      const unique = new Set(keys);
-      expect(unique.size).toBe(keys.length);
-    });
-  });
-
-  describe('getPreferredChannel', () => {
-    it('returns mcp for memory.brain.search', () => {
-      expect(getPreferredChannel('memory', 'brain.search')).toBe('mcp');
+    it('returns mcp for memory.fetch', () => {
+      expect(getPreferredChannel('memory', 'fetch')).toBe('mcp');
     });
 
     it('returns cli for pipeline.release.ship', () => {
@@ -54,15 +26,56 @@ describe('routing-table', () => {
     it('returns either for unknown operations', () => {
       expect(getPreferredChannel('nonexistent', 'op')).toBe('either');
     });
+
+    it('returns mcp for tasks.show', () => {
+      expect(getPreferredChannel('tasks', 'show')).toBe('mcp');
+    });
+
+    it('returns mcp for session.status', () => {
+      expect(getPreferredChannel('session', 'status')).toBe('mcp');
+    });
+
+    it('returns mcp for admin.dash', () => {
+      expect(getPreferredChannel('admin', 'dash')).toBe('mcp');
+    });
   });
 
   describe('getRoutingForDomain', () => {
+    it('returns entries covering all 10 canonical domains', () => {
+      const domains = [
+        'memory',
+        'tasks',
+        'session',
+        'admin',
+        'tools',
+        'check',
+        'pipeline',
+        'orchestrate',
+        'nexus',
+        'sticky',
+      ];
+      for (const domain of domains) {
+        const entries = getRoutingForDomain(domain);
+        expect(entries.length).toBeGreaterThan(0);
+        expect(entries.every((e) => e.domain === domain)).toBe(true);
+      }
+    });
+
     it('returns all memory domain entries', () => {
       const entries = getRoutingForDomain('memory');
       expect(entries.length).toBeGreaterThan(0);
       expect(entries.every((e) => e.domain === 'memory')).toBe(true);
     });
 
+    it('every entry has required fields with valid channel', () => {
+      const entries = getRoutingForDomain('tasks');
+      for (const entry of entries) {
+        expect(entry.domain).toBeTruthy();
+        expect(entry.operation).toBeTruthy();
+        expect(['mcp', 'cli', 'either']).toContain(entry.preferredChannel);
+      }
+    });
+
     it('returns empty array for unknown domain', () => {
       expect(getRoutingForDomain('nonexistent')).toEqual([]);
     });
@@ -86,5 +99,12 @@ describe('routing-table', () => {
       const cliCount = getOperationsByChannel('cli').length;
       expect(mcpCount).toBeGreaterThan(cliCount);
     });
+
+    it('has no duplicate domain+operation pairs within a channel', () => {
+      const mcpOps = getOperationsByChannel('mcp');
+      const keys = mcpOps.map((e) => `${e.domain}.${e.operation}`);
+      const unique = new Set(keys);
+      expect(unique.size).toBe(keys.length);
+    });
   });
 });

package/src/skills/agents/install.ts

@@ -9,10 +9,18 @@
  */
 
 import { existsSync, mkdirSync, readdirSync, readlinkSync, symlinkSync, unlinkSync } from 'node:fs';
+import { platform } from 'node:os';
 import { basename, join } from 'node:path';
 import { getClaudeAgentsDir } from '../../paths.js';
 import { getAgentsDir } from './config.js';
 
+/**
+ * Symlink type for directory symlinks.
+ * On Windows, use 'junction' (no admin privileges required).
+ * On Unix, use 'dir'.
+ */
+const DIR_SYMLINK_TYPE: 'junction' | 'dir' = platform() === 'win32' ? 'junction' : 'dir';
+
 // ============================================================================
 // Agent Installation
 // ============================================================================
@@ -65,7 +73,7 @@ export function installAgent(agentDir: string): {
   }
 
   try {
-    symlinkSync(agentDir, targetPath, 'dir');
+    symlinkSync(agentDir, targetPath, DIR_SYMLINK_TYPE);
     return { installed: true, path: targetPath };
   } catch (err) {
     return { installed: false, path: targetPath, error: `Symlink failed: ${err}` };

package/src/skills/routing-table.ts

@@ -1,24 +1,31 @@
 /**
  * Dynamic Skill Routing Table
  *
- * Token-efficiency routing table that determines whether each operation
- * is more efficient via MCP (lower overhead) or CLI (more flexible).
- *
- * MCP operations avoid CLI process startup overhead (~200ms + ~50 tokens)
- * and are preferred for rapid, repeated queries. CLI is preferred for
- * operations that benefit from human-readable output or shell integration.
+ * Thin wrapper over the merged capability matrix. PreferredChannel data
+ * is now stored as part of OperationCapability in the capability matrix
+ * (packages/core/src/routing/capability-matrix.ts), which is the single
+ * SSoT for both execution mode and channel preference.
  *
  * @task T5240
  * @epic T5149
+ * @see packages/core/src/routing/capability-matrix.ts
  */
 
+import { getCapabilityMatrix } from '../routing/capability-matrix.js';
+
+export type { PreferredChannel } from '../routing/capability-matrix.js';
+
 /**
  * Routing entry describing the preferred channel for an operation.
+ *
+ * Derived from OperationCapability in the capability matrix.
+ * Use this type when consuming domain-level routing results from
+ * getRoutingForDomain() or getOperationsByChannel().
  */
 export interface RoutingEntry {
   /** Domain name (e.g. 'tasks', 'memory', 'session') */
   domain: string;
-  /** Operation name (e.g. 'brain.search', 'show') */
+  /** Operation name (e.g. 'show', 'find') */
   operation: string;
   /** Preferred channel for token efficiency */
   preferredChannel: 'mcp' | 'cli' | 'either';
@@ -26,277 +33,56 @@ export interface RoutingEntry {
   reason: string;
 }
 
-/**
- * Static routing table for all canonical operations.
- *
- * Operations are grouped by domain with channel preferences based on:
- * - MCP: lower overhead (no CLI startup), direct DB access, structured JSON
- * - CLI: human-readable output, shell integration, interactive prompts
- * - Either: no significant difference or context-dependent
- */
-export const ROUTING_TABLE: RoutingEntry[] = [
-  // === Memory domain -- MCP strongly preferred (direct DB, no CLI startup) ===
-  {
-    domain: 'memory',
-    operation: 'brain.search',
-    preferredChannel: 'mcp',
-    reason: 'Low overhead search, direct DB access',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.fetch',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB access, structured response',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.timeline',
-    preferredChannel: 'mcp',
-    reason: 'Complex multi-table query, direct DB',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.observe',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write, no CLI overhead',
-  },
-  {
-    domain: 'memory',
-    operation: 'find',
-    preferredChannel: 'mcp',
-    reason: 'Alias for brain.search',
-  },
-  { domain: 'memory', operation: 'show', preferredChannel: 'mcp', reason: 'Alias for brain.fetch' },
-  {
-    domain: 'memory',
-    operation: 'decision.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'decision.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-  {
-    domain: 'memory',
-    operation: 'learning.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'learning.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-  {
-    domain: 'memory',
-    operation: 'pattern.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'pattern.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-
-  // === Tasks domain -- MCP preferred for queries, CLI for complex ops ===
-  {
-    domain: 'tasks',
-    operation: 'show',
-    preferredChannel: 'mcp',
-    reason: 'Structured JSON response',
-  },
-  { domain: 'tasks', operation: 'find', preferredChannel: 'mcp', reason: 'Low overhead search' },
-  { domain: 'tasks', operation: 'list', preferredChannel: 'mcp', reason: 'Paginated response' },
-  {
-    domain: 'tasks',
-    operation: 'next',
-    preferredChannel: 'mcp',
-    reason: 'Algorithm runs in-process',
-  },
-  { domain: 'tasks', operation: 'current', preferredChannel: 'mcp', reason: 'Simple DB lookup' },
-  {
-    domain: 'tasks',
-    operation: 'plan',
-    preferredChannel: 'mcp',
-    reason: 'Composite view, in-process',
-  },
-  { domain: 'tasks', operation: 'add', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  { domain: 'tasks', operation: 'update', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  {
-    domain: 'tasks',
-    operation: 'complete',
-    preferredChannel: 'mcp',
-    reason: 'Atomic DB write with hooks',
-  },
-  { domain: 'tasks', operation: 'start', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  { domain: 'tasks', operation: 'stop', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-
-  // === Session domain -- MCP preferred (stateful, in-process) ===
-  { domain: 'session', operation: 'status', preferredChannel: 'mcp', reason: 'Quick state lookup' },
-  { domain: 'session', operation: 'start', preferredChannel: 'mcp', reason: 'State transition' },
-  {
-    domain: 'session',
-    operation: 'end',
-    preferredChannel: 'mcp',
-    reason: 'State transition with hooks',
-  },
-  {
-    domain: 'session',
-    operation: 'handoff.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured handoff data',
-  },
-  {
-    domain: 'session',
-    operation: 'briefing.show',
-    preferredChannel: 'mcp',
-    reason: 'Composite cold-start',
-  },
-
-  // === Admin domain -- either (human interaction common) ===
-  { domain: 'admin', operation: 'version', preferredChannel: 'either', reason: 'Simple lookup' },
-  { domain: 'admin', operation: 'health', preferredChannel: 'either', reason: 'Diagnostics' },
-  { domain: 'admin', operation: 'dash', preferredChannel: 'mcp', reason: 'Composite view' },
-  { domain: 'admin', operation: 'help', preferredChannel: 'mcp', reason: 'Operation discovery' },
-  {
-    domain: 'admin',
-    operation: 'map',
-    preferredChannel: 'mcp',
-    reason: 'Structured codebase analysis',
-  },
-
-  // === Tools domain -- MCP preferred (structured responses) ===
-  {
-    domain: 'tools',
-    operation: 'skill.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured catalog',
-  },
-  {
-    domain: 'tools',
-    operation: 'skill.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured skill data',
-  },
-  { domain: 'tools', operation: 'skill.find', preferredChannel: 'mcp', reason: 'Search response' },
-  {
-    domain: 'tools',
-    operation: 'skill.install',
-    preferredChannel: 'either',
-    reason: 'May need shell access',
-  },
-  {
-    domain: 'tools',
-    operation: 'provider.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured list',
-  },
-  {
-    domain: 'tools',
-    operation: 'provider.detect',
-    preferredChannel: 'mcp',
-    reason: 'Detection result',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured list',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured manifest',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.activate',
-    preferredChannel: 'mcp',
-    reason: 'State transition',
-  },
-
-  // === Check domain -- MCP preferred (validation results) ===
-  {
-    domain: 'check',
-    operation: 'validate',
-    preferredChannel: 'mcp',
-    reason: 'Structured validation',
-  },
-  {
-    domain: 'check',
-    operation: 'compliance',
-    preferredChannel: 'mcp',
-    reason: 'Compliance report',
-  },
-
-  // === Pipeline domain -- MCP preferred (lifecycle gates) ===
-  {
-    domain: 'pipeline',
-    operation: 'lifecycle.status',
-    preferredChannel: 'mcp',
-    reason: 'Gate status',
-  },
-  {
-    domain: 'pipeline',
-    operation: 'release.ship',
-    preferredChannel: 'cli',
-    reason: 'Complex multi-step with git ops',
-  },
-
-  // === Orchestrate domain -- MCP preferred (agent coordination) ===
-  { domain: 'orchestrate', operation: 'spawn', preferredChannel: 'mcp', reason: 'Agent spawning' },
-  { domain: 'orchestrate', operation: 'plan', preferredChannel: 'mcp', reason: 'Decomposition' },
-
-  // === Nexus domain -- either (cross-project queries) ===
-  {
-    domain: 'nexus',
-    operation: 'search',
-    preferredChannel: 'either',
-    reason: 'Cross-project search',
-  },
-  { domain: 'nexus', operation: 'sync', preferredChannel: 'either', reason: 'Cross-project sync' },
-
-  // === Sticky domain -- MCP preferred (quick ephemeral notes) ===
-  { domain: 'sticky', operation: 'add', preferredChannel: 'mcp', reason: 'Quick DB write' },
-  { domain: 'sticky', operation: 'list', preferredChannel: 'mcp', reason: 'Quick DB read' },
-  { domain: 'sticky', operation: 'show', preferredChannel: 'mcp', reason: 'Quick DB read' },
-];
-
 /**
  * Look up the preferred channel for a given domain + operation.
  *
+ * Reads from the merged capability matrix (single SSoT).
+ *
  * @param domain - Domain name
  * @param operation - Operation name
  * @returns Preferred channel ('mcp', 'cli', or 'either' as fallback)
  */
 export function getPreferredChannel(domain: string, operation: string): 'mcp' | 'cli' | 'either' {
-  const entry = ROUTING_TABLE.find((e) => e.domain === domain && e.operation === operation);
+  const entry = getCapabilityMatrix().find(
+    (cap) => cap.domain === domain && cap.operation === operation,
+  );
   return entry?.preferredChannel ?? 'either';
 }
 
 /**
  * Get routing entries for a specific domain.
  *
+ * Derives entries from the capability matrix.
+ *
  * @param domain - Domain name
  * @returns All routing entries for the domain
  */
 export function getRoutingForDomain(domain: string): RoutingEntry[] {
-  return ROUTING_TABLE.filter((e) => e.domain === domain);
+  return getCapabilityMatrix()
+    .filter((cap) => cap.domain === domain)
+    .map((cap) => ({
+      domain: cap.domain,
+      operation: cap.operation,
+      preferredChannel: cap.preferredChannel,
+      reason: '',
+    }));
 }
 
 /**
  * Get all operations that prefer a specific channel.
  *
+ * Derives entries from the capability matrix.
+ *
  * @param channel - Channel preference to filter by
  * @returns Matching routing entries
  */
 export function getOperationsByChannel(channel: 'mcp' | 'cli' | 'either'): RoutingEntry[] {
-  return ROUTING_TABLE.filter((e) => e.preferredChannel === channel);
+  return getCapabilityMatrix()
+    .filter((cap) => cap.preferredChannel === channel)
+    .map((cap) => ({
+      domain: cap.domain,
+      operation: cap.operation,
+      preferredChannel: cap.preferredChannel,
+      reason: '',
+    }));
 }

package/src/skills/skill-paths.ts

@@ -15,7 +15,7 @@
 
 import { existsSync, lstatSync, readlinkSync, realpathSync } from 'node:fs';
 import { delimiter, join, resolve } from 'node:path';
-import { getAgentsHome } from '../paths.js';
+import { getCanonicalSkillsDir } from '@cleocode/caamp';
 
 /** Source type classification for a skill directory. */
 export type SkillSourceType = 'embedded' | 'caamp' | 'project-link' | 'global-link';
@@ -31,10 +31,11 @@ export interface SkillSearchPath {
 
 /**
  * Get the CAAMP canonical skill location.
+ * Delegates to caamp's getCanonicalSkillsDir() which is XDG-aware.
  * @task T4552
  */
 function getCaampCanonical(): string {
-  return join(getAgentsHome(), 'skills');
+  return getCanonicalSkillsDir();
 }
 
 /**

package/src/store/__tests__/project-detect.test.ts

@@ -14,7 +14,7 @@ import { detectProjectType } from '../project-detect.js';
 
 // ─── Schema validator setup ───────────────────────────────────────────────────
 const schemaPath = fileURLToPath(
-  new URL('../../../../../schemas/project-context.schema.json', import.meta.url),
+  new URL('../../../schemas/project-context.schema.json', import.meta.url),
 );
 const schema = JSON.parse(readFileSync(schemaPath, 'utf-8'));
 const Ajv = (AjvModule as any).default ?? AjvModule;

package/src/system/health.ts

@@ -1036,7 +1036,7 @@ export async function startupHealthCheck(projectRoot?: string): Promise<StartupH
       !globalSchemaCheck.ok;
 
     if (globalNeedsRepair) {
-      // Auto-repair: ensureGlobalScaffold is idempotent and safe
+      // Auto-repair home and templates via ensureGlobalScaffold (idempotent, safe)
       const scaffoldResult = await ensureGlobalScaffold();
 
       checks.push({
@@ -1049,12 +1049,23 @@ export async function startupHealthCheck(projectRoot?: string): Promise<StartupH
         repaired: scaffoldResult.home.action !== 'skipped',
       });
 
-      checks.push({
-        check: 'global_schemas',
-        status: 'pass',
-        message: `Schemas: ${scaffoldResult.schemas.installed} installed, ${scaffoldResult.schemas.updated} updated of ${scaffoldResult.schemas.total}`,
-        repaired: scaffoldResult.schemas.installed > 0 || scaffoldResult.schemas.updated > 0,
-      });
+      // Schemas are read at runtime from the package path; only copy if stale
+      if (!globalSchemaCheck.ok) {
+        const { ensureGlobalSchemas } = await import('../schema-management.js');
+        const schemaResult = ensureGlobalSchemas();
+        checks.push({
+          check: 'global_schemas',
+          status: 'pass',
+          message: `Schemas: ${schemaResult.installed} installed, ${schemaResult.updated} updated of ${schemaResult.total}`,
+          repaired: schemaResult.installed > 0 || schemaResult.updated > 0,
+        });
+      } else {
+        checks.push({
+          check: 'global_schemas',
+          status: 'pass',
+          message: `All ${globalSchemaCheck.installed} schemas current`,
+        });
+      }
 
       checks.push({
         check: 'global_templates',

package/src/ui/index.ts

@@ -59,9 +59,3 @@ export {
 //   injection.ts    -> CAAMP inject()/checkInjection()
 //   mcp-config.ts   -> CAAMP detectAllProviders()/installMcpServer()
 //   injection-registry.ts -> CAAMP getInstructionFiles()
-
-// Injection legacy utilities (kept for validation output support)
-export {
-  getValidationKey,
-  INJECTION_VALIDATION_KEYS,
-} from './injection-legacy.js';

package/src/validation/operation-gate-validators.ts

@@ -326,7 +326,7 @@ export async function validateLayer2Semantic(context: OperationContext): Promise
   // Session scope validation
   if (context.domain === 'session' && context.operation === 'start') {
     const scope = context.params?.scope as string | undefined;
-    if (scope && !scope.match(/^(epic|task|global):/)) {
+    if (scope && scope !== 'global' && !scope.match(/^(epic|task):/)) {
       violations.push({
         layer: GateLayer.SEMANTIC,
         severity: ErrorSeverity.ERROR,
@@ -334,7 +334,7 @@ export async function validateLayer2Semantic(context: OperationContext): Promise
         message: `Invalid session scope format: ${scope}`,
         field: 'scope',
         constraint: 'Must be epic:<id>, task:<id>, or global',
-        fix: 'Use format: epic:T1234, task:T5678, or global',
+        fix: 'Provide scope as "global" or "epic:TXXX"',
       });
     }
   }