claude-flow-novice 1.6.1 → 1.6.3

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/CLAUDE.md

@@ -390,6 +390,35 @@ claude mcp add claude-flow-novice npx claude-flow-novice mcp start
 }
 ```
 
+**🚨 MANDATORY: Post-Edit Hook Execution**
+
+**CRITICAL**: Every primary swarm agent MUST run the post-edit-pipeline hook after EVERY file edit:
+
+```bash
+# REQUIRED after each file modification
+node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/[agent]/[step]"
+```
+
+**Agent Instructions Template:**
+```
+Task("Agent Name", `
+  Your implementation task here...
+
+  MANDATORY: After EVERY file edit, run:
+  node config/hooks/post-edit-pipeline.js "[FILE_PATH]" --memory-key "swarm/[agent-name]/step-[N]"
+
+  Report confidence score when complete.
+`, "agent-type")
+```
+
+**Post-Edit Hook Benefits:**
+- Real-time validation (formatting, linting, type checking)
+- Security scanning (hardcoded credentials, XSS, eval())
+- Single-file testing (1-5s vs 10-60s full suite)
+- TDD compliance detection (Red-Green-Refactor phases)
+- Rust quality checks (unwrap/expect/panic with line numbers)
+- Coverage tracking (Jest, pytest, cargo-tarpaulin)
+
 **Confidence Score Interpretation:**
 - **0.90-1.00**: Excellent - production ready
 - **0.75-0.89**: Good - minor improvements possible
@@ -443,7 +472,7 @@ claude mcp add claude-flow-novice npx claude-flow-novice mcp start
 Validators MUST spawn in **separate message** AFTER implementation completes AND gate passes:
 
 ```javascript
-// MESSAGE 1: Implementation swarm only
+// MESSAGE 1: Implementation swarm only (NO REVIEWERS/VALIDATORS)
 [Implementation Message]:
   mcp__claude-flow-novice__swarm_init({
     topology: "mesh",
@@ -457,7 +486,7 @@ Validators MUST spawn in **separate message** AFTER implementation completes AND
 
 // [WAIT FOR COMPLETION + GATE PASS (ALL ≥75%)]
 
-// MESSAGE 2: Validation swarm after gate passes
+// MESSAGE 2: Validation swarm AFTER implementation complete
 [Validation Message]:
   mcp__claude-flow-novice__swarm_init({
     topology: "mesh",
@@ -480,20 +509,76 @@ Validators MUST spawn in **separate message** AFTER implementation completes AND
 - **Byzantine consensus voting** across all validators
 - **Multi-dimensional checks**: quality, security, performance, tests, docs
 
-### Step 5: Decision Gate (Loop 2 exit condition)
-- **PASS**: ≥90% validator agreement + all critical criteria met → IMMEDIATELY exit Loop 2, proceed to next phase
-- **FAIL**: <90% agreement OR any critical criterion failed → IMMEDIATELY retry Loop 2 (autonomous)
+### Step 5: Product Owner Decision Gate (GOAP Decision Authority)
+
+**🎯 CRITICAL: Product Owner uses GOAP algorithm for autonomous decisions**
+
+After consensus validation, Product Owner agent makes autonomous PROCEED/DEFER/ESCALATE decision:
+
+```javascript
+// Spawn Product Owner AFTER consensus results available
+Task("Product Owner", `
+  GOAP DECISION EXECUTION - Loop 2 Iteration ${iteration}/10
+
+  CURRENT STATE:
+  - Consensus: ${consensusScore} (target: ≥0.90)
+  - Validator concerns: ${JSON.stringify(concerns)}
+  - Loop 2 iteration: ${loop2Iteration}/10
+  - Scope boundaries: ${scope}
+
+  GOAL STATE:
+  - Consensus: ≥0.90
+  - All in-scope criteria met: true
+  - Scope intact: true
+
+  RETRIEVE SCOPE FROM MEMORY:
+  mcp__claude-flow-novice__memory_usage({
+    action: "retrieve",
+    namespace: "scope-control",
+    key: "project-boundaries"
+  })
+
+  EXECUTE GOAP A* SEARCH:
+  1. Classify validator concerns: in-scope vs out-of-scope
+  2. Generate action space with cost functions
+  3. Run A* pathfinding from current → goal state
+  4. Make autonomous decision (NO PERMISSION)
+
+  OUTPUT: {decision: "PROCEED|DEFER|ESCALATE", ...}
+`, "product-owner")
+```
+
+**Decision Outcomes:**
+
+- **PROCEED** (in-scope blockers found) →
+  - Product Owner selects targeted Loop 3 agents
+  - IMMEDIATELY relaunch Loop 3 with specific fixes
+  - NO PERMISSION NEEDED (iteration < 10)
+
+- **DEFER** (out-of-scope concerns) →
+  - Save concerns to backlog
+  - Approve phase at current state
+  - AUTO-TRANSITION to next phase
+
+- **ESCALATE** (critical ambiguity, rare) →
+  - Generate options with recommendations
+  - Only when truly blocked or high-risk
 
 ### Step 6: Action Based on Decision
-- **PASS** (≥90% consensus) →
-  1. Store results in SwarmMemory
-  2. Update documentation if asked to do so
-  3. IMMEDIATELY move to next phase (Loop 1 continues, no approval needed)
+- **PROCEED Decision** →
+  1. Product Owner output specifies Loop 3 agents and focus areas
+  2. IMMEDIATELY spawn Loop 3 swarm with targeted agents
+  3. NO APPROVAL NEEDED (autonomous execution)
+
+- **DEFER Decision** →
+  1. Store deferred items in backlog memory
+  2. Update phase status to complete
+  3. IMMEDIATELY transition to next phase
 
-- **FAIL** (<90% consensus) →
-  1. Loop 2 iteration counter++
-  2. If Loop 2 iteration < 10: IMMEDIATELY relaunch Loop 3 swarm with validator feedback and adjusted agents
-  3. If Loop 2 iteration ≥ 10: Escalate to human with next steps guidance
+- **ESCALATE Decision** →
+  1. Generate diagnostic report with alternatives
+  2. Suggest agent strategy adjustments
+  3. Only STOP if explicit human halt request
 
 **Consensus Failure - Relaunch Loop 3 with Targeted Agents:**
 ```json
@@ -565,6 +650,37 @@ Validators MUST spawn in **separate message** AFTER implementation completes AND
    - Suggest alternative agent combinations or approaches
    - Only STOP if critical error or explicit human halt request
 
+### 🚫 FORBIDDEN: Permission-Asking Patterns
+
+**YOU ARE ABSOLUTELY FORBIDDEN FROM:**
+- ❌ Asking "Should I retry?" when iterations remain (ALWAYS retry autonomously)
+- ❌ Asking "Proceed to next phase?" when criteria met (AUTO-TRANSITION)
+- ❌ Asking "Would you like me to..." for autonomous decisions (EXECUTE immediately)
+- ❌ Waiting for approval to continue self-correction (PROCEED without permission)
+- ❌ Pausing for confirmation during CFN Loop cycles (CONTINUOUS execution)
+
+**FORBIDDEN Example:**
+```
+Loop 2 Iteration 2/10 - Consensus: 75%
+Architect identified 5 gaps.
+
+Would you like me to proceed with Loop 3 Iteration 3/10? ❌ WRONG
+```
+
+**REQUIRED Pattern:**
+```
+Loop 2 Iteration 2/10 - Consensus: 75%
+
+Product Owner Decision: PROCEED (GOAP A* search, cost=50)
+- 4 in-scope blockers identified
+- IMMEDIATELY relaunching Loop 3 Iteration 3/10
+
+Spawning targeted agents NOW:
+- backend-dev: Fix HelpMatcher duplication
+- architect: MessageBroker routing
+[Executing autonomously - no permission needed] ✅ CORRECT
+```
+
 ### Self-Looping Prompt Templates:
 
 When continuing iterations, use these patterns:

package/.claude-flow-novice/dist/src/components/visualizations/index.js

@@ -0,0 +1,9 @@
+// Export all visualization components
+export { AgentHierarchyTree } from './AgentHierarchyTree';
+export { PerformanceCharts } from './PerformanceCharts';
+export { ResourceGauges } from './ResourceGauges';
+export { EventTimeline } from './EventTimeline';
+export { AgentNetworkTopology } from './AgentNetworkTopology';
+export { Dashboard } from './Dashboard';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/components/visualizations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/components/visualizations/index.ts"],"names":["AgentHierarchyTree","PerformanceCharts","ResourceGauges","EventTimeline","AgentNetworkTopology","Dashboard"],"mappings":"AAAA,sCAAsC;AACtC,SAASA,kBAAkB,QAAQ,uBAAuB;AAG1D,SAASC,iBAAiB,QAAQ,sBAAsB;AAGxD,SAASC,cAAc,QAAQ,mBAAmB;AAGlD,SAASC,aAAa,QAAQ,kBAAkB;AAGhD,SAASC,oBAAoB,QAAQ,yBAAyB;AAG9D,SAASC,SAAS,QAAQ,cAAc"}

package/.claude-flow-novice/dist/src/coordination/adapters/v1-coordinator-adapter.js

@@ -0,0 +1,462 @@
+/**
+ * V1 Coordinator Adapter - Wraps V1 TopologyCoordinator with V2 ICoordinator Interface
+ *
+ * Purpose: Enable V1 coordination system (QueenAgent/MeshCoordinator) to work
+ * transparently through the V2 ICoordinator interface for toggle support.
+ *
+ * Key Features:
+ * - Wraps V1 TopologyCoordinator (hierarchical or mesh)
+ * - Maps V2 spawnAgent() → V1 delegateTask() or assignTask()
+ * - NOOP fallback for SDK-only features (pause/resume)
+ * - Translates V1 metrics to V2 CoordinatorMetrics format
+ * - Handles topology-specific method dispatch
+ *
+ * Limitations:
+ * - V1 does not support pause/resume (SDK feature) → returns error or NOOP
+ * - V1 does not support checkpointing → methods return empty/error
+ * - Metrics translation is best-effort (V1 and V2 track different data)
+ *
+ * @module coordination/adapters/v1-coordinator-adapter
+ */ import { AgentState } from '../v2/core/agent-state.js';
+import { Logger } from '../../core/logger.js';
+/**
+ * V1CoordinatorAdapter - Wraps V1 coordination with V2 interface
+ *
+ * @example
+ * ```typescript
+ * // Wrap V1 hierarchical coordinator
+ * const v1Coord = await createCoordinator({ topology: 'hierarchical' });
+ * const adapter = new V1CoordinatorAdapter(v1Coord, 'noop');
+ * await adapter.initialize();
+ *
+ * // Use V2 interface with V1 backend
+ * const agent = await adapter.spawnAgent({
+ *   agentId: 'worker-1',
+ *   type: 'coder',
+ *   priority: 5
+ * });
+ * ```
+ */ export class V1CoordinatorAdapter {
+    v1Coordinator;
+    fallbackBehavior;
+    logger;
+    isInitialized = false;
+    startTime = Date.now();
+    // Agent tracking for V2 compatibility
+    spawnedAgents = new Map();
+    agentSessions = new Map();
+    // Metrics tracking
+    metrics = {
+        totalAgentsSpawned: 0,
+        totalTerminations: 0,
+        totalCheckpoints: 0,
+        totalRestores: 0,
+        checkpointLatencies: [],
+        restoreLatencies: [],
+        tokensSaved: 0,
+        totalTokensUsed: 0
+    };
+    constructor(v1Coordinator, fallbackBehavior = 'noop'){
+        this.v1Coordinator = v1Coordinator;
+        this.fallbackBehavior = fallbackBehavior;
+        // VUL-4 FIX: Validate v1Coordinator object structure
+        this.validateCoordinatorObject(v1Coordinator);
+        this.logger = new Logger({
+            level: 'info',
+            format: 'json',
+            destination: 'console'
+        }, {
+            component: 'V1CoordinatorAdapter'
+        });
+    }
+    /**
+   * Validate V1 coordinator object for security (VUL-4 FIX)
+   *
+   * Prevents prototype pollution and ensures required structure exists.
+   *
+   * @private
+   * @param coordinator - V1 coordinator object to validate
+   * @throws Error if validation fails
+   */ validateCoordinatorObject(coordinator) {
+        if (!coordinator || typeof coordinator !== 'object') {
+            throw new Error('V1 coordinator must be a valid object');
+        }
+        // VUL-4: Check for prototype pollution attack vectors (use hasOwnProperty to avoid false positives)
+        const dangerousKeys = [
+            '__proto__',
+            'constructor',
+            'prototype'
+        ];
+        for (const key of dangerousKeys){
+            if (Object.prototype.hasOwnProperty.call(coordinator, key)) {
+                throw new Error(`Security violation: Coordinator object contains dangerous key "${key}"`);
+            }
+        }
+        // VUL-4: Validate required properties
+        const requiredProps = [
+            'topology',
+            'coordinator',
+            'initialize',
+            'shutdown'
+        ];
+        for (const prop of requiredProps){
+            if (!(prop in coordinator)) {
+                throw new Error(`V1 coordinator missing required property: "${prop}". Required: ${requiredProps.join(', ')}`);
+            }
+        }
+        // Validate topology value
+        const validTopologies = [
+            'hierarchical',
+            'mesh',
+            'hybrid'
+        ];
+        if (!validTopologies.includes(coordinator.topology)) {
+            throw new Error(`Invalid topology: "${coordinator.topology}". Must be one of: ${validTopologies.join(', ')}`);
+        }
+    }
+    // ===========================
+    // Coordinator Lifecycle
+    // ===========================
+    async initialize() {
+        if (this.isInitialized) {
+            this.logger.warn('V1CoordinatorAdapter already initialized');
+            return;
+        }
+        this.logger.info('Initializing V1CoordinatorAdapter...');
+        // Initialize wrapped V1 coordinator
+        await this.v1Coordinator.initialize();
+        this.isInitialized = true;
+        this.startTime = Date.now();
+        this.logger.info(`V1CoordinatorAdapter initialized with ${this.v1Coordinator.topology} topology`);
+    }
+    async cleanup() {
+        if (!this.isInitialized) {
+            return;
+        }
+        this.logger.info('Cleaning up V1CoordinatorAdapter...');
+        // Shutdown wrapped V1 coordinator
+        await this.v1Coordinator.shutdown();
+        // Clear tracking data
+        this.spawnedAgents.clear();
+        this.agentSessions.clear();
+        this.isInitialized = false;
+        this.logger.info('V1CoordinatorAdapter cleanup complete');
+    }
+    isReady() {
+        return this.isInitialized;
+    }
+    // ===========================
+    // Agent Lifecycle Management
+    // ===========================
+    async spawnAgent(config) {
+        if (!this.isInitialized) {
+            throw new Error('V1CoordinatorAdapter not initialized');
+        }
+        this.logger.debug(`Spawning agent ${config.agentId} (type: ${config.type})`);
+        let v1Result;
+        let agent;
+        // Route to appropriate V1 method based on topology
+        if (this.v1Coordinator.topology === 'hierarchical') {
+            // Hierarchical: Use QueenAgent.delegateTask()
+            const queenAgent = this.v1Coordinator.coordinator;
+            // V1 QueenAgent requires spawning worker first, then delegating task
+            const workerId = await queenAgent.spawnWorker(config.type, {
+                skills: config.metadata?.skills || [],
+                maxConcurrentTasks: 3,
+                priority: config.priority || 1,
+                specializations: config.metadata?.specializations
+            }, config.metadata?.caller);
+            // Create task to delegate (V1 Task format)
+            const task = {
+                id: config.agentId,
+                type: config.type,
+                description: config.metadata?.description || `Task for ${config.agentId}`,
+                priority: config.priority || 1,
+                dependencies: [],
+                status: 'pending',
+                input: config.metadata?.input || {},
+                createdAt: new Date()
+            };
+            v1Result = await queenAgent.delegateTask(task, config.metadata?.caller, workerId);
+            agent = this.mapV1DelegationResultToAgent(v1Result, config, workerId);
+        } else {
+            // Mesh: Use MeshCoordinator.registerAgent() and coordinateTask()
+            const meshCoordinator = this.v1Coordinator.coordinator;
+            // Register agent in mesh
+            await meshCoordinator.registerAgent(config.agentId, {
+                name: config.agentId,
+                type: config.type,
+                status: 'ready',
+                capabilities: config.metadata?.capabilities || []
+            });
+            // Coordinate task for the agent
+            const taskId = await meshCoordinator.coordinateTask(config.metadata?.description || `Task for ${config.agentId}`, {
+                requiredCapabilities: config.metadata?.capabilities,
+                priority: config.priority || 1
+            });
+            agent = this.mapV1MeshResultToAgent(taskId, config);
+        }
+        // Track agent in adapter
+        this.spawnedAgents.set(config.agentId, agent);
+        // Create agent session
+        const session = {
+            sessionId: config.sessionId || `session-${config.agentId}`,
+            agentId: config.agentId,
+            state: agent.state,
+            isPaused: false,
+            checkpoints: [],
+            priority: config.priority || 1,
+            metadata: config.metadata || {}
+        };
+        this.agentSessions.set(config.agentId, session);
+        // Update metrics
+        this.metrics.totalAgentsSpawned++;
+        this.logger.info(`Agent ${config.agentId} spawned successfully via V1 ${this.v1Coordinator.topology} topology`);
+        return agent;
+    }
+    async pauseAgent(agentId, reason) {
+        // V1 does not support pause/resume - SDK-only feature
+        this.logger.warn(`[V1 Adapter] Pause not supported for agent ${agentId} - V1 coordination does not support SDK features`);
+        if (this.fallbackBehavior === 'error') {
+            throw new Error(`V1 coordination does not support pause/resume. Use V2 with SDK mode. Agent: ${agentId}, Reason: ${reason || 'none'}`);
+        }
+        // NOOP fallback - do nothing but log warning
+        this.logger.warn(`[V1 Adapter] Pause operation ignored for agent ${agentId}. Reason: ${reason || 'none'}`);
+    }
+    async resumeAgent(agentId, checkpointId, messageUUID) {
+        // V1 does not support pause/resume - SDK-only feature
+        this.logger.warn(`[V1 Adapter] Resume not supported for agent ${agentId} - V1 coordination does not support SDK features`);
+        if (this.fallbackBehavior === 'error') {
+            throw new Error(`V1 coordination does not support pause/resume. Use V2 with SDK mode. Agent: ${agentId}, CheckpointId: ${checkpointId || 'none'}, MessageUUID: ${messageUUID || 'none'}`);
+        }
+        // NOOP fallback - do nothing but log warning
+        this.logger.warn(`[V1 Adapter] Resume operation ignored for agent ${agentId}. CheckpointId: ${checkpointId || 'none'}, MessageUUID: ${messageUUID || 'none'}`);
+    }
+    async terminateAgent(agentId, reason) {
+        if (!this.isInitialized) {
+            throw new Error('V1CoordinatorAdapter not initialized');
+        }
+        const agent = this.spawnedAgents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        this.logger.debug(`Terminating agent ${agentId}. Reason: ${reason || 'none'}`);
+        // V1 doesn't have explicit termination - just remove from tracking
+        this.spawnedAgents.delete(agentId);
+        this.agentSessions.delete(agentId);
+        // Update metrics
+        this.metrics.totalTerminations++;
+        this.logger.info(`Agent ${agentId} terminated. Reason: ${reason || 'none'}`);
+    }
+    // ===========================
+    // State Management
+    // ===========================
+    async getAgentState(agentId) {
+        const agent = this.spawnedAgents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        return agent.state;
+    }
+    async getAgentSession(agentId) {
+        const session = this.agentSessions.get(agentId);
+        if (!session) {
+            throw new Error(`Agent session not found: ${agentId}`);
+        }
+        return session;
+    }
+    async createCheckpoint(agentId, reason, metadata) {
+        // V1 does not support checkpointing - SDK-only feature
+        this.logger.warn(`[V1 Adapter] Checkpointing not supported for agent ${agentId} - V1 coordination does not support SDK features`);
+        if (this.fallbackBehavior === 'error') {
+            throw new Error(`V1 coordination does not support checkpointing. Use V2 with SDK mode. Agent: ${agentId}, Reason: ${reason || 'none'}`);
+        }
+        // Return stub checkpoint for compatibility
+        const stubCheckpoint = {
+            id: `stub-checkpoint-${agentId}-${Date.now()}`,
+            sessionId: this.agentSessions.get(agentId)?.sessionId || 'unknown',
+            agentId,
+            messageUUID: 'not-supported',
+            state: AgentState.IDLE,
+            timestamp: new Date(),
+            metadata: {
+                reason: reason || 'V1 stub checkpoint',
+                autoCheckpoint: false,
+                context: {
+                    v1Adapter: true,
+                    ...metadata
+                }
+            }
+        };
+        this.logger.warn(`[V1 Adapter] Created stub checkpoint for agent ${agentId}. Checkpoints are not functional in V1 mode.`);
+        return stubCheckpoint;
+    }
+    async restoreCheckpoint(checkpointId) {
+        // V1 does not support checkpointing - SDK-only feature
+        this.logger.warn(`[V1 Adapter] Checkpoint restoration not supported - V1 coordination does not support SDK features. CheckpointId: ${checkpointId}`);
+        if (this.fallbackBehavior === 'error') {
+            throw new Error(`V1 coordination does not support checkpoint restoration. Use V2 with SDK mode. CheckpointId: ${checkpointId}`);
+        }
+        // Return first available agent as stub
+        const firstAgent = Array.from(this.spawnedAgents.values())[0];
+        if (!firstAgent) {
+            throw new Error('No agents available to restore from stub checkpoint');
+        }
+        this.logger.warn(`[V1 Adapter] Restore checkpoint operation ignored. Returning first available agent as stub.`);
+        return firstAgent;
+    }
+    async listCheckpoints(agentId, limit) {
+        // V1 does not support checkpointing - return empty array
+        this.logger.warn(`[V1 Adapter] Checkpoint listing not supported for agent ${agentId} - V1 coordination does not support SDK features`);
+        if (this.fallbackBehavior === 'error') {
+            throw new Error(`V1 coordination does not support checkpointing. Use V2 with SDK mode. Agent: ${agentId}`);
+        }
+        return [];
+    }
+    // ===========================
+    // Metrics & Monitoring
+    // ===========================
+    getMetrics() {
+        const activeAgents = Array.from(this.spawnedAgents.values()).filter((agent)=>agent.state !== AgentState.TERMINATED && agent.state !== AgentState.COMPLETED).length;
+        const pausedAgents = Array.from(this.spawnedAgents.values()).filter((agent)=>agent.state === AgentState.PAUSED).length;
+        const avgCheckpointTime = this.metrics.checkpointLatencies.length > 0 ? this.metrics.checkpointLatencies.reduce((sum, val)=>sum + val, 0) / this.metrics.checkpointLatencies.length : 0;
+        const avgRestoreTime = this.metrics.restoreLatencies.length > 0 ? this.metrics.restoreLatencies.reduce((sum, val)=>sum + val, 0) / this.metrics.restoreLatencies.length : 0;
+        // P99 calculation (simplified - returns max for small datasets)
+        const p99RestoreTime = this.metrics.restoreLatencies.length > 0 ? Math.max(...this.metrics.restoreLatencies) : 0;
+        return {
+            totalAgentsSpawned: this.metrics.totalAgentsSpawned,
+            activeAgents,
+            pausedAgents,
+            totalTerminations: this.metrics.totalTerminations,
+            totalCheckpoints: this.metrics.totalCheckpoints,
+            totalRestores: this.metrics.totalRestores,
+            averageCheckpointTimeMs: avgCheckpointTime,
+            averageRestoreTimeMs: avgRestoreTime,
+            p99RestoreTimeMs: p99RestoreTime,
+            tokensSaved: this.metrics.tokensSaved,
+            totalTokensUsed: this.metrics.totalTokensUsed,
+            uptimeMs: Date.now() - this.startTime
+        };
+    }
+    getActiveAgents() {
+        return Array.from(this.spawnedAgents.values()).filter((agent)=>agent.state !== AgentState.PAUSED && agent.state !== AgentState.TERMINATED && agent.state !== AgentState.COMPLETED);
+    }
+    getPausedAgents() {
+        return Array.from(this.spawnedAgents.values()).filter((agent)=>agent.state === AgentState.PAUSED);
+    }
+    async updateTokenUsage(agentId, tokensUsed) {
+        const agent = this.spawnedAgents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        // Update total token usage
+        this.metrics.totalTokensUsed += tokensUsed;
+        // Update agent metadata
+        if (!agent.metadata) {
+            agent.metadata = {};
+        }
+        agent.metadata.tokensUsed = (agent.metadata.tokensUsed || 0) + tokensUsed;
+        this.logger.debug(`Updated token usage for agent ${agentId}: +${tokensUsed} (total: ${agent.metadata.tokensUsed})`);
+    }
+    // ===========================
+    // Private Helper Methods
+    // ===========================
+    /**
+   * Map V1 QueenAgent DelegationResult to V2 Agent
+   */ mapV1DelegationResultToAgent(v1Result, config, workerId) {
+        const state = this.mapV1StatusToAgentState(v1Result.status);
+        return {
+            agentId: config.agentId,
+            sessionId: config.sessionId || `session-${config.agentId}`,
+            type: config.type,
+            state,
+            isPaused: false,
+            priority: config.priority || 1,
+            session: {
+                sessionId: config.sessionId || `session-${config.agentId}`,
+                agentId: config.agentId,
+                state,
+                isPaused: false,
+                checkpoints: [],
+                priority: config.priority || 1,
+                metadata: {
+                    ...config.metadata,
+                    v1WorkerId: workerId,
+                    v1TaskId: v1Result.taskId,
+                    v1DelegatedAt: v1Result.delegatedAt
+                }
+            },
+            metadata: {
+                ...config.metadata,
+                v1WorkerId: workerId,
+                v1TaskId: v1Result.taskId,
+                v1DelegatedAt: v1Result.delegatedAt
+            }
+        };
+    }
+    /**
+   * Map V1 MeshCoordinator task to V2 Agent
+   */ mapV1MeshResultToAgent(taskId, config) {
+        return {
+            agentId: config.agentId,
+            sessionId: config.sessionId || `session-${config.agentId}`,
+            type: config.type,
+            state: AgentState.WORKING,
+            isPaused: false,
+            priority: config.priority || 1,
+            session: {
+                sessionId: config.sessionId || `session-${config.agentId}`,
+                agentId: config.agentId,
+                state: AgentState.WORKING,
+                isPaused: false,
+                checkpoints: [],
+                priority: config.priority || 1,
+                metadata: {
+                    ...config.metadata,
+                    v1TaskId: taskId
+                }
+            },
+            metadata: {
+                ...config.metadata,
+                v1TaskId: taskId
+            }
+        };
+    }
+    /**
+   * Map V1 worker/task status to V2 AgentState enum
+   */ mapV1StatusToAgentState(v1Status) {
+        switch(v1Status){
+            case 'accepted':
+                return AgentState.WORKING;
+            case 'queued':
+                return AgentState.WAITING;
+            case 'rejected':
+                return AgentState.ERROR;
+            default:
+                return AgentState.IDLE;
+        }
+    }
+    /**
+   * Get topology type from wrapped V1 coordinator
+   * Note: V1 TopologyType includes 'hybrid', but V2 only uses 'hierarchical' | 'mesh'
+   */ getTopology() {
+        const topology = this.v1Coordinator.topology;
+        // Map 'hybrid' to 'mesh' for V2 compatibility
+        return topology === 'hybrid' ? 'mesh' : topology;
+    }
+    /**
+   * Get agent count from wrapped V1 coordinator
+   */ getAgentCount() {
+        if (this.v1Coordinator.topology === 'hierarchical') {
+            const queenAgent = this.v1Coordinator.coordinator;
+            const stats = queenAgent.getWorkerStats();
+            return stats.total;
+        } else {
+            const meshCoordinator = this.v1Coordinator.coordinator;
+            const status = meshCoordinator.getCoordinatorStatus();
+            return status.agentCount;
+        }
+    }
+}
+
+//# sourceMappingURL=v1-coordinator-adapter.js.map