prjct-cli 1.9.0 → 1.11.0

package/dist/bin/prjct.mjs

@@ -9166,10 +9166,52 @@ var init_agents = __esm({
 });
 
 // core/schemas/analysis.ts
-var DEFAULT_ANALYSIS;
+import { z as z4 } from "zod";
+var AnalysisStatusSchema, CodePatternSchema, AntiPatternSchema, AnalysisItemSchema, DEFAULT_ANALYSIS;
 var init_analysis = __esm({
   "core/schemas/analysis.ts"() {
     "use strict";
+    init_model();
+    AnalysisStatusSchema = z4.enum(["draft", "verified", "sealed"]);
+    CodePatternSchema = z4.object({
+      name: z4.string(),
+      description: z4.string(),
+      location: z4.string().optional()
+    });
+    AntiPatternSchema = z4.object({
+      issue: z4.string(),
+      file: z4.string(),
+      suggestion: z4.string()
+    });
+    AnalysisItemSchema = z4.object({
+      projectId: z4.string(),
+      languages: z4.array(z4.string()),
+      frameworks: z4.array(z4.string()),
+      packageManager: z4.string().optional(),
+      sourceDir: z4.string().optional(),
+      testDir: z4.string().optional(),
+      configFiles: z4.array(z4.string()),
+      fileCount: z4.number(),
+      patterns: z4.array(CodePatternSchema),
+      antiPatterns: z4.array(AntiPatternSchema),
+      analyzedAt: z4.string(),
+      // ISO8601
+      /** Which AI model was used for this analysis (PRJ-265) */
+      modelMetadata: ModelMetadataSchema.optional(),
+      // Sealable analysis fields (PRJ-263)
+      /** Lifecycle status: draft (regenerable), verified (confirmed correct), sealed (locked) */
+      status: AnalysisStatusSchema.default("draft"),
+      /** Git commit hash at the time of analysis */
+      commitHash: z4.string().optional(),
+      /** SHA-256 signature of analysis content + commit hash */
+      signature: z4.string().optional(),
+      /** When the analysis was sealed */
+      sealedAt: z4.string().optional(),
+      // ISO8601
+      /** When the analysis was verified */
+      verifiedAt: z4.string().optional()
+      // ISO8601
+    });
     DEFAULT_ANALYSIS = {
       languages: [],
       frameworks: [],
@@ -9177,18 +9219,19 @@ var init_analysis = __esm({
       fileCount: 0,
       patterns: [],
       antiPatterns: [],
-      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "draft"
     };
   }
 });
 
 // core/schemas/classification.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var ClassificationDomainSchema, TaskClassificationSchema, ClassificationCacheEntrySchema, ClassificationCacheSchema, DEFAULT_CLASSIFICATION_CACHE, GENERAL_CLASSIFICATION;
 var init_classification = __esm({
   "core/schemas/classification.ts"() {
     "use strict";
-    ClassificationDomainSchema = z4.enum([
+    ClassificationDomainSchema = z5.enum([
       "frontend",
       "backend",
       "database",
@@ -9198,40 +9241,40 @@ var init_classification = __esm({
       "uxui",
       "general"
     ]);
-    TaskClassificationSchema = z4.object({
+    TaskClassificationSchema = z5.object({
       /** Primary domain for this task */
       primaryDomain: ClassificationDomainSchema,
       /** Secondary domains that are also relevant */
-      secondaryDomains: z4.array(ClassificationDomainSchema),
+      secondaryDomains: z5.array(ClassificationDomainSchema),
       /** Confidence in the classification (0-1) */
-      confidence: z4.number().min(0).max(1),
+      confidence: z5.number().min(0).max(1),
       /** Glob patterns for relevant files */
-      filePatterns: z4.array(z4.string()),
+      filePatterns: z5.array(z5.string()),
       /** Agent names that should handle this task */
-      relevantAgents: z4.array(z4.string())
+      relevantAgents: z5.array(z5.string())
     });
-    ClassificationCacheEntrySchema = z4.object({
+    ClassificationCacheEntrySchema = z5.object({
       /** The classification result */
       classification: TaskClassificationSchema,
       /** When this was classified */
-      classifiedAt: z4.string(),
+      classifiedAt: z5.string(),
       /** How this was classified */
-      source: z4.enum(["cache", "history", "llm", "heuristic"]),
+      source: z5.enum(["cache", "history", "llm", "heuristic"]),
       /** Hash of the task description for cache lookup */
-      descriptionHash: z4.string(),
+      descriptionHash: z5.string(),
       /** Project ID this classification belongs to */
-      projectId: z4.string()
+      projectId: z5.string()
     });
-    ClassificationCacheSchema = z4.object({
+    ClassificationCacheSchema = z5.object({
       /** Cached classifications keyed by descriptionHash */
-      entries: z4.record(z4.string(), ClassificationCacheEntrySchema),
+      entries: z5.record(z5.string(), ClassificationCacheEntrySchema),
       /** Confirmed patterns from successful task completions */
-      confirmedPatterns: z4.array(
-        z4.object({
-          descriptionHash: z4.string(),
+      confirmedPatterns: z5.array(
+        z5.object({
+          descriptionHash: z5.string(),
           classification: TaskClassificationSchema,
-          confirmedAt: z4.string(),
-          taskDescription: z4.string()
+          confirmedAt: z5.string(),
+          taskDescription: z5.string()
         })
       )
     });
@@ -9250,74 +9293,74 @@ var init_classification = __esm({
 });
 
 // core/schemas/ideas.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var IdeaPrioritySchema, IdeaStatusSchema, ImpactLevelSchema, ImpactEffortSchema, TechStackSchema, IdeaModuleSchema, IdeaRoleSchema, IdeaItemSchema, IdeasJsonSchema, DEFAULT_IDEA;
 var init_ideas = __esm({
   "core/schemas/ideas.ts"() {
     "use strict";
-    IdeaPrioritySchema = z5.enum(["low", "medium", "high"]);
-    IdeaStatusSchema = z5.enum(["pending", "converted", "completed", "archived"]);
-    ImpactLevelSchema = z5.enum(["high", "medium", "low"]);
-    ImpactEffortSchema = z5.object({
+    IdeaPrioritySchema = z6.enum(["low", "medium", "high"]);
+    IdeaStatusSchema = z6.enum(["pending", "converted", "completed", "archived"]);
+    ImpactLevelSchema = z6.enum(["high", "medium", "low"]);
+    ImpactEffortSchema = z6.object({
       impact: ImpactLevelSchema,
       effort: ImpactLevelSchema
     });
-    TechStackSchema = z5.object({
-      frontend: z5.string().optional(),
+    TechStackSchema = z6.object({
+      frontend: z6.string().optional(),
       // "Next.js 14, HeroUI"
-      backend: z5.string().optional(),
+      backend: z6.string().optional(),
       // "Supabase (Auth, DB, RLS, Realtime)"
-      payments: z5.string().optional(),
+      payments: z6.string().optional(),
       // "Stripe Billing"
-      ai: z5.string().optional(),
+      ai: z6.string().optional(),
       // "Vercel AI SDK"
-      deploy: z5.string().optional(),
+      deploy: z6.string().optional(),
       // "Vercel"
-      other: z5.array(z5.string()).optional()
+      other: z6.array(z6.string()).optional()
     });
-    IdeaModuleSchema = z5.object({
-      name: z5.string(),
+    IdeaModuleSchema = z6.object({
+      name: z6.string(),
       // "Multi-tenant"
-      description: z5.string()
+      description: z6.string()
       // "Strict RLS for organizations"
     });
-    IdeaRoleSchema = z5.object({
-      name: z5.string(),
+    IdeaRoleSchema = z6.object({
+      name: z6.string(),
       // "SUPER_ADMIN"
-      description: z5.string().optional()
+      description: z6.string().optional()
     });
-    IdeaItemSchema = z5.object({
-      id: z5.string(),
+    IdeaItemSchema = z6.object({
+      id: z6.string(),
       // idea_xxxxxxxx
-      text: z5.string(),
+      text: z6.string(),
       // Title/summary
-      details: z5.string().optional(),
+      details: z6.string().optional(),
       priority: IdeaPrioritySchema,
       status: IdeaStatusSchema,
-      tags: z5.array(z5.string()),
-      addedAt: z5.string(),
+      tags: z6.array(z6.string()),
+      addedAt: z6.string(),
       // ISO8601
-      completedAt: z5.string().optional(),
-      convertedTo: z5.string().optional(),
+      completedAt: z6.string().optional(),
+      convertedTo: z6.string().optional(),
       // Source documentation
-      source: z5.string().optional(),
-      sourceFiles: z5.array(z5.string()).optional(),
+      source: z6.string().optional(),
+      sourceFiles: z6.array(z6.string()).optional(),
       // Enriched fields from MD
-      painPoints: z5.array(z5.string()).optional(),
-      solutions: z5.array(z5.string()).optional(),
-      filesAffected: z5.array(z5.string()).optional(),
+      painPoints: z6.array(z6.string()).optional(),
+      solutions: z6.array(z6.string()).optional(),
+      filesAffected: z6.array(z6.string()).optional(),
       impactEffort: ImpactEffortSchema.optional(),
-      implementationNotes: z5.string().optional(),
+      implementationNotes: z6.string().optional(),
       // Technical spec fields for ZERO DATA LOSS
       stack: TechStackSchema.optional(),
-      modules: z5.array(IdeaModuleSchema).optional(),
-      roles: z5.array(IdeaRoleSchema).optional(),
-      risks: z5.array(z5.string()).optional(),
-      risksCount: z5.number().optional()
+      modules: z6.array(IdeaModuleSchema).optional(),
+      roles: z6.array(IdeaRoleSchema).optional(),
+      risks: z6.array(z6.string()).optional(),
+      risksCount: z6.number().optional()
     });
-    IdeasJsonSchema = z5.object({
-      ideas: z5.array(IdeaItemSchema),
-      lastUpdated: z5.string()
+    IdeasJsonSchema = z6.object({
+      ideas: z6.array(IdeaItemSchema),
+      lastUpdated: z6.string()
     });
     DEFAULT_IDEA = {
       priority: "medium",
@@ -9329,7 +9372,7 @@ var init_ideas = __esm({
 });
 
 // core/schemas/issues.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function createEmptyIssues(provider) {
   return {
     provider,
@@ -9342,8 +9385,8 @@ var IssueProviderSchema, IssueStatusSchema, IssuePrioritySchema, IssueTypeSchema
 var init_issues = __esm({
   "core/schemas/issues.ts"() {
     "use strict";
-    IssueProviderSchema = z6.enum(["linear", "jira", "github", "monday", "asana", "none"]);
-    IssueStatusSchema = z6.enum([
+    IssueProviderSchema = z7.enum(["linear", "jira", "github", "monday", "asana", "none"]);
+    IssueStatusSchema = z7.enum([
       "backlog",
       "todo",
       "in_progress",
@@ -9351,68 +9394,68 @@ var init_issues = __esm({
       "done",
       "cancelled"
     ]);
-    IssuePrioritySchema = z6.enum(["none", "urgent", "high", "medium", "low"]);
-    IssueTypeSchema = z6.enum(["feature", "bug", "improvement", "task", "chore", "epic"]);
-    CachedIssueSchema = z6.object({
+    IssuePrioritySchema = z7.enum(["none", "urgent", "high", "medium", "low"]);
+    IssueTypeSchema = z7.enum(["feature", "bug", "improvement", "task", "chore", "epic"]);
+    CachedIssueSchema = z7.object({
       // Core identifiers
-      id: z6.string(),
+      id: z7.string(),
       // Provider UUID
-      identifier: z6.string(),
+      identifier: z7.string(),
       // Human-readable ID (e.g., "PRJ-123")
       // Issue content
-      title: z6.string(),
-      description: z6.string().optional(),
+      title: z7.string(),
+      description: z7.string().optional(),
       // State
       status: IssueStatusSchema,
       priority: IssuePrioritySchema,
       type: IssueTypeSchema.optional(),
       // Metadata
-      assignee: z6.object({
-        id: z6.string(),
-        name: z6.string(),
-        email: z6.string().optional()
+      assignee: z7.object({
+        id: z7.string(),
+        name: z7.string(),
+        email: z7.string().optional()
       }).optional(),
-      labels: z6.array(z6.string()).default([]),
-      team: z6.object({
-        id: z6.string(),
-        name: z6.string(),
-        key: z6.string().optional()
+      labels: z7.array(z7.string()).default([]),
+      team: z7.object({
+        id: z7.string(),
+        name: z7.string(),
+        key: z7.string().optional()
       }).optional(),
-      project: z6.object({
-        id: z6.string(),
-        name: z6.string()
+      project: z7.object({
+        id: z7.string(),
+        name: z7.string()
       }).optional(),
       // URLs and timestamps
-      url: z6.string(),
-      createdAt: z6.string(),
+      url: z7.string(),
+      createdAt: z7.string(),
       // ISO8601 from provider
-      updatedAt: z6.string(),
+      updatedAt: z7.string(),
       // ISO8601 from provider
-      fetchedAt: z6.string()
+      fetchedAt: z7.string()
       // ISO8601 when we cached it
     });
-    IssuesJsonSchema = z6.object({
+    IssuesJsonSchema = z7.object({
       // Provider info
       provider: IssueProviderSchema,
       // Sync metadata
-      lastSync: z6.string(),
+      lastSync: z7.string(),
       // ISO8601 of last full sync
-      staleAfter: z6.number().default(18e5),
+      staleAfter: z7.number().default(18e5),
       // 30 minutes in ms
       // Issues map: identifier -> issue
-      issues: z6.record(z6.string(), CachedIssueSchema)
+      issues: z7.record(z7.string(), CachedIssueSchema)
     });
-    SyncResultSchema = z6.object({
+    SyncResultSchema = z7.object({
       provider: IssueProviderSchema,
-      fetched: z6.number(),
-      updated: z6.number(),
-      errors: z6.array(
-        z6.object({
-          issueId: z6.string(),
-          error: z6.string()
+      fetched: z7.number(),
+      updated: z7.number(),
+      errors: z7.array(
+        z7.object({
+          issueId: z7.string(),
+          error: z7.string()
         })
       ),
-      timestamp: z6.string()
+      timestamp: z7.string()
     });
     parseIssues = /* @__PURE__ */ __name((data) => IssuesJsonSchema.parse(data), "parseIssues");
     __name(createEmptyIssues, "createEmptyIssues");
@@ -9428,7 +9471,7 @@ __export(llm_output_exports, {
   TaskClassificationSchema: () => TaskClassificationSchema,
   renderSchemaForPrompt: () => renderSchemaForPrompt
 });
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function renderSchemaForPrompt(schemaType) {
   const entry = OUTPUT_SCHEMAS[schemaType];
   if (!entry) return null;
@@ -9444,18 +9487,18 @@ Fields:
 ${describeSchema(entry.schema)}`;
 }
 function describeSchema(schema) {
-  if (schema instanceof z7.ZodObject) {
+  if (schema instanceof z8.ZodObject) {
     const shape = schema.shape;
     return Object.entries(shape).map(([key, field]) => `- \`${key}\`: ${describeField(field)}`).join("\n");
   }
   return "(see example above)";
 }
 function describeField(field) {
-  if (field instanceof z7.ZodString) return "string";
-  if (field instanceof z7.ZodNumber) return "number";
-  if (field instanceof z7.ZodEnum) return `one of: ${field.options.join(", ")}`;
-  if (field instanceof z7.ZodArray) return `array of ${describeField(field.element)}`;
-  if (field instanceof z7.ZodObject) return "object";
+  if (field instanceof z8.ZodString) return "string";
+  if (field instanceof z8.ZodNumber) return "number";
+  if (field instanceof z8.ZodEnum) return `one of: ${field.options.join(", ")}`;
+  if (field instanceof z8.ZodArray) return `array of ${describeField(field.element)}`;
+  if (field instanceof z8.ZodObject) return "object";
   return "any";
 }
 var AgentAssignmentSchema, SubtaskBreakdownSchema, OUTPUT_SCHEMAS;
@@ -9464,30 +9507,30 @@ var init_llm_output = __esm({
     "use strict";
     init_classification();
     init_classification();
-    AgentAssignmentSchema = z7.object({
+    AgentAssignmentSchema = z8.object({
       /** Agent file name (e.g., "backend.md", "frontend.md") */
-      agentName: z7.string(),
+      agentName: z8.string(),
       /** Why this agent was selected */
-      reasoning: z7.string(),
+      reasoning: z8.string(),
       /** Confidence in the assignment (0-1) */
-      confidence: z7.number().min(0).max(1)
+      confidence: z8.number().min(0).max(1)
     });
-    SubtaskBreakdownSchema = z7.object({
+    SubtaskBreakdownSchema = z8.object({
       /** Subtasks in execution order */
-      subtasks: z7.array(
-        z7.object({
+      subtasks: z8.array(
+        z8.object({
           /** Short description of the subtask */
-          description: z7.string(),
+          description: z8.string(),
           /** Domain this subtask belongs to */
           domain: ClassificationDomainSchema,
           /** Suggested agent for this subtask */
-          agent: z7.string(),
+          agent: z8.string(),
           /** IDs of subtasks this depends on (by index, 0-based) */
-          dependsOn: z7.array(z7.number())
+          dependsOn: z8.array(z8.number())
         })
       ),
       /** Estimated total effort */
-      effort: z7.enum(["low", "medium", "high"])
+      effort: z8.enum(["low", "medium", "high"])
     });
     OUTPUT_SCHEMAS = {
       classification: {
@@ -9548,15 +9591,15 @@ var init_llm_output = __esm({
 });
 
 // core/schemas/outcomes.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var QualityScoreSchema, SuccessLevelSchema, WorthAssessmentSchema, VarianceReasonSchema, EffortComparisonSchema, MetricResultSchema, AcceptanceCriteriaResultSchema, SuccessTrackingSchema, LearningSchema, LearningsSchema, ROIAssessmentSchema, TaskOutcomeSchema, FeatureOutcomeSchema, AggregateMetricsSchema, OutcomesJsonSchema;
 var init_outcomes = __esm({
   "core/schemas/outcomes.ts"() {
     "use strict";
-    QualityScoreSchema = z8.number().min(1).max(5);
-    SuccessLevelSchema = z8.enum(["exceeded", "met", "partial", "failed"]);
-    WorthAssessmentSchema = z8.enum(["definitely", "probably", "maybe", "no"]);
-    VarianceReasonSchema = z8.enum([
+    QualityScoreSchema = z9.number().min(1).max(5);
+    SuccessLevelSchema = z9.enum(["exceeded", "met", "partial", "failed"]);
+    WorthAssessmentSchema = z9.enum(["definitely", "probably", "maybe", "no"]);
+    VarianceReasonSchema = z9.enum([
       "scope_creep",
       "underestimated_complexity",
       "technical_debt",
@@ -9567,54 +9610,54 @@ var init_outcomes = __esm({
       "team_changes",
       "other"
     ]);
-    EffortComparisonSchema = z8.object({
-      estimated: z8.object({
-        hours: z8.number(),
-        confidence: z8.enum(["low", "medium", "high"]).optional(),
-        source: z8.enum(["prd", "manual", "historical"]).optional()
+    EffortComparisonSchema = z9.object({
+      estimated: z9.object({
+        hours: z9.number(),
+        confidence: z9.enum(["low", "medium", "high"]).optional(),
+        source: z9.enum(["prd", "manual", "historical"]).optional()
       }),
-      actual: z8.object({
-        hours: z8.number(),
-        commits: z8.number().optional(),
-        linesAdded: z8.number().optional(),
-        linesRemoved: z8.number().optional(),
-        sessions: z8.number().optional()
+      actual: z9.object({
+        hours: z9.number(),
+        commits: z9.number().optional(),
+        linesAdded: z9.number().optional(),
+        linesRemoved: z9.number().optional(),
+        sessions: z9.number().optional()
         // Number of work sessions
       }),
-      variance: z8.object({
-        hours: z8.number(),
+      variance: z9.object({
+        hours: z9.number(),
         // actual - estimated
-        percentage: z8.number(),
+        percentage: z9.number(),
         // ((actual - estimated) / estimated) * 100
         reason: VarianceReasonSchema.optional(),
-        explanation: z8.string().optional()
+        explanation: z9.string().optional()
       })
     });
-    MetricResultSchema = z8.object({
-      name: z8.string(),
-      baseline: z8.number().nullable(),
-      target: z8.number(),
-      actual: z8.number(),
-      unit: z8.string(),
-      achieved: z8.boolean(),
+    MetricResultSchema = z9.object({
+      name: z9.string(),
+      baseline: z9.number().nullable(),
+      target: z9.number(),
+      actual: z9.number(),
+      unit: z9.string(),
+      achieved: z9.boolean(),
       // actual >= target (or <= for decrease metrics)
-      percentOfTarget: z8.number()
+      percentOfTarget: z9.number()
       // (actual / target) * 100
     });
-    AcceptanceCriteriaResultSchema = z8.object({
-      criteria: z8.string(),
-      met: z8.boolean(),
-      notes: z8.string().optional()
+    AcceptanceCriteriaResultSchema = z9.object({
+      criteria: z9.string(),
+      met: z9.boolean(),
+      notes: z9.string().optional()
     });
-    SuccessTrackingSchema = z8.object({
-      metrics: z8.array(MetricResultSchema),
-      acceptanceCriteria: z8.array(AcceptanceCriteriaResultSchema),
+    SuccessTrackingSchema = z9.object({
+      metrics: z9.array(MetricResultSchema),
+      acceptanceCriteria: z9.array(AcceptanceCriteriaResultSchema),
       overallSuccess: SuccessLevelSchema,
-      successScore: z8.number().min(0).max(100)
+      successScore: z9.number().min(0).max(100)
       // Percentage of metrics/criteria met
     });
-    LearningSchema = z8.object({
-      category: z8.enum([
+    LearningSchema = z9.object({
+      category: z9.enum([
         "estimation",
         "technical",
         "process",
@@ -9624,62 +9667,62 @@ var init_outcomes = __esm({
         "testing",
         "other"
       ]),
-      insight: z8.string(),
-      actionable: z8.boolean(),
-      action: z8.string().optional()
+      insight: z9.string(),
+      actionable: z9.boolean(),
+      action: z9.string().optional()
       // What to do differently next time
     });
-    LearningsSchema = z8.object({
-      whatWorked: z8.array(z8.string()),
-      whatDidnt: z8.array(z8.string()),
-      surprises: z8.array(z8.string()),
-      recommendations: z8.array(LearningSchema)
+    LearningsSchema = z9.object({
+      whatWorked: z9.array(z9.string()),
+      whatDidnt: z9.array(z9.string()),
+      surprises: z9.array(z9.string()),
+      recommendations: z9.array(LearningSchema)
     });
-    ROIAssessmentSchema = z8.object({
-      valueDelivered: z8.number().min(1).max(10),
+    ROIAssessmentSchema = z9.object({
+      valueDelivered: z9.number().min(1).max(10),
       // Subjective 1-10 score
-      userImpact: z8.enum(["none", "low", "medium", "high", "critical"]),
-      businessImpact: z8.enum(["none", "low", "medium", "high", "critical"]),
+      userImpact: z9.enum(["none", "low", "medium", "high", "critical"]),
+      businessImpact: z9.enum(["none", "low", "medium", "high", "critical"]),
       // Calculated: (valueDelivered * 10) / (actual hours)
-      roiScore: z8.number(),
+      roiScore: z9.number(),
       // Would you build this again knowing what you know now?
       worthIt: WorthAssessmentSchema,
-      worthItReason: z8.string().optional(),
+      worthItReason: z9.string().optional(),
       // Comparison to alternatives
-      alternativeConsidered: z8.string().optional(),
-      betterAlternativeExists: z8.boolean().optional()
+      alternativeConsidered: z9.string().optional(),
+      betterAlternativeExists: z9.boolean().optional()
     });
-    TaskOutcomeSchema = z8.object({
-      id: z8.string(),
+    TaskOutcomeSchema = z9.object({
+      id: z9.string(),
       // out_task_xxxxxxxx
-      taskId: z8.string(),
-      description: z8.string(),
+      taskId: z9.string(),
+      description: z9.string(),
       // Time tracking
-      estimatedMinutes: z8.number().optional(),
-      actualMinutes: z8.number(),
+      estimatedMinutes: z9.number().optional(),
+      actualMinutes: z9.number(),
       // Quality
-      completedAsPlanned: z8.boolean(),
+      completedAsPlanned: z9.boolean(),
       qualityScore: QualityScoreSchema,
       // Context
-      blockers: z8.array(z8.string()),
-      agentUsed: z8.string().optional(),
-      skillsUsed: z8.array(z8.string()).optional(),
+      blockers: z9.array(z9.string()),
+      agentUsed: z9.string().optional(),
+      skillsUsed: z9.array(z9.string()).optional(),
       // Timestamps
-      startedAt: z8.string(),
-      completedAt: z8.string()
+      startedAt: z9.string(),
+      completedAt: z9.string()
     });
-    FeatureOutcomeSchema = z8.object({
-      id: z8.string(),
+    FeatureOutcomeSchema = z9.object({
+      id: z9.string(),
       // out_feat_xxxxxxxx
       // Links
-      featureId: z8.string(),
-      featureName: z8.string(),
-      prdId: z8.string().nullable(),
+      featureId: z9.string(),
+      featureName: z9.string(),
+      prdId: z9.string().nullable(),
       // null for legacy features
       // Version info
-      version: z8.string().optional(),
-      branch: z8.string().optional(),
-      prUrl: z8.string().optional(),
+      version: z9.string().optional(),
+      branch: z9.string().optional(),
+      prUrl: z9.string().optional(),
       // Effort
       effort: EffortComparisonSchema,
       // Success (only if PRD exists)
@@ -9691,61 +9734,61 @@ var init_outcomes = __esm({
       // Overall rating
       rating: QualityScoreSchema,
       // Task outcomes (sub-tasks)
-      taskOutcomes: z8.array(TaskOutcomeSchema).optional(),
+      taskOutcomes: z9.array(TaskOutcomeSchema).optional(),
       // Timestamps
-      startedAt: z8.string(),
-      shippedAt: z8.string(),
-      reviewedAt: z8.string().optional(),
+      startedAt: z9.string(),
+      shippedAt: z9.string(),
+      reviewedAt: z9.string().optional(),
       // When impact was captured
       // Metadata
-      reviewedBy: z8.string().optional(),
+      reviewedBy: z9.string().optional(),
       // Who filled out the impact review
-      legacy: z8.boolean().optional()
+      legacy: z9.boolean().optional()
       // Legacy feature (no PRD)
     });
-    AggregateMetricsSchema = z8.object({
-      totalFeatures: z8.number(),
-      averageEstimationAccuracy: z8.number(),
+    AggregateMetricsSchema = z9.object({
+      totalFeatures: z9.number(),
+      averageEstimationAccuracy: z9.number(),
       // Percentage
-      averageSuccessRate: z8.number(),
+      averageSuccessRate: z9.number(),
       // Percentage
-      averageROI: z8.number(),
+      averageROI: z9.number(),
       // By category
-      bySuccessLevel: z8.object({
-        exceeded: z8.number(),
-        met: z8.number(),
-        partial: z8.number(),
-        failed: z8.number()
+      bySuccessLevel: z9.object({
+        exceeded: z9.number(),
+        met: z9.number(),
+        partial: z9.number(),
+        failed: z9.number()
       }),
       // Variance patterns
-      variancePatterns: z8.array(
-        z8.object({
+      variancePatterns: z9.array(
+        z9.object({
           reason: VarianceReasonSchema,
-          count: z8.number(),
-          averageVariance: z8.number()
+          count: z9.number(),
+          averageVariance: z9.number()
         })
       ),
       // Top learnings (aggregated)
-      topLearnings: z8.array(
-        z8.object({
-          insight: z8.string(),
-          frequency: z8.number()
+      topLearnings: z9.array(
+        z9.object({
+          insight: z9.string(),
+          frequency: z9.number()
         })
       )
     });
-    OutcomesJsonSchema = z8.object({
-      outcomes: z8.array(FeatureOutcomeSchema),
-      taskOutcomes: z8.array(TaskOutcomeSchema).optional(),
+    OutcomesJsonSchema = z9.object({
+      outcomes: z9.array(FeatureOutcomeSchema),
+      taskOutcomes: z9.array(TaskOutcomeSchema).optional(),
       // Standalone task outcomes
       aggregates: AggregateMetricsSchema.optional(),
-      lastUpdated: z8.string(),
-      lastAggregated: z8.string().optional()
+      lastUpdated: z9.string(),
+      lastAggregated: z9.string().optional()
     });
   }
 });
 
 // core/schemas/permissions.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function buildDefaultPermissions() {
   const bash = {};
   for (const pattern of DEFAULT_BASH_ALLOW) {
@@ -9778,20 +9821,20 @@ var PermissionLevelSchema, FileOperationSchema, BashPermissionSchema, FilePermis
 var init_permissions = __esm({
   "core/schemas/permissions.ts"() {
     "use strict";
-    PermissionLevelSchema = z9.enum(["allow", "deny", "ask"]);
-    FileOperationSchema = z9.enum(["read", "write", "delete", "create"]);
-    BashPermissionSchema = z9.record(z9.string(), PermissionLevelSchema);
-    FilePermissionSchema = z9.record(z9.string(), PermissionLevelSchema);
-    WebPermissionSchema = z9.object({
-      enabled: z9.boolean().default(true),
-      allowedDomains: z9.array(z9.string()).optional(),
-      blockedDomains: z9.array(z9.string()).optional()
+    PermissionLevelSchema = z10.enum(["allow", "deny", "ask"]);
+    FileOperationSchema = z10.enum(["read", "write", "delete", "create"]);
+    BashPermissionSchema = z10.record(z10.string(), PermissionLevelSchema);
+    FilePermissionSchema = z10.record(z10.string(), PermissionLevelSchema);
+    WebPermissionSchema = z10.object({
+      enabled: z10.boolean().default(true),
+      allowedDomains: z10.array(z10.string()).optional(),
+      blockedDomains: z10.array(z10.string()).optional()
     });
-    PermissionsConfigSchema = z9.object({
+    PermissionsConfigSchema = z10.object({
       /** Bash command permissions - glob patterns */
       bash: BashPermissionSchema.optional(),
       /** File operation permissions - glob patterns */
-      files: z9.object({
+      files: z10.object({
         read: FilePermissionSchema.optional(),
         write: FilePermissionSchema.optional(),
         delete: FilePermissionSchema.optional()
@@ -9799,11 +9842,11 @@ var init_permissions = __esm({
       /** Web fetch permissions */
       web: WebPermissionSchema.optional(),
       /** Skill invocation permissions */
-      skills: z9.record(z9.string(), PermissionLevelSchema).optional(),
+      skills: z10.record(z10.string(), PermissionLevelSchema).optional(),
       /** Doom loop protection - prevent infinite retries */
-      doomLoop: z9.object({
-        enabled: z9.boolean().default(true),
-        maxRetries: z9.number().default(3)
+      doomLoop: z10.object({
+        enabled: z10.boolean().default(true),
+        maxRetries: z10.number().default(3)
       }).optional(),
       /** External directory access */
       externalDirectories: PermissionLevelSchema.default("ask")
@@ -9856,30 +9899,30 @@ var init_permissions = __esm({
 });
 
 // core/schemas/project.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var ProjectItemSchema, DEFAULT_PROJECT;
 var init_project = __esm({
   "core/schemas/project.ts"() {
     "use strict";
-    ProjectItemSchema = z10.object({
-      projectId: z10.string(),
-      name: z10.string(),
-      repoPath: z10.string(),
-      description: z10.string().optional(),
-      version: z10.string().optional(),
-      cliVersion: z10.string().optional(),
+    ProjectItemSchema = z11.object({
+      projectId: z11.string(),
+      name: z11.string(),
+      repoPath: z11.string(),
+      description: z11.string().optional(),
+      version: z11.string().optional(),
+      cliVersion: z11.string().optional(),
       // prjct-cli version used to sync
-      techStack: z10.array(z10.string()),
-      fileCount: z10.number(),
-      commitCount: z10.number(),
-      createdAt: z10.string(),
+      techStack: z11.array(z11.string()),
+      fileCount: z11.number(),
+      commitCount: z11.number(),
+      createdAt: z11.string(),
       // ISO8601
-      lastSync: z10.string(),
+      lastSync: z11.string(),
       // ISO8601
       // Staleness tracking (PRJ-120)
-      lastSyncCommit: z10.string().optional(),
+      lastSyncCommit: z11.string().optional(),
       // Git commit hash at last sync
-      lastSyncBranch: z10.string().optional()
+      lastSyncBranch: z11.string().optional()
       // Git branch at last sync
     });
     DEFAULT_PROJECT = {
@@ -9893,181 +9936,181 @@ var init_project = __esm({
 });
 
 // core/schemas/roadmap.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var FeatureStatusSchema, FeatureImpactSchema, FeatureTypeSchema, PhaseStatusSchema, QuarterStatusSchema, InferredFromSchema, FeatureTaskSchema, RoadmapPhaseSchema, RoadmapStrategySchema, FeatureDurationSchema, GitCommitSchema, EffortEstimateSchema, EffortActualSchema, FeatureEffortSchema, QuarterCapacitySchema, QuarterSchema, FeatureItemSchema, BacklogItemSchema, RoadmapJsonSchema, DEFAULT_FEATURE;
 var init_roadmap = __esm({
   "core/schemas/roadmap.ts"() {
     "use strict";
-    FeatureStatusSchema = z11.enum(["planned", "active", "completed", "shipped"]);
-    FeatureImpactSchema = z11.enum(["low", "medium", "high"]);
-    FeatureTypeSchema = z11.enum([
+    FeatureStatusSchema = z12.enum(["planned", "active", "completed", "shipped"]);
+    FeatureImpactSchema = z12.enum(["low", "medium", "high"]);
+    FeatureTypeSchema = z12.enum([
       "feature",
       "breaking_change",
       "refactor",
       "infrastructure"
     ]);
-    PhaseStatusSchema = z11.enum(["completed", "active", "planned"]);
-    QuarterStatusSchema = z11.enum(["planned", "active", "completed"]);
-    InferredFromSchema = z11.enum(["git", "git-branch", "manual", "prd"]);
-    FeatureTaskSchema = z11.object({
-      id: z11.string(),
+    PhaseStatusSchema = z12.enum(["completed", "active", "planned"]);
+    QuarterStatusSchema = z12.enum(["planned", "active", "completed"]);
+    InferredFromSchema = z12.enum(["git", "git-branch", "manual", "prd"]);
+    FeatureTaskSchema = z12.object({
+      id: z12.string(),
       // task_xxxxxxxx
-      description: z11.string(),
-      completed: z11.boolean(),
-      completedAt: z11.string().optional()
+      description: z12.string(),
+      completed: z12.boolean(),
+      completedAt: z12.string().optional()
     });
-    RoadmapPhaseSchema = z11.object({
-      id: z11.string(),
+    RoadmapPhaseSchema = z12.object({
+      id: z12.string(),
       // P0, P1, etc.
-      name: z11.string(),
+      name: z12.string(),
       status: PhaseStatusSchema,
-      completedAt: z11.string().optional()
+      completedAt: z12.string().optional()
     });
-    RoadmapStrategySchema = z11.object({
-      goal: z11.string(),
-      phases: z11.array(RoadmapPhaseSchema),
-      successMetrics: z11.array(z11.string()).optional()
+    RoadmapStrategySchema = z12.object({
+      goal: z12.string(),
+      phases: z12.array(RoadmapPhaseSchema),
+      successMetrics: z12.array(z12.string()).optional()
     });
-    FeatureDurationSchema = z11.object({
-      hours: z11.number(),
-      minutes: z11.number(),
-      totalMinutes: z11.number(),
-      display: z11.string().optional()
+    FeatureDurationSchema = z12.object({
+      hours: z12.number(),
+      minutes: z12.number(),
+      totalMinutes: z12.number(),
+      display: z12.string().optional()
     });
-    GitCommitSchema = z11.object({
-      hash: z11.string(),
-      message: z11.string(),
-      date: z11.string(),
-      author: z11.string().optional()
+    GitCommitSchema = z12.object({
+      hash: z12.string(),
+      message: z12.string(),
+      date: z12.string(),
+      author: z12.string().optional()
     });
-    EffortEstimateSchema = z11.object({
-      hours: z11.number(),
-      confidence: z11.enum(["low", "medium", "high"]).optional(),
-      breakdown: z11.array(
-        z11.object({
-          area: z11.string(),
-          hours: z11.number()
+    EffortEstimateSchema = z12.object({
+      hours: z12.number(),
+      confidence: z12.enum(["low", "medium", "high"]).optional(),
+      breakdown: z12.array(
+        z12.object({
+          area: z12.string(),
+          hours: z12.number()
         })
       ).optional()
     });
-    EffortActualSchema = z11.object({
-      hours: z11.number().optional(),
-      commits: z11.number().optional(),
-      linesAdded: z11.number().optional(),
-      linesRemoved: z11.number().optional()
+    EffortActualSchema = z12.object({
+      hours: z12.number().optional(),
+      commits: z12.number().optional(),
+      linesAdded: z12.number().optional(),
+      linesRemoved: z12.number().optional()
     });
-    FeatureEffortSchema = z11.object({
+    FeatureEffortSchema = z12.object({
       estimated: EffortEstimateSchema.nullable(),
       actual: EffortActualSchema.nullable()
     });
-    QuarterCapacitySchema = z11.object({
-      totalHours: z11.number(),
-      allocatedHours: z11.number(),
-      bufferPercent: z11.number().optional()
+    QuarterCapacitySchema = z12.object({
+      totalHours: z12.number(),
+      allocatedHours: z12.number(),
+      bufferPercent: z12.number().optional()
       // % reserved for unknowns
     });
-    QuarterSchema = z11.object({
-      id: z11.string(),
+    QuarterSchema = z12.object({
+      id: z12.string(),
       // Q1-2026
-      name: z11.string(),
+      name: z12.string(),
       // "Q1 2026"
-      theme: z11.string().optional(),
+      theme: z12.string().optional(),
       // "Foundation"
-      goals: z11.array(z11.string()).optional(),
-      features: z11.array(z11.string()),
+      goals: z12.array(z12.string()).optional(),
+      features: z12.array(z12.string()),
       // Feature IDs
       capacity: QuarterCapacitySchema.optional(),
       status: QuarterStatusSchema,
-      startDate: z11.string().optional(),
+      startDate: z12.string().optional(),
       // ISO8601
-      endDate: z11.string().optional()
+      endDate: z12.string().optional()
       // ISO8601
     });
-    FeatureItemSchema = z11.object({
-      id: z11.string(),
+    FeatureItemSchema = z12.object({
+      id: z12.string(),
       // feat_xxxxxxxx
-      name: z11.string(),
-      description: z11.string().optional(),
-      date: z11.string(),
+      name: z12.string(),
+      description: z12.string().optional(),
+      date: z12.string(),
       // YYYY-MM-DD creation date
       status: FeatureStatusSchema,
       impact: FeatureImpactSchema,
-      effort: z11.string().optional(),
-      progress: z11.number(),
+      effort: z12.string().optional(),
+      progress: z12.number(),
       // 0-100
       // Enriched fields from MD
       type: FeatureTypeSchema.optional(),
-      roi: z11.number().optional(),
+      roi: z12.number().optional(),
       // 1-5 from star count
-      why: z11.array(z11.string()).optional(),
-      technicalNotes: z11.array(z11.string()).optional(),
-      compatibility: z11.string().optional(),
-      phase: z11.string().optional(),
+      why: z12.array(z12.string()).optional(),
+      technicalNotes: z12.array(z12.string()).optional(),
+      compatibility: z12.string().optional(),
+      phase: z12.string().optional(),
       // P0, P1, etc.
-      tasks: z11.array(FeatureTaskSchema),
-      createdAt: z11.string(),
+      tasks: z12.array(FeatureTaskSchema),
+      createdAt: z12.string(),
       // ISO8601
-      shippedAt: z11.string().optional(),
-      version: z11.string().optional(),
+      shippedAt: z12.string().optional(),
+      version: z12.string().optional(),
       // ZERO DATA LOSS - additional fields
       duration: FeatureDurationSchema.optional(),
-      taskCount: z11.number().optional(),
-      agent: z11.string().optional(),
+      taskCount: z12.number().optional(),
+      agent: z12.string().optional(),
       // "fe+be", "fe", "be"
-      sprintName: z11.string().optional(),
-      completedDate: z11.string().optional(),
+      sprintName: z12.string().optional(),
+      completedDate: z12.string().optional(),
       // =========================================================================
       // AI ORCHESTRATION FIELDS (v0.29.0)
       // =========================================================================
       // PRD Integration
-      prdId: z11.string().nullable().optional(),
+      prdId: z12.string().nullable().optional(),
       // Link to PRD (prd_xxxxxxxx)
       // Legacy Support (for existing projects)
-      legacy: z11.boolean().optional(),
+      legacy: z12.boolean().optional(),
       // true = no PRD required
       inferredFrom: InferredFromSchema.optional(),
       // git, git-branch, manual, prd
       // Quarter Planning
-      quarter: z11.string().nullable().optional(),
+      quarter: z12.string().nullable().optional(),
       // Q1-2026, etc.
       // Dependency Tracking
-      dependencies: z11.array(z11.string()).optional(),
+      dependencies: z12.array(z12.string()).optional(),
       // Feature IDs this depends on
-      blockedBy: z11.array(z11.string()).optional(),
+      blockedBy: z12.array(z12.string()).optional(),
       // Feature IDs blocking this
       // Effort Tracking (for PRD comparison)
       effortTracking: FeatureEffortSchema.optional(),
       // Value Scoring (calculated from PRD)
-      valueScore: z11.number().optional(),
+      valueScore: z12.number().optional(),
       // Calculated priority score
       // Git Data (for legacy features)
-      commits: z11.array(GitCommitSchema).optional(),
+      commits: z12.array(GitCommitSchema).optional(),
       // Commits for this feature
-      branch: z11.string().optional(),
+      branch: z12.string().optional(),
       // Branch name (for active)
-      commitsAhead: z11.number().optional()
+      commitsAhead: z12.number().optional()
       // Commits ahead of main
     });
-    BacklogItemSchema = z11.object({
-      id: z11.string(),
-      title: z11.string(),
-      prdId: z11.string().nullable().optional(),
-      valueScore: z11.number().optional(),
-      effortEstimate: z11.number().optional(),
-      reason: z11.string().optional()
+    BacklogItemSchema = z12.object({
+      id: z12.string(),
+      title: z12.string(),
+      prdId: z12.string().nullable().optional(),
+      valueScore: z12.number().optional(),
+      effortEstimate: z12.number().optional(),
+      reason: z12.string().optional()
       // Why in backlog
     });
-    RoadmapJsonSchema = z11.object({
+    RoadmapJsonSchema = z12.object({
       strategy: RoadmapStrategySchema.nullable().optional(),
-      features: z11.array(FeatureItemSchema),
-      backlog: z11.array(z11.union([z11.string(), BacklogItemSchema])),
+      features: z12.array(FeatureItemSchema),
+      backlog: z12.array(z12.union([z12.string(), BacklogItemSchema])),
       // Support both formats
-      lastUpdated: z11.string(),
+      lastUpdated: z12.string(),
       // AI ORCHESTRATION FIELDS (v0.29.0)
-      quarters: z11.array(QuarterSchema).optional(),
+      quarters: z12.array(QuarterSchema).optional(),
       // Metadata (for git-inferred roadmaps)
-      generatedFrom: z11.enum(["git-history", "manual", "prd"]).optional(),
-      generatedAt: z11.string().optional()
+      generatedFrom: z12.enum(["git-history", "manual", "prd"]).optional(),
+      generatedAt: z12.string().optional()
     });
     DEFAULT_FEATURE = {
       date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
@@ -10105,79 +10148,79 @@ var init_schemas = __esm({
 });
 
 // core/schemas/shipped.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var ShipTypeSchema, CheckStatusSchema, ChangeTypeSchema, DurationSchema, CodeMetricsSchema, ShipChangeSchema, QualityMetricsSchema, CommitInfoSchema, ShippedItemSchema, ShippedJsonSchema;
 var init_shipped = __esm({
   "core/schemas/shipped.ts"() {
     "use strict";
-    ShipTypeSchema = z12.enum(["feature", "fix", "improvement", "refactor"]);
-    CheckStatusSchema = z12.enum(["pass", "warning", "fail", "skipped"]);
-    ChangeTypeSchema = z12.enum(["added", "changed", "fixed", "removed"]);
-    DurationSchema = z12.object({
-      hours: z12.number(),
-      minutes: z12.number(),
-      totalMinutes: z12.number()
+    ShipTypeSchema = z13.enum(["feature", "fix", "improvement", "refactor"]);
+    CheckStatusSchema = z13.enum(["pass", "warning", "fail", "skipped"]);
+    ChangeTypeSchema = z13.enum(["added", "changed", "fixed", "removed"]);
+    DurationSchema = z13.object({
+      hours: z13.number(),
+      minutes: z13.number(),
+      totalMinutes: z13.number()
     });
-    CodeMetricsSchema = z12.object({
-      filesChanged: z12.number().nullable().optional(),
-      linesAdded: z12.number().nullable().optional(),
-      linesRemoved: z12.number().nullable().optional(),
-      commits: z12.number().nullable().optional()
+    CodeMetricsSchema = z13.object({
+      filesChanged: z13.number().nullable().optional(),
+      linesAdded: z13.number().nullable().optional(),
+      linesRemoved: z13.number().nullable().optional(),
+      commits: z13.number().nullable().optional()
     });
-    ShipChangeSchema = z12.object({
-      description: z12.string(),
+    ShipChangeSchema = z13.object({
+      description: z13.string(),
       type: ChangeTypeSchema.optional()
     });
-    QualityMetricsSchema = z12.object({
+    QualityMetricsSchema = z13.object({
       lintStatus: CheckStatusSchema.nullable().optional(),
-      lintDetails: z12.string().optional(),
+      lintDetails: z13.string().optional(),
       testStatus: CheckStatusSchema.nullable().optional(),
-      testDetails: z12.string().optional()
+      testDetails: z13.string().optional()
     });
-    CommitInfoSchema = z12.object({
-      hash: z12.string().optional(),
-      message: z12.string().optional(),
-      branch: z12.string().optional()
+    CommitInfoSchema = z13.object({
+      hash: z13.string().optional(),
+      message: z13.string().optional(),
+      branch: z13.string().optional()
     });
-    ShippedItemSchema = z12.object({
-      id: z12.string(),
+    ShippedItemSchema = z13.object({
+      id: z13.string(),
       // ship_xxxxxxxx
-      name: z12.string(),
-      version: z12.string().nullable().optional(),
+      name: z13.string(),
+      version: z13.string().nullable().optional(),
       type: ShipTypeSchema,
-      agent: z12.string().optional(),
+      agent: z13.string().optional(),
       // "fe+be", "be", "fe"
-      description: z12.string().optional(),
-      changes: z12.array(ShipChangeSchema).optional(),
-      codeSnippets: z12.array(z12.string()).optional(),
+      description: z13.string().optional(),
+      changes: z13.array(ShipChangeSchema).optional(),
+      codeSnippets: z13.array(z13.string()).optional(),
       commit: CommitInfoSchema.optional(),
       codeMetrics: CodeMetricsSchema.optional(),
       qualityMetrics: QualityMetricsSchema.optional(),
-      quantitativeImpact: z12.string().optional(),
+      quantitativeImpact: z13.string().optional(),
       duration: DurationSchema.optional(),
-      tasksCompleted: z12.number().nullable().optional(),
-      shippedAt: z12.string(),
+      tasksCompleted: z13.number().nullable().optional(),
+      shippedAt: z13.string(),
       // ISO8601
-      featureId: z12.string().optional()
+      featureId: z13.string().optional()
     });
-    ShippedJsonSchema = z12.object({
-      shipped: z12.array(ShippedItemSchema),
-      lastUpdated: z12.string()
+    ShippedJsonSchema = z13.object({
+      shipped: z13.array(ShippedItemSchema),
+      lastUpdated: z13.string()
     });
   }
 });
 
 // core/schemas/state.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var PrioritySchema, TaskTypeSchema, TaskSectionSchema, TaskStatusSchema, ActivityTypeSchema, SubtaskSummarySchema, SubtaskSchema, SubtaskProgressSchema, CurrentTaskSchema, PreviousTaskSchema, StateJsonSchema, QueueTaskSchema, QueueJsonSchema, StatsSchema, RecentActivitySchema, StateSchemaFull;
 var init_state = __esm({
   "core/schemas/state.ts"() {
     "use strict";
     init_model();
-    PrioritySchema = z13.enum(["low", "medium", "high", "critical"]);
-    TaskTypeSchema = z13.enum(["feature", "bug", "improvement", "chore"]);
-    TaskSectionSchema = z13.enum(["active", "backlog", "previously_active"]);
-    TaskStatusSchema = z13.enum([
+    PrioritySchema = z14.enum(["low", "medium", "high", "critical"]);
+    TaskTypeSchema = z14.enum(["feature", "bug", "improvement", "chore"]);
+    TaskSectionSchema = z14.enum(["active", "backlog", "previously_active"]);
+    TaskStatusSchema = z14.enum([
       "pending",
       "in_progress",
       "completed",
@@ -10186,151 +10229,151 @@ var init_state = __esm({
       "failed",
       "skipped"
     ]);
-    ActivityTypeSchema = z13.enum([
+    ActivityTypeSchema = z14.enum([
       "task_completed",
       "feature_shipped",
       "idea_captured",
       "session_started"
     ]);
-    SubtaskSummarySchema = z13.object({
-      title: z13.string(),
-      description: z13.string(),
-      filesChanged: z13.array(
-        z13.object({
-          path: z13.string(),
-          action: z13.enum(["created", "modified", "deleted"])
+    SubtaskSummarySchema = z14.object({
+      title: z14.string(),
+      description: z14.string(),
+      filesChanged: z14.array(
+        z14.object({
+          path: z14.string(),
+          action: z14.enum(["created", "modified", "deleted"])
         })
       ),
-      whatWasDone: z13.array(z13.string()),
-      outputForNextAgent: z13.string().optional(),
-      notes: z13.string().optional()
+      whatWasDone: z14.array(z14.string()),
+      outputForNextAgent: z14.string().optional(),
+      notes: z14.string().optional()
     });
-    SubtaskSchema = z13.object({
-      id: z13.string(),
+    SubtaskSchema = z14.object({
+      id: z14.string(),
       // subtask-xxx
-      description: z13.string(),
-      domain: z13.string(),
+      description: z14.string(),
+      domain: z14.string(),
       // frontend, backend, database, testing, etc.
-      agent: z13.string(),
+      agent: z14.string(),
       // agent file name (e.g., "frontend.md")
       status: TaskStatusSchema,
-      dependsOn: z13.array(z13.string()),
+      dependsOn: z14.array(z14.string()),
       // IDs of dependent subtasks
-      startedAt: z13.string().optional(),
+      startedAt: z14.string().optional(),
       // ISO8601
-      completedAt: z13.string().optional(),
+      completedAt: z14.string().optional(),
       // ISO8601
-      output: z13.string().optional(),
+      output: z14.string().optional(),
       // Brief output description
       summary: SubtaskSummarySchema.optional(),
       // Full summary for context handoff
-      skipReason: z13.string().optional(),
+      skipReason: z14.string().optional(),
       // Why this subtask was skipped
-      blockReason: z13.string().optional(),
+      blockReason: z14.string().optional(),
       // What is blocking this subtask
       // Fibonacci estimation
-      estimatedPoints: z13.number().optional(),
+      estimatedPoints: z14.number().optional(),
       // Fibonacci: 1,2,3,5,8,13,21
-      estimatedMinutes: z13.number().optional()
+      estimatedMinutes: z14.number().optional()
       // Derived from points
     });
-    SubtaskProgressSchema = z13.object({
-      completed: z13.number(),
-      total: z13.number(),
-      percentage: z13.number()
+    SubtaskProgressSchema = z14.object({
+      completed: z14.number(),
+      total: z14.number(),
+      percentage: z14.number()
     });
-    CurrentTaskSchema = z13.object({
-      id: z13.string(),
+    CurrentTaskSchema = z14.object({
+      id: z14.string(),
       // task_xxxxxxxx
-      description: z13.string(),
-      startedAt: z13.string(),
+      description: z14.string(),
+      startedAt: z14.string(),
       // ISO8601
-      sessionId: z13.string(),
+      sessionId: z14.string(),
       // sess_xxxxxxxx
-      featureId: z13.string().optional(),
+      featureId: z14.string().optional(),
       // feat_xxxxxxxx
       // Subtask tracking for fragmented tasks
-      subtasks: z13.array(SubtaskSchema).optional(),
-      currentSubtaskIndex: z13.number().optional(),
+      subtasks: z14.array(SubtaskSchema).optional(),
+      currentSubtaskIndex: z14.number().optional(),
       subtaskProgress: SubtaskProgressSchema.optional(),
       // Linear integration - bidirectional sync
-      linearId: z13.string().optional(),
+      linearId: z14.string().optional(),
       // "PRJ-123" - Linear identifier
-      linearUuid: z13.string().optional(),
+      linearUuid: z14.string().optional(),
       // Linear internal UUID for API calls
       // Fibonacci estimation
-      estimatedPoints: z13.number().optional(),
+      estimatedPoints: z14.number().optional(),
       // Fibonacci: 1,2,3,5,8,13,21
-      estimatedMinutes: z13.number().optional(),
+      estimatedMinutes: z14.number().optional(),
       // Derived from points
       // Model specification - which AI model was used (PRJ-265)
       modelMetadata: ModelMetadataSchema.optional()
     });
-    PreviousTaskSchema = z13.object({
-      id: z13.string(),
-      description: z13.string(),
-      status: z13.literal("paused"),
-      startedAt: z13.string(),
+    PreviousTaskSchema = z14.object({
+      id: z14.string(),
+      description: z14.string(),
+      status: z14.literal("paused"),
+      startedAt: z14.string(),
       // ISO8601
-      pausedAt: z13.string(),
+      pausedAt: z14.string(),
       // ISO8601
-      pauseReason: z13.string().optional()
+      pauseReason: z14.string().optional()
     });
-    StateJsonSchema = z13.object({
+    StateJsonSchema = z14.object({
       currentTask: CurrentTaskSchema.nullable(),
       previousTask: PreviousTaskSchema.nullable().optional(),
       // deprecated: use pausedTasks
-      pausedTasks: z13.array(PreviousTaskSchema).optional(),
+      pausedTasks: z14.array(PreviousTaskSchema).optional(),
       // replaces previousTask
-      lastUpdated: z13.string()
+      lastUpdated: z14.string()
     });
-    QueueTaskSchema = z13.object({
-      id: z13.string(),
+    QueueTaskSchema = z14.object({
+      id: z14.string(),
       // task_xxxxxxxx
-      description: z13.string(),
+      description: z14.string(),
       priority: PrioritySchema,
       type: TaskTypeSchema,
       // detect from emoji 🐛=bug
-      featureId: z13.string().optional(),
-      originFeature: z13.string().optional(),
-      completed: z13.boolean(),
-      completedAt: z13.string().optional(),
-      createdAt: z13.string(),
+      featureId: z14.string().optional(),
+      originFeature: z14.string().optional(),
+      completed: z14.boolean(),
+      completedAt: z14.string().optional(),
+      createdAt: z14.string(),
       // ISO8601
       section: TaskSectionSchema,
       // Additional fields for ZERO DATA LOSS
-      agent: z13.string().optional(),
+      agent: z14.string().optional(),
       // "fe", "be", "fe + be"
-      groupName: z13.string().optional(),
+      groupName: z14.string().optional(),
       // "Sales Reports", "Stock Audits"
-      groupId: z13.string().optional()
+      groupId: z14.string().optional()
       // For grouping related tasks
     });
-    QueueJsonSchema = z13.object({
-      tasks: z13.array(QueueTaskSchema),
-      lastUpdated: z13.string()
+    QueueJsonSchema = z14.object({
+      tasks: z14.array(QueueTaskSchema),
+      lastUpdated: z14.string()
     });
-    StatsSchema = z13.object({
-      tasksToday: z13.number(),
-      tasksThisWeek: z13.number(),
-      streak: z13.number(),
-      velocity: z13.string(),
-      avgDuration: z13.string()
+    StatsSchema = z14.object({
+      tasksToday: z14.number(),
+      tasksThisWeek: z14.number(),
+      streak: z14.number(),
+      velocity: z14.string(),
+      avgDuration: z14.string()
     });
-    RecentActivitySchema = z13.object({
+    RecentActivitySchema = z14.object({
       type: ActivityTypeSchema,
-      description: z13.string(),
-      timestamp: z13.string(),
+      description: z14.string(),
+      timestamp: z14.string(),
       // ISO8601
-      duration: z13.string().optional()
+      duration: z14.string().optional()
     });
-    StateSchemaFull = z13.object({
-      projectId: z13.string(),
+    StateSchemaFull = z14.object({
+      projectId: z14.string(),
       currentTask: CurrentTaskSchema.nullable(),
-      queue: z13.array(QueueTaskSchema),
+      queue: z14.array(QueueTaskSchema),
       stats: StatsSchema,
-      recentActivity: z13.array(RecentActivitySchema),
-      lastSync: z13.string()
+      recentActivity: z14.array(RecentActivitySchema),
+      lastSync: z14.string()
       // ISO8601
     });
   }
@@ -11327,6 +11370,250 @@ Context: ${context2}` : ""}`,
   }
 });
 
+// core/storage/analysis-storage.ts
+import { createHash } from "node:crypto";
+var AnalysisStorage, analysisStorage;
+var init_analysis_storage = __esm({
+  "core/storage/analysis-storage.ts"() {
+    "use strict";
+    init_analysis();
+    init_date_helper();
+    init_storage_manager();
+    AnalysisStorage = class extends StorageManager {
+      static {
+        __name(this, "AnalysisStorage");
+      }
+      constructor() {
+        super("analysis.json");
+      }
+      getDefault() {
+        return {
+          draft: null,
+          sealed: null,
+          lastUpdated: ""
+        };
+      }
+      getMdFilename() {
+        return "analysis.md";
+      }
+      getLayer() {
+        return "analysis";
+      }
+      getEventType(action) {
+        return `analysis.${action}d`;
+      }
+      toMarkdown(data) {
+        const lines = ["# Analysis Status", ""];
+        if (data.sealed) {
+          lines.push("## Sealed Analysis");
+          lines.push(`- **Status**: sealed`);
+          lines.push(`- **Commit**: \`${data.sealed.commitHash || "unknown"}\``);
+          lines.push(`- **Sealed at**: ${data.sealed.sealedAt || "unknown"}`);
+          lines.push(`- **Languages**: ${data.sealed.languages.join(", ") || "none"}`);
+          lines.push(`- **Frameworks**: ${data.sealed.frameworks.join(", ") || "none"}`);
+          lines.push(`- **Files**: ${data.sealed.fileCount}`);
+          if (data.sealed.patterns.length > 0) {
+            lines.push(`- **Patterns**: ${data.sealed.patterns.map((p) => p.name).join(", ")}`);
+          }
+          lines.push("");
+        }
+        if (data.draft && data.draft.status === "draft") {
+          lines.push("## Draft Analysis");
+          lines.push(`- **Status**: draft (not yet sealed)`);
+          lines.push(`- **Commit**: \`${data.draft.commitHash || "unknown"}\``);
+          lines.push(`- **Analyzed at**: ${data.draft.analyzedAt}`);
+          lines.push(`- **Languages**: ${data.draft.languages.join(", ") || "none"}`);
+          lines.push(`- **Frameworks**: ${data.draft.frameworks.join(", ") || "none"}`);
+          lines.push(`- **Files**: ${data.draft.fileCount}`);
+          lines.push("");
+        }
+        if (!data.sealed && !data.draft) {
+          lines.push("_No analysis available. Run `p. sync` to generate._");
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      // ===========================================================================
+      // Domain Methods
+      // ===========================================================================
+      /**
+       * Save a new draft analysis (called by sync-service).
+       * Preserves existing sealed analysis.
+       */
+      async saveDraft(projectId, analysis2) {
+        const draft = {
+          ...analysis2,
+          status: "draft"
+        };
+        AnalysisItemSchema.parse(draft);
+        await this.update(projectId, (data) => ({
+          ...data,
+          draft,
+          lastUpdated: getTimestamp()
+        }));
+        await this.publishEntityEvent(projectId, "analysis", "drafted", {
+          commitHash: draft.commitHash,
+          fileCount: draft.fileCount
+        });
+      }
+      /**
+       * Seal the current draft analysis.
+       * Computes SHA-256 signature and locks the analysis.
+       */
+      async seal(projectId) {
+        const data = await this.read(projectId);
+        if (!data.draft) {
+          return { success: false, error: "No draft analysis to seal. Run `p. sync` first." };
+        }
+        if (data.draft.status === "sealed") {
+          return { success: false, error: "Draft is already sealed." };
+        }
+        const signature = this.computeSignature(data.draft);
+        const now = getTimestamp();
+        const sealed = {
+          ...data.draft,
+          status: "sealed",
+          signature,
+          sealedAt: now
+        };
+        AnalysisItemSchema.parse(sealed);
+        await this.write(projectId, {
+          draft: null,
+          // Clear draft — it's now sealed
+          sealed,
+          lastUpdated: now
+        });
+        await this.publishEntityEvent(projectId, "analysis", "sealed", {
+          commitHash: sealed.commitHash,
+          signature
+        });
+        return { success: true, signature };
+      }
+      /**
+       * Get the sealed analysis (for task context injection).
+       * Returns null if no sealed analysis exists.
+       */
+      async getSealed(projectId) {
+        const data = await this.read(projectId);
+        return data.sealed;
+      }
+      /**
+       * Get the current draft analysis.
+       */
+      async getDraft(projectId) {
+        const data = await this.read(projectId);
+        return data.draft;
+      }
+      /**
+       * Get the active analysis (sealed if available, otherwise draft).
+       * This is what tasks should consume.
+       */
+      async getActive(projectId) {
+        const data = await this.read(projectId);
+        return data.sealed ?? data.draft;
+      }
+      /**
+       * Get the current analysis status.
+       */
+      async getStatus(projectId) {
+        const data = await this.read(projectId);
+        return {
+          hasSealed: data.sealed !== null,
+          hasDraft: data.draft !== null,
+          sealedCommit: data.sealed?.commitHash ?? null,
+          draftCommit: data.draft?.commitHash ?? null,
+          sealedAt: data.sealed?.sealedAt ?? null
+        };
+      }
+      /**
+       * Check if sealed analysis is stale (commit hash differs from current HEAD).
+       */
+      checkStaleness(sealedCommit, currentCommit) {
+        if (!sealedCommit) {
+          return {
+            isStale: false,
+            sealedCommit: null,
+            currentCommit,
+            message: "No sealed analysis. Run `p. sync` then `p. seal`."
+          };
+        }
+        if (!currentCommit) {
+          return {
+            isStale: true,
+            sealedCommit,
+            currentCommit: null,
+            message: "Cannot determine current commit. Analysis may be stale."
+          };
+        }
+        if (sealedCommit !== currentCommit) {
+          return {
+            isStale: true,
+            sealedCommit,
+            currentCommit,
+            message: `Analysis is stale: sealed at ${sealedCommit}, HEAD is ${currentCommit}. Run \`p. sync\` + \`p. seal\` to update.`
+          };
+        }
+        return {
+          isStale: false,
+          sealedCommit,
+          currentCommit,
+          message: "Analysis is current."
+        };
+      }
+      /**
+       * Verify the integrity of a sealed analysis by recomputing its signature.
+       */
+      async verify(projectId) {
+        const data = await this.read(projectId);
+        if (!data.sealed) {
+          return { valid: false, message: "No sealed analysis to verify." };
+        }
+        if (!data.sealed.signature) {
+          return { valid: false, message: "Sealed analysis has no signature." };
+        }
+        const expected = this.computeSignature({
+          ...data.sealed,
+          // Strip signature and sealedAt before recomputing — they weren't part of the original hash
+          signature: void 0,
+          sealedAt: void 0
+        });
+        if (expected === data.sealed.signature) {
+          return { valid: true, message: "Signature verified. Analysis integrity confirmed." };
+        }
+        return {
+          valid: false,
+          message: `Signature mismatch. Expected ${expected}, got ${data.sealed.signature}. Analysis may have been modified.`
+        };
+      }
+      // ===========================================================================
+      // Private Helpers
+      // ===========================================================================
+      /**
+       * Compute SHA-256 signature for analysis data.
+       * Deterministic: same input always produces same hash.
+       */
+      computeSignature(analysis2) {
+        const canonical = {
+          projectId: analysis2.projectId,
+          languages: analysis2.languages,
+          frameworks: analysis2.frameworks,
+          packageManager: analysis2.packageManager,
+          sourceDir: analysis2.sourceDir,
+          testDir: analysis2.testDir,
+          configFiles: analysis2.configFiles,
+          fileCount: analysis2.fileCount,
+          patterns: analysis2.patterns,
+          antiPatterns: analysis2.antiPatterns,
+          analyzedAt: analysis2.analyzedAt,
+          commitHash: analysis2.commitHash
+        };
+        return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+      }
+    };
+    analysisStorage = new AnalysisStorage();
+  }
+});
+
 // core/storage/ideas-storage.ts
 var IdeasStorage, ideasStorage;
 var init_ideas_storage = __esm({
@@ -13363,6 +13650,7 @@ var init_storage = __esm({
 var init_storage2 = __esm({
   "core/storage/index.ts"() {
     "use strict";
+    init_analysis_storage();
     init_ideas_storage();
     init_index_storage();
     init_metrics_storage();
@@ -13375,11 +13663,11 @@ var init_storage2 = __esm({
 });
 
 // core/agentic/domain-classifier.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import fs28 from "node:fs/promises";
 import path26 from "node:path";
 function hashDescription(description) {
-  return createHash("sha256").update(description.toLowerCase().trim()).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(description.toLowerCase().trim()).digest("hex").slice(0, 16);
 }
 async function loadCache(globalPath) {
   try {
@@ -15054,22 +15342,94 @@ var init_outcomes2 = __esm({
   }
 });
 
+// core/agentic/anti-hallucination.ts
+import { z as z15 } from "zod";
+function buildAntiHallucinationBlock(truth) {
+  const parts = [];
+  parts.push("## CONSTRAINTS (Read Before Acting)\n");
+  const available = [];
+  if (truth.language) available.push(truth.language);
+  if (truth.framework) available.push(truth.framework);
+  const techStack = truth.techStack ?? [];
+  available.push(...techStack.filter((t) => t !== truth.framework));
+  if (available.length > 0) {
+    parts.push(`AVAILABLE in this project: ${available.join(", ")}`);
+  }
+  if (truth.domains) {
+    const absent = Object.entries(truth.domains).filter(([, hasIt]) => !hasIt).map(([key]) => DOMAIN_LABELS[key]).filter(Boolean);
+    if (absent.length > 0) {
+      parts.push(`NOT PRESENT: ${absent.join(", ")}`);
+    }
+  }
+  const availableAgents = truth.availableAgents ?? [];
+  if (availableAgents.length > 0) {
+    parts.push(`AGENTS: ${availableAgents.join(", ")}`);
+  }
+  parts.push("");
+  parts.push(`SCOPE: Only files in \`${truth.projectPath}\` are accessible.`);
+  parts.push("RULE: Use ONLY file paths explicitly shown in context. Do NOT infer or guess paths.");
+  parts.push("RULE: NEVER assume a library is available. Check package.json/imports first.");
+  parts.push("RULE: If previous context contradicts this section, trust this section.");
+  parts.push("RULE: Read files BEFORE modifying. Never assume code structure.");
+  if (truth.fileCount) {
+    parts.push(`
+Context: ${truth.fileCount} files in project.`);
+  }
+  return parts.join("\n");
+}
+var ProjectGroundTruthSchema, DOMAIN_LABELS;
+var init_anti_hallucination = __esm({
+  "core/agentic/anti-hallucination.ts"() {
+    "use strict";
+    ProjectGroundTruthSchema = z15.object({
+      /** Project root path */
+      projectPath: z15.string(),
+      /** Programming language (e.g., 'TypeScript', 'JavaScript', 'Python') */
+      language: z15.string().optional(),
+      /** Primary framework (e.g., 'Hono', 'Next.js', 'Express') */
+      framework: z15.string().optional(),
+      /** Technology stack items (e.g., ['Hono', 'Zod', 'Vitest']) */
+      techStack: z15.array(z15.string()).default([]),
+      /** Domain flags from sealed analysis */
+      domains: z15.object({
+        hasFrontend: z15.boolean().default(false),
+        hasBackend: z15.boolean().default(false),
+        hasDatabase: z15.boolean().default(false),
+        hasTesting: z15.boolean().default(false),
+        hasDocker: z15.boolean().default(false)
+      }).optional(),
+      /** Total files in project */
+      fileCount: z15.number().optional(),
+      /** Available agent names (e.g., ['backend', 'testing']) */
+      availableAgents: z15.array(z15.string()).default([])
+    });
+    DOMAIN_LABELS = {
+      hasFrontend: "Frontend (UI/components)",
+      hasBackend: "Backend (APIs/servers)",
+      hasDatabase: "Database (SQL/ORM)",
+      hasTesting: "Testing (unit/integration)",
+      hasDocker: "Docker/containers"
+    };
+    __name(buildAntiHallucinationBlock, "buildAntiHallucinationBlock");
+  }
+});
+
 // core/schemas/command-context.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 var CommandContextEntrySchema, CommandContextConfigSchema;
 var init_command_context = __esm({
   "core/schemas/command-context.ts"() {
     "use strict";
-    CommandContextEntrySchema = z14.object({
-      agents: z14.boolean(),
-      patterns: z14.boolean(),
-      checklist: z14.boolean(),
-      modules: z14.array(z14.string())
+    CommandContextEntrySchema = z16.object({
+      agents: z16.boolean(),
+      patterns: z16.boolean(),
+      checklist: z16.boolean(),
+      modules: z16.array(z16.string())
     });
-    CommandContextConfigSchema = z14.object({
-      version: z14.string(),
-      description: z14.string().optional(),
-      commands: z14.record(z14.string(), CommandContextEntrySchema).refine((commands) => "*" in commands, {
+    CommandContextConfigSchema = z16.object({
+      version: z16.string(),
+      description: z16.string().optional(),
+      commands: z16.record(z16.string(), CommandContextEntrySchema).refine((commands) => "*" in commands, {
         message: 'Config must include a "*" wildcard entry for unknown commands'
       })
     });
@@ -15259,7 +15619,82 @@ var init_command_context2 = __esm({
   }
 });
 
+// core/agentic/environment-block.ts
+import os10 from "node:os";
+import { z as z17 } from "zod";
+function detectRuntime2() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    return "bun";
+  }
+  return "node";
+}
+function normalizePlatform(platform) {
+  const platformMap = {
+    darwin: "macOS",
+    linux: "Linux",
+    win32: "Windows",
+    freebsd: "FreeBSD"
+  };
+  return platformMap[platform] ?? platform;
+}
+function buildEnvironmentBlock(input) {
+  const platform = input.platform ?? os10.platform();
+  const runtime = input.runtime ?? detectRuntime2();
+  const date = input.date ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const fields = [
+    ["project", input.projectName],
+    ["path", input.projectPath],
+    ["git", input.isGitRepo ? "true" : "false"],
+    ["branch", input.gitBranch],
+    ["platform", normalizePlatform(platform)],
+    ["runtime", runtime],
+    ["date", date],
+    ["model", input.model],
+    ["provider", input.provider]
+  ];
+  const lines = fields.filter(([, value]) => value !== void 0).map(([key, value]) => `${key}: ${value}`);
+  return `<env>
+${lines.join("\n")}
+</env>`;
+}
+var EnvironmentBlockInputSchema;
+var init_environment_block = __esm({
+  "core/agentic/environment-block.ts"() {
+    "use strict";
+    EnvironmentBlockInputSchema = z17.object({
+      /** Project display name */
+      projectName: z17.string(),
+      /** Absolute path to project root */
+      projectPath: z17.string(),
+      /** Whether the project is a git repository */
+      isGitRepo: z17.boolean().default(true),
+      /** Current git branch name */
+      gitBranch: z17.string().optional(),
+      /** Operating system platform (auto-detected if not provided) */
+      platform: z17.string().optional(),
+      /** JavaScript runtime (auto-detected if not provided) */
+      runtime: z17.string().optional(),
+      /** Current date in ISO format (auto-generated if not provided) */
+      date: z17.string().optional(),
+      /** AI model identifier (e.g., 'opus', 'sonnet', '2.5-pro') */
+      model: z17.string().optional(),
+      /** AI provider name (e.g., 'claude', 'gemini', 'cursor') */
+      provider: z17.string().optional()
+    });
+    __name(detectRuntime2, "detectRuntime");
+    __name(normalizePlatform, "normalizePlatform");
+    __name(buildEnvironmentBlock, "buildEnvironmentBlock");
+  }
+});
+
 // core/agentic/injection-validator.ts
+function budgetsFromCoordinator(coordinator) {
+  const injectionBudget = coordinator.getAllocationFor("injection");
+  return {
+    ...DEFAULT_BUDGETS,
+    totalPrompt: injectionBudget
+  };
+}
 function truncateToTokenBudget(text, maxTokens) {
   const maxChars = maxTokens * CHARS_PER_TOKEN2;
   if (text.length <= maxChars) return text;
@@ -15299,6 +15734,7 @@ var init_injection_validator = __esm({
       memories: 600,
       totalPrompt: 8e3
     };
+    __name(budgetsFromCoordinator, "budgetsFromCoordinator");
     CHARS_PER_TOKEN2 = 4;
     __name(truncateToTokenBudget, "truncateToTokenBudget");
     __name(estimateTokens, "estimateTokens");
@@ -15362,7 +15798,9 @@ var init_prompt_builder = __esm({
     init_fs();
     init_fs_helpers();
     init_version();
+    init_anti_hallucination();
     init_command_context2();
+    init_environment_block();
     init_injection_validator();
     PromptBuilder = class {
       static {
@@ -15379,6 +15817,8 @@ var init_prompt_builder = __esm({
       _templateCache = /* @__PURE__ */ new Map();
       TEMPLATE_CACHE_TTL_MS = 6e4;
       // 60 seconds
+      /** Active token budget coordinator (PRJ-266) */
+      _coordinator = null;
       /**
        * Get a template with TTL caching.
        * Returns cached content if within TTL, otherwise loads from disk.
@@ -15414,6 +15854,31 @@ var init_prompt_builder = __esm({
         this._checklistRoutingCache = null;
         this._checklistRoutingCacheTime = 0;
       }
+      /**
+       * Set the token budget coordinator for model-aware budget management.
+       * When set, budget allocations flow from the coordinator instead of defaults.
+       *
+       * @see PRJ-266
+       */
+      setCoordinator(coordinator) {
+        this._coordinator = coordinator;
+      }
+      /** Get the active coordinator (may be null) */
+      getCoordinator() {
+        return this._coordinator;
+      }
+      /**
+       * Get effective injection budgets.
+       * Uses coordinator allocation when available, falls back to DEFAULT_BUDGETS.
+       *
+       * @see PRJ-266
+       */
+      getEffectiveBudgets() {
+        if (this._coordinator) {
+          return budgetsFromCoordinator(this._coordinator);
+        }
+        return DEFAULT_BUDGETS;
+      }
       /**
        * Reset context (for testing)
        */
@@ -15555,7 +16020,7 @@ var init_prompt_builder = __esm({
         parts.push("---");
         parts.push("");
         const result = parts.join("\n");
-        return truncateToTokenBudget(result, DEFAULT_BUDGETS.autoContext);
+        return truncateToTokenBudget(result, this.getEffectiveBudgets().autoContext);
       }
       /**
        * Calculate elapsed time from ISO timestamp.
@@ -15622,7 +16087,12 @@ var init_prompt_builder = __esm({
         return parts.join("");
       }
       /**
-       * Build a complete prompt for Claude from template, context, and enhancements
+       * Build a complete prompt for Claude from template, context, and enhancements.
+       *
+       * Section ordering follows research-backed pattern (PRJ-301):
+       * Identity → Environment → Ground Truth → Capabilities → Constraints →
+       * Task Context → Task → Output Schema → Efficiency
+       *
        * @deprecated Use buildWithInjection for auto-injected context
        */
       async build(template, context2, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null, orchestratorContext = null) {
@@ -15661,33 +16131,70 @@ Apply specialized expertise. Read agent file for details if needed.
           parts.push(`INPUT: ${params.params.task || params.params.description}
 `);
         }
-        parts.push("\n---\n");
-        parts.push(template.content);
+        const projectPath = context2.projectPath;
+        if (projectPath) {
+          const projectName = orchestratorContext?.project?.id ? path31.basename(projectPath) : path31.basename(projectPath);
+          const envBlock = buildEnvironmentBlock({
+            projectName,
+            projectPath,
+            isGitRepo: true,
+            gitBranch: orchestratorContext?.realContext?.gitBranch
+          });
+          parts.push(`
+${envBlock}
+`);
+        }
         if (orchestratorContext) {
-          parts.push("\n## ORCHESTRATOR CONTEXT\n");
+          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(", ")}
-`);
-          parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}
 
 `);
+        }
+        const needsPatterns = commandContext.patterns;
+        const codePatternsContent = state?.codePatterns || "";
+        if (needsPatterns && codePatternsContent && codePatternsContent.trim()) {
+          const patternSummary = this.extractPatternSummary(codePatternsContent);
+          if (patternSummary) {
+            parts.push("## CODE PATTERNS\n");
+            parts.push(patternSummary);
+            parts.push("\nFull patterns: Read analysis/patterns.md\n");
+          }
+        }
+        const analysisContent = state?.analysis || "";
+        if (needsPatterns && analysisContent && analysisContent.trim()) {
+          const stackMatch = analysisContent.match(/Stack[:\s]+([^\n]+)/i) || analysisContent.match(/Technology[:\s]+([^\n]+)/i);
+          const stack = stackMatch ? stackMatch[1].trim() : "detected";
+          parts.push(`
+## STACK
+Stack: ${stack}
+`);
+          if (!codePatternsContent) {
+            parts.push(
+              "Read analysis/repo-summary.md + similar files before coding. Match patterns exactly.\n"
+            );
+          }
+        }
+        if (orchestratorContext) {
           if (orchestratorContext.agents.length > 0) {
-            parts.push("### LOADED AGENTS (Project-Specific Specialists)\n\n");
-            for (const agent2 of orchestratorContext.agents) {
-              parts.push(`#### Agent: ${agent2.name} (${agent2.domain})
+            parts.push("\n### LOADED AGENTS (Project-Specific Specialists)\n\n");
+            for (const orcAgent of orchestratorContext.agents) {
+              parts.push(`#### Agent: ${orcAgent.name} (${orcAgent.domain})
 `);
-              if (agent2.effort) parts.push(`Effort: ${agent2.effort}
+              if (orcAgent.effort) parts.push(`Effort: ${orcAgent.effort}
 `);
-              if (agent2.model) parts.push(`Model: ${agent2.model}
+              if (orcAgent.model) parts.push(`Model: ${orcAgent.model}
 `);
-              if (agent2.skills.length > 0) {
-                parts.push(`Skills: ${agent2.skills.join(", ")}
+              if (orcAgent.skills.length > 0) {
+                parts.push(`Skills: ${orcAgent.skills.join(", ")}
 `);
               }
               const truncatedContent = truncateToTokenBudget(
-                agent2.content,
-                DEFAULT_BUDGETS.agentContent
+                orcAgent.content,
+                this.getEffectiveBudgets().agentContent
               );
               parts.push(`\`\`\`markdown
 ${truncatedContent}
@@ -15707,87 +16214,94 @@ ${truncatedContent}
 `);
               const truncatedContent = truncateToTokenBudget(
                 skill.content,
-                DEFAULT_BUDGETS.skillContent
+                this.getEffectiveBudgets().skillContent
               );
               parts.push(`\`\`\`markdown
 ${truncatedContent}
 \`\`\`
 
 `);
-            }
-          }
-          if (orchestratorContext.realContext) {
-            const rc = orchestratorContext.realContext;
-            parts.push("### CODEBASE CONTEXT (Real \u2014 gathered proactively)\n\n");
-            parts.push(`**Git State**: Branch \`${rc.gitBranch}\` | ${rc.gitStatus}
+            }
+          }
+        }
+        const additionalModules = this.getModulesForCommand(commandName, commandContext);
+        if (additionalModules.length > 0) {
+          for (const moduleName of additionalModules) {
+            const moduleContent = await this.loadModule(moduleName);
+            if (moduleContent) {
+              parts.push("\n");
+              parts.push(moduleContent);
+            }
+          }
+        }
+        if (planInfo?.isPlanning) {
+          parts.push(
+            `
+## PLAN MODE
+Read-only. Gather info \u2192 Analyze \u2192 Propose plan \u2192 Wait for approval.
+`
+          );
+          if (planInfo.allowedTools) parts.push(`Tools: ${planInfo.allowedTools.join(", ")}
+`);
+        }
+        if (planInfo?.requiresApproval) {
+          parts.push(
+            `
+## APPROVAL REQUIRED
+Show changes, list affected files, ask for confirmation.
+`
+          );
+        }
+        if (projectPath) {
+          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) || []
+          };
+          parts.push(`
+${buildAntiHallucinationBlock(groundTruth2)}
+`);
+        } else {
+          parts.push(this.buildCriticalRules());
+        }
+        if (orchestratorContext?.realContext) {
+          const rc = orchestratorContext.realContext;
+          parts.push("\n### CODEBASE CONTEXT\n\n");
+          parts.push(`**Git State**: Branch \`${rc.gitBranch}\` | ${rc.gitStatus}
 
 `);
-            if (rc.relevantFiles.length > 0) {
-              parts.push("**Relevant Files** (scored by task relevance):\n");
-              parts.push("| Score | File | Why |\n");
-              parts.push("|-------|------|-----|\n");
-              for (const f of rc.relevantFiles.slice(0, 8)) {
-                parts.push(`| ${f.score} | ${f.path} | ${f.reason} |
+          if (rc.relevantFiles.length > 0) {
+            parts.push("**Relevant Files** (scored by task relevance):\n");
+            parts.push("| Score | File | Why |\n");
+            parts.push("|-------|------|-----|\n");
+            for (const f of rc.relevantFiles.slice(0, 8)) {
+              parts.push(`| ${f.score} | ${f.path} | ${f.reason} |
 `);
-              }
-              parts.push("\n");
             }
-            if (rc.signatures.length > 0) {
-              parts.push("**Code Signatures** (top files):\n");
-              for (const sig of rc.signatures) {
-                parts.push(`\`\`\`typescript
+            parts.push("\n");
+          }
+          if (rc.signatures.length > 0) {
+            parts.push("**Code Signatures** (top files):\n");
+            for (const sig of rc.signatures) {
+              parts.push(`\`\`\`typescript
 // ${sig.path}
 ${sig.content}
 \`\`\`
-`);
-              }
-              parts.push("\n");
-            }
-            if (rc.recentFiles.length > 0) {
-              parts.push("**Recently Changed**: ");
-              const recentSummary = rc.recentFiles.slice(0, 5).map((f) => `${f.path} (${f.lastChanged})`).join(", ");
-              parts.push(`${recentSummary}
-
 `);
             }
+            parts.push("\n");
           }
-          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 statusIcon2 = subtask.status === "in_progress" ? "\u25B6\uFE0F **CURRENT**" : subtask.status === "completed" ? "\u2705 Done" : subtask.status === "failed" ? "\u274C Failed" : "\u23F3 Pending";
-              parts.push(
-                `| ${subtask.order} | ${subtask.domain} | ${subtask.description} | ${statusIcon2} |
-`
-              );
-            }
-            const currentSubtask = orchestratorContext.subtasks.find((s) => s.status === "in_progress");
-            if (currentSubtask) {
-              parts.push(
-                `
-**FOCUS ON SUBTASK #${currentSubtask.order}**: ${currentSubtask.description}
-`
-              );
-              parts.push(`Agent: ${currentSubtask.agent} | Domain: ${currentSubtask.domain}
-`);
-              if (currentSubtask.dependsOn.length > 0) {
-                parts.push(`Dependencies: ${currentSubtask.dependsOn.join(", ")}
+          if (rc.recentFiles.length > 0) {
+            parts.push("**Recently Changed**: ");
+            const recentSummary = rc.recentFiles.slice(0, 5).map((f) => `${f.path} (${f.lastChanged})`).join(", ");
+            parts.push(`${recentSummary}
+
 `);
-              }
-            }
-            parts.push("\n");
           }
         }
-        const relevantState = this.filterRelevantState(state);
-        if (relevantState) {
-          parts.push("\n## PRJCT STATE (Project Management Data)\n");
-          parts.push(relevantState);
-          parts.push("\n");
-        }
         const files = context2.files || [];
         if (files.length > 0) {
           const top5 = files.slice(0, 5).join(", ");
@@ -15795,49 +16309,18 @@ ${sig.content}
 ## FILES: ${files.length} available. Top: ${top5}
 `);
           parts.push("Read BEFORE modifying. Use Glob/Grep to find more.\n\n");
-        } else if (context2.projectPath) {
-          parts.push(
-            `
-## PROJECT: ${context2.projectPath}
+        } else if (projectPath) {
+          parts.push(`
+## PROJECT: ${projectPath}
 Read files before modifying.
 
-`
-          );
-        }
-        const needsPatterns = commandContext.patterns;
-        const codePatternsContent = state?.codePatterns || "";
-        if (needsPatterns && codePatternsContent && codePatternsContent.trim()) {
-          const patternSummary = this.extractPatternSummary(codePatternsContent);
-          if (patternSummary) {
-            parts.push("\n## CODE PATTERNS\n");
-            parts.push(patternSummary);
-            parts.push("\nFull patterns: Read analysis/patterns.md\n");
-          }
-        }
-        const analysisContent = state?.analysis || "";
-        if (needsPatterns && analysisContent && analysisContent.trim()) {
-          const stackMatch = analysisContent.match(/Stack[:\s]+([^\n]+)/i) || analysisContent.match(/Technology[:\s]+([^\n]+)/i);
-          const stack = stackMatch ? stackMatch[1].trim() : "detected";
-          parts.push(`
-## STACK
-Stack: ${stack}
 `);
-          if (!codePatternsContent) {
-            parts.push(
-              "Read analysis/repo-summary.md + similar files before coding. Match patterns exactly.\n"
-            );
-          }
         }
-        parts.push(this.buildCriticalRules());
-        const additionalModules = this.getModulesForCommand(commandName, commandContext);
-        if (additionalModules.length > 0) {
-          for (const moduleName of additionalModules) {
-            const moduleContent = await this.loadModule(moduleName);
-            if (moduleContent) {
-              parts.push("\n");
-              parts.push(moduleContent);
-            }
-          }
+        const relevantState = this.filterRelevantState(state);
+        if (relevantState) {
+          parts.push("\n## PRJCT STATE (Project Management Data)\n");
+          parts.push(relevantState);
+          parts.push("\n");
         }
         if (learnedPatterns && Object.keys(learnedPatterns).some((k) => learnedPatterns[k])) {
           parts.push("\n## PROJECT DEFAULTS (apply automatically)\n");
@@ -15876,23 +16359,47 @@ Stack: ${stack}
             }
           }
         }
-        if (planInfo?.isPlanning) {
+        parts.push("\n---\n");
+        parts.push(template.content);
+        if (orchestratorContext?.requiresFragmentation && orchestratorContext.subtasks) {
+          parts.push("\n### SUBTASKS (Execute in Order)\n\n");
           parts.push(
-            `
-## PLAN MODE
-Read-only. Gather info \u2192 Analyze \u2192 Propose plan \u2192 Wait for approval.
-`
+            "**IMPORTANT**: Focus on the CURRENT subtask. Use `p. done` when complete to advance.\n\n"
           );
-          if (planInfo.allowedTools) parts.push(`Tools: ${planInfo.allowedTools.join(", ")}
+          parts.push("| # | Domain | Description | Status |\n");
+          parts.push("|---|--------|-------------|--------|\n");
+          for (const subtask of orchestratorContext.subtasks) {
+            const statusIcon2 = subtask.status === "in_progress" ? "\u25B6\uFE0F **CURRENT**" : subtask.status === "completed" ? "\u2705 Done" : subtask.status === "failed" ? "\u274C Failed" : "\u23F3 Pending";
+            parts.push(
+              `| ${subtask.order} | ${subtask.domain} | ${subtask.description} | ${statusIcon2} |
+`
+            );
+          }
+          const currentSubtask = orchestratorContext.subtasks.find((s) => s.status === "in_progress");
+          if (currentSubtask) {
+            parts.push(
+              `
+**FOCUS ON SUBTASK #${currentSubtask.order}**: ${currentSubtask.description}
+`
+            );
+            parts.push(`Agent: ${currentSubtask.agent} | Domain: ${currentSubtask.domain}
 `);
+            if (currentSubtask.dependsOn.length > 0) {
+              parts.push(`Dependencies: ${currentSubtask.dependsOn.join(", ")}
+`);
+            }
+          }
+          parts.push("\n");
         }
-        if (planInfo?.requiresApproval) {
-          parts.push(
-            `
-## APPROVAL REQUIRED
-Show changes, list affected files, ask for confirmation.
-`
-          );
+        const schemaType = this.getSchemaTypeForCommand(commandName);
+        if (schemaType) {
+          const { renderSchemaForPrompt: renderSchemaForPrompt2 } = await Promise.resolve().then(() => (init_llm_output(), llm_output_exports));
+          const schemaBlock = renderSchemaForPrompt2(schemaType);
+          if (schemaBlock) {
+            parts.push(`
+${schemaBlock}
+`);
+          }
         }
         if (commandContext.checklist) {
           const routing = await this.loadChecklistRouting();
@@ -15908,17 +16415,7 @@ Show changes, list affected files, ask for confirmation.
             parts.push("Use Read tool to load checklists you determine are relevant.\n");
           }
         }
-        const schemaType = this.getSchemaTypeForCommand(commandName);
-        if (schemaType) {
-          const { renderSchemaForPrompt: renderSchemaForPrompt2 } = await Promise.resolve().then(() => (init_llm_output(), llm_output_exports));
-          const schemaBlock = renderSchemaForPrompt2(schemaType);
-          if (schemaBlock) {
-            parts.push(`
-${schemaBlock}
-`);
-          }
-        }
-        parts.push("\nEXECUTE: Follow flow. Use tools. Decide.\n");
+        parts.push(this.buildEfficiencyDirective());
         return parts.join("");
       }
       /**
@@ -15927,7 +16424,8 @@ ${schemaBlock}
        */
       filterRelevantState(state) {
         if (!state || Object.keys(state).length === 0) return null;
-        const tracker = new InjectionBudgetTracker({ totalPrompt: DEFAULT_BUDGETS.stateData });
+        const budgets = this.getEffectiveBudgets();
+        const tracker = new InjectionBudgetTracker({ totalPrompt: budgets.stateData });
         const criticalFiles = ["now", "next", "context", "analysis", "codePatterns"];
         const relevant = [];
         for (const [key, content] of Object.entries(state)) {
@@ -15992,7 +16490,9 @@ ${antiPatterns}`);
         return schemaMap[commandName] ?? null;
       }
       /**
-       * Build critical anti-hallucination rules section
+       * Build critical anti-hallucination rules section.
+       * Used as fallback when full anti-hallucination block can't be built
+       * (e.g., no project path available).
        */
       buildCriticalRules() {
         const fileCount = this._currentContext?.files?.length || this._currentContext?.filteredSize || 0;
@@ -16006,6 +16506,41 @@ ${antiPatterns}`);
 Context: ${fileCount} files available. Read what you need.
 `;
       }
+      /**
+       * Build token efficiency directive (PRJ-301).
+       * Instructs the LLM to be concise and avoid wasting tokens on preamble.
+       */
+      buildEfficiencyDirective() {
+        return `
+## OUTPUT RULES
+- Be concise. Maximum 4 lines of explanation unless asked for detail.
+- No preamble ("Here is...", "I'll help you...", "Based on...").
+- No postamble (summaries, next steps suggestions unless asked).
+- When executing code: show the code, not the explanation.
+- Prefer structured output (JSON) over free text when applicable.
+
+EXECUTE: Follow flow. Use tools. Decide.
+`;
+      }
+      /**
+       * Extract domain flags from state data.
+       * Returns the domains object if available in the raw state.
+       */
+      extractDomains(state) {
+        if (!state) return void 0;
+        const raw = state;
+        if (raw.domains && typeof raw.domains === "object") {
+          const d = raw.domains;
+          return {
+            hasFrontend: d.hasFrontend ?? false,
+            hasBackend: d.hasBackend ?? false,
+            hasDatabase: d.hasDatabase ?? false,
+            hasTesting: d.hasTesting ?? false,
+            hasDocker: d.hasDocker ?? false
+          };
+        }
+        return void 0;
+      }
     };
     promptBuilder = new PromptBuilder();
     prompt_builder_default = promptBuilder;
@@ -16302,7 +16837,7 @@ var init_tool_registry = __esm({
 
 // core/agentic/command-executor.ts
 import fs35 from "node:fs/promises";
-import os10 from "node:os";
+import os11 from "node:os";
 import path33 from "node:path";
 async function signalStart(commandName) {
   try {
@@ -16341,7 +16876,7 @@ var init_command_executor = __esm({
     init_template_executor();
     init_template_loader();
     init_tool_registry();
-    RUNNING_FILE = path33.join(os10.homedir(), ".prjct-cli", ".running");
+    RUNNING_FILE = path33.join(os11.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -16652,7 +17187,7 @@ var init_command_executor = __esm({
 // core/infrastructure/update-checker.ts
 import fs36 from "node:fs/promises";
 import https from "node:https";
-import os11 from "node:os";
+import os12 from "node:os";
 import path34 from "node:path";
 import chalk8 from "chalk";
 var UpdateChecker, update_checker_default;
@@ -16671,7 +17206,7 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path34.join(os11.homedir(), ".prjct-cli", "config");
+        this.cacheDir = path34.join(os12.homedir(), ".prjct-cli", "config");
         this.cacheFile = path34.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
@@ -19456,10 +19991,10 @@ var init_onboarding = __esm({
       async detectInstalledAgents() {
         const fs56 = await import("node:fs/promises");
         const path68 = await import("node:path");
-        const os21 = await import("node:os");
+        const os22 = await import("node:os");
         const agents = [];
         try {
-          await fs56.access(path68.join(os21.homedir(), ".claude"));
+          await fs56.access(path68.join(os22.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
@@ -19479,7 +20014,7 @@ var init_onboarding = __esm({
         } catch {
         }
         try {
-          await fs56.access(path68.join(os21.homedir(), ".gemini"));
+          await fs56.access(path68.join(os22.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -20398,6 +20933,7 @@ var init_analysis2 = __esm({
     init_metrics();
     init_services();
     init_diff_generator();
+    init_analysis_storage();
     init_metrics_storage();
     init_fs();
     init_next_steps();
@@ -20998,22 +21534,83 @@ ${formatFullDiff(diff)}`);
           const checker = createStalenessChecker(projectPath);
           const status = await checker.check(projectId);
           const sessionInfo = await checker.getSessionInfo(projectId);
+          const analysisStatus = await analysisStorage.getStatus(projectId);
           if (options.json) {
             console.log(
               JSON.stringify({
                 success: true,
                 ...status,
-                session: sessionInfo
+                session: sessionInfo,
+                analysis: analysisStatus
               })
             );
-            return { success: true, data: { ...status, session: sessionInfo } };
+            return {
+              success: true,
+              data: { ...status, session: sessionInfo, analysis: analysisStatus }
+            };
           }
           console.log("");
           console.log(checker.formatStatus(status));
           console.log("");
           console.log(checker.formatSessionInfo(sessionInfo));
+          if (analysisStatus.hasSealed || analysisStatus.hasDraft) {
+            console.log("");
+            console.log("Analysis:");
+            if (analysisStatus.hasSealed) {
+              console.log(`  Sealed: ${analysisStatus.sealedCommit} (${analysisStatus.sealedAt})`);
+            }
+            if (analysisStatus.hasDraft) {
+              console.log(`  Draft: ${analysisStatus.draftCommit} (pending seal)`);
+            }
+          }
+          console.log("");
+          return { success: true, data: { ...status, session: sessionInfo, analysis: analysisStatus } };
+        } catch (error) {
+          const errMsg = getErrorMessage2(error);
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: errMsg }));
+          } else {
+            output_default.fail(errMsg);
+          }
+          return { success: false, error: errMsg };
+        }
+      }
+      /**
+       * prjct seal - Seal the current draft analysis (PRJ-263)
+       *
+       * Locks the current draft with a SHA-256 signature.
+       * Only sealed analysis feeds task context.
+       */
+      async seal(projectPath = process.cwd(), options = {}) {
+        try {
+          const initResult = await this.ensureProjectInit(projectPath);
+          if (!initResult.success) return initResult;
+          const projectId = await config_manager_default.getProjectId(projectPath);
+          if (!projectId) {
+            if (options.json) {
+              console.log(JSON.stringify({ success: false, error: "No project ID found" }));
+            }
+            return { success: false, error: "No project ID found" };
+          }
+          const result = await analysisStorage.seal(projectId);
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                success: result.success,
+                signature: result.signature,
+                error: result.error
+              })
+            );
+            return { success: result.success, error: result.error };
+          }
+          if (!result.success) {
+            output_default.fail(result.error || "Seal failed");
+            return { success: false, error: result.error };
+          }
+          output_default.done("Analysis sealed");
+          console.log(`  Signature: ${result.signature?.substring(0, 16)}...`);
           console.log("");
-          return { success: true, data: { ...status, session: sessionInfo } };
+          return { success: true, data: { signature: result.signature } };
         } catch (error) {
           const errMsg = getErrorMessage2(error);
           if (options.json) {
@@ -21024,6 +21621,35 @@ ${formatFullDiff(diff)}`);
           return { success: false, error: errMsg };
         }
       }
+      /**
+       * prjct verify - Verify integrity of sealed analysis (PRJ-263)
+       */
+      async verify(projectPath = process.cwd(), options = {}) {
+        try {
+          const initResult = await this.ensureProjectInit(projectPath);
+          if (!initResult.success) return initResult;
+          const projectId = await config_manager_default.getProjectId(projectPath);
+          if (!projectId) {
+            return { success: false, error: "No project ID found" };
+          }
+          const result = await analysisStorage.verify(projectId);
+          if (options.json) {
+            console.log(JSON.stringify(result));
+            return { success: result.valid };
+          }
+          if (result.valid) {
+            output_default.done(result.message);
+          } else {
+            output_default.fail(result.message);
+          }
+          console.log("");
+          return { success: result.valid, data: result };
+        } catch (error) {
+          const errMsg = getErrorMessage2(error);
+          output_default.fail(errMsg);
+          return { success: false, error: errMsg };
+        }
+      }
       /**
        * Get session activity stats from today's events
        * @see PRJ-89
@@ -22363,7 +22989,7 @@ var init_formatters = __esm({
 
 // core/ai-tools/registry.ts
 import { exec as exec13 } from "node:child_process";
-import os12 from "node:os";
+import os13 from "node:os";
 import path45 from "node:path";
 import { promisify as promisify14 } from "node:util";
 function getAIToolConfig(id) {
@@ -22391,7 +23017,7 @@ async function detectInstalledTools(repoPath = process.cwd()) {
   if (await commandExists("windsurf") || await fileExists(path45.join(repoPath, ".windsurf"))) {
     detected.push("windsurf");
   }
-  if (await fileExists(path45.join(repoPath, ".continue")) || await fileExists(path45.join(os12.homedir(), ".continue"))) {
+  if (await fileExists(path45.join(repoPath, ".continue")) || await fileExists(path45.join(os13.homedir(), ".continue"))) {
     detected.push("continue");
   }
   return detected;
@@ -23011,10 +23637,10 @@ var init_local_state_generator = __esm({
 
 // core/services/skill-lock.ts
 import fs46 from "node:fs/promises";
-import os13 from "node:os";
+import os14 from "node:os";
 import path49 from "node:path";
 function getLockFilePath() {
-  return path49.join(os13.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+  return path49.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
 }
 function createEmptyLockFile() {
   return {
@@ -23089,13 +23715,13 @@ var init_skill_lock = __esm({
 // core/services/skill-installer.ts
 import { exec as execCallback7 } from "node:child_process";
 import fs47 from "node:fs/promises";
-import os14 from "node:os";
+import os15 from "node:os";
 import path50 from "node:path";
 import { promisify as promisify15 } from "node:util";
 import { glob } from "glob";
 function parseSource(source) {
   if (source.startsWith("./") || source.startsWith("/") || source.startsWith("~")) {
-    const resolvedPath = source.startsWith("~") ? path50.join(os14.homedir(), source.slice(1)) : path50.resolve(source);
+    const resolvedPath = source.startsWith("~") ? path50.join(os15.homedir(), source.slice(1)) : path50.resolve(source);
     return {
       type: "local",
       localPath: resolvedPath,
@@ -23184,7 +23810,7 @@ ${prjctBlock.join("\n")}
 ${content}`;
 }
 function getInstallDir() {
-  return path50.join(os14.homedir(), ".claude", "skills");
+  return path50.join(os15.homedir(), ".claude", "skills");
 }
 async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
@@ -23210,7 +23836,7 @@ async function installFromGitHub(source) {
     );
     return result;
   }
-  const tmpDir = path50.join(os14.tmpdir(), `prjct-skill-${Date.now()}`);
+  const tmpDir = path50.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
   try {
     const cloneUrl = `https://github.com/${source.owner}/${source.repo}.git`;
     await exec14(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
@@ -23747,7 +24373,7 @@ var init_sync_verifier = __esm({
 // core/services/sync-service.ts
 import { exec as exec16 } from "node:child_process";
 import fs50 from "node:fs/promises";
-import os15 from "node:os";
+import os16 from "node:os";
 import path53 from "node:path";
 import { promisify as promisify17 } from "node:util";
 var execAsync11, SyncService, syncService;
@@ -23759,6 +24385,7 @@ var init_sync_service = __esm({
     init_command_installer();
     init_config_manager();
     init_path_manager();
+    init_analysis_storage();
     init_metrics_storage();
     init_citations();
     init_date_helper();
@@ -23863,7 +24490,8 @@ var init_sync_service = __esm({
           await Promise.all([
             this.updateProjectJson(git, stats),
             this.updateStateJson(stats, stack),
-            this.logToMemory(git, stats)
+            this.logToMemory(git, stats),
+            this.saveDraftAnalysis(git, stats, stack)
           ]);
           const duration = Date.now() - startTime;
           const syncMetrics = await this.recordSyncMetrics(stats, contextFiles, agents, duration);
@@ -24384,7 +25012,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             }
           }
           if (packagesToInstall.length === 0) return results;
-          const skillsDir = path53.join(os15.homedir(), ".claude", "skills");
+          const skillsDir = path53.join(os16.homedir(), ".claude", "skills");
           for (const { pkg, agent } of packagesToInstall) {
             const skillName = pkg.split("/").pop() || pkg;
             const subdirPath = path53.join(skillsDir, skillName, "SKILL.md");
@@ -24598,6 +25226,32 @@ You are the ${name} expert for this project. Apply best practices for the detect
         };
       }
       // ==========================================================================
+      // DRAFT ANALYSIS (PRJ-263)
+      // ==========================================================================
+      /**
+       * Save sync results as a draft analysis.
+       * Preserves existing sealed analysis — only the draft is overwritten.
+       */
+      async saveDraftAnalysis(git, stats, _stack) {
+        try {
+          const commitHash = git.recentCommits[0]?.hash || null;
+          await analysisStorage.saveDraft(this.projectId, {
+            projectId: this.projectId,
+            languages: stats.languages,
+            frameworks: stats.frameworks,
+            configFiles: [],
+            fileCount: stats.fileCount,
+            patterns: [],
+            antiPatterns: [],
+            analyzedAt: getTimestamp(),
+            status: "draft",
+            commitHash: commitHash ?? void 0
+          });
+        } catch (error) {
+          logger_default.debug("Failed to save draft analysis (non-critical)", { error: getErrorMessage(error) });
+        }
+      }
+      // ==========================================================================
       // HELPERS
       // ==========================================================================
       async fileExists(filename) {
@@ -24774,7 +25428,7 @@ __export(uninstall_exports, {
 });
 import { execSync as execSync3 } from "node:child_process";
 import fs51 from "node:fs/promises";
-import os16 from "node:os";
+import os17 from "node:os";
 import path54 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
@@ -24942,7 +25596,7 @@ async function removePrjctSection(filePath) {
   }
 }
 async function createBackup2() {
-  const homeDir = os16.homedir();
+  const homeDir = os17.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
   const backupDir = path54.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
@@ -25607,6 +26261,35 @@ var init_command_data = __esm({
           "Configurable staleness thresholds"
         ]
       },
+      {
+        name: "seal",
+        group: "core",
+        description: "Seal the current draft analysis with a commit-hash signature",
+        usage: { claude: "/p:seal", terminal: "prjct seal" },
+        params: "[--json]",
+        implemented: true,
+        hasTemplate: false,
+        requiresProject: true,
+        features: [
+          "Locks draft analysis with SHA-256 signature",
+          "Only sealed analysis feeds task context",
+          "Detects staleness when HEAD moves past sealed commit"
+        ]
+      },
+      {
+        name: "verify",
+        group: "core",
+        description: "Verify integrity of sealed analysis",
+        usage: { claude: "/p:verify", terminal: "prjct verify" },
+        params: "[--json]",
+        implemented: true,
+        hasTemplate: false,
+        requiresProject: true,
+        features: [
+          "Recomputes SHA-256 signature and compares",
+          "Detects if sealed analysis was modified"
+        ]
+      },
       {
         name: "help",
         group: "core",
@@ -26068,7 +26751,7 @@ __export(setup_exports, {
 });
 import { execSync as execSync4 } from "node:child_process";
 import fs52 from "node:fs/promises";
-import os17 from "node:os";
+import os18 from "node:os";
 import path56 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
@@ -26208,7 +26891,7 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path56.join(os17.homedir(), ".gemini", "commands");
+    const geminiCommandsDir = path56.join(os18.homedir(), ".gemini", "commands");
     const routerSource = path56.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
     const routerDest = path56.join(geminiCommandsDir, "p.toml");
     await fs52.mkdir(geminiCommandsDir, { recursive: true });
@@ -26224,7 +26907,7 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path56.join(os17.homedir(), ".gemini");
+    const geminiDir = path56.join(os18.homedir(), ".gemini");
     const globalConfigPath = path56.join(geminiDir, "GEMINI.md");
     const templatePath = path56.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
     await fs52.mkdir(geminiDir, { recursive: true });
@@ -26273,7 +26956,7 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path56.join(os17.homedir(), ".gemini", "antigravity", "skills");
+    const antigravitySkillsDir = path56.join(os18.homedir(), ".gemini", "antigravity", "skills");
     const prjctSkillDir = path56.join(antigravitySkillsDir, "prjct");
     const skillMdPath = path56.join(prjctSkillDir, "SKILL.md");
     const templatePath = path56.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
@@ -26467,7 +27150,7 @@ async function needsWindsurfRegeneration(projectRoot) {
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path56.join(os17.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path56.join(os18.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
@@ -26517,10 +27200,10 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path56.join(os17.homedir(), ".claude");
+    const claudeDir = path56.join(os18.homedir(), ".claude");
     const settingsPath = path56.join(claudeDir, "settings.json");
     const claudeStatusLinePath = path56.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path56.join(os17.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLineDir = path56.join(os18.homedir(), ".prjct-cli", "statusline");
     const prjctStatusLinePath = path56.join(prjctStatusLineDir, "statusline.sh");
     const prjctThemesDir = path56.join(prjctStatusLineDir, "themes");
     const prjctLibDir = path56.join(prjctStatusLineDir, "lib");
@@ -26627,7 +27310,7 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path56.join(os17.homedir(), ".claude");
+    const claudeDir = path56.join(os18.homedir(), ".claude");
     const mcpConfigPath = path56.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
       await fs52.mkdir(claudeDir, { recursive: true });
@@ -29694,10 +30377,10 @@ var init_linear = __esm({
 
 // core/utils/project-credentials.ts
 import fs55 from "node:fs/promises";
-import os18 from "node:os";
+import os19 from "node:os";
 import path65 from "node:path";
 function getCredentialsPath(projectId) {
-  return path65.join(os18.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path65.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
@@ -30235,6 +30918,12 @@ var init_commands = __esm({
       async status(projectPath = process.cwd(), options = {}) {
         return this.analysis.status(projectPath, options);
       }
+      async seal(projectPath = process.cwd(), options = {}) {
+        return this.analysis.seal(projectPath, options);
+      }
+      async verify(projectPath = process.cwd(), options = {}) {
+        return this.analysis.verify(projectPath, options);
+      }
       // ========== Context Commands ==========
       async context(input = null, projectPath = process.cwd()) {
         return this.contextCmds.context(input, projectPath);
@@ -30306,6 +30995,8 @@ function registerAllCommands() {
   commandRegistry.registerMethod("sync", analysis, "sync", getMeta("sync"));
   commandRegistry.registerMethod("stats", analysis, "stats", getMeta("stats"));
   commandRegistry.registerMethod("status", analysis, "status", getMeta("status"));
+  commandRegistry.registerMethod("seal", analysis, "seal", getMeta("seal"));
+  commandRegistry.registerMethod("verify", analysis, "verify", getMeta("verify"));
   commandRegistry.registerMethod("start", setup, "start", getMeta("start"));
   commandRegistry.registerMethod("setup", setup, "setup", getMeta("setup"));
   commandRegistry.registerMethod("uninstall", uninstallCmd, "uninstall", getMeta("uninstall"));
@@ -30359,7 +31050,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.9.0",
+      version: "1.11.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -30465,7 +31156,7 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import os19 from "node:os";
+import os20 from "node:os";
 import path66 from "node:path";
 import chalk19 from "chalk";
 async function main() {
@@ -30572,6 +31263,8 @@ async function main() {
           json: options.json === true,
           package: options.package ? String(options.package) : void 0
         }), "sync"),
+        seal: /* @__PURE__ */ __name(() => commands.seal(process.cwd(), { json: options.json === true }), "seal"),
+        verify: /* @__PURE__ */ __name(() => commands.verify(process.cwd(), { json: options.json === true }), "verify"),
         start: /* @__PURE__ */ __name(() => commands.start(), "start"),
         // Context (for Claude templates)
         context: /* @__PURE__ */ __name((p) => commands.context(p), "context")
@@ -30676,8 +31369,8 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path66.join(os19.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path66.join(os19.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = path66.join(os20.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path66.join(os20.homedir(), ".gemini", "commands", "p.toml");
   const [claudeConfigured, geminiConfigured, cursorConfigured, cursorExists] = await Promise.all([
     fileExists(claudeCommandPath),
     fileExists(geminiCommandPath),
@@ -30820,7 +31513,7 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import os20 from "node:os";
+import os21 from "node:os";
 import path67 from "node:path";
 import chalk20 from "chalk";
 
@@ -31639,7 +32332,7 @@ init_provider_cache();
 init_version();
 globalThis.__perfStartNs = process.hrtime.bigint();
 async function checkRoutersInstalled() {
-  const home = os20.homedir();
+  const home = os21.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
     const claudeRouter = path67.join(home, ".claude", "commands", "p.md");
@@ -31806,7 +32499,7 @@ if (args[0] === "start" || args[0] === "setup") {
   process.exitCode = 0;
 } else if (args[0] === "version" || args[0] === "-v" || args[0] === "--version") {
   const detection = await detectAllProviders(isRefresh);
-  const home = os20.homedir();
+  const home = os21.homedir();
   const cwd = process.cwd();
   const [
     claudeConfigured,
@@ -31860,7 +32553,7 @@ ${chalk20.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk20.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path67.join(os20.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path67.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`