prjct-cli 1.21.0 → 1.22.0

package/dist/bin/prjct.mjs

@@ -10968,7 +10968,7 @@ var init_shipped = __esm({
 
 // core/schemas/state.ts
 import { z as z14 } from "zod";
-var PrioritySchema, TaskTypeSchema, TaskSectionSchema, TaskStatusSchema, ActivityTypeSchema, SubtaskSummarySchema, SubtaskCompletionDataSchema, SubtaskSchema, SubtaskProgressSchema, CurrentTaskSchema, PreviousTaskSchema, StateJsonSchema, QueueTaskSchema, QueueJsonSchema, StatsSchema, RecentActivitySchema, StateSchemaFull;
+var PrioritySchema, TaskTypeSchema, TaskSectionSchema, TaskStatusSchema, ActivityTypeSchema, SubtaskSummarySchema, SubtaskCompletionDataSchema, SubtaskSchema, SubtaskProgressSchema, CurrentTaskSchema, PreviousTaskSchema, TaskFeedbackSchema, TaskHistoryEntrySchema, StateJsonSchema, QueueTaskSchema, QueueJsonSchema, StatsSchema, RecentActivitySchema, StateSchemaFull;
 var init_state = __esm({
   "core/schemas/state.ts"() {
     "use strict";
@@ -11079,12 +11079,63 @@ var init_state = __esm({
       // ISO8601
       pauseReason: z14.string().optional()
     });
+    TaskFeedbackSchema = z14.object({
+      // Stack confirmations - tech confirmed/used during the task
+      stackConfirmed: z14.array(z14.string()).optional(),
+      // ["React 18", "TypeScript strict mode"]
+      // Patterns discovered during the task
+      patternsDiscovered: z14.array(z14.string()).optional(),
+      // ["API routes follow /api/v1/{resource}"]
+      // Agent accuracy - how well domain agents performed
+      agentAccuracy: z14.array(
+        z14.object({
+          agent: z14.string(),
+          // "backend.md"
+          rating: z14.enum(["helpful", "neutral", "inaccurate"]),
+          note: z14.string().optional()
+          // "Missing Tailwind context"
+        })
+      ).optional(),
+      // Issues encountered during the task
+      issuesEncountered: z14.array(z14.string()).optional()
+      // ["ESLint conflicts with Prettier"]
+    });
+    TaskHistoryEntrySchema = z14.object({
+      taskId: z14.string(),
+      // task UUID
+      title: z14.string(),
+      // parent task description
+      classification: TaskTypeSchema,
+      // feature, bug, improvement, chore
+      startedAt: z14.string(),
+      // ISO8601
+      completedAt: z14.string(),
+      // ISO8601
+      subtaskCount: z14.number(),
+      // total number of subtasks
+      subtaskSummaries: z14.array(SubtaskSummarySchema),
+      // summary of each subtask
+      outcome: z14.string(),
+      // brief description of what was accomplished
+      branchName: z14.string(),
+      // git branch used
+      linearId: z14.string().optional(),
+      // Linear issue ID if linked
+      linearUuid: z14.string().optional(),
+      // Linear internal UUID
+      prUrl: z14.string().optional(),
+      // PR URL if shipped
+      feedback: TaskFeedbackSchema.optional()
+      // Task-to-analysis feedback (PRJ-272)
+    });
     StateJsonSchema = z14.object({
       currentTask: CurrentTaskSchema.nullable(),
       previousTask: PreviousTaskSchema.nullable().optional(),
       // deprecated: use pausedTasks
       pausedTasks: z14.array(PreviousTaskSchema).optional(),
       // replaces previousTask
+      taskHistory: z14.array(TaskHistoryEntrySchema).optional(),
+      // completed tasks history (max 20)
       lastUpdated: z14.string()
     });
     QueueTaskSchema = z14.object({
@@ -15187,6 +15238,8 @@ var init_state_storage = __esm({
         return {
           currentTask: null,
           previousTask: null,
+          pausedTasks: [],
+          taskHistory: [],
           lastUpdated: ""
         };
       }
@@ -15245,6 +15298,28 @@ var init_state_storage = __esm({
             if (prev.pauseReason) m.raw(`   Reason: ${prev.pauseReason}`);
           });
           m.blank().italic("Use /p:resume to continue");
+        }).when((data.taskHistory?.length || 0) > 0, (m) => {
+          const history2 = this.getTaskHistoryFromState(data);
+          if (history2.length === 0) return;
+          const currentTaskType = data.currentTask?.type;
+          const relevantHistory = currentTaskType ? history2.filter((h) => h.classification === currentTaskType).slice(0, 3) : history2.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();
       }
       // =========== Transition Validation ===========
@@ -15306,29 +15381,65 @@ var init_state_storage = __esm({
       }
       /**
        * 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) {
+      async completeTask(projectId, feedback) {
         const state = await this.read(projectId);
         const completedTask = state.currentTask;
         if (!completedTask) {
           return null;
         }
         this.validateTransition(state, "done");
+        const completedAt = getTimestamp();
+        const historyEntry = this.createTaskHistoryEntry(completedTask, completedAt, feedback);
+        const existingHistory = this.getTaskHistoryFromState(state);
+        const taskHistory = [historyEntry, ...existingHistory].slice(0, this.maxTaskHistory);
         await this.update(projectId, () => ({
           currentTask: null,
           previousTask: null,
-          lastUpdated: getTimestamp()
+          taskHistory,
+          lastUpdated: completedAt
         }));
         await this.publishEvent(projectId, "task.completed", {
           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)
+       */
+      createTaskHistoryEntry(task, completedAt, feedback) {
+        const taskAny = task;
+        const subtaskSummaries = (task.subtasks || []).filter((st) => st.status === "completed" && st.summary).map((st) => st.summary);
+        const outcome = subtaskSummaries.length > 0 ? subtaskSummaries.map((s) => s.title).join(", ") : "Task completed";
+        const entry = {
+          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
+        };
+        if (feedback) {
+          entry.feedback = feedback;
+        }
+        return entry;
+      }
       /** Max number of paused tasks (configurable) */
       maxPausedTasks = 5;
+      /** Max number of task history entries (configurable) */
+      maxTaskHistory = 20;
       /** Staleness threshold in days */
       stalenessThresholdDays = 30;
       /**
@@ -15417,6 +15528,13 @@ var init_state_storage = __esm({
         }
         return paused;
       }
+      /**
+       * Get task history from state with backward compatibility
+       * Ensures taskHistory is always an array (never undefined)
+       */
+      getTaskHistoryFromState(state) {
+        return state.taskHistory || [];
+      }
       /**
        * Get stale paused tasks (older than threshold)
        */
@@ -15498,6 +15616,63 @@ var init_state_storage = __esm({
         const state = await this.read(projectId);
         return this.getPausedTasksFromState(state);
       }
+      /**
+       * Get full task history (completed tasks)
+       */
+      async getTaskHistory(projectId) {
+        const state = await this.read(projectId);
+        return this.getTaskHistoryFromState(state);
+      }
+      /**
+       * Get most recent task from history
+       */
+      async getMostRecentTask(projectId) {
+        const state = await this.read(projectId);
+        const history2 = this.getTaskHistoryFromState(state);
+        return history2[0] || null;
+      }
+      /**
+       * Get task history filtered by classification
+       */
+      async getTaskHistoryByType(projectId, classification) {
+        const state = await this.read(projectId);
+        const history2 = this.getTaskHistoryFromState(state);
+        return history2.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) {
+        const history2 = await this.getTaskHistory(projectId);
+        const entriesWithFeedback = history2.filter((h) => h.feedback);
+        const stackConfirmed = [];
+        const patternsDiscovered = [];
+        const agentAccuracy = [];
+        const allIssues = [];
+        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);
+        }
+        const uniqueStack = [...new Set(stackConfirmed)];
+        const uniquePatterns = [...new Set(patternsDiscovered)];
+        const issueCounts = /* @__PURE__ */ new Map();
+        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 ===========
       /**
        * Create subtasks when fragmenting a task
@@ -27970,6 +28145,8 @@ var init_sync_service = __esm({
       projectId = null;
       globalPath = "";
       cliVersion = "0.0.0";
+      /** Task feedback context for agent generation (PRJ-272) */
+      taskFeedbackContext;
       constructor() {
         this.projectPath = process.cwd();
       }
@@ -28094,7 +28271,17 @@ var init_sync_service = __esm({
               });
             }
           }
-          const agents = shouldRegenerateAgents ? await this.generateAgents(stack, stats) : await this.loadExistingAgents();
+          let taskFeedbackContext;
+          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 {
+            }
+          }
+          const agents = shouldRegenerateAgents ? await this.generateAgents(stack, stats, taskFeedbackContext) : await this.loadExistingAgents();
           const skills = this.configureSkills(agents);
           const skillsInstalled = shouldRegenerateAgents ? await this.autoInstallSkills(agents) : [];
           const sources = this.buildSources(stats, commands);
@@ -28424,7 +28611,8 @@ var init_sync_service = __esm({
       // ==========================================================================
       // AGENT GENERATION
       // ==========================================================================
-      async generateAgents(stack, stats) {
+      async generateAgents(stack, stats, feedbackContext) {
+        this.taskFeedbackContext = feedbackContext;
         const agents = [];
         const agentsPath = path59.join(this.globalPath, "agents");
         try {
@@ -28565,8 +28753,45 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
+        content = this.injectFeedbackSection(content, name);
         await fs56.writeFile(path59.join(agentsPath, `${name}.md`), content, "utf-8");
       }
+      /**
+       * Inject a "Recent Learnings" section into agent content from task feedback (PRJ-272)
+       */
+      injectFeedbackSection(content, agentName) {
+        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 = ["\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 ? ` \u2014 ${note.note}` : "";
+            lines.push(`- ${note.rating}${desc}`);
+          }
+          lines.push("");
+        }
+        return content + lines.join("\n");
+      }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
           "prjct-workflow": "Task lifecycle: now, done, pause, resume",
@@ -28892,18 +29117,38 @@ 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).
        */
       async saveDraftAnalysis(git, stats, _stack) {
         try {
           const commitHash = git.recentCommits[0]?.hash || null;
+          let patterns = [];
+          let antiPatterns = [];
+          try {
+            const feedback = await stateStorage.getAggregatedFeedback(this.projectId);
+            if (feedback.patternsDiscovered.length > 0) {
+              patterns = feedback.patternsDiscovered.map((p) => ({
+                name: p,
+                description: `Discovered during task execution: ${p}`
+              }));
+            }
+            if (feedback.knownGotchas.length > 0) {
+              antiPatterns = feedback.knownGotchas.map((g) => ({
+                issue: g,
+                file: "multiple",
+                suggestion: `Recurring issue reported across tasks: ${g}`
+              }));
+            }
+          } catch {
+          }
           await analysisStorage.saveDraft(this.projectId, {
             projectId: this.projectId,
             languages: stats.languages,
             frameworks: stats.frameworks,
             configFiles: [],
             fileCount: stats.fileCount,
-            patterns: [],
-            antiPatterns: [],
+            patterns,
+            antiPatterns,
             analyzedAt: getTimestamp(),
             status: "draft",
             commitHash: commitHash ?? void 0
@@ -34388,6 +34633,7 @@ var init_workflow = __esm({
       }
       /**
        * /p:done - Complete current task
+       * Optionally accepts structured feedback for the task-to-analysis feedback loop (PRJ-272)
        */
       async done(projectPath = process.cwd(), options = {}) {
         try {
@@ -34443,7 +34689,7 @@ var init_workflow = __esm({
             const sign = diff >= 0 ? "+" : "";
             varianceDisplay = ` | est: ${estimatedPoints}pt (${formatMinutesToDuration(estimatedMinutes)}) \u2192 ${sign}${pct}%`;
           }
-          await stateStorage.completeTask(projectId);
+          await stateStorage.completeTask(projectId, options.feedback);
           const linearId = currentTask.linearId;
           if (linearId) {
             try {
@@ -34890,7 +35136,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.21.0",
+      version: "1.22.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {