bmad-fh 6.0.0-alpha.23.50b728f9 → 6.0.0-alpha.23.599980af

package/test/test-scope-e2e.js

@@ -214,9 +214,9 @@ async function testParallelScopeWorkflow() {
         projectRoot: tmpDir,
       });
 
-      // Payments scope can read auth scope
+      // Payments scope can read auth scope - canRead returns {allowed, reason}
       assertTrue(
-        resolver.canRead(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md')),
+        resolver.canRead(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md')).allowed,
         'Should allow cross-scope read',
       );
     });
@@ -229,9 +229,9 @@ async function testParallelScopeWorkflow() {
         isolationMode: 'strict',
       });
 
-      // Payments scope cannot write to auth scope
+      // Payments scope cannot write to auth scope - canWrite returns {allowed, reason, warning}
       assertFalse(
-        resolver.canWrite(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'new.md')),
+        resolver.canWrite(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'new.md')).allowed,
         'Should block cross-scope write',
       );
     });
@@ -262,19 +262,16 @@ async function testParallelScopeWorkflow() {
     await asyncTest('Sync-up promotes artifacts to shared layer', async () => {
       const sync = new ScopeSync({ projectRoot: tmpDir });
 
-      // Create a promotable artifact (architecture.md)
-      const archPath = path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'architecture.md');
+      // Create a promotable artifact matching pattern 'architecture/*.md'
+      const archPath = path.join(tmpDir, '_bmad-output', 'auth', 'architecture', 'overview.md');
       fs.mkdirSync(path.dirname(archPath), { recursive: true });
       fs.writeFileSync(archPath, '# Auth Architecture\n\nShared auth patterns...');
 
-      // Create architecture directory in shared
-      fs.mkdirSync(path.join(tmpDir, '_bmad-output', '_shared', 'auth'), { recursive: true });
-
       await sync.syncUp('auth');
 
-      // Check artifact was promoted
+      // Check artifact was promoted to _shared/auth/architecture/overview.md
       assertFileExists(
-        path.join(tmpDir, '_bmad-output', '_shared', 'auth', 'architecture.md'),
+        path.join(tmpDir, '_bmad-output', '_shared', 'auth', 'architecture', 'overview.md'),
         'Architecture should be promoted to shared',
       );
     });
@@ -284,14 +281,13 @@ async function testParallelScopeWorkflow() {
     // ========================================
     await asyncTest('Events are logged', async () => {
       const eventLogger = new EventLogger({ projectRoot: tmpDir });
+      await eventLogger.initialize();
 
-      await eventLogger.log({
-        type: 'artifact_created',
-        scope: 'auth',
-        artifact: 'prd.md',
-      });
+      // EventLogger uses logEvent(type, scopeId, data) not log({...})
+      await eventLogger.logEvent('artifact_created', 'auth', { artifact: 'prd.md' });
 
-      const events = await eventLogger.getEvents({ scope: 'auth' });
+      // getEvents takes (scopeId, options) not ({scope})
+      const events = await eventLogger.getEvents('auth');
       assertTrue(events.length > 0, 'Should have logged events');
       assertEqual(events[0].type, 'artifact_created');
     });

package/test/test-scope-system.js

@@ -32,10 +32,10 @@ let passCount = 0;
 let failCount = 0;
 const failures = [];
 
-function test(name, fn) {
+async function test(name, fn) {
   testCount++;
   try {
-    fn();
+    await fn();
     passCount++;
     console.log(`  ${colors.green}✓${colors.reset} ${name}`);
   } catch (error) {
@@ -102,103 +102,122 @@ function cleanupTempDir(tmpDir) {
 // ScopeValidator Tests
 // ============================================================================
 
-function testScopeValidator() {
+async function testScopeValidator() {
   console.log(`\n${colors.blue}ScopeValidator Tests${colors.reset}`);
 
   const { ScopeValidator } = require('../src/core/lib/scope/scope-validator');
   const validator = new ScopeValidator();
 
-  // Valid scope IDs
-  test('validates simple scope ID', () => {
-    assertTrue(validator.isValidScopeId('auth'), 'auth should be valid');
+  // Valid scope IDs - using validateScopeId which returns {valid, error}
+  await test('validates simple scope ID', () => {
+    const result = validator.validateScopeId('auth');
+    assertTrue(result.valid, 'auth should be valid');
   });
 
-  test('validates hyphenated scope ID', () => {
-    assertTrue(validator.isValidScopeId('user-service'), 'user-service should be valid');
+  await test('validates hyphenated scope ID', () => {
+    const result = validator.validateScopeId('user-service');
+    assertTrue(result.valid, 'user-service should be valid');
   });
 
-  test('validates scope ID with numbers', () => {
-    assertTrue(validator.isValidScopeId('api-v2'), 'api-v2 should be valid');
+  await test('validates scope ID with numbers', () => {
+    const result = validator.validateScopeId('api-v2');
+    assertTrue(result.valid, 'api-v2 should be valid');
   });
 
-  test('validates minimum length scope ID', () => {
-    assertTrue(validator.isValidScopeId('ab'), 'ab (2 chars) should be valid');
+  await test('validates minimum length scope ID', () => {
+    const result = validator.validateScopeId('ab');
+    assertTrue(result.valid, 'ab (2 chars) should be valid');
   });
 
   // Invalid scope IDs
-  test('rejects single character scope ID', () => {
-    assertFalse(validator.isValidScopeId('a'), 'single char should be invalid');
+  await test('rejects single character scope ID', () => {
+    const result = validator.validateScopeId('a');
+    assertFalse(result.valid, 'single char should be invalid');
   });
 
-  test('rejects scope ID starting with number', () => {
-    assertFalse(validator.isValidScopeId('1auth'), 'starting with number should be invalid');
+  await test('rejects scope ID starting with number', () => {
+    const result = validator.validateScopeId('1auth');
+    assertFalse(result.valid, 'starting with number should be invalid');
   });
 
-  test('rejects scope ID with uppercase', () => {
-    assertFalse(validator.isValidScopeId('Auth'), 'uppercase should be invalid');
+  await test('rejects scope ID with uppercase', () => {
+    const result = validator.validateScopeId('Auth');
+    assertFalse(result.valid, 'uppercase should be invalid');
   });
 
-  test('rejects scope ID with underscore', () => {
-    assertFalse(validator.isValidScopeId('user_service'), 'underscore should be invalid');
+  await test('rejects scope ID with underscore', () => {
+    const result = validator.validateScopeId('user_service');
+    assertFalse(result.valid, 'underscore should be invalid');
   });
 
-  test('rejects scope ID ending with hyphen', () => {
-    assertFalse(validator.isValidScopeId('auth-'), 'ending with hyphen should be invalid');
+  await test('rejects scope ID ending with hyphen', () => {
+    const result = validator.validateScopeId('auth-');
+    assertFalse(result.valid, 'ending with hyphen should be invalid');
   });
 
-  test('rejects scope ID starting with hyphen', () => {
-    assertFalse(validator.isValidScopeId('-auth'), 'starting with hyphen should be invalid');
+  await test('rejects scope ID starting with hyphen', () => {
+    const result = validator.validateScopeId('-auth');
+    assertFalse(result.valid, 'starting with hyphen should be invalid');
   });
 
-  test('rejects scope ID with spaces', () => {
-    assertFalse(validator.isValidScopeId('auth service'), 'spaces should be invalid');
+  await test('rejects scope ID with spaces', () => {
+    const result = validator.validateScopeId('auth service');
+    assertFalse(result.valid, 'spaces should be invalid');
   });
 
-  // Reserved IDs
-  test('rejects reserved ID _shared', () => {
-    assertFalse(validator.isValidScopeId('_shared'), '_shared is reserved');
+  // Reserved IDs - note: reserved IDs like _shared start with _ which fails pattern before reserved check
+  await test('rejects reserved ID _shared', () => {
+    const result = validator.validateScopeId('_shared');
+    assertFalse(result.valid, '_shared should be invalid (pattern or reserved)');
   });
 
-  test('rejects reserved ID _events', () => {
-    assertFalse(validator.isValidScopeId('_events'), '_events is reserved');
+  await test('rejects reserved ID _events', () => {
+    const result = validator.validateScopeId('_events');
+    assertFalse(result.valid, '_events should be invalid (pattern or reserved)');
   });
 
-  test('rejects reserved ID _config', () => {
-    assertFalse(validator.isValidScopeId('_config'), '_config is reserved');
+  await test('rejects reserved ID _config', () => {
+    const result = validator.validateScopeId('_config');
+    assertFalse(result.valid, '_config should be invalid (pattern or reserved)');
   });
 
-  test('rejects reserved ID global', () => {
-    assertFalse(validator.isValidScopeId('global'), 'global is reserved');
+  await test('rejects reserved ID global', () => {
+    const result = validator.validateScopeId('global');
+    // 'global' matches pattern but is reserved
+    assertFalse(result.valid, 'global is reserved');
   });
 
   // Circular dependency detection
-  test('detects direct circular dependency', () => {
+  // Note: detectCircularDependencies takes (scopeId, dependencies, allScopes) and returns {hasCircular, chain}
+  await test('detects direct circular dependency', () => {
     const scopes = {
-      auth: { dependencies: ['payments'] },
-      payments: { dependencies: ['auth'] },
+      auth: { id: 'auth', dependencies: ['payments'] },
+      payments: { id: 'payments', dependencies: ['auth'] },
     };
-    const result = validator.detectCircularDependencies(scopes);
+    // Check from payments perspective - it depends on auth, which depends on payments
+    const result = validator.detectCircularDependencies('payments', ['auth'], scopes);
     assertTrue(result.hasCircular, 'Should detect circular dependency');
-    assertTrue(result.cycles.length > 0, 'Should report cycles');
   });
 
-  test('detects indirect circular dependency', () => {
+  await test('detects indirect circular dependency', () => {
     const scopes = {
-      aa: { dependencies: ['bb'] },
-      bb: { dependencies: ['cc'] },
-      cc: { dependencies: ['aa'] },
+      aa: { id: 'aa', dependencies: ['bb'] },
+      bb: { id: 'bb', dependencies: ['cc'] },
+      cc: { id: 'cc', dependencies: ['aa'] },
     };
-    const result = validator.detectCircularDependencies(scopes);
+    // Check from cc perspective - it depends on aa, which eventually leads back to cc
+    const result = validator.detectCircularDependencies('cc', ['aa'], scopes);
     assertTrue(result.hasCircular, 'Should detect indirect circular dependency');
   });
 
-  test('accepts valid dependency graph', () => {
+  await test('accepts valid dependency graph', () => {
     const scopes = {
-      auth: { dependencies: [] },
-      payments: { dependencies: ['auth'] },
-      orders: { dependencies: ['auth', 'payments'] },
+      auth: { id: 'auth', dependencies: [] },
+      payments: { id: 'payments', dependencies: ['auth'] },
+      orders: { id: 'orders', dependencies: ['auth', 'payments'] },
     };
-    const result = validator.detectCircularDependencies(scopes);
+    // Check from orders perspective - no circular deps
+    const result = validator.detectCircularDependencies('orders', ['auth', 'payments'], scopes);
     assertFalse(result.hasCircular, 'Should not detect circular dependency');
   });
 }
@@ -207,7 +226,7 @@ function testScopeValidator() {
 // ScopeManager Tests
 // ============================================================================
 
-function testScopeManager() {
+async function testScopeManager() {
   console.log(`\n${colors.blue}ScopeManager Tests${colors.reset}`);
 
   const { ScopeManager } = require('../src/core/lib/scope/scope-manager');
@@ -230,7 +249,7 @@ function testScopeManager() {
   }
 
   // Test initialization
-  test('initializes scope system', async () => {
+  await test('initializes scope system', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -242,7 +261,7 @@ function testScopeManager() {
   });
 
   // Test scope creation
-  test('creates new scope', async () => {
+  await test('creates new scope', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -255,7 +274,7 @@ function testScopeManager() {
     }
   });
 
-  test('creates scope directory structure', async () => {
+  await test('creates scope directory structure', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -271,7 +290,7 @@ function testScopeManager() {
     }
   });
 
-  test('rejects invalid scope ID on create', async () => {
+  await test('rejects invalid scope ID on create', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -287,7 +306,7 @@ function testScopeManager() {
     }
   });
 
-  test('rejects duplicate scope ID', async () => {
+  await test('rejects duplicate scope ID', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -305,7 +324,7 @@ function testScopeManager() {
   });
 
   // Test scope retrieval
-  test('retrieves scope by ID', async () => {
+  await test('retrieves scope by ID', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -320,7 +339,7 @@ function testScopeManager() {
     }
   });
 
-  test('returns null for non-existent scope', async () => {
+  await test('returns null for non-existent scope', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -332,7 +351,7 @@ function testScopeManager() {
   });
 
   // Test scope listing
-  test('lists all scopes', async () => {
+  await test('lists all scopes', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -346,7 +365,7 @@ function testScopeManager() {
     }
   });
 
-  test('filters scopes by status', async () => {
+  await test('filters scopes by status', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -363,7 +382,7 @@ function testScopeManager() {
   });
 
   // Test scope update
-  test('updates scope properties', async () => {
+  await test('updates scope properties', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -379,7 +398,7 @@ function testScopeManager() {
   });
 
   // Test scope archive/activate
-  test('archives scope', async () => {
+  await test('archives scope', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -394,7 +413,7 @@ function testScopeManager() {
     }
   });
 
-  test('activates archived scope', async () => {
+  await test('activates archived scope', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -411,7 +430,7 @@ function testScopeManager() {
   });
 
   // Test path resolution
-  test('resolves scope paths', async () => {
+  await test('resolves scope paths', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -428,7 +447,7 @@ function testScopeManager() {
   });
 
   // Test dependency management
-  test('tracks scope dependencies', async () => {
+  await test('tracks scope dependencies', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -442,7 +461,7 @@ function testScopeManager() {
     }
   });
 
-  test('finds dependent scopes', async () => {
+  await test('finds dependent scopes', async () => {
     const manager = setup();
     try {
       await manager.initialize();
@@ -464,51 +483,52 @@ function testScopeManager() {
 // ArtifactResolver Tests
 // ============================================================================
 
-function testArtifactResolver() {
+async function testArtifactResolver() {
   console.log(`\n${colors.blue}ArtifactResolver Tests${colors.reset}`);
 
   const { ArtifactResolver } = require('../src/core/lib/scope/artifact-resolver');
 
-  test('allows read from any scope', () => {
+  // Note: canRead() and canWrite() return {allowed: boolean, reason: string, warning?: string}
+  await test('allows read from any scope', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
     });
 
-    assertTrue(resolver.canRead('_bmad-output/payments/planning-artifacts/prd.md'), 'Should allow cross-scope read');
-    assertTrue(resolver.canRead('_bmad-output/auth/planning-artifacts/prd.md'), 'Should allow own-scope read');
-    assertTrue(resolver.canRead('_bmad-output/_shared/project-context.md'), 'Should allow shared read');
+    assertTrue(resolver.canRead('_bmad-output/payments/planning-artifacts/prd.md').allowed, 'Should allow cross-scope read');
+    assertTrue(resolver.canRead('_bmad-output/auth/planning-artifacts/prd.md').allowed, 'Should allow own-scope read');
+    assertTrue(resolver.canRead('_bmad-output/_shared/project-context.md').allowed, 'Should allow shared read');
   });
 
-  test('allows write to own scope', () => {
+  await test('allows write to own scope', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
     });
 
-    assertTrue(resolver.canWrite('_bmad-output/auth/planning-artifacts/prd.md'), 'Should allow own-scope write');
+    assertTrue(resolver.canWrite('_bmad-output/auth/planning-artifacts/prd.md').allowed, 'Should allow own-scope write');
   });
 
-  test('blocks write to other scope in strict mode', () => {
+  await test('blocks write to other scope in strict mode', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
       isolationMode: 'strict',
     });
 
-    assertFalse(resolver.canWrite('_bmad-output/payments/planning-artifacts/prd.md'), 'Should block cross-scope write');
+    assertFalse(resolver.canWrite('_bmad-output/payments/planning-artifacts/prd.md').allowed, 'Should block cross-scope write');
   });
 
-  test('blocks direct write to _shared', () => {
+  await test('blocks direct write to _shared', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
     });
 
-    assertFalse(resolver.canWrite('_bmad-output/_shared/project-context.md'), 'Should block _shared write');
+    assertFalse(resolver.canWrite('_bmad-output/_shared/project-context.md').allowed, 'Should block _shared write');
   });
 
-  test('extracts scope from path', () => {
+  await test('extracts scope from path', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
@@ -519,7 +539,7 @@ function testArtifactResolver() {
     assertEqual(resolver.extractScopeFromPath('_bmad-output/_shared/context.md'), '_shared');
   });
 
-  test('throws on cross-scope write validation in strict mode', () => {
+  await test('throws on cross-scope write validation in strict mode', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
@@ -529,17 +549,17 @@ function testArtifactResolver() {
     assertThrows(() => resolver.validateWrite('_bmad-output/payments/prd.md'), 'Cannot write to scope');
   });
 
-  test('warns on cross-scope write in warn mode', () => {
+  await test('warns on cross-scope write in warn mode', () => {
     const resolver = new ArtifactResolver({
       currentScope: 'auth',
       basePath: '_bmad-output',
       isolationMode: 'warn',
     });
 
-    // Should not throw in warn mode
+    // In warn mode, allowed should be true but warning should be set
     const result = resolver.canWrite('_bmad-output/payments/prd.md');
-    // In warn mode, it may return true but log a warning
-    // The exact behavior depends on implementation
+    assertTrue(result.allowed, 'Should allow write in warn mode');
+    assertTrue(result.warning !== null, 'Should have a warning message');
   });
 }
 
@@ -547,7 +567,7 @@ function testArtifactResolver() {
 // StateLock Tests
 // ============================================================================
 
-function testStateLock() {
+async function testStateLock() {
   console.log(`\n${colors.blue}StateLock Tests${colors.reset}`);
 
   const { StateLock } = require('../src/core/lib/scope/state-lock');
@@ -565,7 +585,7 @@ function testStateLock() {
     }
   }
 
-  test('acquires and releases lock', async () => {
+  await test('acquires and releases lock', async () => {
     const lock = setup();
     try {
       const lockPath = path.join(tmpDir, 'test.lock');
@@ -580,7 +600,7 @@ function testStateLock() {
     }
   });
 
-  test('prevents concurrent access', async () => {
+  await test('prevents concurrent access', async () => {
     const lock = setup();
     try {
       const lockPath = path.join(tmpDir, 'test.lock');
@@ -610,7 +630,7 @@ function testStateLock() {
     }
   });
 
-  test('detects stale locks', async () => {
+  await test('detects stale locks', async () => {
     const lock = setup();
     try {
       const lockPath = path.join(tmpDir, 'test.lock');
@@ -637,7 +657,7 @@ function testStateLock() {
 // ScopeContext Tests
 // ============================================================================
 
-function testScopeContext() {
+async function testScopeContext() {
   console.log(`\n${colors.blue}ScopeContext Tests${colors.reset}`);
 
   const { ScopeContext } = require('../src/core/lib/scope/scope-context');
@@ -658,7 +678,7 @@ function testScopeContext() {
     }
   }
 
-  test('sets session scope', async () => {
+  await test('sets session scope', async () => {
     const context = setup();
     try {
       // Initialize scope system first
@@ -675,7 +695,7 @@ function testScopeContext() {
     }
   });
 
-  test('gets current scope from session', async () => {
+  await test('gets current scope from session', async () => {
     const context = setup();
     try {
       // Initialize scope system first
@@ -692,7 +712,7 @@ function testScopeContext() {
     }
   });
 
-  test('clears session scope', async () => {
+  await test('clears session scope', async () => {
     const context = setup();
     try {
       const manager = new ScopeManager({ projectRoot: tmpDir });
@@ -709,7 +729,7 @@ function testScopeContext() {
     }
   });
 
-  test('loads merged project context', async () => {
+  await test('loads merged project context', async () => {
     const context = setup();
     try {
       const manager = new ScopeManager({ projectRoot: tmpDir });
@@ -723,10 +743,10 @@ function testScopeContext() {
       fs.mkdirSync(path.join(tmpDir, '_bmad-output', 'auth'), { recursive: true });
       fs.writeFileSync(path.join(tmpDir, '_bmad-output', 'auth', 'project-context.md'), '# Auth Scope\n\nScope-specific content.');
 
-      const merged = await context.loadProjectContext('auth');
+      const result = await context.loadProjectContext('auth');
 
-      assertTrue(merged.includes('Global content'), 'Should include global content');
-      assertTrue(merged.includes('Scope-specific content'), 'Should include scope content');
+      assertTrue(result.merged.includes('Global content'), 'Should include global content');
+      assertTrue(result.merged.includes('Scope-specific content'), 'Should include scope content');
     } finally {
       teardown();
     }