prjct-cli 1.11.0 → 1.13.0

package/core/agentic/orchestrator-executor.ts

@@ -23,13 +23,14 @@ import { getRecentFiles } from '../context-tools/recent-tool'
 import { extractSignatures } from '../context-tools/signatures-tool'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
-import { stateStorage } from '../storage'
+import { analysisStorage, stateStorage } from '../storage'
 import type {
   LoadedAgent,
   LoadedSkill,
   OrchestratorContext,
   OrchestratorSubtask,
   RealCodebaseContext,
+  SealedAnalysisContext,
 } from '../types'
 import { getErrorMessage, isNotFoundError } from '../types/fs'
 import domainClassifier, { type ProjectContext } from './domain-classifier'
@@ -76,8 +77,11 @@ export class OrchestratorExecutor {
     // Step 5: Load skills from agent frontmatter
     const skills = await this.loadSkills(agents)
 
-    // Step 6: Gather real codebase context proactively
-    const realContext = await this.gatherRealContext(taskDescription, projectPath)
+    // Step 6: Gather real codebase context and sealed analysis in parallel
+    const [realContext, sealedAnalysis] = await Promise.all([
+      this.gatherRealContext(taskDescription, projectPath),
+      this.loadSealedAnalysis(projectId),
+    ])
 
     // Step 7: Determine if fragmentation is needed
     const requiresFragmentation = this.shouldFragment(domains, taskDescription)
@@ -101,6 +105,7 @@ export class OrchestratorExecutor {
         conventions: repoAnalysis?.conventions || [],
       },
       realContext,
+      sealedAnalysis,
     }
   }
 
@@ -197,6 +202,34 @@ export class OrchestratorExecutor {
     }
   }
 
+  /**
+   * Load sealed/active analysis from analysis storage (PRJ-260).
+   * Returns sealed if available, otherwise draft as fallback.
+   * Returns null if no analysis exists (graceful degradation).
+   */
+  private async loadSealedAnalysis(projectId: string): Promise<SealedAnalysisContext | null> {
+    try {
+      const analysis = await analysisStorage.getActive(projectId)
+      if (!analysis) return null
+
+      return {
+        languages: analysis.languages,
+        frameworks: analysis.frameworks,
+        packageManager: analysis.packageManager,
+        sourceDir: analysis.sourceDir,
+        testDir: analysis.testDir,
+        fileCount: analysis.fileCount,
+        patterns: analysis.patterns,
+        antiPatterns: analysis.antiPatterns,
+        status: analysis.status ?? 'draft',
+        commitHash: analysis.commitHash,
+      }
+    } catch {
+      // Graceful degradation — analysis is optional enhancement
+      return null
+    }
+  }
+
   /**
    * Load repo-analysis.json for project context
    */

package/core/agentic/prompt-builder.ts

@@ -542,10 +542,50 @@ class PromptBuilder {
     // =========================================================================
 
     if (orchestratorContext) {
+      const sa = orchestratorContext.sealedAnalysis
       parts.push('\n## PROJECT ANALYSIS (Sealed)\n')
       parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}\n`)
       parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}\n`)
-      parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(', ')}\n\n`)
+      parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(', ')}\n`)
+
+      // Inject sealed analysis data (PRJ-260)
+      if (sa) {
+        if (sa.languages.length > 0) {
+          parts.push(`**Languages**: ${sa.languages.join(', ')}\n`)
+        }
+        if (sa.frameworks.length > 0) {
+          parts.push(`**Frameworks**: ${sa.frameworks.join(', ')}\n`)
+        }
+        if (sa.packageManager) {
+          parts.push(`**Package Manager**: ${sa.packageManager}\n`)
+        }
+        if (sa.sourceDir) {
+          parts.push(`**Source Dir**: ${sa.sourceDir}\n`)
+        }
+        if (sa.testDir) {
+          parts.push(`**Test Dir**: ${sa.testDir}\n`)
+        }
+        parts.push(`**Files Analyzed**: ${sa.fileCount}\n`)
+        parts.push(
+          `**Analysis Status**: ${sa.status}${sa.commitHash ? ` (commit: ${sa.commitHash.slice(0, 8)})` : ''}\n`
+        )
+
+        if (sa.patterns.length > 0) {
+          parts.push('\n### Code Patterns (Follow These)\n')
+          for (const p of sa.patterns) {
+            parts.push(`- **${p.name}**: ${p.description}${p.location ? ` (${p.location})` : ''}\n`)
+          }
+        }
+
+        if (sa.antiPatterns.length > 0) {
+          parts.push('\n### Anti-Patterns (Avoid These)\n')
+          for (const ap of sa.antiPatterns) {
+            parts.push(`- **${ap.issue}** in \`${ap.file}\` — ${ap.suggestion}\n`)
+          }
+        }
+      }
+
+      parts.push('\n')
     }
 
     const needsPatterns = commandContext.patterns
@@ -648,6 +688,7 @@ class PromptBuilder {
     // =========================================================================
 
     if (projectPath) {
+      const sa = orchestratorContext?.sealedAnalysis
       const groundTruth: ProjectGroundTruth = {
         projectPath,
         language: orchestratorContext?.project?.ecosystem,
@@ -655,6 +696,10 @@ class PromptBuilder {
         domains: this.extractDomains(state),
         fileCount: context.files?.length || context.filteredSize || 0,
         availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
+        // Inject sealed analysis data for enriched grounding (PRJ-260)
+        analysisLanguages: sa?.languages || [],
+        analysisFrameworks: sa?.frameworks || [],
+        analysisPackageManager: sa?.packageManager,
       }
       parts.push(`\n${buildAntiHallucinationBlock(groundTruth)}\n`)
     } else {
@@ -800,6 +845,24 @@ class PromptBuilder {
         if (currentSubtask.dependsOn.length > 0) {
           parts.push(`Dependencies: ${currentSubtask.dependsOn.join(', ')}\n`)
         }
+
+        // Inject previous subtask handoff for context continuity (PRJ-262)
+        if (currentSubtask.handoff) {
+          const h = currentSubtask.handoff
+          parts.push('\n### Previous Subtask Handoff\n\n')
+          parts.push(`**From:** ${h.fromSubtask}\n\n`)
+          parts.push('**What was done:**\n')
+          for (const item of h.whatWasDone) {
+            parts.push(`- ${item}\n`)
+          }
+          if (h.filesChanged.length > 0) {
+            parts.push('\n**Files changed:**\n')
+            for (const f of h.filesChanged) {
+              parts.push(`- \`${f.path}\` (${f.action})\n`)
+            }
+          }
+          parts.push(`\n**Context for this subtask:**\n${h.outputForNextAgent}\n`)
+        }
       }
       parts.push('\n')
     }

package/core/schemas/state.ts

@@ -44,11 +44,18 @@ export const SubtaskSummarySchema = z.object({
       action: z.enum(['created', 'modified', 'deleted']),
     })
   ),
-  whatWasDone: z.array(z.string()),
-  outputForNextAgent: z.string().optional(),
+  whatWasDone: z.array(z.string()).min(1),
+  outputForNextAgent: z.string().min(1),
   notes: z.string().optional(),
 })
 
+// Schema for validating completion data before persisting
+// Used by completeSubtask() to enforce mandatory handoff
+export const SubtaskCompletionDataSchema = z.object({
+  output: z.string().min(1, 'Subtask output is required'),
+  summary: SubtaskSummarySchema,
+})
+
 // Subtask schema for task fragmentation
 export const SubtaskSchema = z.object({
   id: z.string(), // subtask-xxx
@@ -169,6 +176,7 @@ export type ActivityType = z.infer<typeof ActivityTypeSchema>
 
 export type Subtask = z.infer<typeof SubtaskSchema>
 export type SubtaskSummary = z.infer<typeof SubtaskSummarySchema>
+export type SubtaskCompletionData = z.infer<typeof SubtaskCompletionDataSchema>
 export type SubtaskProgress = z.infer<typeof SubtaskProgressSchema>
 
 export type CurrentTask = z.infer<typeof CurrentTaskSchema>
@@ -197,6 +205,18 @@ export const parseQueue = (data: unknown): QueueJson => QueueJsonSchema.parse(da
 export const safeParseState = (data: unknown) => StateJsonSchema.safeParse(data)
 export const safeParseQueue = (data: unknown) => QueueJsonSchema.safeParse(data)
 
+/** Validate subtask completion data — returns errors or null */
+export const validateSubtaskCompletion = (
+  data: unknown
+): { success: true; data: SubtaskCompletionData } | { success: false; errors: string[] } => {
+  const result = SubtaskCompletionDataSchema.safeParse(data)
+  if (result.success) return { success: true, data: result.data }
+  return {
+    success: false,
+    errors: result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`),
+  }
+}
+
 // =============================================================================
 // Defaults
 // =============================================================================

package/core/storage/state-storage.ts

@@ -14,9 +14,9 @@ import type {
   PreviousTask,
   StateJson,
   Subtask,
-  SubtaskSummary,
+  SubtaskCompletionData,
 } from '../schemas/state'
-import { StateJsonSchema } from '../schemas/state'
+import { StateJsonSchema, SubtaskCompletionDataSchema } from '../schemas/state'
 import { getTimestamp, toRelative } from '../utils/date-helper'
 import { md } from '../utils/markdown-builder'
 import type { WorkflowCommand } from '../workflow/state-machine'
@@ -497,14 +497,23 @@ class StateStorage extends StorageManager<StateJson> {
   }
 
   /**
-   * Complete current subtask and advance to next
-   * Returns the next subtask (or null if all complete)
+   * Complete current subtask and advance to next.
+   * Requires output and summary for mandatory handoff (PRJ-262).
+   * Returns the next subtask (or null if all complete).
    */
   async completeSubtask(
     projectId: string,
-    output?: string,
-    summary?: SubtaskSummary
+    completionData: SubtaskCompletionData
   ): Promise<Subtask | null> {
+    // Validate handoff data with Zod before persisting
+    const validation = SubtaskCompletionDataSchema.safeParse(completionData)
+    if (!validation.success) {
+      const errors = validation.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`)
+      throw new Error(`Subtask completion requires handoff data:\n${errors.join('\n')}`)
+    }
+
+    const { output, summary } = validation.data
+
     const state = await this.read(projectId)
     if (!state.currentTask?.subtasks) return null
 
@@ -512,7 +521,7 @@ class StateStorage extends StorageManager<StateJson> {
     const current = state.currentTask.subtasks[currentIndex]
     if (!current) return null
 
-    // Mark current as completed
+    // Mark current as completed with mandatory handoff
     const updatedSubtasks = [...state.currentTask.subtasks]
     updatedSubtasks[currentIndex] = {
       ...current,
@@ -548,12 +557,14 @@ class StateStorage extends StorageManager<StateJson> {
       lastUpdated: getTimestamp(),
     }))
 
-    // Publish event
+    // Publish event with handoff data
     await this.publishEvent(projectId, 'subtask.completed', {
       taskId: state.currentTask.id,
       subtaskId: current.id,
       description: current.description,
       output,
+      handoff: summary.outputForNextAgent,
+      filesChanged: summary.filesChanged.length,
       progress: { completed, total, percentage },
     })
 
@@ -592,6 +603,27 @@ class StateStorage extends StorageManager<StateJson> {
     return state.currentTask.subtasks[prevIndex] || null
   }
 
+  /**
+   * Get handoff from the most recently completed subtask (PRJ-262).
+   * Returns the summary.outputForNextAgent and related context,
+   * or null if no previous subtask or no handoff data.
+   */
+  async getPreviousHandoff(projectId: string): Promise<{
+    fromSubtask: string
+    outputForNextAgent: string
+    filesChanged: Array<{ path: string; action: string }>
+    whatWasDone: string[]
+  } | null> {
+    const prev = await this.getPreviousSubtask(projectId)
+    if (!prev?.summary?.outputForNextAgent) return null
+    return {
+      fromSubtask: prev.description,
+      outputForNextAgent: prev.summary.outputForNextAgent,
+      filesChanged: prev.summary.filesChanged,
+      whatWasDone: prev.summary.whatWasDone,
+    }
+  }
+
   /**
    * Get all subtasks
    */

package/core/types/agentic.ts

@@ -673,6 +673,13 @@ export interface OrchestratorSubtask {
   status: 'pending' | 'in_progress' | 'completed' | 'failed'
   dependsOn: string[]
   order: number
+  /** Handoff from previous subtask — injected into prompt for context continuity (PRJ-262) */
+  handoff?: {
+    fromSubtask: string
+    outputForNextAgent: string
+    filesChanged: Array<{ path: string; action: string }>
+    whatWasDone: string[]
+  }
 }
 
 /**
@@ -717,4 +724,35 @@ export interface OrchestratorContext {
   }
   /** Real codebase context gathered proactively */
   realContext?: RealCodebaseContext
+  /** Sealed/active analysis from PRJ-263 storage — injected into prompt context (PRJ-260) */
+  sealedAnalysis?: SealedAnalysisContext | null
+}
+
+/**
+ * Subset of analysis data injected into prompt context.
+ * Extracted from AnalysisSchema to avoid coupling types to storage schema.
+ *
+ * @see PRJ-260
+ */
+export interface SealedAnalysisContext {
+  /** Programming languages detected */
+  languages: string[]
+  /** Frameworks detected */
+  frameworks: string[]
+  /** Package manager (e.g., 'bun', 'npm', 'pnpm') */
+  packageManager?: string
+  /** Source directory */
+  sourceDir?: string
+  /** Test directory */
+  testDir?: string
+  /** Total files analyzed */
+  fileCount: number
+  /** Code patterns found */
+  patterns: Array<{ name: string; description: string; location?: string }>
+  /** Anti-patterns found */
+  antiPatterns: Array<{ issue: string; file: string; suggestion: string }>
+  /** Lifecycle status */
+  status: 'draft' | 'verified' | 'sealed'
+  /** Git commit hash when analysis was performed */
+  commitHash?: string
 }

package/core/types/index.ts

@@ -81,6 +81,8 @@ export type {
   RealCodebaseContext,
   ReasoningResult,
   ReasoningStep,
+  // Sealed analysis context (PRJ-260)
+  SealedAnalysisContext,
   SimpleExecutionResult,
   SkillContext,
   SmartContextProjectState,

package/dist/bin/prjct.mjs

@@ -10212,7 +10212,7 @@ var init_shipped = __esm({
 
 // core/schemas/state.ts
 import { z as z14 } from "zod";
-var PrioritySchema, TaskTypeSchema, TaskSectionSchema, TaskStatusSchema, ActivityTypeSchema, SubtaskSummarySchema, SubtaskSchema, SubtaskProgressSchema, CurrentTaskSchema, PreviousTaskSchema, StateJsonSchema, QueueTaskSchema, QueueJsonSchema, StatsSchema, RecentActivitySchema, StateSchemaFull;
+var PrioritySchema, TaskTypeSchema, TaskSectionSchema, TaskStatusSchema, ActivityTypeSchema, SubtaskSummarySchema, SubtaskCompletionDataSchema, SubtaskSchema, SubtaskProgressSchema, CurrentTaskSchema, PreviousTaskSchema, StateJsonSchema, QueueTaskSchema, QueueJsonSchema, StatsSchema, RecentActivitySchema, StateSchemaFull;
 var init_state = __esm({
   "core/schemas/state.ts"() {
     "use strict";
@@ -10244,10 +10244,14 @@ var init_state = __esm({
           action: z14.enum(["created", "modified", "deleted"])
         })
       ),
-      whatWasDone: z14.array(z14.string()),
-      outputForNextAgent: z14.string().optional(),
+      whatWasDone: z14.array(z14.string()).min(1),
+      outputForNextAgent: z14.string().min(1),
       notes: z14.string().optional()
     });
+    SubtaskCompletionDataSchema = z14.object({
+      output: z14.string().min(1, "Subtask output is required"),
+      summary: SubtaskSummarySchema
+    });
     SubtaskSchema = z14.object({
       id: z14.string(),
       // subtask-xxx
@@ -13259,10 +13263,18 @@ var init_state_storage = __esm({
         });
       }
       /**
-       * Complete current subtask and advance to next
-       * Returns the next subtask (or null if all complete)
+       * Complete current subtask and advance to next.
+       * Requires output and summary for mandatory handoff (PRJ-262).
+       * Returns the next subtask (or null if all complete).
        */
-      async completeSubtask(projectId, output, summary) {
+      async completeSubtask(projectId, completionData) {
+        const validation = SubtaskCompletionDataSchema.safeParse(completionData);
+        if (!validation.success) {
+          const errors = validation.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+          throw new Error(`Subtask completion requires handoff data:
+${errors.join("\n")}`);
+        }
+        const { output, summary } = validation.data;
         const state = await this.read(projectId);
         if (!state.currentTask?.subtasks) return null;
         const currentIndex = state.currentTask.currentSubtaskIndex || 0;
@@ -13302,6 +13314,8 @@ var init_state_storage = __esm({
           subtaskId: current.id,
           description: current.description,
           output,
+          handoff: summary.outputForNextAgent,
+          filesChanged: summary.filesChanged.length,
           progress: { completed, total, percentage }
         });
         return nextIndex < total ? updatedSubtasks[nextIndex] : null;
@@ -13334,6 +13348,21 @@ var init_state_storage = __esm({
         if (prevIndex < 0) return null;
         return state.currentTask.subtasks[prevIndex] || null;
       }
+      /**
+       * Get handoff from the most recently completed subtask (PRJ-262).
+       * Returns the summary.outputForNextAgent and related context,
+       * or null if no previous subtask or no handoff data.
+       */
+      async getPreviousHandoff(projectId) {
+        const prev = await this.getPreviousSubtask(projectId);
+        if (!prev?.summary?.outputForNextAgent) return null;
+        return {
+          fromSubtask: prev.description,
+          outputForNextAgent: prev.summary.outputForNextAgent,
+          filesChanged: prev.summary.filesChanged,
+          whatWasDone: prev.summary.whatWasDone
+        };
+      }
       /**
        * Get all subtasks
        */
@@ -14174,7 +14203,10 @@ var init_orchestrator_executor = __esm({
         const { domains, primary } = await this.detectDomains(taskDescription, projectId, repoAnalysis);
         const agents = await this.loadAgents(domains, projectId);
         const skills = await this.loadSkills(agents);
-        const realContext = await this.gatherRealContext(taskDescription, projectPath);
+        const [realContext, sealedAnalysis] = await Promise.all([
+          this.gatherRealContext(taskDescription, projectPath),
+          this.loadSealedAnalysis(projectId)
+        ]);
         const requiresFragmentation = this.shouldFragment(domains, taskDescription);
         let subtasks = null;
         if (requiresFragmentation && command === "task") {
@@ -14192,7 +14224,8 @@ var init_orchestrator_executor = __esm({
             ecosystem: repoAnalysis?.ecosystem || "unknown",
             conventions: repoAnalysis?.conventions || []
           },
-          realContext
+          realContext,
+          sealedAnalysis
         };
       }
       /**
@@ -14272,6 +14305,31 @@ var init_orchestrator_executor = __esm({
           return { branch: "unknown", status: "git unavailable" };
         }
       }
+      /**
+       * Load sealed/active analysis from analysis storage (PRJ-260).
+       * Returns sealed if available, otherwise draft as fallback.
+       * Returns null if no analysis exists (graceful degradation).
+       */
+      async loadSealedAnalysis(projectId) {
+        try {
+          const analysis2 = await analysisStorage.getActive(projectId);
+          if (!analysis2) return null;
+          return {
+            languages: analysis2.languages,
+            frameworks: analysis2.frameworks,
+            packageManager: analysis2.packageManager,
+            sourceDir: analysis2.sourceDir,
+            testDir: analysis2.testDir,
+            fileCount: analysis2.fileCount,
+            patterns: analysis2.patterns,
+            antiPatterns: analysis2.antiPatterns,
+            status: analysis2.status ?? "draft",
+            commitHash: analysis2.commitHash
+          };
+        } catch {
+          return null;
+        }
+      }
       /**
        * Load repo-analysis.json for project context
        */
@@ -15352,9 +15410,24 @@ function buildAntiHallucinationBlock(truth) {
   if (truth.framework) available.push(truth.framework);
   const techStack = truth.techStack ?? [];
   available.push(...techStack.filter((t) => t !== truth.framework));
+  const analysisLangs = truth.analysisLanguages ?? [];
+  const analysisFrameworks = truth.analysisFrameworks ?? [];
+  for (const lang of analysisLangs) {
+    if (!available.some((a) => a.toLowerCase() === lang.toLowerCase())) {
+      available.push(lang);
+    }
+  }
+  for (const fw of analysisFrameworks) {
+    if (!available.some((a) => a.toLowerCase() === fw.toLowerCase())) {
+      available.push(fw);
+    }
+  }
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(", ")}`);
   }
+  if (truth.analysisPackageManager) {
+    parts.push(`PACKAGE MANAGER: ${truth.analysisPackageManager}`);
+  }
   if (truth.domains) {
     const absent = Object.entries(truth.domains).filter(([, hasIt]) => !hasIt).map(([key]) => DOMAIN_LABELS[key]).filter(Boolean);
     if (absent.length > 0) {
@@ -15401,7 +15474,13 @@ var init_anti_hallucination = __esm({
       /** Total files in project */
       fileCount: z15.number().optional(),
       /** Available agent names (e.g., ['backend', 'testing']) */
-      availableAgents: z15.array(z15.string()).default([])
+      availableAgents: z15.array(z15.string()).default([]),
+      /** Sealed analysis languages — used to ground available tech (PRJ-260) */
+      analysisLanguages: z15.array(z15.string()).default([]),
+      /** Sealed analysis frameworks — used to ground available tech (PRJ-260) */
+      analysisFrameworks: z15.array(z15.string()).default([]),
+      /** Package manager from sealed analysis (PRJ-260) */
+      analysisPackageManager: z15.string().optional()
     });
     DOMAIN_LABELS = {
       hasFrontend: "Frontend (UI/components)",
@@ -16145,14 +16224,57 @@ ${envBlock}
 `);
         }
         if (orchestratorContext) {
+          const sa = orchestratorContext.sealedAnalysis;
           parts.push("\n## PROJECT ANALYSIS (Sealed)\n");
           parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}
 `);
           parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}
 `);
           parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(", ")}
-
 `);
+          if (sa) {
+            if (sa.languages.length > 0) {
+              parts.push(`**Languages**: ${sa.languages.join(", ")}
+`);
+            }
+            if (sa.frameworks.length > 0) {
+              parts.push(`**Frameworks**: ${sa.frameworks.join(", ")}
+`);
+            }
+            if (sa.packageManager) {
+              parts.push(`**Package Manager**: ${sa.packageManager}
+`);
+            }
+            if (sa.sourceDir) {
+              parts.push(`**Source Dir**: ${sa.sourceDir}
+`);
+            }
+            if (sa.testDir) {
+              parts.push(`**Test Dir**: ${sa.testDir}
+`);
+            }
+            parts.push(`**Files Analyzed**: ${sa.fileCount}
+`);
+            parts.push(
+              `**Analysis Status**: ${sa.status}${sa.commitHash ? ` (commit: ${sa.commitHash.slice(0, 8)})` : ""}
+`
+            );
+            if (sa.patterns.length > 0) {
+              parts.push("\n### Code Patterns (Follow These)\n");
+              for (const p of sa.patterns) {
+                parts.push(`- **${p.name}**: ${p.description}${p.location ? ` (${p.location})` : ""}
+`);
+              }
+            }
+            if (sa.antiPatterns.length > 0) {
+              parts.push("\n### Anti-Patterns (Avoid These)\n");
+              for (const ap of sa.antiPatterns) {
+                parts.push(`- **${ap.issue}** in \`${ap.file}\` \u2014 ${ap.suggestion}
+`);
+              }
+            }
+          }
+          parts.push("\n");
         }
         const needsPatterns = commandContext.patterns;
         const codePatternsContent = state?.codePatterns || "";
@@ -16253,13 +16375,18 @@ Show changes, list affected files, ask for confirmation.
           );
         }
         if (projectPath) {
+          const sa = orchestratorContext?.sealedAnalysis;
           const groundTruth2 = {
             projectPath,
             language: orchestratorContext?.project?.ecosystem,
             techStack: orchestratorContext?.project?.conventions || [],
             domains: this.extractDomains(state),
             fileCount: context2.files?.length || context2.filteredSize || 0,
-            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || []
+            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
+            // Inject sealed analysis data for enriched grounding (PRJ-260)
+            analysisLanguages: sa?.languages || [],
+            analysisFrameworks: sa?.frameworks || [],
+            analysisPackageManager: sa?.packageManager
           };
           parts.push(`
 ${buildAntiHallucinationBlock(groundTruth2)}
@@ -16386,6 +16513,29 @@ Read files before modifying.
 `);
             if (currentSubtask.dependsOn.length > 0) {
               parts.push(`Dependencies: ${currentSubtask.dependsOn.join(", ")}
+`);
+            }
+            if (currentSubtask.handoff) {
+              const h = currentSubtask.handoff;
+              parts.push("\n### Previous Subtask Handoff\n\n");
+              parts.push(`**From:** ${h.fromSubtask}
+
+`);
+              parts.push("**What was done:**\n");
+              for (const item of h.whatWasDone) {
+                parts.push(`- ${item}
+`);
+              }
+              if (h.filesChanged.length > 0) {
+                parts.push("\n**Files changed:**\n");
+                for (const f of h.filesChanged) {
+                  parts.push(`- \`${f.path}\` (${f.action})
+`);
+                }
+              }
+              parts.push(`
+**Context for this subtask:**
+${h.outputForNextAgent}
 `);
             }
           }
@@ -31050,7 +31200,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.11.0",
+      version: "1.13.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.11.0",
+  "version": "1.13.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {