prjct-cli 0.35.0 → 0.35.2

package/core/agentic/prompt-builder.ts

@@ -24,6 +24,7 @@ import type {
   ThinkBlock,
   Memory,
   PlanInfo,
+  OrchestratorContext,
 } from '../types'
 
 // Re-export types for convenience
@@ -287,7 +288,8 @@ class PromptBuilder {
     learnedPatterns: LearnedPatterns | null = null,
     thinkBlock: ThinkBlock | null = null,
     relevantMemories: Memory[] | null = null,
-    planInfo: PlanInfo | null = null
+    planInfo: PlanInfo | null = null,
+    orchestratorContext: OrchestratorContext | null = null
   ): string {
     const parts: string[] = []
 
@@ -326,6 +328,70 @@ class PromptBuilder {
     // This ensures Claude sees ALL instructions including critical rules at the top
     parts.push(template.content)
 
+    // ORCHESTRATOR CONTEXT: Inject loaded agents, skills, and subtasks
+    if (orchestratorContext) {
+      parts.push('\n## ORCHESTRATOR CONTEXT\n')
+      parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}\n`)
+      parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(', ')}\n`)
+      parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}\n\n`)
+
+      // Inject loaded agent content (truncated for context efficiency)
+      if (orchestratorContext.agents.length > 0) {
+        parts.push('### LOADED AGENTS (Project-Specific Specialists)\n\n')
+        for (const agent of orchestratorContext.agents) {
+          parts.push(`#### Agent: ${agent.name} (${agent.domain})\n`)
+          if (agent.skills.length > 0) {
+            parts.push(`Skills: ${agent.skills.join(', ')}\n`)
+          }
+          // Include first 1500 chars of agent content
+          const truncatedContent = agent.content.length > 1500
+            ? agent.content.substring(0, 1500) + '\n... (truncated, read full file for more)'
+            : agent.content
+          parts.push(`\`\`\`markdown\n${truncatedContent}\n\`\`\`\n\n`)
+        }
+      }
+
+      // Inject loaded skill content (truncated)
+      if (orchestratorContext.skills.length > 0) {
+        parts.push('### LOADED SKILLS (From Agent Frontmatter)\n\n')
+        for (const skill of orchestratorContext.skills) {
+          parts.push(`#### Skill: ${skill.name}\n`)
+          // Include first 1000 chars of skill content
+          const truncatedContent = skill.content.length > 1000
+            ? skill.content.substring(0, 1000) + '\n... (truncated)'
+            : skill.content
+          parts.push(`\`\`\`markdown\n${truncatedContent}\n\`\`\`\n\n`)
+        }
+      }
+
+      // Inject subtasks if fragmented
+      if (orchestratorContext.requiresFragmentation && orchestratorContext.subtasks) {
+        parts.push('### SUBTASKS (Execute in Order)\n\n')
+        parts.push('**IMPORTANT**: Focus on the CURRENT subtask. Use `p. done` when complete to advance.\n\n')
+        parts.push('| # | Domain | Description | Status |\n')
+        parts.push('|---|--------|-------------|--------|\n')
+
+        for (const subtask of orchestratorContext.subtasks) {
+          const statusIcon = subtask.status === 'in_progress' ? '▶️ **CURRENT**'
+            : subtask.status === 'completed' ? '✅ Done'
+            : subtask.status === 'failed' ? '❌ Failed'
+            : '⏳ Pending'
+          parts.push(`| ${subtask.order} | ${subtask.domain} | ${subtask.description} | ${statusIcon} |\n`)
+        }
+
+        // Find and highlight current subtask
+        const currentSubtask = orchestratorContext.subtasks.find(s => s.status === 'in_progress')
+        if (currentSubtask) {
+          parts.push(`\n**FOCUS ON SUBTASK #${currentSubtask.order}**: ${currentSubtask.description}\n`)
+          parts.push(`Agent: ${currentSubtask.agent} | Domain: ${currentSubtask.domain}\n`)
+          if (currentSubtask.dependsOn.length > 0) {
+            parts.push(`Dependencies: ${currentSubtask.dependsOn.join(', ')}\n`)
+          }
+        }
+        parts.push('\n')
+      }
+    }
+
     // Current state (only if exists and relevant)
     const relevantState = this.filterRelevantState(state)
     if (relevantState) {

package/core/commands/workflow.ts

@@ -19,6 +19,7 @@ import {
 } from './base'
 import { stateStorage, queueStorage } from '../storage'
 import { templateExecutor } from '../agentic/template-executor'
+import commandExecutor from '../agentic/command-executor'
 
 export class WorkflowCommands extends PrjctCommandsBase {
   /**
@@ -36,12 +37,13 @@ export class WorkflowCommands extends PrjctCommandsBase {
       }
 
       if (task) {
-        // AGENTIC: Build execution context for Claude to decide
-        const execContext = await templateExecutor.buildContext('task', task, projectPath)
-        const agenticInfo = templateExecutor.buildAgenticPrompt(execContext)
+        // AGENTIC: Use CommandExecutor for full orchestration support
+        const result = await commandExecutor.execute('task', { task }, projectPath)
 
-        // Get available agents for context
-        const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
+        if (!result.success) {
+          out.fail(result.error || 'Failed to execute task')
+          return { success: false, error: result.error }
+        }
 
         // Write-through: JSON → MD → Event
         await stateStorage.startTask(projectId, {
@@ -50,18 +52,31 @@ export class WorkflowCommands extends PrjctCommandsBase {
           sessionId: generateUUID()
         })
 
-        // AGENTIC: Log that Claude will decide via templates
+        // Log orchestrator results if available
+        if (result.orchestratorContext) {
+          const oc = result.orchestratorContext
+          const agentsList = oc.agents.map((a: { name: string }) => a.name).join(', ') || 'none'
+          const domainsList = oc.detectedDomains.join(', ')
+          console.log(`🎯 Orchestrator: ${domainsList} → [${agentsList}]`)
+
+          if (oc.requiresFragmentation && oc.subtasks) {
+            console.log(`   → ${oc.subtasks.length} subtasks created`)
+          }
+        }
+
+        // Get available agents for backward compatibility
+        const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
         const agentsList = availableAgents.length > 0
           ? availableAgents.join(', ')
           : 'none (run p. sync)'
 
-        console.log(`🤖 Agentic mode: Claude will read templates and decide`)
         out.done(`${task} [specialists: ${agentsList}]`)
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
           agenticMode: true,
           availableAgents,
+          orchestratorContext: result.orchestratorContext,
           timestamp: dateHelper.getTimestamp(),
         })
 
@@ -70,8 +85,8 @@ export class WorkflowCommands extends PrjctCommandsBase {
           task,
           agenticMode: true,
           availableAgents,
-          execContext,
-          agenticPrompt: agenticInfo.prompt,
+          // Include full CommandExecutor result (orchestratorContext, prompt, etc.)
+          ...result,
         }
       } else {
         // Read from storage (JSON is source of truth)

package/core/types/agentic.ts

@@ -443,6 +443,7 @@ export interface ExecutionResult {
   compressionMetrics?: unknown
   learnedPatterns?: unknown
   relevantMemories?: unknown
+  orchestratorContext?: OrchestratorContext | null
   formatResponse?: (data: unknown) => string
   formatThinkBlock?: (verbose: boolean) => string
   parallel?: {
@@ -571,3 +572,64 @@ export interface LearnedPatterns {
   preferred_agent?: string | null
   [key: string]: string | null | undefined
 }
+
+// =============================================================================
+// Orchestrator Types
+// =============================================================================
+
+/**
+ * A loaded agent with its content
+ */
+export interface LoadedAgent {
+  name: string
+  domain: string
+  content: string
+  skills: string[]
+  filePath: string
+}
+
+/**
+ * A loaded skill with its content
+ */
+export interface LoadedSkill {
+  name: string
+  content: string
+  filePath: string
+}
+
+/**
+ * Subtask for task fragmentation
+ */
+export interface OrchestratorSubtask {
+  id: string
+  description: string
+  domain: string
+  agent: string
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  dependsOn: string[]
+  order: number
+}
+
+/**
+ * Full orchestrator context returned after execution
+ */
+export interface OrchestratorContext {
+  /** Domains detected for this task */
+  detectedDomains: string[]
+  /** Primary domain (most important) */
+  primaryDomain: string
+  /** Loaded agents with their content */
+  agents: LoadedAgent[]
+  /** Loaded skills from agent frontmatter */
+  skills: LoadedSkill[]
+  /** Whether task requires fragmentation (3+ domains) */
+  requiresFragmentation: boolean
+  /** Subtasks if fragmented, null otherwise */
+  subtasks: OrchestratorSubtask[] | null
+  /** Project info */
+  project: {
+    id: string
+    ecosystem: string
+    conventions: string[]
+  }
+}

package/core/types/index.ts

@@ -158,6 +158,11 @@ export type {
   ReasoningStep,
   ReasoningResult,
   ChainOfThoughtResult,
+  // Orchestrator types
+  OrchestratorContext,
+  LoadedAgent,
+  LoadedSkill,
+  OrchestratorSubtask,
 } from './agentic'
 
 // =============================================================================