prjct-cli 1.21.0 → 1.22.0

package/core/services/sync-service.ts

@@ -77,6 +77,12 @@ class SyncService {
   private projectId: string | null = null
   private globalPath: string = ''
   private cliVersion: string = '0.0.0'
+  /** Task feedback context for agent generation (PRJ-272) */
+  private taskFeedbackContext?: {
+    patternsDiscovered: string[]
+    knownGotchas: string[]
+    agentAccuracy: Array<{ agent: string; rating: string; note?: string }>
+  }
 
   constructor() {
     this.projectPath = process.cwd()
@@ -246,9 +252,32 @@ class SyncService {
       }
 
       // 4. Generate all files (depends on gathered data)
+      // Load task feedback for agent generation (PRJ-272)
+      let taskFeedbackContext:
+        | {
+            patternsDiscovered: string[]
+            knownGotchas: string[]
+            agentAccuracy: Array<{ agent: string; rating: string; note?: string }>
+          }
+        | undefined
+      if (shouldRegenerateAgents) {
+        try {
+          const feedback = await stateStorage.getAggregatedFeedback(this.projectId!)
+          if (
+            feedback.patternsDiscovered.length > 0 ||
+            feedback.knownGotchas.length > 0 ||
+            feedback.agentAccuracy.length > 0
+          ) {
+            taskFeedbackContext = feedback
+          }
+        } catch {
+          // Feedback loading failure should not block agent generation
+        }
+      }
+
       // Skip agent regeneration if nothing structural changed
       const agents = shouldRegenerateAgents
-        ? await this.generateAgents(stack, stats)
+        ? await this.generateAgents(stack, stats, taskFeedbackContext)
         : await this.loadExistingAgents()
       const skills = this.configureSkills(agents)
       const skillsInstalled = shouldRegenerateAgents ? await this.autoInstallSkills(agents) : []
@@ -658,8 +687,14 @@ class SyncService {
 
   private async generateAgents(
     stack: StackDetection,
-    stats: ProjectStats
+    stats: ProjectStats,
+    feedbackContext?: {
+      patternsDiscovered: string[]
+      knownGotchas: string[]
+      agentAccuracy: Array<{ agent: string; rating: string; note?: string }>
+    }
   ): Promise<SyncAgentInfo[]> {
+    this.taskFeedbackContext = feedbackContext
     const agents: SyncAgentInfo[] = []
     const agentsPath = path.join(this.globalPath, 'agents')
 
@@ -837,9 +872,58 @@ class SyncService {
       content = this.generateMinimalDomainAgent(name, stats, stack)
     }
 
+    // Inject task feedback learnings (PRJ-272)
+    content = this.injectFeedbackSection(content, name)
+
     await fs.writeFile(path.join(agentsPath, `${name}.md`), content, 'utf-8')
   }
 
+  /**
+   * Inject a "Recent Learnings" section into agent content from task feedback (PRJ-272)
+   */
+  private injectFeedbackSection(content: string, agentName: string): string {
+    if (!this.taskFeedbackContext) return content
+
+    const { patternsDiscovered, knownGotchas, agentAccuracy } = this.taskFeedbackContext
+
+    const agentNotes = agentAccuracy.filter(
+      (a) => a.agent === `${agentName}.md` || a.agent === agentName
+    )
+
+    const hasContent =
+      patternsDiscovered.length > 0 || knownGotchas.length > 0 || agentNotes.length > 0
+    if (!hasContent) return content
+
+    const lines: string[] = ['\n## Recent Learnings (from completed tasks)\n']
+
+    if (patternsDiscovered.length > 0) {
+      lines.push('### Discovered Patterns')
+      for (const pattern of patternsDiscovered) {
+        lines.push(`- ${pattern}`)
+      }
+      lines.push('')
+    }
+
+    if (knownGotchas.length > 0) {
+      lines.push('### Known Gotchas')
+      for (const gotcha of knownGotchas) {
+        lines.push(`- ${gotcha}`)
+      }
+      lines.push('')
+    }
+
+    if (agentNotes.length > 0) {
+      lines.push('### Agent Accuracy Notes')
+      for (const note of agentNotes) {
+        const desc = note.note ? ` — ${note.note}` : ''
+        lines.push(`- ${note.rating}${desc}`)
+      }
+      lines.push('')
+    }
+
+    return content + lines.join('\n')
+  }
+
   private generateMinimalWorkflowAgent(name: string): string {
     const descriptions: Record<string, string> = {
       'prjct-workflow': 'Task lifecycle: now, done, pause, resume',
@@ -1253,6 +1337,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
   /**
    * Save sync results as a draft analysis.
    * Preserves existing sealed analysis — only the draft is overwritten.
+   * Incorporates task feedback from completed tasks (PRJ-272).
    */
   private async saveDraftAnalysis(
     git: GitData,
@@ -1262,14 +1347,40 @@ You are the ${name} expert for this project. Apply best practices for the detect
     try {
       const commitHash = git.recentCommits[0]?.hash || null
 
+      // Load aggregated feedback from completed tasks (PRJ-272)
+      let patterns: Array<{ name: string; description: string; location?: string }> = []
+      let antiPatterns: Array<{ issue: string; file: string; suggestion: string }> = []
+      try {
+        const feedback = await stateStorage.getAggregatedFeedback(this.projectId!)
+
+        // Convert discovered patterns to CodePattern objects
+        if (feedback.patternsDiscovered.length > 0) {
+          patterns = feedback.patternsDiscovered.map((p) => ({
+            name: p,
+            description: `Discovered during task execution: ${p}`,
+          }))
+        }
+
+        // Convert known gotchas (recurring issues) to AntiPattern objects
+        if (feedback.knownGotchas.length > 0) {
+          antiPatterns = feedback.knownGotchas.map((g) => ({
+            issue: g,
+            file: 'multiple',
+            suggestion: `Recurring issue reported across tasks: ${g}`,
+          }))
+        }
+      } catch {
+        // Feedback aggregation failure should not block analysis
+      }
+
       await analysisStorage.saveDraft(this.projectId!, {
         projectId: this.projectId!,
         languages: stats.languages,
         frameworks: stats.frameworks,
         configFiles: [],
         fileCount: stats.fileCount,
-        patterns: [],
-        antiPatterns: [],
+        patterns,
+        antiPatterns,
         analyzedAt: dateHelper.getTimestamp(),
         status: 'draft',
         commitHash: commitHash ?? undefined,

package/core/storage/state-storage.ts

@@ -15,6 +15,8 @@ import type {
   StateJson,
   Subtask,
   SubtaskCompletionData,
+  TaskFeedback,
+  TaskHistoryEntry,
 } from '../schemas/state'
 import { StateJsonSchema, SubtaskCompletionDataSchema } from '../schemas/state'
 import { getTimestamp, toRelative } from '../utils/date-helper'
@@ -33,6 +35,8 @@ class StateStorage extends StorageManager<StateJson> {
     return {
       currentTask: null,
       previousTask: null,
+      pausedTasks: [],
+      taskHistory: [],
       lastUpdated: '',
     }
   }
@@ -140,6 +144,39 @@ class StateStorage extends StorageManager<StateJson> {
         })
         m.blank().italic('Use /p:resume to continue')
       })
+      .when((data.taskHistory?.length || 0) > 0, (m) => {
+        const history = this.getTaskHistoryFromState(data)
+        if (history.length === 0) return
+
+        // Filter by current task classification if available
+        const currentTaskType = (data.currentTask as any)?.type
+        const relevantHistory = currentTaskType
+          ? history.filter((h) => h.classification === currentTaskType).slice(0, 3)
+          : history.slice(0, 5)
+
+        if (relevantHistory.length === 0) return
+
+        m.hr().h2(
+          currentTaskType
+            ? `Recent ${currentTaskType} tasks (${relevantHistory.length})`
+            : `Recent tasks (${relevantHistory.length})`
+        )
+        relevantHistory.forEach((entry, i) => {
+          m.raw(`${i + 1}. **${entry.title}** (${entry.classification})`)
+            .raw(
+              `   Completed: ${toRelative(entry.completedAt)} | ${entry.subtaskCount} subtask${entry.subtaskCount > 1 ? 's' : ''}`
+            )
+            .raw(`   Outcome: ${entry.outcome}`)
+          if (entry.linearId) m.raw(`   Linear: ${entry.linearId}`)
+          if (entry.feedback?.patternsDiscovered?.length) {
+            m.raw(`   Patterns: ${entry.feedback.patternsDiscovered.join(', ')}`)
+          }
+          if (entry.feedback?.issuesEncountered?.length) {
+            m.raw(`   Gotchas: ${entry.feedback.issuesEncountered.join(', ')}`)
+          }
+        })
+        m.blank().italic('Task history helps identify patterns and improve decisions')
+      })
       .blank()
       .build()
   }
@@ -220,8 +257,10 @@ class StateStorage extends StorageManager<StateJson> {
 
   /**
    * Complete current task
+   * Creates a TaskHistoryEntry and adds it to taskHistory with FIFO eviction
+   * Optionally accepts structured feedback for the task-to-analysis feedback loop (PRJ-272)
    */
-  async completeTask(projectId: string): Promise<CurrentTask | null> {
+  async completeTask(projectId: string, feedback?: TaskFeedback): Promise<CurrentTask | null> {
     const state = await this.read(projectId)
     const completedTask = state.currentTask
 
@@ -231,10 +270,22 @@ class StateStorage extends StorageManager<StateJson> {
 
     this.validateTransition(state, 'done')
 
+    const completedAt = getTimestamp()
+
+    // Create task history entry for completed task (with optional feedback)
+    const historyEntry = this.createTaskHistoryEntry(completedTask, completedAt, feedback)
+
+    // Get existing task history with backward compatibility
+    const existingHistory = this.getTaskHistoryFromState(state)
+
+    // Add new entry to beginning, enforce max limit with FIFO eviction
+    const taskHistory = [historyEntry, ...existingHistory].slice(0, this.maxTaskHistory)
+
     await this.update(projectId, () => ({
       currentTask: null,
       previousTask: null,
-      lastUpdated: getTimestamp(),
+      taskHistory,
+      lastUpdated: completedAt,
     }))
 
     // Publish incremental event
@@ -242,15 +293,64 @@ class StateStorage extends StorageManager<StateJson> {
       taskId: completedTask.id,
       description: completedTask.description,
       startedAt: completedTask.startedAt,
-      completedAt: getTimestamp(),
+      completedAt,
     })
 
     return completedTask
   }
 
+  /**
+   * Create a TaskHistoryEntry from a completed task
+   * Optionally includes structured feedback for the feedback loop (PRJ-272)
+   */
+  private createTaskHistoryEntry(
+    task: CurrentTask,
+    completedAt: string,
+    feedback?: TaskFeedback
+  ): TaskHistoryEntry {
+    // Extended task properties (may be present in storage but not in schema)
+    const taskAny = task as any
+
+    // Extract subtask summaries (only completed subtasks with summaries)
+    const subtaskSummaries = (task.subtasks || [])
+      .filter((st) => st.status === 'completed' && st.summary)
+      .map((st) => st.summary!)
+
+    // Calculate outcome description from subtask summaries
+    const outcome =
+      subtaskSummaries.length > 0
+        ? subtaskSummaries.map((s) => s.title).join(', ')
+        : 'Task completed'
+
+    const entry: TaskHistoryEntry = {
+      taskId: task.id,
+      title: taskAny.parentDescription || task.description,
+      classification: taskAny.type || 'improvement',
+      startedAt: task.startedAt,
+      completedAt,
+      subtaskCount: task.subtasks?.length || 0,
+      subtaskSummaries,
+      outcome,
+      branchName: taskAny.branch || 'unknown',
+      linearId: task.linearId,
+      linearUuid: task.linearUuid,
+      prUrl: taskAny.prUrl,
+    }
+
+    // Attach feedback if provided (PRJ-272)
+    if (feedback) {
+      entry.feedback = feedback
+    }
+
+    return entry
+  }
+
   /** Max number of paused tasks (configurable) */
   private maxPausedTasks = 5
 
+  /** Max number of task history entries (configurable) */
+  private maxTaskHistory = 20
+
   /** Staleness threshold in days */
   private stalenessThresholdDays = 30
 
@@ -367,6 +467,14 @@ class StateStorage extends StorageManager<StateJson> {
     return paused
   }
 
+  /**
+   * Get task history from state with backward compatibility
+   * Ensures taskHistory is always an array (never undefined)
+   */
+  private getTaskHistoryFromState(state: StateJson): TaskHistoryEntry[] {
+    return state.taskHistory || []
+  }
+
   /**
    * Get stale paused tasks (older than threshold)
    */
@@ -462,6 +570,85 @@ class StateStorage extends StorageManager<StateJson> {
     return this.getPausedTasksFromState(state)
   }
 
+  /**
+   * Get full task history (completed tasks)
+   */
+  async getTaskHistory(projectId: string): Promise<TaskHistoryEntry[]> {
+    const state = await this.read(projectId)
+    return this.getTaskHistoryFromState(state)
+  }
+
+  /**
+   * Get most recent task from history
+   */
+  async getMostRecentTask(projectId: string): Promise<TaskHistoryEntry | null> {
+    const state = await this.read(projectId)
+    const history = this.getTaskHistoryFromState(state)
+    return history[0] || null
+  }
+
+  /**
+   * Get task history filtered by classification
+   */
+  async getTaskHistoryByType(
+    projectId: string,
+    classification: TaskHistoryEntry['classification']
+  ): Promise<TaskHistoryEntry[]> {
+    const state = await this.read(projectId)
+    const history = this.getTaskHistoryFromState(state)
+    return history.filter((t) => t.classification === classification)
+  }
+
+  /**
+   * Aggregate feedback from all task history entries (PRJ-272)
+   * Used by sync to feed task discoveries back into analysis and agent generation.
+   * Returns consolidated patterns, stack confirmations, issues, and agent accuracy.
+   */
+  async getAggregatedFeedback(projectId: string): Promise<{
+    stackConfirmed: string[]
+    patternsDiscovered: string[]
+    agentAccuracy: Array<{ agent: string; rating: string; note?: string }>
+    issuesEncountered: string[]
+    knownGotchas: string[]
+  }> {
+    const history = await this.getTaskHistory(projectId)
+    const entriesWithFeedback = history.filter((h) => h.feedback)
+
+    const stackConfirmed: string[] = []
+    const patternsDiscovered: string[] = []
+    const agentAccuracy: Array<{ agent: string; rating: string; note?: string }> = []
+    const allIssues: string[] = []
+
+    for (const entry of entriesWithFeedback) {
+      const fb = entry.feedback!
+      if (fb.stackConfirmed) stackConfirmed.push(...fb.stackConfirmed)
+      if (fb.patternsDiscovered) patternsDiscovered.push(...fb.patternsDiscovered)
+      if (fb.agentAccuracy) agentAccuracy.push(...fb.agentAccuracy)
+      if (fb.issuesEncountered) allIssues.push(...fb.issuesEncountered)
+    }
+
+    // Deduplicate patterns and stack confirmations
+    const uniqueStack = [...new Set(stackConfirmed)]
+    const uniquePatterns = [...new Set(patternsDiscovered)]
+
+    // Promote recurring issues (2+) to known gotchas
+    const issueCounts = new Map<string, number>()
+    for (const issue of allIssues) {
+      issueCounts.set(issue, (issueCounts.get(issue) || 0) + 1)
+    }
+    const knownGotchas = [...issueCounts.entries()]
+      .filter(([_, count]) => count >= 2)
+      .map(([issue]) => issue)
+
+    return {
+      stackConfirmed: uniqueStack,
+      patternsDiscovered: uniquePatterns,
+      agentAccuracy,
+      issuesEncountered: [...new Set(allIssues)],
+      knownGotchas,
+    }
+  }
+
   // =========== Subtask Methods ===========
 
   /**