mindforge-cc 3.0.0 → 5.0.0

package/.mindforge/engine/nexus-tracer.js

@@ -0,0 +1,115 @@
+/**
+ * MindForge Nexus — Core Tracer Engine (v4.1.0-alpha.nexus)
+ *
+ * Handles Agentic Reasoning Tracing (ART) spans and OpenTelemetry-compatible 
+ * trace context propagation across the agentic mesh.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+class NexusTracer {
+  constructor(config = {}) {
+    this.projectId = config.projectId || 'mindforge-nexus';
+    this.auditPath = config.auditPath || path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+    this.currentTraceId = null;
+    this.activeSpans = new Map();
+  }
+
+  /**
+   * Initialize or resume a trace.
+   */
+  startTrace(traceId = null) {
+    this.currentTraceId = traceId || `tr_${crypto.randomBytes(8).toString('hex')}`;
+    return this.currentTraceId;
+  }
+
+  /**
+   * Start a new ART span.
+   */
+  startSpan(name, attributes = {}, parentSpanId = null) {
+    const spanId = `sp_${crypto.randomBytes(6).toString('hex')}`;
+    const startTime = new Date().toISOString();
+
+    const span = {
+      id: spanId,
+      trace_id: this.currentTraceId,
+      parent_id: parentSpanId || null,
+      name,
+      status: 'active',
+      start_time: startTime,
+      attributes: {
+        ...attributes,
+        service: 'mindforge-nexus',
+      }
+    };
+
+    this.activeSpans.set(spanId, span);
+
+    // Record span start in AUDIT.jsonl
+    this._recordEvent('span_started', { 
+      span_id: spanId, 
+      parent_span_id: parentSpanId,
+      span_name: name,
+      ...attributes 
+    });
+
+    return spanId;
+  }
+
+  /**
+   * End an active span.
+   */
+  endSpan(spanId, status = 'success', metadata = {}) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) return;
+
+    span.status = status;
+    span.end_time = new Date().toISOString();
+    
+    this._recordEvent('span_completed', {
+      span_id: spanId,
+      status,
+      ...metadata
+    });
+
+    this.activeSpans.delete(spanId);
+  }
+
+  /**
+   * Record a Reasoning Trace event (ART granularity).
+   */
+  recordReasoning(spanId, agent, thought, resolution = 'none') {
+    this._recordEvent('reasoning_trace', {
+      span_id: spanId,
+      agent,
+      thought,
+      resolution
+    });
+  }
+
+  /**
+   * Internal AUDIT writer.
+   */
+  _recordEvent(event, data) {
+    const entry = {
+      id: crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      event,
+      trace_id: this.currentTraceId,
+      ...data
+    };
+
+    try {
+      if (!fs.existsSync(path.dirname(this.auditPath))) {
+        fs.mkdirSync(path.dirname(this.auditPath), { recursive: true });
+      }
+      fs.appendFileSync(this.auditPath, JSON.stringify(entry) + '\n');
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to write audit entry: ${err.message}`);
+    }
+  }
+}
+
+module.exports = NexusTracer;

package/.mindforge/engine/persona-factory.md

@@ -0,0 +1,45 @@
+# MindForge Engine — Persona Factory
+
+## Purpose
+
+Dynamically generate specialized "Micro-Personas" by combining base persona definitions with real-time "Context Patches" (from Context7 or task context).
+
+## The Factory Loop
+
+1. **Base Layer:** Load the base persona file from `.mindforge/personas/[base].md`.
+2. **Context Patching:**
+   - Query `Context7` for library-specific best practices matching the task's `files` list.
+   - Example: `mcp__context7__get-library-docs("zod")` → extract validation patterns.
+3. **Rule Synthesis:**
+   - Append the fetched documentation as a `<specialist_knowledge>` block.
+   - Add task-specific `<imperative_rules>` (e.g., "Must use strict typing for all new interfaces").
+4. **Validation:** Ensure the resulting micro-persona is semantically valid and fits within the agent's context window.
+
+## Micro-Persona Schema (Extended)
+
+```markdown
+---
+name: [base-persona]-specialist-[id]
+base: [path/to/base.md]
+specialization: [library/topic]
+---
+
+<role>
+You are the [base-persona] specialized in [topic].
+[Incorporates base role + specialization]
+</role>
+
+<specialist_knowledge>
+[Dynamic docs from Context7]
+</specialist_knowledge>
+
+<imperative_rules>
+[Dynamic rules for this specific task]
+</imperative_rules>
+```
+
+## Persona Persistence
+
+- Micro-personas are stored in `.planning/phases/[N]/micro-personas/` for the duration of the task.
+- They are auto-pruned after the task SUMMARY is written to minimize workspace clutter.
+- If a task is resumed, the persona factory re-generates the micro-persona to ensure fresh context from Context7.

package/.mindforge/engine/swarm-controller.md

@@ -0,0 +1,59 @@
+# MindForge Engine — Swarm Controller
+
+## Purpose
+
+Determine when a task requires a "Swarm Cluster" instead of a single persona, and select the optimal cluster configuration.
+
+## Trigger Logic
+
+### 1. Complexity Threshold
+
+- Evaluate the task's complexity via `difficulty-scorer.md`.
+- **Trigger Swarm** if `compositeScore >= MINDFORGE.AUTO_SWARM_THRESHOLD` (default 7.0).
+
+### 2. Multi-Disciplinary Detection
+
+- Analyze the `files` and `taskName` for cross-stack markers:
+  - `UI + API` → **FullStackSwarm**
+  - `Auth + Database` → **SecuritySwarm**
+  - `Performance + Infrastructure` → **OptimizationSwarm**
+
+### 3. Impact Analysis
+
+- **Trigger Swarm** for any task touching:
+  - `.mindforge/governance/`
+  - `src/auth/`
+  - `src/payments/`
+  - Core infrastructure config (`docker-compose.yml`, `ci.yml`).
+
+## Cluster Selection
+
+Once a swarm is triggered, select a template from `swarm-templates.json`:
+
+| Task Category | Template | Core Personas |
+| :--- | :--- | :--- |
+| UI / Styling | `UISwarm` | `ui-auditor` (leader), `developer`, `accessibility` |
+| API / Logic | `BackendSwarm` | `architect` (leader), `developer`, `security-reviewer` |
+| Security | `SecuritySwarm` | `security-reviewer` (leader), `architect`, `developer` |
+| Database | `MigrationSwarm` | `architect` (leader), `database-patterns`, `developer` |
+| Optimization | `PerfSwarm` | `performance` (leader), `analyst`, `developer` |
+
+## Swarm Initialization Protocol
+
+1. **Nexus Trace:** Call `NexusTracer.startSpan('swarm_cluster_[Template]')`.
+2. **Assign Identity (ZTAI):** For each specialist, call `ztai-manager.registerAgent(persona, tier)`.
+3. **Select Leader:** The designated leader persona is responsible for the final `SUMMARY` write.
+4. **Generate Micro-Personas:** Call `persona-factory.md` for each member of the cluster.
+5. **Establish Shared State:** Initialize `.planning/phases/[N]/SWARM-STATE-[M].json` for inter-agent communication.
+6. **Nexus ART:** Record reasoning traces for each agent as they join the mesh.
+7. **Context Injection:** Inject the base context + swarm-specific documentation (from Context7) into all agents.
+8. **Enforce Trust Tier:** Validate that all agents in the cluster have the required `trust_tier` (ZTAI) for the task.
+9. **Signing:** All swarm actions MUST be cryptographically signed with the agent's DID (see ZTAI protocol).
+
+## Decision Gates & Governance
+
+- **Decision Gate Mode:** If template `decision_gate === "hitl"`, the swarm leader MUST request user approval for Tier 3 actions.
+- **Resource Management:** FinOps Hub monitors the `resource_budget`. If a `high` budget swarm exceeds 50% without a SUMMARY, alert the user.
+- **Audit Signing:** All swarm actions are cryptographically signed with the agent's DID (see ZTAI protocol).
+- **Consolidation:** The Swarm Leader must consolidate all member findings into the unified summary.
+- **Emergency Halt:** If any member finds a **CRITICAL** issue (e.g., security vulnerability), the entire swarm must halt and report.

package/.mindforge/engine/wave-executor.md

@@ -1,6 +1,11 @@
-# MindForge Engine — Wave Executor
+# MindForge Engine — Wave Execution Engine
+
+## Core Objective
+
+Orchestrate the parallel and sequential execution of a MindForge phase with atomic reliability and strict dependency enforcement.
 
 ## Purpose
+
 Group tasks from the dependency graph into waves and execute each wave.
 Within a wave, all tasks are independent and can run in parallel.
 Between waves, execution is strictly sequential.
@@ -8,11 +13,12 @@ Between waves, execution is strictly sequential.
 ## Wave grouping algorithm
 
 ### Input
+
 The dependency graph from `dependency-parser.md`.
 
 ### Algorithm — Kahn's topological sort (adapted for waves)
 
-```
+```text
 Initialize:
   remaining = all plan IDs
   completed = empty set
@@ -34,8 +40,9 @@ Repeat until remaining is empty:
 Return waves
 ```
 
-### Example output for the 5-plan example above:
-```
+### Example output for the 5-plan example above
+
+```text
 Wave 1: [01, 02]          ← No dependencies — run in parallel
 Wave 2: [03, 04]          ← Depend on Wave 1 — run in parallel after Wave 1
 Wave 3: [05]              ← Depends on both Wave 2 tasks — runs after Wave 2
@@ -44,7 +51,15 @@ Wave 3: [05]              ← Depends on both Wave 2 tasks — runs after Wave 2
 ## Wave execution protocol
 
 ### Before starting a wave
-1. Confirm all plans in previous wave have:
+
+1. **Nexus Trace:** Call `NexusTracer.startSpan('wave_[W]')`.
+2. **Identity Verification (ZTAI):** 
+   - Call `TrustVerifier.verifyAuditLog('.planning/AUDIT.jsonl')`.
+   - Ensure all `span_completed` events from the previous wave have a valid cryptographic signature and DID.
+3. **Identity-Lock (Tier 3):**
+   - If any task in the upcoming wave involves Tier 3 actions (e.g., modifying `.mindforge/governance/`), ensure the assigned agent DID has `tier >= 3`.
+   - If verification fails or tier is insufficient: **STOP** the phase and report an `identity_lock_violation`.
+4. Confirm all plans in previous wave have:
    - Status: Completed in SUMMARY file
    - Git commit SHA recorded
    - `<verify>` step passed
@@ -53,18 +68,41 @@ Wave 3: [05]              ← Depends on both Wave 2 tasks — runs after Wave 2
    Do not start the next wave. Report which plan failed and why.
 
 ### During a wave — parallel execution
+
 For each plan in the current wave, spawn a subagent with this exact context
 package (see `context-injector.md` for the injection protocol):
 
 ### Subagent invocation protocol (runtime-agnostic)
+
 Use the runtime-specific mechanism, but keep the inputs identical:
+
+#### 1. Swarm Check (MindForge V4)
+
+Before spawning any subagent, the executor MUST call `swarm-controller.md`.
+- **Input:** The PLAN file, task name, and file list.
+- **Output:** `single_persona` OR `swarm_cluster(template, leader, members)`.
+
+#### 2. Single Persona Execution
+
+If `single_persona` is returned:
+- **Nexus Trace:** Call `NexusTracer.startSpan('task_[N]-[M]', { parent_span_id: 'wave_[W]' })`.
 - **Claude Code:** spawn a subagent with the context package and the PLAN file.
-  Require the subagent to write `SUMMARY-[N]-[M].md` and report completion.
-- **Antigravity:** spawn an agent via `.agent/` command with the same context
-  package and the PLAN file. Require the same SUMMARY file output.
+- **Antigravity:** spawn an agent via `.agent/` command with the same context.
+- Target: `SUMMARY-[N]-[M].md`.
 
-**Context package per subagent:**
-```
+#### 3. Swarm Cluster Execution (The "Mesh" Mode)
+
+If `swarm_cluster` is returned:
+- **Nexus Trace:** Call `NexusTracer.startSpan('swarm_[N]-[M]', { parent_span_id: 'wave_[W]', template: '[Template]' })`.
+- **Initialize Swarm State:** Create `.planning/phases/[N]/SWARM-STATE-[M].json`.
+- **Spawn Cluster:** Simultaneously spawn all members in the cluster (e.g., Architect, Dev, Security).
+- **Communication:** Agents in the swarm MUST read/write to `SWARM-STATE-[M].json` for coordination.
+- **Consolidation:** The **Swarm Leader** is responsible for collecting all findings and writing a unified `SWARM-SUMMARY-[N]-[M].md`.
+- **Context:** Each agent gets a specialized persona from `persona-factory.md` (weighted by Context7 insights).
+
+**Context package per subagent**
+
+```text
 REQUIRED (always inject):
   .mindforge/org/CONVENTIONS.md
   .mindforge/org/SECURITY.md
@@ -84,6 +122,7 @@ NEVER inject to subagents:
 ```
 
 ### After each plan in a wave completes
+
 The executing subagent must:
 1. Run the `<verify>` step and capture output
 2. Write SUMMARY-[N]-[M].md with verify output included
@@ -92,6 +131,7 @@ The executing subagent must:
 5. Report completion status back to the orchestrator
 
 ### Wave completion
+
 After all plans in a wave complete:
 1. Collect all SUMMARY files from this wave
 2. Run the project's full test suite
@@ -112,24 +152,28 @@ When a task's `<verify>` step fails:
 4. **Stop the entire wave.** Other tasks in this wave that have not yet started:
    do not start them. Tasks already running in parallel: let them complete
    naturally, but do not start the next wave regardless of their outcome.
-5. **Report to the orchestrator:**
-   ```
-   ━━━ Wave [W] STOPPED — Task Failure ━━━━━━━━━━━━━━━━━━━━━━
-   Failed task : Plan [N]-[M]: [task name]
-   Verify output:
-   [full verify output]
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   ```
-6. **Ask the user:**
-   ```
-   Options:
-     1. Spawn debug agent to diagnose the failure
-     2. Show me the failing code and I'll fix it manually
-     3. Skip this task and continue the wave (not recommended)
-     4. Abort the entire phase
-   
-   Choose 1, 2, 3, or 4:
-   ```
+5. **Report to the orchestrator**
+
+```text
+━━━ Wave [W] STOPPED — Task Failure ━━━━━━━━━━━━━━━━━━━━━━
+Failed task : Plan [N]-[M]: [task name]
+Verify output:
+[full verify output]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+6. **Ask the user**
+
+```text
+Options:
+  1. Spawn debug agent to diagnose the failure
+  2. Show me the failing code and I'll fix it manually
+  3. Skip this task and continue the wave (not recommended)
+  4. Abort the entire phase
+
+Choose 1, 2, 3, or 4:
+```
+
 7. If user chooses 1: invoke `/mindforge:debug` with the failure context pre-loaded.
 8. If user chooses 3 (skip): write a `quality_gate_failed` AUDIT entry with
    `"gate": "verify_skipped_by_user"` and continue. This is tracked.
@@ -140,30 +184,35 @@ When a task's `<verify>` step fails:
 When the test suite fails after a wave completes:
 
 1. **Identify the failing tests** — capture the full test output.
-2. **Identify the likely causal commit:**
-   ```bash
-   git log --oneline -[number of tasks in this wave]
-   ```
-3. **Report specifically:**
-   ```
-   ━━━ Test Suite Failure After Wave [W] ━━━━━━━━━━━━━━━━━━━━━
-   [N] tests failing.
-   
-   Likely cause: [commit sha] — [commit message]
-   Failing tests:
-     - [test name]: [error]
-     - [test name]: [error]
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   ```
+2. **Identify the likely causal commit**
+
+```bash
+git log --oneline -[number of tasks in this wave]
+```
+
+3. **Report specifically**
+
+```text
+━━━ Test Suite Failure After Wave [W] ━━━━━━━━━━━━━━━━━━━━━
+[N] tests failing.
+
+Likely cause: [commit sha] — [commit message]
+Failing tests:
+  - [test name]: [error]
+  - [test name]: [error]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
 4. **Write a `quality_gate_failed` AUDIT entry.**
 5. **Do not start the next wave.** This is absolute — no exceptions.
-6. **Ask the user:**
-   ```
-   Options:
-     1. Debug the failing tests now
-     2. Revert the last wave's commits and re-plan
-     3. I'll fix the tests manually — notify me when done
-   ```
+6. **Ask the user**
+
+```text
+Options:
+  1. Debug the failing tests now
+  2. Revert the last wave's commits and re-plan
+  3. I'll fix the tests manually — notify me when done
+```
 
 ### Subagent hang (no SUMMARY file after expected duration)
 
@@ -185,6 +234,7 @@ When execute-phase discovers a PLAN file referenced in the dependency graph is m
 3. Do not continue with partial plan execution.
 
 ### Phase completion
+
 After all waves complete:
 1. Run the phase verification pipeline (see `verification-pipeline.md`)
 2. Write VERIFICATION.md
@@ -200,7 +250,7 @@ Write to `.planning/phases/[N]/WAVE-REPORT-[N].md`:
 
 ## Wave 1
 | Plan | Task Name           | Status | Duration | Commit     |
-|------|---------------------|--------|----------|------------|
+| :--- | :--- | :--- | :--- | :--- |
 | 01   | Create user model   | ✅     | ~8 min   | abc1234    |
 | 02   | Create product model| ✅     | ~6 min   | def5678    |
 
@@ -208,7 +258,7 @@ Write to `.planning/phases/[N]/WAVE-REPORT-[N].md`:
 
 ## Wave 2
 | Plan | Task Name             | Status | Duration | Commit     |
-|------|-----------------------|--------|----------|------------|
+| :--- | :--- | :--- | :--- | :--- |
 | 03   | User API endpoints    | ✅     | ~12 min  | ghi9012    |
 | 04   | Product API endpoints | ✅     | ~10 min  | jkl3456    |
 
@@ -216,14 +266,14 @@ Write to `.planning/phases/[N]/WAVE-REPORT-[N].md`:
 
 ## Wave 3
 | Plan | Task Name     | Status | Duration | Commit     |
-|------|---------------|--------|----------|------------|
+| :--- | :--- | :--- | :--- | :--- |
 | 05   | Checkout UI   | ✅     | ~15 min  | mno7890    |
 
 **Wave 3 test results:** All passing ✅
 
 ### Failure row format (if any task fails)
 | Plan | Task Name         | Status | Duration | Commit  | Error |
-|------|-------------------|--------|----------|---------|-------|
+| :--- | :--- | :--- | :--- | :--- | :--- |
 | 02   | Create product model | ❌  | ~4 min   | n/a     | Verify failed: TypeError ... |
 
 ## Phase summary

package/.mindforge/memory/pattern-library.jsonl

@@ -1,2 +1 @@
-{"id":"a9878977-cb7c-4dcf-8161-760ffd5e7de9","timestamp":"2026-03-22T17:25:37.673Z","type":"code_pattern","topic":"React Memo","content":"Use React.memo to prevent re-renders.","source":"manual","project":"[Project Name]","confidence":0.6,"tags":["ui"],"linked_adrs":[],"times_referenced":0,"last_referenced":null,"deprecated":false,"deprecated_by":null}
-{"id":"a9878977-cb7c-4dcf-8161-760ffd5e7de9","timestamp":"2026-03-22T17:25:37.673Z","type":"code_pattern","topic":"React Memo","content":"Use React.memo to prevent re-renders.","source":"manual","project":"[Project Name]","confidence":0.65,"tags":["ui"],"linked_adrs":[],"times_referenced":1,"last_referenced":"2026-03-25T17:42:57.297Z","deprecated":false,"deprecated_by":null}
+{"id":"LOCAL-SAFE-001","tags":["performance"],"description":"Standard optimization"}

package/.mindforge/personas/swarm-templates.json

@@ -0,0 +1,118 @@
+{
+  "version": "4.2.0",
+  "mesh_protocols": {
+    "shared_state": ".planning/phases/[N]/SWARM-STATE-[M].json",
+    "consolidation_format": "SWARM-SUMMARY-[N]-[M].md",
+    "trust_verification": "ZTAI-v4"
+  },
+  "templates": {
+    "UISwarm": {
+      "leader": "ui-auditor",
+      "members": ["developer", "accessibility", "whimsy-injector"],
+      "focus": "Visual fidelity, interaction states, and WCAG 2.2 compliance.",
+      "trust_tier": 1,
+      "decision_gate": "autonomous",
+      "resource_budget": "medium",
+      "required_skills": ["ui-ux-pro-max"]
+    },
+    "BackendSwarm": {
+      "leader": "architect",
+      "members": ["developer", "security-reviewer", "database-optimizer"],
+      "focus": "Architectural alignment, performance, and API versioning.",
+      "trust_tier": 2,
+      "decision_gate": "autonomous",
+      "resource_budget": "medium",
+      "required_skills": ["system-architecture"]
+    },
+    "SecuritySwarm": {
+      "leader": "security-reviewer",
+      "members": ["architect", "developer", "threat-detection-engineer"],
+      "focus": "OWASP A01-A10 mitigation, secret detection, and trust boundary enforcement.",
+      "trust_tier": 3,
+      "decision_gate": "hitl",
+      "resource_budget": "high",
+      "required_skills": ["security-engineer"]
+    },
+    "AIEngineeringSwarm": {
+      "leader": "ai-engineer",
+      "members": ["prompt-engineer", "developer", "model-qa-specialist"],
+      "focus": "Model orchestration, prompt grounding, hallucination mitigation, and inference optimization.",
+      "trust_tier": 2,
+      "decision_gate": "autonomous",
+      "resource_budget": "high",
+      "required_skills": ["agency-ai-engineer"]
+    },
+    "DeveloperExperienceSwarm": {
+      "leader": "developer-advocate",
+      "members": ["devops-automator", "tech-writer", "workflow-optimizer"],
+      "focus": "CI/CD pipeline ergonomics, DX documentation, and internal tool optimization.",
+      "trust_tier": 1,
+      "decision_gate": "autonomous",
+      "resource_budget": "low",
+      "required_skills": ["agency-developer-advocate"]
+    },
+    "DataMeshSwarm": {
+      "leader": "data-engineer",
+      "members": ["database-optimizer", "analytics-reporter", "compliance-auditor"],
+      "focus": "Data lakehouse patterns, ETL pipelining, and semantic layer integrity.",
+      "trust_tier": 2,
+      "decision_gate": "hitl",
+      "resource_budget": "medium",
+      "required_skills": ["agency-data-engineer"]
+    },
+    "IdentityTrustSwarm": {
+      "leader": "agentic-identity-trust-architect",
+      "members": ["security-reviewer", "architect", "blockchain-security-auditor"],
+      "focus": "Zero-Trust Agentic Identity (ZTAI), DID-based signing, and authentication bypass mitigation.",
+      "trust_tier": 3,
+      "decision_gate": "hitl",
+      "resource_budget": "high",
+      "required_skills": ["agency-agentic-identity-trust-architect"]
+    },
+    "GrowthAnalyticsSwarm": {
+      "leader": "growth-hacker",
+      "members": ["analytics-reporter", "ui-auditor", "tracking-measurement-specialist"],
+      "focus": "A/B testing, conversion funnel optimization, and telemetry instrumentation.",
+      "trust_tier": 1,
+      "decision_gate": "autonomous",
+      "resource_budget": "medium",
+      "required_skills": ["agency-growth-hacker"]
+    },
+    "IncidentResponseSwarm": {
+      "leader": "sre-site-reliability-engineer",
+      "members": ["developer", "incident-response-commander", "debug-specialist"],
+      "focus": "Rapid root cause analysis (RCA), hotfix deployment, and post-mortem drafting.",
+      "trust_tier": 3,
+      "decision_gate": "hitl",
+      "resource_budget": "high",
+      "required_skills": ["gsd-debug"]
+    },
+    "ComplianceSwarm": {
+      "leader": "compliance-auditor",
+      "members": ["legal-compliance-checker", "architect", "security-reviewer"],
+      "focus": "GDPR/SOC2 alignment, PII masking, and regulatory audit trail verification.",
+      "trust_tier": 3,
+      "decision_gate": "hitl",
+      "resource_budget": "medium",
+      "required_skills": ["agency-legal-compliance-checker"]
+    },
+    "QualityAssuranceSwarm": {
+      "leader": "qa-engineer",
+      "members": ["developer", "verifier", "test-results-analyzer"],
+      "focus": "End-to-end regression, edge-case fuzzing, and coverage-gap analysis.",
+      "trust_tier": 1,
+      "decision_gate": "autonomous",
+      "resource_budget": "medium",
+      "required_skills": ["gsd-add-tests"]
+    },
+    "FullStackSwarm": {
+      "leader": "architect",
+      "members": ["ui-auditor", "developer", "security-reviewer", "tech-writer"],
+      "focus": "End-to-end feature delivery with unified UI, API security, and documentation.",
+      "trust_tier": 2,
+      "decision_gate": "autonomous",
+      "resource_budget": "high",
+      "required_skills": ["system-architecture", "ui-ux-pro-max"]
+    }
+  }
+}

package/.planning/ROI.jsonl

@@ -0,0 +1,2 @@
+{"timestamp":"2026-03-27T20:44:37.178Z","planId":"test-plan-001","task":"Implement Auth","model":"claude-3-5-sonnet","costTier":"medium","inputTokens":1000,"outputTokens":500,"durationMs":1200,"status":"completed","goalAchieved":1,"estimatedCostUSD":0.010499999999999999}
+{"timestamp":"2026-03-27T20:54:21.126Z","planId":"test-plan-001","task":"Implement Auth","model":"claude-3-5-sonnet","costTier":"medium","inputTokens":1000,"outputTokens":500,"durationMs":1200,"status":"completed","goalAchieved":1,"estimatedCostUSD":0.010499999999999999}