aios-core 4.2.15 → 4.4.0

package/.aios-core/development/tasks/analyze-project-structure.md

@@ -556,6 +556,54 @@ After this analysis:
 
 ---
 
+### Step 5.5: Code Intelligence: Dependency & Complexity (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true.
+> If no code intelligence provider is available, skip this step silently and proceed to Step 6.
+
+When code intelligence is available, enrich the analysis with real dependency and complexity data:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getDependencyGraph, getComplexityAnalysis } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const depGraph = await getDependencyGraph(projectPath);
+  const complexity = await getComplexityAnalysis(serviceEntryPoints);
+
+  // Add to project-analysis.md:
+  // - depGraph.dependencies: real module dependency graph
+  // - depGraph.summary: { totalDeps, depth }
+  // - complexity.perFile: complexity score per file
+  // - complexity.average: average complexity across analyzed files
+}
+```
+
+**If data is available, add these sections to the analysis documents:**
+
+**Dependency Graph (Code Intelligence):**
+
+| Metric | Value |
+|--------|-------|
+| Total Dependencies | {{depGraph.summary.totalDeps}} |
+| Dependency Depth | {{depGraph.summary.depth}} |
+
+{{depGraph.dependencies key relationships}}
+
+**Complexity Metrics (Code Intelligence):**
+
+| File | Complexity Score |
+|------|-----------------|
+{{for each complexity.perFile}}
+| {{file}} | {{complexity.score}} |
+{{end for}}
+
+**Average Complexity:** {{complexity.average}}
+
+> **Note:** These metrics are from real code analysis, not estimates.
+
+---
+
 ### Step 6: Present Results
 
 Display summary to user:

package/.aios-core/development/tasks/apply-qa-fixes.md

@@ -338,3 +338,10 @@ This task is complete when:
 - ✅ All tests pass (linting, unit, integration)
 - ✅ Story file is updated with changes
 - ✅ Code is ready for QA re-review
+
+## Handoff
+next_agent: @qa
+next_command: *review {story-id}
+condition: Fixes applied, ready for re-review
+alternatives:
+  - agent: @dev, command: *run-tests, condition: Need to verify fixes pass tests first

package/.aios-core/development/tasks/architect-analyze-impact.md

@@ -824,4 +824,11 @@ module.exports = AnalyzeImpactTask;
 - Sanitize component paths and modification descriptions
 - Ensure approval workflow cannot be bypassed for critical changes
 - Validate output file paths for report generation
-- Log all high-risk modification attempts for audit 
+- Log all high-risk modification attempts for audit
+
+## Handoff
+next_agent: @analyst
+next_command: *research {topic}
+condition: Complexity class is STANDARD or COMPLEX (research needed)
+alternatives:
+  - agent: @pm, command: *write-spec, condition: Complexity class is SIMPLE (skip research) 

package/.aios-core/development/tasks/brownfield-create-epic.md

@@ -55,6 +55,47 @@ const architectureShardedLocation = config.architectureShardedLocation || 'docs/
 
 ## Instructions
 
+### 0. Code Intelligence: Codebase Overview (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true.
+> If no code intelligence provider is available, skip this step silently and proceed to Step 1.
+
+When code intelligence is available, enrich the epic with real codebase data:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getCodebaseOverview, getDependencyGraph } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const overview = await getCodebaseOverview('.');
+  const depGraph = await getDependencyGraph('.');
+
+  // Include in epic under "Codebase Intelligence" section:
+  // - overview.codebase: project patterns, file groups
+  // - overview.stats: file counts, language distribution
+  // - depGraph.dependencies: module relationships
+  // - depGraph.summary: { totalDeps, depth }
+}
+```
+
+**If data is available, add this section to the epic:**
+
+#### Codebase Intelligence
+
+| Metric | Value |
+|--------|-------|
+| Project Overview | {{overview.codebase summary}} |
+| File Statistics | {{overview.stats}} |
+| Dependency Depth | {{depGraph.summary.depth}} |
+| Total Dependencies | {{depGraph.summary.totalDeps}} |
+
+**Dependency Graph Summary:**
+{{depGraph.dependencies key relationships}}
+
+> **Note:** This section is auto-generated from code intelligence. Values are real codebase data, not estimates.
+
+---
+
 ### 1. Project Analysis (Required)
 
 Before creating the epic, gather essential information about the existing project:

package/.aios-core/development/tasks/brownfield-create-story.md

@@ -354,4 +354,11 @@ The story creation is successful when:
 - Always prioritize existing system integrity
 - When in doubt about integration complexity, use brownfield-create-epic instead
 - Stories should take no more than 4 hours of focused development work
+
+## Handoff
+next_agent: @po
+next_command: *validate-story-draft {story-id}
+condition: Brownfield story created from assessment
+alternatives:
+  - agent: @sm, command: *draft, condition: Need additional stories from same assessment
  

package/.aios-core/development/tasks/build-autonomous.md

@@ -190,3 +190,10 @@ The AutonomousBuildLoop emits these events for monitoring:
 ---
 
 _Task file for Story 8.1 - Coder Agent Loop_
+
+## Handoff
+next_agent: @qa
+next_command: *review {story-id}
+condition: Autonomous build completed successfully
+alternatives:
+  - agent: @dev, command: *build-resume {story-id}, condition: Build failed, needs resume

package/.aios-core/development/tasks/create-deep-research-prompt.md

@@ -496,4 +496,11 @@ CRITICAL: collaborate with the user to develop specific, actionable research que
 - Balance comprehensiveness with focus
 - Document assumptions and limitations clearly
 - Plan for iterative refinement based on initial findings
+
+## Handoff
+next_agent: @pm
+next_command: *write-spec
+condition: Research complete (research.json created)
+alternatives:
+  - agent: @architect, command: *analyze-impact, condition: Research reveals higher complexity than expected
  

package/.aios-core/development/tasks/create-doc.md

@@ -250,6 +250,50 @@ If a YAML Template has not been provided, list all templates from .aios-core/pro
 
 **NEVER ask yes/no questions or use any other format.**
 
+## Code Intelligence: Codebase Intelligence Section (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true AND the document being created is a PRD or architecture document.
+> If no code intelligence provider is available, skip this enhancement silently.
+
+When creating PRDs or architecture documents with code intelligence available, add a "Codebase Intelligence" section:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getCodebaseOverview, getDependencyGraph } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const overview = await getCodebaseOverview('.');
+  const depGraph = await getDependencyGraph('.');
+
+  // Add optional section to generated document:
+  // - overview.codebase: project patterns, file groups, architecture
+  // - overview.stats: file counts, language distribution, LOC
+  // - depGraph.summary: { totalDeps, depth }
+}
+```
+
+**If data is available, append this section to the generated document:**
+
+```markdown
+## Codebase Intelligence
+
+> Auto-generated from code intelligence provider. Real codebase data, not estimates.
+
+### Project Overview
+{{overview.codebase summary — patterns, file groups, architecture}}
+
+### Statistics
+{{overview.stats — file counts, language distribution}}
+
+### Dependency Summary
+- **Total Dependencies:** {{depGraph.summary.totalDeps}}
+- **Dependency Depth:** {{depGraph.summary.depth}}
+```
+
+> **Note:** This section is optional and only appears when a code intelligence provider is available. The document is fully functional without it.
+
+---
+
 ## Processing Flow
 
 1. **Parse YAML template** - Load template metadata and sections

package/.aios-core/development/tasks/create-next-story.md

@@ -239,6 +239,16 @@ To identify the next logical story based on project progress and epic definition
 - **If no story files exist:** The next story is ALWAYS 1.1 (first story of first epic)
 - Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}"
 
+### 1.2 Code Intelligence: Duplicate Detection & File Suggestions (Auto-skip if unavailable)
+
+- **Check code intelligence availability:** Call `isCodeIntelAvailable()` from `.aios-core/core/code-intel`
+- **If available:**
+  - Call `detectDuplicateStory(storyDescription)` from `.aios-core/core/code-intel/helpers/story-helper`
+    - If matches found: Display advisory warning to user — "Similar functionality found: {warning}". This is **advisory only** and does NOT block story creation.
+  - Call `suggestRelevantFiles(storyDescription)` from `.aios-core/core/code-intel/helpers/story-helper`
+    - If files found: Pre-populate a "Suggested Files" note in the Dev Notes section with the relevant file references
+- **If NOT available:** Skip this step silently — story creation proceeds exactly as before
+
 ### 2. Gather Story Requirements and Previous Story Context
 
 - Extract story requirements from the identified epic file
@@ -772,3 +782,10 @@ Use the primary agent from "Specialized Agent Assignment" to determine which sel
   - Next steps: For Complex stories, suggest the user carefully review the story draft and also optionally have the PO run the task `aios-core/tasks/validate-next-story`
 
 **ClickUp Integration Note:** This task now includes Epic verification (Section 5.1), ClickUp story task creation (Section 5.3), and automatic frontmatter updates (Section 5.4). Stories are created as subtasks of their parent Epic in ClickUp's Backlog list. If Epic verification or ClickUp sync fails, the story file will still be created locally with a warning message.
+
+## Handoff
+next_agent: @po
+next_command: *validate-story-draft {story-id}
+condition: Story status is Draft
+alternatives:
+  - agent: @dev, command: *develop {story-id}, condition: Story already validated by PO

package/.aios-core/development/tasks/create-suite.md

@@ -281,4 +281,11 @@ Creates multiple related components in a single batch operation with dependency
 - Supports atomic creation (all or nothing)
 - Transaction log enables rollback functionality
 - Dependency resolution ensures correct creation order
+
+## Handoff
+next_agent: @dev
+next_command: *run-tests
+condition: Test suite created, ready for execution
+alternatives:
+  - agent: @qa, command: *review {story-id}, condition: Tests written as part of review
 - Preview functionality helps prevent mistakes 

package/.aios-core/development/tasks/dev-develop-story.md

@@ -559,7 +559,7 @@ Execute **AFTER** all tasks are complete but **BEFORE** running the DOD checklis
 │  WHILE iteration < max_iterations:                           │
 │    ┌────────────────────────────────────────────────────┐   │
 │    │ 1. Run CodeRabbit CLI                              │   │
-│    │    wsl bash -c 'cd /mnt/c/.../@synkra/aios-core &&    │   │
+│    │    wsl bash -c 'cd /mnt/c/.../aios-core &&    │   │
 │    │    ~/.local/bin/coderabbit --prompt-only           │   │
 │    │    -t uncommitted'                                  │   │
 │    │                                                     │   │
@@ -914,3 +914,11 @@ Found 5 technical decisions needed.
 - **Decision Logs**: Persisted in `.ai/decision-log-{story-id}.md` for future reference and review
 - **Educational Value**: Interactive mode explanations help developers learn framework patterns
 - **Scope Drift Prevention**: Pre-flight mode eliminates mid-development ambiguity
+
+## Handoff
+next_agent: @qa
+next_command: *review {story-id}
+condition: Story status is Ready for Review
+alternatives:
+  - agent: @qa, command: *gate {story-id}, condition: Quick gate decision needed
+  - agent: @dev, command: *apply-qa-fixes, condition: Self-identified issues during dev

package/.aios-core/development/tasks/execute-checklist.md

@@ -299,3 +299,10 @@ The LLM will:
 - Execute the complete checklist validation
 - Present a final report with pass/fail rates and key findings
 - Offer to provide detailed analysis of any section, especially those with warnings or failures
+
+## Handoff
+next_agent: @qa
+next_command: *review {story-id}
+condition: Checklist completed with all items passing
+alternatives:
+  - agent: @dev, command: *develop {story-id}, condition: Checklist found blocking issues

package/.aios-core/development/tasks/github-devops-github-pr-automation.md

@@ -501,6 +501,55 @@ function generatePRDescription(storyInfo, context) {
 }
 ```
 
+### Step 5.1: Enrich PR Description with Impact Analysis (Code Intelligence — Advisory)
+
+> **Added by:** Story NOG-7 (DevOps Pre-Push Impact Analysis)
+> **Behavior:** Auto-skips if code intelligence unavailable. Appends "Impact Analysis" section to PR body.
+
+```javascript
+const { generateImpactSummary } = require('.aios-core/core/code-intel/helpers/devops-helper');
+
+async function enrichPRWithImpactAnalysis(description, changedFiles) {
+  // Auto-skip if code intelligence unavailable
+  const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+  if (!isCodeIntelAvailable()) {
+    return description; // Return original description unchanged
+  }
+
+  const impact = await generateImpactSummary(changedFiles);
+
+  if (!impact) {
+    return description; // No impact data — return original
+  }
+
+  // Append Impact Analysis section to PR description
+  const impactSection = [
+    '',
+    '## Impact Analysis',
+    '',
+    impact.summary,
+    '',
+    '---',
+    '*Generated by Code Intelligence (advisory only)*',
+  ].join('\n');
+
+  return description + impactSection;
+}
+```
+
+**Usage in PR creation flow:**
+
+After `generatePRDescription()` returns the base description, call `enrichPRWithImpactAnalysis()` to optionally append the impact section:
+
+```javascript
+let description = generatePRDescription(storyInfo, context);
+description = await enrichPRWithImpactAnalysis(description, changedFiles);
+```
+
+**Important:** If code intelligence is unavailable or returns null, the PR description remains unchanged — zero impact on existing workflow.
+
+---
+
 ### Step 6: Determine Base Branch
 
 ```javascript
@@ -662,3 +711,10 @@ github:
 - Gracefully handles missing story file
 - Uses GitHub CLI for reliability
 - Repository context from detector
+
+## Handoff
+next_agent: @po
+next_command: *close-story {story-id}
+condition: PR merged successfully
+alternatives:
+  - agent: @dev, command: *apply-qa-fixes, condition: PR review requested changes

package/.aios-core/development/tasks/github-devops-pre-push-quality-gate.md

@@ -630,6 +630,64 @@ function determineSecurityGate(results) {
 }
 ```
 
+### 9.1 Impact Analysis (Code Intelligence — Advisory Only)
+
+> **Added by:** Story NOG-7 (DevOps Pre-Push Impact Analysis)
+> **Behavior:** Advisory only — NEVER blocks push. Auto-skips if code intelligence unavailable.
+
+```javascript
+const { assessPrePushImpact, classifyRiskLevel } = require('.aios-core/core/code-intel/helpers/devops-helper');
+
+async function runImpactAnalysis(changedFiles) {
+  // Auto-skip if code intelligence unavailable
+  const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+  if (!isCodeIntelAvailable()) {
+    console.log('ℹ️  Code intelligence not available — skipping impact analysis');
+    return { skipped: true };
+  }
+
+  console.log('\n📊 Running Impact Analysis...\n');
+
+  const result = await assessPrePushImpact(changedFiles);
+
+  if (!result) {
+    console.log('ℹ️  Impact analysis returned no data — skipping');
+    return { skipped: true };
+  }
+
+  // Display formatted report
+  console.log(result.report);
+
+  // HIGH risk: add extra warning (advisory, does not block)
+  if (result.riskLevel === 'HIGH') {
+    console.log('\n⚠️  HIGH RISK detected. Additional confirmation recommended before push.');
+  }
+
+  return {
+    skipped: false,
+    riskLevel: result.riskLevel,
+    blastRadius: result.impact ? result.impact.blastRadius : 0,
+    report: result.report,
+  };
+}
+```
+
+**Integration with Summary Report:**
+
+Add impact analysis results to the summary report section:
+
+```
+Impact Analysis:
+  📊 Blast Radius: {N} files affected
+  📊 Risk Level: {LOW|MEDIUM|HIGH}
+  {if HIGH: ⚠️  HIGH RISK: {N} files affected. Confirm push?}
+  {if skipped: ℹ️  Skipped (code intelligence not available)}
+```
+
+**Important:** This step is purely advisory. A HIGH risk level does NOT change the overall gate status from PASS to FAIL. It only adds an informational warning and may prompt additional user confirmation.
+
+---
+
 ### 10. Verify Story Status (Optional - if using story-driven workflow)
 
 ```javascript
@@ -684,6 +742,11 @@ Quality Checks:
   ✓ Security scan        PASSED
   ⚠️ Story status         SKIPPED (no story file)
 
+Impact Analysis (Advisory):
+  📊 Blast Radius: {N} files affected
+  📊 Risk Level: LOW | MEDIUM | HIGH
+  ℹ️  Advisory only — does not affect gate status
+
 Security Scan Results:
   ✓ Dependencies: 0 critical, 0 high, 2 moderate, 5 low
   ✓ Code patterns: No security issues
@@ -788,3 +851,10 @@ Called via `@github-devops *pre-push` command.
 - Security scan is mandatory (TR-3.14.11)
 - User always has final approval
 - Detailed logging for troubleshooting
+
+## Handoff
+next_agent: @devops
+next_command: *push
+condition: All quality checks PASS
+alternatives:
+  - agent: @dev, command: *run-tests, condition: Quality checks FAIL, needs fixes

package/.aios-core/development/tasks/github-issue-triage.md

@@ -0,0 +1,118 @@
+# GitHub Issue Triage
+
+## Task Metadata
+
+```yaml
+id: github-issue-triage
+name: GitHub Issue Triage
+agent: devops
+elicit: true
+category: repository-management
+story: GHIM-001
+```
+
+## Description
+
+Systematic triage of GitHub issues for the aios-core repository. This task guides @devops through the process of reviewing, classifying, and labeling open issues.
+
+## Prerequisites
+
+- GitHub CLI authenticated (`gh auth status`)
+- Label taxonomy deployed (see GHIM-001 Phase 1)
+- Access to repository issue list
+
+## Workflow
+
+### Step 1: List Untriaged Issues
+
+```bash
+gh issue list --label "status: needs-triage" --json number,title,labels,createdAt,author --limit 50
+```
+
+### Step 2: Per-Issue Triage (Interactive)
+
+For each issue, apply the triage checklist:
+
+1. **Read the issue** — Open and understand the content
+2. **Classify type** — Apply ONE `type:` label:
+   - `type: bug` — Something isn't working
+   - `type: feature` — New feature request
+   - `type: enhancement` — Improvement to existing feature
+   - `type: docs` — Documentation issue
+   - `type: test` — Test coverage
+   - `type: chore` — Maintenance/cleanup
+3. **Assess priority** — Apply ONE `priority:` label:
+   - `priority: P1` — Critical, blocks users (SLA: 24h response)
+   - `priority: P2` — High, affects most users (SLA: 3 days)
+   - `priority: P3` — Medium, affects some users (SLA: 1 week)
+   - `priority: P4` — Low, edge cases (backlog)
+4. **Assign area** — Apply ONE or more `area:` labels:
+   - `area: core`, `area: installer`, `area: synapse`, `area: cli`
+   - `area: pro`, `area: health-check`, `area: docs`, `area: devops`
+5. **Update status** — Replace `status: needs-triage` with appropriate status:
+   - `status: confirmed` — Valid issue, ready for work
+   - `status: needs-info` — Need more details from reporter
+6. **Check for duplicates** — If duplicate, label `duplicate` and close with reference
+7. **Community labels** — If appropriate, add `community: good first issue` or `community: help wanted`
+
+### Step 3: Apply Labels
+
+```bash
+gh issue edit {number} --add-label "type: bug,priority: P2,area: installer,status: confirmed" --remove-label "status: needs-triage"
+```
+
+### Step 4: Batch Triage (Optional)
+
+For bulk operations, use the triage script:
+
+```bash
+node .aios-core/development/scripts/issue-triage.js --list
+node .aios-core/development/scripts/issue-triage.js --apply {number} --type bug --priority P2 --area installer
+```
+
+### Step 5: Report
+
+After triage session, generate summary:
+
+```bash
+node .aios-core/development/scripts/issue-triage.js --report
+```
+
+## Triage Decision Tree
+
+```
+Issue received
+  ├── Is it a duplicate? → Label "duplicate", close with reference
+  ├── Is it spam/invalid? → Label "status: invalid", close
+  ├── Needs more info? → Label "status: needs-info", comment asking for details
+  └── Valid issue
+       ├── Bug → "type: bug" + priority + area
+       ├── Feature → "type: feature" + priority + area
+       ├── Enhancement → "type: enhancement" + priority + area
+       ├── Docs → "type: docs" + priority: P3/P4
+       └── Tests → "type: test" + area
+```
+
+## Priority Guidelines
+
+| Signal | Priority |
+|--------|----------|
+| Blocks installation/usage for all users | P1 |
+| Breaks core functionality, no workaround | P1 |
+| Significant bug with workaround | P2 |
+| Feature highly requested by community | P2 |
+| Minor bug, edge case | P3 |
+| Nice-to-have improvement | P3 |
+| Cosmetic, low impact | P4 |
+
+## Command Integration
+
+This task is invocable via @devops:
+- `*triage` — Start interactive triage session
+- `*triage --batch` — Run batch triage with script
+
+## Output
+
+- All issues labeled with `type:`, `priority:`, `area:` labels
+- `status: needs-triage` removed from all triaged issues
+- Triage report with summary of actions taken