@atlashub/smartstack-cli 3.37.0 → 3.38.0

package/templates/skills/business-analyse/references/handoff-seeddata-generation.md

@@ -0,0 +1,312 @@
+# SeedData Core Generation for Handoff
+
+Complete reference for generating `seedDataCore` from feature.json modules, application roles, and coverage matrix.
+
+## Helper Functions
+
+### PascalCase to Human Readable
+
+```javascript
+function toHumanReadable(pascalCase) {
+  return pascalCase
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+}
+```
+
+### PascalCase to Kebab Case
+
+```javascript
+function toKebabCase(code) {
+  return code
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase();
+}
+```
+
+## SeedDataCore Template
+
+```javascript
+const appCode = master.metadata.application;
+const appLabel = toHumanReadable(appCode);
+const appDesc = master.cadrage?.problem?.split('.')[0] || `Gestion ${appLabel}`;
+const lang = master.metadata.language || "fr";
+
+const seedDataCore = {
+  // Application-level navigation (MANDATORY — one entry per application)
+  navigationApplications: (() => {
+    if (workflow.mode === "project") {
+      // Multi-app: one navigation entry per application
+      return projectFeature.applications.map((app, idx) => {
+        const appLabel = toHumanReadable(app.code);
+        return {
+          code: app.code.toLowerCase(),
+          name: app.code,
+          labels: {
+            fr: lang === "fr" ? (app.name || appLabel) : appLabel,
+            en: lang === "en" ? (app.name || appLabel) : appLabel,
+            it: appLabel,
+            de: appLabel
+          },
+          description: {
+            fr: lang === "fr" ? (app.description || `Gestion ${appLabel}`) : `Gestion ${appLabel}`,
+            en: lang === "en" ? (app.description || `${appLabel} management`) : `${appLabel} management`,
+            it: `Gestione ${appLabel}`,
+            de: `${appLabel} Verwaltung`
+          },
+          icon: app.icon || inferIconFromApplication({ metadata: { application: app.code } }) || "layout-grid",
+          iconType: "lucide",
+          route: `/${toKebabCase(app.code)}`,
+          displayOrder: (idx + 1) * 10
+        };
+      });
+    } else {
+      // Single-app: one navigation entry
+      return [{
+        code: appCode.toLowerCase(),
+        name: appCode,
+        labels: {
+          fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          it: appLabel,
+          de: appLabel
+        },
+        description: {
+          fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
+          en: lang === "en" ? appDesc : `${appLabel} management`,
+          it: `Gestione ${appLabel}`,
+          de: `${appLabel} Verwaltung`
+        },
+        icon: inferIconFromApplication(master) || "layout-grid",
+        iconType: "lucide",
+        route: `/${toKebabCase(appCode)}`,
+        displayOrder: 1
+      }];
+    }
+  })(),
+
+  navigationModules: (() => {
+    if (workflow.mode === "project") {
+      let order = 0;
+      return projectFeature.applications.flatMap(app => {
+        return (app.modules || []).map(m => ({
+          code: m.code,
+          applicationCode: app.code,
+          label: m.name || m.code,
+          description: m.description,
+          icon: inferIconFromModule(m) || "folder",
+          iconType: "lucide",
+          route: `/${toKebabCase(app.code)}/${toKebabCase(m.code)}`,
+          displayOrder: (++order) * 10
+        }));
+      });
+    } else {
+      return master.modules.map((m, i) => ({
+        code: m.code,
+        label: m.name || m.code,
+        description: m.description,
+        icon: inferIconFromModule(m) || "folder",
+        iconType: "lucide",
+        route: `/${toKebabCase(appCode)}/${toKebabCase(m.code)}`,
+        displayOrder: (i + 1) * 10
+      }));
+    }
+  })(),
+
+  navigationSections: (() => {
+    const buildSections = (modules, appCode) =>
+      modules.flatMap(m =>
+        (m.anticipatedSections || []).map((s, j) => ({
+          moduleCode: m.code,
+          code: s.code,
+          label: s.description?.split(':')[0] || s.code,
+          description: s.description || "",
+          route: s.code === "list"
+            ? `/${toKebabCase(appCode)}/${toKebabCase(m.code)}`
+            : s.code === "detail"
+              ? `/${toKebabCase(appCode)}/${toKebabCase(m.code)}/:id`
+              : `/${toKebabCase(appCode)}/${toKebabCase(m.code)}/${toKebabCase(s.code)}`,
+          displayOrder: (j + 1) * 10,
+          navigation: s.code === "detail" ? "hidden" : "visible"
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildSections(app.modules || [], app.code)
+      );
+    } else {
+      return buildSections(master.modules, appCode);
+    }
+  })(),
+
+  navigationResources: master.cadrage.coverageMatrix
+    .filter(cm => cm.module && cm.anticipatedResources?.length > 0)
+    .flatMap(cm =>
+      cm.anticipatedResources.map((r, k) => ({
+        moduleCode: cm.module,
+        sectionCode: cm.anticipatedSections?.[0] || "list",
+        code: r,
+        label: r.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+        displayOrder: (k + 1) * 10
+      }))
+    ),
+
+  navigationTranslations: master.modules.flatMap(m => {
+    const langs = ["fr", "en", "it", "de"];
+    return langs.map(lang => ({
+      moduleCode: m.code,
+      language: lang,
+      label: lang === master.metadata.language ? (m.name || m.code) : m.code,
+      description: lang === master.metadata.language ? m.description : ""
+    }));
+  }),
+
+  permissions: (() => {
+    const buildPermissions = (modules, appCode) =>
+      modules.flatMap(m => {
+        const basePath = `${toKebabCase(appCode)}.${toKebabCase(m.code)}`;
+        const actions = ['read', 'create', 'update', 'delete'];
+        return [
+          { path: `${basePath}.*`, action: '*', description: `Full ${m.name || m.code} access` },
+          ...actions.map(action => ({
+            path: `${basePath}.${action}`,
+            action: action,
+            description: `${action.charAt(0).toUpperCase() + action.slice(1)} ${m.name || m.code}`
+          }))
+        ];
+      });
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildPermissions(app.modules || [], app.code)
+      );
+    } else {
+      return buildPermissions(master.modules, appCode);
+    }
+  })(),
+
+  rolePermissions: (() => {
+    const buildRolePermissions = (roles, modules, appCode) =>
+      roles.map(role => ({
+        role: role.role,
+        level: role.level,
+        permissions: modules.map(m => `${toKebabCase(appCode)}.${toKebabCase(m.code)}.${
+          role.level === 'admin' ? '*' :
+          role.level === 'manager' ? 'read,create,update' :
+          role.level === 'contributor' ? 'read,create' : 'read'
+        }`)
+      }));
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildRolePermissions(app.applicationRoles || [], app.modules || [], app.code)
+      );
+    } else {
+      return buildRolePermissions(master.cadrage.applicationRoles, master.modules, appCode);
+    }
+  })(),
+
+  permissionConstants: (() => {
+    const buildConstants = (modules, appCode) =>
+      modules.flatMap(m =>
+        ['Read', 'Create', 'Update', 'Delete', 'Validate', 'Export'].map(action => ({
+          module: m.code,
+          application: appCode,
+          action: action,
+          constant: `${appCode}${m.code}${action}`,
+          path: `${toKebabCase(appCode)}.${toKebabCase(m.code)}.${action.toLowerCase()}`
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildConstants(app.modules || [], app.code)
+      );
+    } else {
+      return buildConstants(master.modules, appCode);
+    }
+  })()
+};
+```
+
+## Icon Inference Functions
+
+### Application Level
+
+```javascript
+function inferIconFromApplication(master) {
+  const appLC = (master.metadata.application || '').toLowerCase();
+  const iconMap = {
+    'humanresource': 'users', 'rh': 'users', 'hr': 'users', 'personnel': 'users',
+    'sales': 'shopping-cart', 'vente': 'shopping-cart', 'commerce': 'shopping-cart',
+    'finance': 'wallet', 'comptabilite': 'calculator', 'accounting': 'calculator',
+    'inventory': 'warehouse', 'stock': 'package', 'logistic': 'truck',
+    'crm': 'building-2', 'customer': 'building', 'client': 'building-2',
+    'project': 'folder-kanban', 'task': 'check-square', 'gestion': 'layout-grid',
+    'admin': 'shield', 'support': 'headphones', 'maintenance': 'wrench',
+    'production': 'factory', 'quality': 'badge-check', 'document': 'file-text',
+    'fleet': 'car', 'vehicle': 'car', 'transport': 'truck',
+    'education': 'graduation-cap', 'formation': 'graduation-cap', 'training': 'graduation-cap'
+  };
+  for (const [keyword, icon] of Object.entries(iconMap)) {
+    if (appLC.includes(keyword)) return icon;
+  }
+  return "layout-grid";  // fallback — NEVER null
+}
+```
+
+### Module Level
+
+```javascript
+function inferIconFromModule(module) {
+  const codeLC = module.code.toLowerCase();
+  const iconMap = {
+    'employee': 'users', 'staff': 'users', 'personnel': 'users', 'user': 'users',
+    'project': 'folder-kanban', 'task': 'check-square', 'work': 'briefcase',
+    'time': 'clock', 'schedule': 'calendar', 'planning': 'calendar-days',
+    'absence': 'calendar-off', 'leave': 'calendar-off', 'vacation': 'palm-tree',
+    'finance': 'wallet', 'billing': 'receipt', 'invoice': 'file-text',
+    'inventory': 'warehouse', 'stock': 'package', 'product': 'shopping-bag',
+    'customer': 'building', 'client': 'building-2', 'contact': 'contact',
+    'report': 'bar-chart', 'dashboard': 'layout-dashboard', 'analytics': 'trending-up',
+    'document': 'file-text', 'notification': 'bell', 'setting': 'settings',
+    'order': 'shopping-cart', 'vehicle': 'car', 'maintenance': 'wrench',
+    'audit': 'shield-check', 'workflow': 'git-branch', 'approval': 'check-circle'
+  };
+  for (const [keyword, icon] of Object.entries(iconMap)) {
+    if (codeLC.includes(keyword)) return icon;
+  }
+  return "folder";  // fallback — NEVER null
+}
+```
+
+## POST-CHECK (BLOCKING for icons/application, warning for counts)
+
+```javascript
+IF !seedDataCore.navigationApplications || seedDataCore.navigationApplications.length === 0:
+  BLOCKING ERROR: "navigationApplications is empty — Application navigation will NOT be seeded. Menu will show (nothing) → Modules."
+IF seedDataCore.navigationApplications[0].icon === null || seedDataCore.navigationApplications[0].icon === undefined:
+  BLOCKING ERROR: "Application icon is null — ralph-loop will render empty navigation"
+IF !seedDataCore.navigationApplications[0].labels?.fr || !seedDataCore.navigationApplications[0].labels?.en:
+  BLOCKING ERROR: "Application labels missing fr/en — translations will fail"
+IF seedDataCore.navigationModules.length !== master.modules.length:
+  WARNING: seedDataCore has ${seedDataCore.navigationModules.length} nav modules but ${master.modules.length} modules exist
+IF seedDataCore.permissions.length === 0:
+  WARNING: seedDataCore has 0 permissions — applicationRoles may be missing
+IF seedDataCore.navigationModules.some(m => !m.icon || m.icon === null):
+  BLOCKING ERROR: "Navigation modules with null icons detected — ralph-loop will render empty navigation"
+  → Fix: Re-run inferIconFromModule() for modules with null icons
+IF seedDataCore.navigationSections.length === 0:
+  WARNING: "0 navigation sections — every module should have at least 1 section (e.g., 'list')"
+```
+
+## Writing to Feature.json
+
+```javascript
+ba-writer.enrichSection({
+  featureId: {feature_id},
+  section: "seedDataCore",
+  data: seedDataCore
+})
+```

package/templates/skills/business-analyse/references/init-schema-deployment.md

@@ -6,7 +6,7 @@
 
 ### Step 1: Check Deployment Cache
 
-Cache file location: `docs/business/{app}/business-analyse/.schema-cache.json`
+Cache file location: `docs/{app}/business-analyse/.schema-cache.json`
 
 ```
 IF EXISTS .schema-cache.json:
@@ -25,10 +25,10 @@ ELSE:
 ### Step 2: Deploy Schemas (if needed)
 
 Source: `schemas/` (relative to skill root = `~/.claude/skills/business-analyse/schemas/`)
-Destination: `docs/business/{app}/business-analyse/schemas/`
+Destination: `docs/{app}/business-analyse/schemas/`
 
 ```
-docs/business/{app}/business-analyse/schemas/
+docs/{app}/business-analyse/schemas/
 ├── feature-schema.json
 ├── application-schema.json
 ├── sections/

package/templates/skills/business-analyse/references/naming-conventions.md

@@ -15,7 +15,7 @@
 
 ### In URL Routes
 
-- **kebab-case lowercase** (e.g., `"/business/human-resources/employees"`)
+- **kebab-case lowercase** (e.g., `"/human-resources/employees"`)
 - Transform: `PascalCase` → `kebab-case` via helper function
 - Used for: Web URLs, navigation routes, API paths
 
@@ -27,8 +27,7 @@
 |--------|--------|---------|-------|
 | Module code | `PascalCase` | `HumanResources` | C# files, classes, namespaces |
 | Application code | `PascalCase` | `HumanResources` | Namespaces, folders |
-| Context code | `lowercase` | `business` | URLs, routes, contexts |
-| Route path | `kebab-case` | `/business/human-resources` | Web URLs, navigation |
+| Route path | `kebab-case` | `/human-resources` | Web URLs, navigation |
 | Section code | `kebab-case` | `time-tracking`, `approve` | URLs, API paths, sections |
 | Resource code | `kebab-case` | `repair-grid`, `employee-form` | Component IDs, resources |
 
@@ -63,7 +62,7 @@
 
 **Usage:**
 ```csharp
-Route = ToKebabCase($"/{contextCode}/{appCode}/{moduleCode}")
+Route = ToKebabCase($"/{appCode}/{moduleCode}")
 ```
 
 **Transformation Examples:**
@@ -80,7 +79,7 @@ Route = ToKebabCase($"/{contextCode}/{appCode}/{moduleCode}")
 
 **Usage:**
 ```javascript
-const route = `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+const route = `/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
 ```
 
 **Implementation:**
@@ -139,8 +138,8 @@ validate_frontend_routes
 **Output Example:**
 ```
 ❌ Case mismatch detected (1 routes with uppercase):
-   Route "business.humanresources" uses PascalCase in URL.
-   Found: business/HumanResources → Expected: business/human-resources
+   Route "humanresources" uses PascalCase in URL.
+   Found: HumanResources → Expected: human-resources
    Fix: Use ToKebabCase() in NavigationSeedData route generation
 ```
 
@@ -152,27 +151,27 @@ validate_frontend_routes
 
 **Wrong (causes 404 on menu click):**
 ```csharp
-Route = $"/{contextCode}/{appCode}/{moduleCode}"
-// Result: /business/HumanResources/Projects
+Route = $"/{appCode}/{moduleCode}"
+// Result: /HumanResources/Projects
 ```
 
 **Correct:**
 ```csharp
-Route = ToKebabCase($"/{contextCode}/{appCode}/{moduleCode}")
-// Result: /business/human-resources/projects
+Route = ToKebabCase($"/{appCode}/{moduleCode}")
+// Result: /human-resources/projects
 ```
 
 ### ❌ Hardcoding Routes in lowercase
 
 **Wrong (loses traceability to code):**
 ```csharp
-Route = "/business/humanresources"  // Flattens multi-word into single word
+Route = "/humanresources"  // Flattens multi-word into single word
 ```
 
 **Correct:**
 ```csharp
-Route = ToKebabCase($"/{contextCode}/{appCode}")
-// If appCode = "HumanResources" → /business/human-resources
+Route = ToKebabCase($"/{appCode}")
+// If appCode = "HumanResources" → /human-resources
 ```
 
 ### ❌ Inconsistent Section/Resource Codes
@@ -189,7 +188,7 @@ Route = ToKebabCase($"/{contextCode}/{appCode}")
 ```json
 {
   "code": "time-tracking",  // kebab-case from start
-  "route": "/business/human-resources/time-tracking"
+  "route": "/human-resources/time-tracking"
 }
 ```
 
@@ -205,7 +204,6 @@ Sections and resources ALWAYS use kebab-case (no transformation needed).
 ```json
 {
   "metadata": {
-    "context": "business",
     "application": "HumanResources"
   },
   "modules": [
@@ -217,22 +215,22 @@ Sections and resources ALWAYS use kebab-case (no transformation needed).
 
 **Generated Routes (seed data):**
 ```
-Application: /business/human-resources
-Module 1:    /business/human-resources/time-management
-Module 2:    /business/human-resources/projects
+Application: /human-resources
+Module 1:    /human-resources/time-management
+Module 2:    /human-resources/projects
 ```
 
 **C# Code Structure:**
 ```
-src/Domain/Entities/Business/HumanResources/TimeManagement/TimeEntry.cs
-src/Application/Services/Business/HumanResources/TimeManagement/TimeEntryService.cs
-src/API/Controllers/Business/HumanResources/TimeManagementController.cs
+src/Domain/Entities/HumanResources/TimeManagement/TimeEntry.cs
+src/Application/Services/HumanResources/TimeManagement/TimeEntryService.cs
+src/API/Controllers/HumanResources/TimeManagementController.cs
 ```
 
 **Frontend Routes (React Router):**
 ```tsx
-<Route path="/business/human-resources/time-management" element={<TimeManagementPage />} />
-<Route path="/business/human-resources/projects" element={<ProjectsPage />} />
+<Route path="/human-resources/time-management" element={<TimeManagementPage />} />
+<Route path="/human-resources/projects" element={<ProjectsPage />} />
 ```
 
 ---

package/templates/skills/business-analyse/references/prd-generation.md

@@ -216,14 +216,14 @@ BLOCKING_ERROR: api: prd has 8 files but feature.json has 12
 **Derive PRD from feature.json:**
 ```bash
 ss derive-prd \
-  --feature docs/business/{App}/{Module}/business-analyse/v1.0/feature.json \
+  --feature docs/{App}/business-analyse/v1.0/feature.json \
   --output .ralph/prd-{ModuleCode}.json
 ```
 
 **Example:**
 ```bash
 ss derive-prd \
-  --feature docs/business/HumanResources/Projects/business-analyse/v1.0/feature.json \
+  --feature docs/HumanResources/business-analyse/v1.0/feature.json \
   --output .ralph/prd-Projects.json
 ```
 

package/templates/skills/business-analyse/references/review-data-mapping.md

@@ -220,12 +220,12 @@ reversePermissions(htmlPermissions, moduleCode, appName) {
     if (action === "*") {
       // Wildcard: add all standard permission paths
       Object.values(actionToPermission).forEach(permAction => {
-        const path = `business.${appName}.${moduleCode}.*.${permAction}`;
+        const path = `${appName}.${moduleCode}.*.${permAction}`;
         if (!rolePerms[role].includes(path)) rolePerms[role].push(path);
       });
     } else {
       const permAction = actionToPermission[action] || action.toLowerCase();
-      const path = `business.${appName}.${moduleCode}.*.${permAction}`;
+      const path = `${appName}.${moduleCode}.*.${permAction}`;
       if (!rolePerms[role].includes(path)) rolePerms[role].push(path);
     }
   });

package/templates/skills/business-analyse/references/robustness-checks.md

@@ -50,7 +50,7 @@ Ensures each module has ALL required components before being marked as "specifie
 | # | Check | Minimum | Blocking | Rationale |
 |---|-------|---------|----------|-----------|
 | 4.1 | Permissions count | ≥5 | YES | CRUD (4) + 1 business action minimum |
-| 4.2 | Permission format | Module: `business.{app}.{module}.{action}` or Section: `business.{app}.{module}.{section}.{action}` | YES | Wrong format breaks RBAC system |
+| 4.2 | Permission format | Module: `{app}.{module}.{action}` or Section: `{app}.{module}.{section}.{action}` | YES | Wrong format breaks RBAC system |
 | 4.3 | Role permissions | All roles have ≥1 permission | YES | Roles without permissions are useless |
 
 #### SECTION 5: UI & Navigation (4 checks)

package/templates/skills/business-analyse/references/spec-auto-inference.md

@@ -90,15 +90,15 @@ IF entity has lifeCycles:
 ### Detail section auto-generation
 
 When auto-generating the detail section, create:
-- `specification.sections[]` entry with `code: "detail"`, `navigation: "hidden"`, route `/business/{app}/{module}/:id`
+- `specification.sections[]` entry with `code: "detail"`, `navigation: "hidden"`, route `/{app}/{module}/:id`
 - `specification.uiWireframes[]` entry with `section: "detail"` and ASCII mockup showing all tabs
 - Resources: `{module}-detail-header` (DetailHeader), `{module}-detail-tabs` (TabPanel), `{module}-info-card` (DetailCard), one `{module}-{relation}-grid` per relation tab, `{module}-history` (Timeline if auditable)
 
 ### Detail page navigation wiring
 
 The detail page is NOT a sidebar entry. Navigation is handled by:
-- **From list**: row click action `navigate:detail` → `/business/{app}/{module}/{id}`
-- **Back button**: detail header → `/business/{app}/{module}`
+- **From list**: row click action `navigate:detail` → `/{app}/{module}/{id}`
+- **Back button**: detail header → `/{app}/{module}`
 - **Route registration**: route MUST be registered in frontend routing with `:id` parameter
 
 ## Status/Lifecycle Enhancement

package/templates/skills/business-analyse/references/team-orchestration.md

@@ -80,7 +80,7 @@ rm -rf ~/.claude/teams/ba-{appName} 2>/dev/null
 ### 1b. Create Team and Capture Actual Name
 
 ```javascript
-const result = TeamCreate({ team_name: "ba-{appName}" });
+const result = TeamCreate({ team_name: "ba-{appName}", description: "BA module analysis for {appName}" });
 // CRITICAL: TeamCreate may return a DIFFERENT name than requested!
 // Always use the RETURNED team_name, not the requested one.
 const actualTeamName = result.team_name;
@@ -139,8 +139,8 @@ IF layer.modules.length >= 2:
 
   5. Permission path consistency
      → Verify permission paths won't collide:
-       {context}.{app}.{module1}.{entity}.{action}
-       {context}.{app}.{module2}.{entity}.{action}
+       {app}.{module1}.{entity}.{action}
+       {app}.{module2}.{entity}.{action}
 
   Build coordinationNotes for EACH module in the layer:
 ```
@@ -215,7 +215,7 @@ Task({
     completedModulesSummary,
     coordinationNotes: "",  // empty for single-module layer
     language: metadata.language,
-    docsDir: "docs/business/{appName}/{moduleCode}/business-analyse/v{version}/"
+    docsDir: "docs/{appName}/{moduleCode}/business-analyse/v{version}/"
   }),
   description: "Specify {moduleCode}"
 });
@@ -507,7 +507,7 @@ IF layer.modules.length >= 2 AND all modules approved:
      → e.g., if Products.CategoryId references Categories.Category, names must match
 
   2. Permission paths: Are paths consistent and non-colliding?
-     → business.{app}.{module1}.{entity}.read vs business.{app}.{module2}.{entity}.read
+     → {app}.{module1}.{entity}.read vs {app}.{module2}.{entity}.read
 
   3. i18n keys: Do keys follow consistent patterns? No collisions?
      → {module1}.labels.name vs {module2}.labels.name (OK — namespaced)
@@ -691,7 +691,7 @@ Validate interactions between ALL applications in the project:
 1. Cross-application shared entities
    → Entity defined in App A, referenced by App B via data dependency
 2. Cross-application permission path consistency
-   → Each app uses its own context prefix (e.g., business.hr.* vs business.selfservice.*)
+   → Each app uses its own context prefix (e.g., hr.* vs selfservice.*)
 3. Cross-application role consistency
    → Same role names have compatible permission levels across apps
 4. Cross-application navigation coherence
@@ -902,6 +902,49 @@ If the entire session crashes:
 
 ---
 
+## Task List Coordination (T10)
+
+Create tasks for each module analysis before spawning teammates:
+
+```javascript
+// Create tasks for each module before spawning agents
+for (const mod of moduleOrder) {
+  TaskCreate({
+    subject: `Specify ${mod} module`,
+    description: `Propose business specification including entities, attributes, permissions, and workflows for ${mod}`,
+    activeForm: `Analyzing ${mod}`
+  });
+}
+
+// Teammates update task status when done
+TaskUpdate({ taskId: currentTaskId, status: 'completed' });
+
+// Team lead checks progress
+TaskList(); // View all tasks and their status
+```
+
+---
+
+## Idle State Handling (T13)
+
+> **IMPORTANT:** Teammates go idle after every turn — this is completely normal.
+> Idle simply means the teammate is waiting for input. An idle notification immediately
+> after a message does NOT mean the teammate is done or has errors.
+> Send a message to an idle teammate to wake it up.
+
+---
+
+## Team Config Discovery (T14)
+
+```javascript
+// Teammates can discover each other via team config:
+// ~/.claude/teams/{team-name}/config.json
+// Contains: members[] with name, agentId, agentType
+// Always refer to teammates by NAME, not by UUID.
+```
+
+---
+
 ## Decision Matrix
 
 | Condition | Action |

package/templates/skills/business-analyse/references/ui-dashboard-spec.md

@@ -56,7 +56,7 @@ When a "dashboard" section is selected, capture structured KPI and chart data **
     { "field": "dateRange", "type": "dateRange", "label": "Période" },
     { "field": "status", "type": "multiselect", "label": "Statut" }
   ],
-  "permissionsRequired": ["business.{app}.{module}.read"]
+  "permissionsRequired": ["{app}.{module}.read"]
 }
 ```