prjct-cli 0.42.0 → 0.44.1

package/dist/bin/prjct.mjs

@@ -16,10 +16,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path41) => {
-  var fn = map[path41];
+var __glob = (map) => (path44) => {
+  var fn = map[path44];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path41);
+  throw new Error("Module not found in bundle: " + path44);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -3330,7 +3330,12 @@ var init_state = __esm({
       // Subtask tracking for fragmented tasks
       subtasks: z2.array(SubtaskSchema).optional(),
       currentSubtaskIndex: z2.number().optional(),
-      subtaskProgress: SubtaskProgressSchema.optional()
+      subtaskProgress: SubtaskProgressSchema.optional(),
+      // Linear integration - bidirectional sync
+      linearId: z2.string().optional(),
+      // "PRJ-123" - Linear identifier
+      linearUuid: z2.string().optional()
+      // Linear internal UUID for API calls
     });
     PreviousTaskSchema = z2.object({
       id: z2.string(),
@@ -3399,26 +3404,108 @@ var init_state = __esm({
   }
 });
 
-// core/schemas/project.ts
+// core/schemas/issues.ts
 import { z as z3 } from "zod";
+function createEmptyIssues(provider) {
+  return {
+    provider,
+    lastSync: "",
+    staleAfter: 18e5,
+    issues: {}
+  };
+}
+var IssueProviderSchema, IssueStatusSchema, IssuePrioritySchema, IssueTypeSchema, CachedIssueSchema, IssuesJsonSchema, SyncResultSchema, parseIssues;
+var init_issues = __esm({
+  "core/schemas/issues.ts"() {
+    "use strict";
+    IssueProviderSchema = z3.enum(["linear", "jira", "github", "monday", "asana", "none"]);
+    IssueStatusSchema = z3.enum(["backlog", "todo", "in_progress", "in_review", "done", "cancelled"]);
+    IssuePrioritySchema = z3.enum(["none", "urgent", "high", "medium", "low"]);
+    IssueTypeSchema = z3.enum(["feature", "bug", "improvement", "task", "chore", "epic"]);
+    CachedIssueSchema = z3.object({
+      // Core identifiers
+      id: z3.string(),
+      // Provider UUID
+      identifier: z3.string(),
+      // Human-readable ID (e.g., "PRJ-123")
+      // Issue content
+      title: z3.string(),
+      description: z3.string().optional(),
+      // State
+      status: IssueStatusSchema,
+      priority: IssuePrioritySchema,
+      type: IssueTypeSchema.optional(),
+      // Metadata
+      assignee: z3.object({
+        id: z3.string(),
+        name: z3.string(),
+        email: z3.string().optional()
+      }).optional(),
+      labels: z3.array(z3.string()).default([]),
+      team: z3.object({
+        id: z3.string(),
+        name: z3.string(),
+        key: z3.string().optional()
+      }).optional(),
+      project: z3.object({
+        id: z3.string(),
+        name: z3.string()
+      }).optional(),
+      // URLs and timestamps
+      url: z3.string(),
+      createdAt: z3.string(),
+      // ISO8601 from provider
+      updatedAt: z3.string(),
+      // ISO8601 from provider
+      fetchedAt: z3.string()
+      // ISO8601 when we cached it
+    });
+    IssuesJsonSchema = z3.object({
+      // Provider info
+      provider: IssueProviderSchema,
+      // Sync metadata
+      lastSync: z3.string(),
+      // ISO8601 of last full sync
+      staleAfter: z3.number().default(18e5),
+      // 30 minutes in ms
+      // Issues map: identifier -> issue
+      issues: z3.record(z3.string(), CachedIssueSchema)
+    });
+    SyncResultSchema = z3.object({
+      provider: IssueProviderSchema,
+      fetched: z3.number(),
+      updated: z3.number(),
+      errors: z3.array(z3.object({
+        issueId: z3.string(),
+        error: z3.string()
+      })),
+      timestamp: z3.string()
+    });
+    parseIssues = /* @__PURE__ */ __name((data) => IssuesJsonSchema.parse(data), "parseIssues");
+    __name(createEmptyIssues, "createEmptyIssues");
+  }
+});
+
+// core/schemas/project.ts
+import { z as z4 } from "zod";
 var ProjectItemSchema, DEFAULT_PROJECT;
 var init_project = __esm({
   "core/schemas/project.ts"() {
     "use strict";
-    ProjectItemSchema = z3.object({
-      projectId: z3.string(),
-      name: z3.string(),
-      repoPath: z3.string(),
-      description: z3.string().optional(),
-      version: z3.string().optional(),
-      cliVersion: z3.string().optional(),
+    ProjectItemSchema = z4.object({
+      projectId: z4.string(),
+      name: z4.string(),
+      repoPath: z4.string(),
+      description: z4.string().optional(),
+      version: z4.string().optional(),
+      cliVersion: z4.string().optional(),
       // prjct-cli version used to sync
-      techStack: z3.array(z3.string()),
-      fileCount: z3.number(),
-      commitCount: z3.number(),
-      createdAt: z3.string(),
+      techStack: z4.array(z4.string()),
+      fileCount: z4.number(),
+      commitCount: z4.number(),
+      createdAt: z4.string(),
       // ISO8601
-      lastSync: z3.string()
+      lastSync: z4.string()
       // ISO8601
     });
     DEFAULT_PROJECT = {
@@ -3439,74 +3526,74 @@ var init_agents = __esm({
 });
 
 // core/schemas/ideas.ts
-import { z as z4 } from "zod";
+import { z as z5 } 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 = z4.enum(["low", "medium", "high"]);
-    IdeaStatusSchema = z4.enum(["pending", "converted", "completed", "archived"]);
-    ImpactLevelSchema = z4.enum(["high", "medium", "low"]);
-    ImpactEffortSchema = z4.object({
+    IdeaPrioritySchema = z5.enum(["low", "medium", "high"]);
+    IdeaStatusSchema = z5.enum(["pending", "converted", "completed", "archived"]);
+    ImpactLevelSchema = z5.enum(["high", "medium", "low"]);
+    ImpactEffortSchema = z5.object({
       impact: ImpactLevelSchema,
       effort: ImpactLevelSchema
     });
-    TechStackSchema = z4.object({
-      frontend: z4.string().optional(),
+    TechStackSchema = z5.object({
+      frontend: z5.string().optional(),
       // "Next.js 14, HeroUI"
-      backend: z4.string().optional(),
+      backend: z5.string().optional(),
       // "Supabase (Auth, DB, RLS, Realtime)"
-      payments: z4.string().optional(),
+      payments: z5.string().optional(),
       // "Stripe Billing"
-      ai: z4.string().optional(),
+      ai: z5.string().optional(),
       // "Vercel AI SDK"
-      deploy: z4.string().optional(),
+      deploy: z5.string().optional(),
       // "Vercel"
-      other: z4.array(z4.string()).optional()
+      other: z5.array(z5.string()).optional()
     });
-    IdeaModuleSchema = z4.object({
-      name: z4.string(),
+    IdeaModuleSchema = z5.object({
+      name: z5.string(),
       // "Multi-tenant"
-      description: z4.string()
+      description: z5.string()
       // "Empresas con RLS estricto"
     });
-    IdeaRoleSchema = z4.object({
-      name: z4.string(),
+    IdeaRoleSchema = z5.object({
+      name: z5.string(),
       // "SUPER_ADMIN"
-      description: z4.string().optional()
+      description: z5.string().optional()
     });
-    IdeaItemSchema = z4.object({
-      id: z4.string(),
+    IdeaItemSchema = z5.object({
+      id: z5.string(),
       // idea_xxxxxxxx
-      text: z4.string(),
+      text: z5.string(),
       // Title/summary
-      details: z4.string().optional(),
+      details: z5.string().optional(),
       priority: IdeaPrioritySchema,
       status: IdeaStatusSchema,
-      tags: z4.array(z4.string()),
-      addedAt: z4.string(),
+      tags: z5.array(z5.string()),
+      addedAt: z5.string(),
       // ISO8601
-      completedAt: z4.string().optional(),
-      convertedTo: z4.string().optional(),
+      completedAt: z5.string().optional(),
+      convertedTo: z5.string().optional(),
       // Source documentation
-      source: z4.string().optional(),
-      sourceFiles: z4.array(z4.string()).optional(),
+      source: z5.string().optional(),
+      sourceFiles: z5.array(z5.string()).optional(),
       // Enriched fields from MD
-      painPoints: z4.array(z4.string()).optional(),
-      solutions: z4.array(z4.string()).optional(),
-      filesAffected: z4.array(z4.string()).optional(),
+      painPoints: z5.array(z5.string()).optional(),
+      solutions: z5.array(z5.string()).optional(),
+      filesAffected: z5.array(z5.string()).optional(),
       impactEffort: ImpactEffortSchema.optional(),
-      implementationNotes: z4.string().optional(),
+      implementationNotes: z5.string().optional(),
       // Technical spec fields for ZERO DATA LOSS
       stack: TechStackSchema.optional(),
-      modules: z4.array(IdeaModuleSchema).optional(),
-      roles: z4.array(IdeaRoleSchema).optional(),
-      risks: z4.array(z4.string()).optional(),
-      risksCount: z4.number().optional()
+      modules: z5.array(IdeaModuleSchema).optional(),
+      roles: z5.array(IdeaRoleSchema).optional(),
+      risks: z5.array(z5.string()).optional(),
+      risksCount: z5.number().optional()
     });
-    IdeasJsonSchema = z4.object({
-      ideas: z4.array(IdeaItemSchema),
-      lastUpdated: z4.string()
+    IdeasJsonSchema = z5.object({
+      ideas: z5.array(IdeaItemSchema),
+      lastUpdated: z5.string()
     });
     DEFAULT_IDEA = {
       priority: "medium",
@@ -3518,174 +3605,174 @@ var init_ideas = __esm({
 });
 
 // core/schemas/roadmap.ts
-import { z as z5 } from "zod";
+import { z as z6 } 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 = z5.enum(["planned", "active", "completed", "shipped"]);
-    FeatureImpactSchema = z5.enum(["low", "medium", "high"]);
-    FeatureTypeSchema = z5.enum(["feature", "breaking_change", "refactor", "infrastructure"]);
-    PhaseStatusSchema = z5.enum(["completed", "active", "planned"]);
-    QuarterStatusSchema = z5.enum(["planned", "active", "completed"]);
-    InferredFromSchema = z5.enum(["git", "git-branch", "manual", "prd"]);
-    FeatureTaskSchema = z5.object({
-      id: z5.string(),
+    FeatureStatusSchema = z6.enum(["planned", "active", "completed", "shipped"]);
+    FeatureImpactSchema = z6.enum(["low", "medium", "high"]);
+    FeatureTypeSchema = z6.enum(["feature", "breaking_change", "refactor", "infrastructure"]);
+    PhaseStatusSchema = z6.enum(["completed", "active", "planned"]);
+    QuarterStatusSchema = z6.enum(["planned", "active", "completed"]);
+    InferredFromSchema = z6.enum(["git", "git-branch", "manual", "prd"]);
+    FeatureTaskSchema = z6.object({
+      id: z6.string(),
       // task_xxxxxxxx
-      description: z5.string(),
-      completed: z5.boolean(),
-      completedAt: z5.string().optional()
+      description: z6.string(),
+      completed: z6.boolean(),
+      completedAt: z6.string().optional()
     });
-    RoadmapPhaseSchema = z5.object({
-      id: z5.string(),
+    RoadmapPhaseSchema = z6.object({
+      id: z6.string(),
       // P0, P1, etc.
-      name: z5.string(),
+      name: z6.string(),
       status: PhaseStatusSchema,
-      completedAt: z5.string().optional()
+      completedAt: z6.string().optional()
     });
-    RoadmapStrategySchema = z5.object({
-      goal: z5.string(),
-      phases: z5.array(RoadmapPhaseSchema),
-      successMetrics: z5.array(z5.string()).optional()
+    RoadmapStrategySchema = z6.object({
+      goal: z6.string(),
+      phases: z6.array(RoadmapPhaseSchema),
+      successMetrics: z6.array(z6.string()).optional()
     });
-    FeatureDurationSchema = z5.object({
-      hours: z5.number(),
-      minutes: z5.number(),
-      totalMinutes: z5.number(),
-      display: z5.string().optional()
+    FeatureDurationSchema = z6.object({
+      hours: z6.number(),
+      minutes: z6.number(),
+      totalMinutes: z6.number(),
+      display: z6.string().optional()
     });
-    GitCommitSchema = z5.object({
-      hash: z5.string(),
-      message: z5.string(),
-      date: z5.string(),
-      author: z5.string().optional()
+    GitCommitSchema = z6.object({
+      hash: z6.string(),
+      message: z6.string(),
+      date: z6.string(),
+      author: z6.string().optional()
     });
-    EffortEstimateSchema = z5.object({
-      hours: z5.number(),
-      confidence: z5.enum(["low", "medium", "high"]).optional(),
-      breakdown: z5.array(z5.object({
-        area: z5.string(),
-        hours: z5.number()
+    EffortEstimateSchema = z6.object({
+      hours: z6.number(),
+      confidence: z6.enum(["low", "medium", "high"]).optional(),
+      breakdown: z6.array(z6.object({
+        area: z6.string(),
+        hours: z6.number()
       })).optional()
     });
-    EffortActualSchema = z5.object({
-      hours: z5.number().optional(),
-      commits: z5.number().optional(),
-      linesAdded: z5.number().optional(),
-      linesRemoved: z5.number().optional()
+    EffortActualSchema = z6.object({
+      hours: z6.number().optional(),
+      commits: z6.number().optional(),
+      linesAdded: z6.number().optional(),
+      linesRemoved: z6.number().optional()
     });
-    FeatureEffortSchema = z5.object({
+    FeatureEffortSchema = z6.object({
       estimated: EffortEstimateSchema.nullable(),
       actual: EffortActualSchema.nullable()
     });
-    QuarterCapacitySchema = z5.object({
-      totalHours: z5.number(),
-      allocatedHours: z5.number(),
-      bufferPercent: z5.number().optional()
+    QuarterCapacitySchema = z6.object({
+      totalHours: z6.number(),
+      allocatedHours: z6.number(),
+      bufferPercent: z6.number().optional()
       // % reserved for unknowns
     });
-    QuarterSchema = z5.object({
-      id: z5.string(),
+    QuarterSchema = z6.object({
+      id: z6.string(),
       // Q1-2026
-      name: z5.string(),
+      name: z6.string(),
       // "Q1 2026"
-      theme: z5.string().optional(),
+      theme: z6.string().optional(),
       // "Foundation"
-      goals: z5.array(z5.string()).optional(),
-      features: z5.array(z5.string()),
+      goals: z6.array(z6.string()).optional(),
+      features: z6.array(z6.string()),
       // Feature IDs
       capacity: QuarterCapacitySchema.optional(),
       status: QuarterStatusSchema,
-      startDate: z5.string().optional(),
+      startDate: z6.string().optional(),
       // ISO8601
-      endDate: z5.string().optional()
+      endDate: z6.string().optional()
       // ISO8601
     });
-    FeatureItemSchema = z5.object({
-      id: z5.string(),
+    FeatureItemSchema = z6.object({
+      id: z6.string(),
       // feat_xxxxxxxx
-      name: z5.string(),
-      description: z5.string().optional(),
-      date: z5.string(),
+      name: z6.string(),
+      description: z6.string().optional(),
+      date: z6.string(),
       // YYYY-MM-DD creation date
       status: FeatureStatusSchema,
       impact: FeatureImpactSchema,
-      effort: z5.string().optional(),
-      progress: z5.number(),
+      effort: z6.string().optional(),
+      progress: z6.number(),
       // 0-100
       // Enriched fields from MD
       type: FeatureTypeSchema.optional(),
-      roi: z5.number().optional(),
+      roi: z6.number().optional(),
       // 1-5 from star count
-      why: z5.array(z5.string()).optional(),
-      technicalNotes: z5.array(z5.string()).optional(),
-      compatibility: z5.string().optional(),
-      phase: z5.string().optional(),
+      why: z6.array(z6.string()).optional(),
+      technicalNotes: z6.array(z6.string()).optional(),
+      compatibility: z6.string().optional(),
+      phase: z6.string().optional(),
       // P0, P1, etc.
-      tasks: z5.array(FeatureTaskSchema),
-      createdAt: z5.string(),
+      tasks: z6.array(FeatureTaskSchema),
+      createdAt: z6.string(),
       // ISO8601
-      shippedAt: z5.string().optional(),
-      version: z5.string().optional(),
+      shippedAt: z6.string().optional(),
+      version: z6.string().optional(),
       // ZERO DATA LOSS - additional fields
       duration: FeatureDurationSchema.optional(),
-      taskCount: z5.number().optional(),
-      agent: z5.string().optional(),
+      taskCount: z6.number().optional(),
+      agent: z6.string().optional(),
       // "fe+be", "fe", "be"
-      sprintName: z5.string().optional(),
-      completedDate: z5.string().optional(),
+      sprintName: z6.string().optional(),
+      completedDate: z6.string().optional(),
       // =========================================================================
       // AI ORCHESTRATION FIELDS (v0.29.0)
       // =========================================================================
       // PRD Integration
-      prdId: z5.string().nullable().optional(),
+      prdId: z6.string().nullable().optional(),
       // Link to PRD (prd_xxxxxxxx)
       // Legacy Support (for existing projects)
-      legacy: z5.boolean().optional(),
+      legacy: z6.boolean().optional(),
       // true = no PRD required
       inferredFrom: InferredFromSchema.optional(),
       // git, git-branch, manual, prd
       // Quarter Planning
-      quarter: z5.string().nullable().optional(),
+      quarter: z6.string().nullable().optional(),
       // Q1-2026, etc.
       // Dependency Tracking
-      dependencies: z5.array(z5.string()).optional(),
+      dependencies: z6.array(z6.string()).optional(),
       // Feature IDs this depends on
-      blockedBy: z5.array(z5.string()).optional(),
+      blockedBy: z6.array(z6.string()).optional(),
       // Feature IDs blocking this
       // Effort Tracking (for PRD comparison)
       effortTracking: FeatureEffortSchema.optional(),
       // Value Scoring (calculated from PRD)
-      valueScore: z5.number().optional(),
+      valueScore: z6.number().optional(),
       // Calculated priority score
       // Git Data (for legacy features)
-      commits: z5.array(GitCommitSchema).optional(),
+      commits: z6.array(GitCommitSchema).optional(),
       // Commits for this feature
-      branch: z5.string().optional(),
+      branch: z6.string().optional(),
       // Branch name (for active)
-      commitsAhead: z5.number().optional()
+      commitsAhead: z6.number().optional()
       // Commits ahead of main
     });
-    BacklogItemSchema = z5.object({
-      id: z5.string(),
-      title: z5.string(),
-      prdId: z5.string().nullable().optional(),
-      valueScore: z5.number().optional(),
-      effortEstimate: z5.number().optional(),
-      reason: z5.string().optional()
+    BacklogItemSchema = z6.object({
+      id: z6.string(),
+      title: z6.string(),
+      prdId: z6.string().nullable().optional(),
+      valueScore: z6.number().optional(),
+      effortEstimate: z6.number().optional(),
+      reason: z6.string().optional()
       // Why in backlog
     });
-    RoadmapJsonSchema = z5.object({
+    RoadmapJsonSchema = z6.object({
       strategy: RoadmapStrategySchema.nullable().optional(),
-      features: z5.array(FeatureItemSchema),
-      backlog: z5.array(z5.union([z5.string(), BacklogItemSchema])),
+      features: z6.array(FeatureItemSchema),
+      backlog: z6.array(z6.union([z6.string(), BacklogItemSchema])),
       // Support both formats
-      lastUpdated: z5.string(),
+      lastUpdated: z6.string(),
       // AI ORCHESTRATION FIELDS (v0.29.0)
-      quarters: z5.array(QuarterSchema).optional(),
+      quarters: z6.array(QuarterSchema).optional(),
       // Metadata (for git-inferred roadmaps)
-      generatedFrom: z5.enum(["git-history", "manual", "prd"]).optional(),
-      generatedAt: z5.string().optional()
+      generatedFrom: z6.enum(["git-history", "manual", "prd"]).optional(),
+      generatedAt: z6.string().optional()
     });
     DEFAULT_FEATURE = {
       date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
@@ -3703,64 +3790,64 @@ var init_roadmap = __esm({
 });
 
 // core/schemas/shipped.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var ShipTypeSchema, CheckStatusSchema, ChangeTypeSchema, DurationSchema, CodeMetricsSchema, ShipChangeSchema, QualityMetricsSchema, CommitInfoSchema, ShippedItemSchema, ShippedJsonSchema;
 var init_shipped = __esm({
   "core/schemas/shipped.ts"() {
     "use strict";
-    ShipTypeSchema = z6.enum(["feature", "fix", "improvement", "refactor"]);
-    CheckStatusSchema = z6.enum(["pass", "warning", "fail", "skipped"]);
-    ChangeTypeSchema = z6.enum(["added", "changed", "fixed", "removed"]);
-    DurationSchema = z6.object({
-      hours: z6.number(),
-      minutes: z6.number(),
-      totalMinutes: z6.number()
+    ShipTypeSchema = z7.enum(["feature", "fix", "improvement", "refactor"]);
+    CheckStatusSchema = z7.enum(["pass", "warning", "fail", "skipped"]);
+    ChangeTypeSchema = z7.enum(["added", "changed", "fixed", "removed"]);
+    DurationSchema = z7.object({
+      hours: z7.number(),
+      minutes: z7.number(),
+      totalMinutes: z7.number()
     });
-    CodeMetricsSchema = z6.object({
-      filesChanged: z6.number().nullable().optional(),
-      linesAdded: z6.number().nullable().optional(),
-      linesRemoved: z6.number().nullable().optional(),
-      commits: z6.number().nullable().optional()
+    CodeMetricsSchema = z7.object({
+      filesChanged: z7.number().nullable().optional(),
+      linesAdded: z7.number().nullable().optional(),
+      linesRemoved: z7.number().nullable().optional(),
+      commits: z7.number().nullable().optional()
     });
-    ShipChangeSchema = z6.object({
-      description: z6.string(),
+    ShipChangeSchema = z7.object({
+      description: z7.string(),
       type: ChangeTypeSchema.optional()
     });
-    QualityMetricsSchema = z6.object({
+    QualityMetricsSchema = z7.object({
       lintStatus: CheckStatusSchema.nullable().optional(),
-      lintDetails: z6.string().optional(),
+      lintDetails: z7.string().optional(),
       testStatus: CheckStatusSchema.nullable().optional(),
-      testDetails: z6.string().optional()
+      testDetails: z7.string().optional()
     });
-    CommitInfoSchema = z6.object({
-      hash: z6.string().optional(),
-      message: z6.string().optional(),
-      branch: z6.string().optional()
+    CommitInfoSchema = z7.object({
+      hash: z7.string().optional(),
+      message: z7.string().optional(),
+      branch: z7.string().optional()
     });
-    ShippedItemSchema = z6.object({
-      id: z6.string(),
+    ShippedItemSchema = z7.object({
+      id: z7.string(),
       // ship_xxxxxxxx
-      name: z6.string(),
-      version: z6.string().nullable().optional(),
+      name: z7.string(),
+      version: z7.string().nullable().optional(),
       type: ShipTypeSchema,
-      agent: z6.string().optional(),
+      agent: z7.string().optional(),
       // "fe+be", "be", "fe"
-      description: z6.string().optional(),
-      changes: z6.array(ShipChangeSchema),
-      codeSnippets: z6.array(z6.string()).optional(),
+      description: z7.string().optional(),
+      changes: z7.array(ShipChangeSchema),
+      codeSnippets: z7.array(z7.string()).optional(),
       commit: CommitInfoSchema.optional(),
       codeMetrics: CodeMetricsSchema.optional(),
       qualityMetrics: QualityMetricsSchema.optional(),
-      quantitativeImpact: z6.string().optional(),
+      quantitativeImpact: z7.string().optional(),
       duration: DurationSchema.optional(),
-      tasksCompleted: z6.number().nullable().optional(),
-      shippedAt: z6.string(),
+      tasksCompleted: z7.number().nullable().optional(),
+      shippedAt: z7.string(),
       // ISO8601
-      featureId: z6.string().optional()
+      featureId: z7.string().optional()
     });
-    ShippedJsonSchema = z6.object({
-      items: z6.array(ShippedItemSchema),
-      lastUpdated: z6.string()
+    ShippedJsonSchema = z7.object({
+      items: z7.array(ShippedItemSchema),
+      lastUpdated: z7.string()
     });
   }
 });
@@ -3783,15 +3870,15 @@ var init_analysis = __esm({
 });
 
 // core/schemas/outcomes.ts
-import { z as z7 } from "zod";
+import { z as z8 } 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 = z7.number().min(1).max(5);
-    SuccessLevelSchema = z7.enum(["exceeded", "met", "partial", "failed"]);
-    WorthAssessmentSchema = z7.enum(["definitely", "probably", "maybe", "no"]);
-    VarianceReasonSchema = z7.enum([
+    QualityScoreSchema = z8.number().min(1).max(5);
+    SuccessLevelSchema = z8.enum(["exceeded", "met", "partial", "failed"]);
+    WorthAssessmentSchema = z8.enum(["definitely", "probably", "maybe", "no"]);
+    VarianceReasonSchema = z8.enum([
       "scope_creep",
       "underestimated_complexity",
       "technical_debt",
@@ -3802,54 +3889,54 @@ var init_outcomes = __esm({
       "team_changes",
       "other"
     ]);
-    EffortComparisonSchema = z7.object({
-      estimated: z7.object({
-        hours: z7.number(),
-        confidence: z7.enum(["low", "medium", "high"]).optional(),
-        source: z7.enum(["prd", "manual", "historical"]).optional()
+    EffortComparisonSchema = z8.object({
+      estimated: z8.object({
+        hours: z8.number(),
+        confidence: z8.enum(["low", "medium", "high"]).optional(),
+        source: z8.enum(["prd", "manual", "historical"]).optional()
       }),
-      actual: z7.object({
-        hours: z7.number(),
-        commits: z7.number().optional(),
-        linesAdded: z7.number().optional(),
-        linesRemoved: z7.number().optional(),
-        sessions: z7.number().optional()
+      actual: z8.object({
+        hours: z8.number(),
+        commits: z8.number().optional(),
+        linesAdded: z8.number().optional(),
+        linesRemoved: z8.number().optional(),
+        sessions: z8.number().optional()
         // Number of work sessions
       }),
-      variance: z7.object({
-        hours: z7.number(),
+      variance: z8.object({
+        hours: z8.number(),
         // actual - estimated
-        percentage: z7.number(),
+        percentage: z8.number(),
         // ((actual - estimated) / estimated) * 100
         reason: VarianceReasonSchema.optional(),
-        explanation: z7.string().optional()
+        explanation: z8.string().optional()
       })
     });
-    MetricResultSchema = z7.object({
-      name: z7.string(),
-      baseline: z7.number().nullable(),
-      target: z7.number(),
-      actual: z7.number(),
-      unit: z7.string(),
-      achieved: z7.boolean(),
+    MetricResultSchema = z8.object({
+      name: z8.string(),
+      baseline: z8.number().nullable(),
+      target: z8.number(),
+      actual: z8.number(),
+      unit: z8.string(),
+      achieved: z8.boolean(),
       // actual >= target (or <= for decrease metrics)
-      percentOfTarget: z7.number()
+      percentOfTarget: z8.number()
       // (actual / target) * 100
     });
-    AcceptanceCriteriaResultSchema = z7.object({
-      criteria: z7.string(),
-      met: z7.boolean(),
-      notes: z7.string().optional()
+    AcceptanceCriteriaResultSchema = z8.object({
+      criteria: z8.string(),
+      met: z8.boolean(),
+      notes: z8.string().optional()
     });
-    SuccessTrackingSchema = z7.object({
-      metrics: z7.array(MetricResultSchema),
-      acceptanceCriteria: z7.array(AcceptanceCriteriaResultSchema),
+    SuccessTrackingSchema = z8.object({
+      metrics: z8.array(MetricResultSchema),
+      acceptanceCriteria: z8.array(AcceptanceCriteriaResultSchema),
       overallSuccess: SuccessLevelSchema,
-      successScore: z7.number().min(0).max(100)
+      successScore: z8.number().min(0).max(100)
       // Percentage of metrics/criteria met
     });
-    LearningSchema = z7.object({
-      category: z7.enum([
+    LearningSchema = z8.object({
+      category: z8.enum([
         "estimation",
         "technical",
         "process",
@@ -3859,62 +3946,62 @@ var init_outcomes = __esm({
         "testing",
         "other"
       ]),
-      insight: z7.string(),
-      actionable: z7.boolean(),
-      action: z7.string().optional()
+      insight: z8.string(),
+      actionable: z8.boolean(),
+      action: z8.string().optional()
       // What to do differently next time
     });
-    LearningsSchema = z7.object({
-      whatWorked: z7.array(z7.string()),
-      whatDidnt: z7.array(z7.string()),
-      surprises: z7.array(z7.string()),
-      recommendations: z7.array(LearningSchema)
+    LearningsSchema = z8.object({
+      whatWorked: z8.array(z8.string()),
+      whatDidnt: z8.array(z8.string()),
+      surprises: z8.array(z8.string()),
+      recommendations: z8.array(LearningSchema)
     });
-    ROIAssessmentSchema = z7.object({
-      valueDelivered: z7.number().min(1).max(10),
+    ROIAssessmentSchema = z8.object({
+      valueDelivered: z8.number().min(1).max(10),
       // Subjective 1-10 score
-      userImpact: z7.enum(["none", "low", "medium", "high", "critical"]),
-      businessImpact: z7.enum(["none", "low", "medium", "high", "critical"]),
+      userImpact: z8.enum(["none", "low", "medium", "high", "critical"]),
+      businessImpact: z8.enum(["none", "low", "medium", "high", "critical"]),
       // Calculated: (valueDelivered * 10) / (actual hours)
-      roiScore: z7.number(),
+      roiScore: z8.number(),
       // Would you build this again knowing what you know now?
       worthIt: WorthAssessmentSchema,
-      worthItReason: z7.string().optional(),
+      worthItReason: z8.string().optional(),
       // Comparison to alternatives
-      alternativeConsidered: z7.string().optional(),
-      betterAlternativeExists: z7.boolean().optional()
+      alternativeConsidered: z8.string().optional(),
+      betterAlternativeExists: z8.boolean().optional()
     });
-    TaskOutcomeSchema = z7.object({
-      id: z7.string(),
+    TaskOutcomeSchema = z8.object({
+      id: z8.string(),
       // out_task_xxxxxxxx
-      taskId: z7.string(),
-      description: z7.string(),
+      taskId: z8.string(),
+      description: z8.string(),
       // Time tracking
-      estimatedMinutes: z7.number().optional(),
-      actualMinutes: z7.number(),
+      estimatedMinutes: z8.number().optional(),
+      actualMinutes: z8.number(),
       // Quality
-      completedAsPlanned: z7.boolean(),
+      completedAsPlanned: z8.boolean(),
       qualityScore: QualityScoreSchema,
       // Context
-      blockers: z7.array(z7.string()),
-      agentUsed: z7.string().optional(),
-      skillsUsed: z7.array(z7.string()).optional(),
+      blockers: z8.array(z8.string()),
+      agentUsed: z8.string().optional(),
+      skillsUsed: z8.array(z8.string()).optional(),
       // Timestamps
-      startedAt: z7.string(),
-      completedAt: z7.string()
+      startedAt: z8.string(),
+      completedAt: z8.string()
     });
-    FeatureOutcomeSchema = z7.object({
-      id: z7.string(),
+    FeatureOutcomeSchema = z8.object({
+      id: z8.string(),
       // out_feat_xxxxxxxx
       // Links
-      featureId: z7.string(),
-      featureName: z7.string(),
-      prdId: z7.string().nullable(),
+      featureId: z8.string(),
+      featureName: z8.string(),
+      prdId: z8.string().nullable(),
       // null for legacy features
       // Version info
-      version: z7.string().optional(),
-      branch: z7.string().optional(),
-      prUrl: z7.string().optional(),
+      version: z8.string().optional(),
+      branch: z8.string().optional(),
+      prUrl: z8.string().optional(),
       // Effort
       effort: EffortComparisonSchema,
       // Success (only if PRD exists)
@@ -3926,57 +4013,57 @@ var init_outcomes = __esm({
       // Overall rating
       rating: QualityScoreSchema,
       // Task outcomes (sub-tasks)
-      taskOutcomes: z7.array(TaskOutcomeSchema).optional(),
+      taskOutcomes: z8.array(TaskOutcomeSchema).optional(),
       // Timestamps
-      startedAt: z7.string(),
-      shippedAt: z7.string(),
-      reviewedAt: z7.string().optional(),
+      startedAt: z8.string(),
+      shippedAt: z8.string(),
+      reviewedAt: z8.string().optional(),
       // When impact was captured
       // Metadata
-      reviewedBy: z7.string().optional(),
+      reviewedBy: z8.string().optional(),
       // Who filled out the impact review
-      legacy: z7.boolean().optional()
+      legacy: z8.boolean().optional()
       // Legacy feature (no PRD)
     });
-    AggregateMetricsSchema = z7.object({
-      totalFeatures: z7.number(),
-      averageEstimationAccuracy: z7.number(),
+    AggregateMetricsSchema = z8.object({
+      totalFeatures: z8.number(),
+      averageEstimationAccuracy: z8.number(),
       // Percentage
-      averageSuccessRate: z7.number(),
+      averageSuccessRate: z8.number(),
       // Percentage
-      averageROI: z7.number(),
+      averageROI: z8.number(),
       // By category
-      bySuccessLevel: z7.object({
-        exceeded: z7.number(),
-        met: z7.number(),
-        partial: z7.number(),
-        failed: z7.number()
+      bySuccessLevel: z8.object({
+        exceeded: z8.number(),
+        met: z8.number(),
+        partial: z8.number(),
+        failed: z8.number()
       }),
       // Variance patterns
-      variancePatterns: z7.array(z7.object({
+      variancePatterns: z8.array(z8.object({
         reason: VarianceReasonSchema,
-        count: z7.number(),
-        averageVariance: z7.number()
+        count: z8.number(),
+        averageVariance: z8.number()
       })),
       // Top learnings (aggregated)
-      topLearnings: z7.array(z7.object({
-        insight: z7.string(),
-        frequency: z7.number()
+      topLearnings: z8.array(z8.object({
+        insight: z8.string(),
+        frequency: z8.number()
       }))
     });
-    OutcomesJsonSchema = z7.object({
-      outcomes: z7.array(FeatureOutcomeSchema),
-      taskOutcomes: z7.array(TaskOutcomeSchema).optional(),
+    OutcomesJsonSchema = z8.object({
+      outcomes: z8.array(FeatureOutcomeSchema),
+      taskOutcomes: z8.array(TaskOutcomeSchema).optional(),
       // Standalone task outcomes
       aggregates: AggregateMetricsSchema.optional(),
-      lastUpdated: z7.string(),
-      lastAggregated: z7.string().optional()
+      lastUpdated: z8.string(),
+      lastAggregated: z8.string().optional()
     });
   }
 });
 
 // core/schemas/permissions.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function buildDefaultPermissions() {
   const bash = {};
   for (const pattern of DEFAULT_BASH_ALLOW) {
@@ -4009,20 +4096,20 @@ var PermissionLevelSchema, FileOperationSchema, BashPermissionSchema, FilePermis
 var init_permissions = __esm({
   "core/schemas/permissions.ts"() {
     "use strict";
-    PermissionLevelSchema = z8.enum(["allow", "deny", "ask"]);
-    FileOperationSchema = z8.enum(["read", "write", "delete", "create"]);
-    BashPermissionSchema = z8.record(z8.string(), PermissionLevelSchema);
-    FilePermissionSchema = z8.record(z8.string(), PermissionLevelSchema);
-    WebPermissionSchema = z8.object({
-      enabled: z8.boolean().default(true),
-      allowedDomains: z8.array(z8.string()).optional(),
-      blockedDomains: z8.array(z8.string()).optional()
+    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()
     });
-    PermissionsConfigSchema = z8.object({
+    PermissionsConfigSchema = z9.object({
       /** Bash command permissions - glob patterns */
       bash: BashPermissionSchema.optional(),
       /** File operation permissions - glob patterns */
-      files: z8.object({
+      files: z9.object({
         read: FilePermissionSchema.optional(),
         write: FilePermissionSchema.optional(),
         delete: FilePermissionSchema.optional()
@@ -4030,11 +4117,11 @@ var init_permissions = __esm({
       /** Web fetch permissions */
       web: WebPermissionSchema.optional(),
       /** Skill invocation permissions */
-      skills: z8.record(z8.string(), PermissionLevelSchema).optional(),
+      skills: z9.record(z9.string(), PermissionLevelSchema).optional(),
       /** Doom loop protection - prevent infinite retries */
-      doomLoop: z8.object({
-        enabled: z8.boolean().default(true),
-        maxRetries: z8.number().default(3)
+      doomLoop: z9.object({
+        enabled: z9.boolean().default(true),
+        maxRetries: z9.number().default(3)
       }).optional(),
       /** External directory access */
       externalDirectories: PermissionLevelSchema.default("ask")
@@ -4093,12 +4180,16 @@ import { homedir } from "os";
 function generateUUID() {
   return crypto3.randomUUID();
 }
+function getProjectPath2(projectId) {
+  return join(GLOBAL_STORAGE, projectId);
+}
 var GLOBAL_STORAGE;
 var init_schemas = __esm({
   "core/schemas/schemas.ts"() {
     "use strict";
     __name(generateUUID, "generateUUID");
     GLOBAL_STORAGE = join(homedir(), ".prjct-cli", "projects");
+    __name(getProjectPath2, "getProjectPath");
   }
 });
 
@@ -4107,6 +4198,7 @@ var init_schemas2 = __esm({
   "core/schemas/index.ts"() {
     "use strict";
     init_state();
+    init_issues();
     init_project();
     init_agents();
     init_ideas();
@@ -10004,6 +10096,120 @@ var init_orchestrator_executor = __esm({
   }
 });
 
+// core/utils/agent-stream.ts
+import chalk from "chalk";
+function getIcon(domain) {
+  return DOMAIN_ICONS[domain.toLowerCase()] || DOMAIN_ICONS.default;
+}
+var DOMAIN_ICONS, AgentStream, agentStream;
+var init_agent_stream = __esm({
+  "core/utils/agent-stream.ts"() {
+    "use strict";
+    DOMAIN_ICONS = {
+      database: "\u{1F4BE}",
+      backend: "\u{1F527}",
+      frontend: "\u{1F4E6}",
+      testing: "\u{1F9EA}",
+      devops: "\u{1F680}",
+      uxui: "\u{1F3A8}",
+      security: "\u{1F512}",
+      docs: "\u{1F4DD}",
+      api: "\u{1F310}",
+      default: "\u26A1"
+    };
+    __name(getIcon, "getIcon");
+    AgentStream = class {
+      static {
+        __name(this, "AgentStream");
+      }
+      currentAgent = null;
+      startTime = 0;
+      quiet = false;
+      /**
+       * Set quiet mode (no output)
+       */
+      setQuiet(quiet) {
+        this.quiet = quiet;
+      }
+      /**
+       * Show orchestration start
+       */
+      orchestrate(domains) {
+        if (this.quiet) return;
+        console.log(chalk.cyan(`
+\u{1F3AF} Orchestrating: ${domains.join(", ")} domains detected
+`));
+      }
+      /**
+       * Start an agent activity block
+       */
+      startAgent(name, domain, description) {
+        if (this.quiet) return;
+        this.currentAgent = name;
+        this.startTime = Date.now();
+        const icon = getIcon(domain);
+        console.log(chalk.cyan(`\u250C\u2500 ${icon} ${name} (${domain})`));
+        if (description) {
+          console.log(chalk.dim(`\u2502  ${description}`));
+        }
+      }
+      /**
+       * Show progress within current agent
+       */
+      progress(message) {
+        if (this.quiet || !this.currentAgent) return;
+        console.log(chalk.dim(`\u2502  \u2514\u2500\u2500 ${message}`));
+      }
+      /**
+       * Show multiple progress items
+       */
+      progressList(items) {
+        if (this.quiet || !this.currentAgent) return;
+        for (const item of items) {
+          console.log(chalk.dim(`\u2502  \u2514\u2500\u2500 ${item}`));
+        }
+      }
+      /**
+       * End current agent block
+       */
+      endAgent(success = true) {
+        if (this.quiet || !this.currentAgent) return;
+        const duration = Date.now() - this.startTime;
+        const durationStr = this.formatDuration(duration);
+        const icon = success ? chalk.green("\u2713") : chalk.red("\u2717");
+        const status = success ? "Complete" : "Failed";
+        console.log(`\u2514\u2500 ${icon} ${status} ${chalk.dim(`(${durationStr})`)}
+`);
+        this.currentAgent = null;
+      }
+      /**
+       * Show a simple status line (no block)
+       */
+      status(icon, message) {
+        if (this.quiet) return;
+        console.log(`${icon} ${message}`);
+      }
+      /**
+       * Show task completion summary
+       */
+      complete(taskName, totalDuration) {
+        if (this.quiet) return;
+        const durationStr = totalDuration ? ` ${chalk.dim(`[${this.formatDuration(totalDuration)}]`)}` : "";
+        console.log(chalk.green(`\u2705 ${taskName}${durationStr}`));
+      }
+      /**
+       * Format duration in human-readable form
+       */
+      formatDuration(ms) {
+        if (ms < 1e3) return `${ms}ms`;
+        const seconds = (ms / 1e3).toFixed(1);
+        return `${seconds}s`;
+      }
+    };
+    agentStream = new AgentStream();
+  }
+});
+
 // core/agentic/command-executor.ts
 import fs23 from "fs";
 import path22 from "path";
@@ -10041,6 +10247,7 @@ var init_command_executor = __esm({
     init_plan_mode();
     init_template_executor();
     init_orchestrator_executor();
+    init_agent_stream();
     RUNNING_FILE = path22.join(os10.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
@@ -10129,11 +10336,16 @@ var init_command_executor = __esm({
                 taskDescription,
                 projectPath
               );
-              console.log(`\u{1F3AF} Orchestrator:`);
-              console.log(`   \u2192 Domains: ${orchestratorContext.detectedDomains.join(", ")}`);
-              console.log(`   \u2192 Agents: ${orchestratorContext.agents.map((a) => a.name).join(", ") || "none loaded"}`);
+              if (orchestratorContext.detectedDomains.length > 0) {
+                agentStream.orchestrate(orchestratorContext.detectedDomains);
+              }
+              for (const agent of orchestratorContext.agents) {
+                const domain = agent.domain || agent.name.replace(".md", "");
+                agentStream.startAgent(agent.name, domain, `Loading ${domain} specialist...`);
+                agentStream.endAgent(true);
+              }
               if (orchestratorContext.requiresFragmentation && orchestratorContext.subtasks) {
-                console.log(`   \u2192 Subtasks: ${orchestratorContext.subtasks.length}`);
+                agentStream.status("\u{1F4CB}", `${orchestratorContext.subtasks.length} subtasks planned`);
               }
             } catch (error) {
               console.warn(`\u26A0\uFE0F  Orchestrator warning: ${error.message}`);
@@ -10321,7 +10533,7 @@ import https from "https";
 import fs24 from "fs";
 import path23 from "path";
 import os11 from "os";
-import chalk from "chalk";
+import chalk2 from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
   "core/infrastructure/update-checker.ts"() {
@@ -10484,7 +10696,7 @@ var init_update_checker = __esm({
         if (!result || !result.updateAvailable) {
           return null;
         }
-        return "\n" + chalk.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510") + "\n" + chalk.yellow("\u2502") + "  " + chalk.bold("Update available!") + " " + chalk.dim(`${result.currentVersion} \u2192 ${result.latestVersion}`) + "  " + chalk.yellow("\u2502") + "\n" + chalk.yellow("\u2502") + "                                                           " + chalk.yellow("\u2502") + "\n" + chalk.yellow("\u2502") + "  Run: " + chalk.cyan("npm update -g prjct-cli") + "                       " + chalk.yellow("\u2502") + "\n" + chalk.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518") + "\n";
+        return "\n" + chalk2.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510") + "\n" + chalk2.yellow("\u2502") + "  " + chalk2.bold("Update available!") + " " + chalk2.dim(`${result.currentVersion} \u2192 ${result.latestVersion}`) + "  " + chalk2.yellow("\u2502") + "\n" + chalk2.yellow("\u2502") + "                                                           " + chalk2.yellow("\u2502") + "\n" + chalk2.yellow("\u2502") + "  Run: " + chalk2.cyan("npm update -g prjct-cli") + "                       " + chalk2.yellow("\u2502") + "\n" + chalk2.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518") + "\n";
       }
     };
     update_checker_default = UpdateChecker;
@@ -10492,7 +10704,7 @@ var init_update_checker = __esm({
 });
 
 // core/utils/branding.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var SPINNER_FRAMES, SPINNER_SPEED, branding, branding_default;
 var init_branding = __esm({
   "core/utils/branding.ts"() {
@@ -10512,9 +10724,9 @@ var init_branding = __esm({
       },
       // CLI output (with chalk colors)
       cli: {
-        header: /* @__PURE__ */ __name(() => chalk2.cyan.bold("\u26A1") + " " + chalk2.cyan("prjct"), "header"),
-        footer: /* @__PURE__ */ __name(() => chalk2.dim("\u26A1 prjct"), "footer"),
-        spin: /* @__PURE__ */ __name((frame2, msg) => chalk2.cyan("\u26A1") + " " + chalk2.cyan("prjct") + " " + chalk2.cyan(SPINNER_FRAMES[frame2 % 10]) + " " + chalk2.dim(msg || ""), "spin")
+        header: /* @__PURE__ */ __name(() => chalk3.cyan.bold("\u26A1") + " " + chalk3.cyan("prjct"), "header"),
+        footer: /* @__PURE__ */ __name(() => chalk3.dim("\u26A1 prjct"), "footer"),
+        spin: /* @__PURE__ */ __name((frame2, msg) => chalk3.cyan("\u26A1") + " " + chalk3.cyan("prjct") + " " + chalk3.cyan(SPINNER_FRAMES[frame2 % 10]) + " " + chalk3.dim(msg || ""), "spin")
       },
       // Template (plain text)
       template: {
@@ -10543,7 +10755,7 @@ Designed for [Claude](https://www.anthropic.com/claude)`,
 });
 
 // core/utils/output.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var FRAMES, SPEED, interval, frame, truncate, clear, out, output_default;
 var init_output = __esm({
   "core/utils/output.ts"() {
@@ -10576,17 +10788,17 @@ var init_output = __esm({
       },
       done(msg) {
         this.stop();
-        console.log(`${chalk3.green("\u2713")} ${truncate(msg, 65)}`);
+        console.log(`${chalk4.green("\u2713")} ${truncate(msg, 65)}`);
         return this;
       },
       fail(msg) {
         this.stop();
-        console.log(`${chalk3.red("\u2717")} ${truncate(msg, 65)}`);
+        console.log(`${chalk4.red("\u2717")} ${truncate(msg, 65)}`);
         return this;
       },
       warn(msg) {
         this.stop();
-        console.log(`${chalk3.yellow("\u26A0")} ${truncate(msg, 65)}`);
+        console.log(`${chalk4.yellow("\u26A0")} ${truncate(msg, 65)}`);
         return this;
       },
       stop() {
@@ -10596,6 +10808,28 @@ var init_output = __esm({
           clear();
         }
         return this;
+      },
+      // Step counter: [3/7] Running tests...
+      step(current, total, msg) {
+        this.stop();
+        const counter = chalk4.dim(`[${current}/${total}]`);
+        interval = setInterval(() => {
+          process.stdout.write(`\r${branding_default.cli.spin(frame++, `${counter} ${truncate(msg, 35)}`)}`);
+        }, SPEED);
+        return this;
+      },
+      // Progress bar: [████░░░░] 50% Analyzing...
+      progress(current, total, msg) {
+        this.stop();
+        const percent = Math.round(current / total * 100);
+        const filled = Math.round(percent / 10);
+        const empty = 10 - filled;
+        const bar = chalk4.cyan("\u2588".repeat(filled)) + chalk4.dim("\u2591".repeat(empty));
+        const text = msg ? ` ${truncate(msg, 25)}` : "";
+        interval = setInterval(() => {
+          process.stdout.write(`\r${branding_default.cli.spin(frame++, `[${bar}] ${percent}%${text}`)}`);
+        }, SPEED);
+        return this;
       }
     };
     output_default = out;
@@ -10980,6 +11214,206 @@ var init_agent_service = __esm({
   }
 });
 
+// core/workflow/state-machine.ts
+var WORKFLOW_STATES, WorkflowStateMachine, workflowStateMachine;
+var init_state_machine = __esm({
+  "core/workflow/state-machine.ts"() {
+    "use strict";
+    WORKFLOW_STATES = {
+      idle: {
+        transitions: ["task", "next"],
+        prompt: "p. task <description>  Start working",
+        description: "No active task"
+      },
+      working: {
+        transitions: ["done", "pause"],
+        prompt: "p. done  Complete task  |  p. pause  Switch context",
+        description: "Task in progress"
+      },
+      paused: {
+        transitions: ["resume", "task"],
+        prompt: "p. resume  Continue  |  p. task <new>  Start different",
+        description: "Task paused"
+      },
+      completed: {
+        transitions: ["ship", "task", "next"],
+        prompt: "p. ship  Ship it  |  p. task <next>  Start next",
+        description: "Task completed"
+      },
+      shipped: {
+        transitions: ["task", "next"],
+        prompt: "p. task <description>  Start new task",
+        description: "Feature shipped"
+      }
+    };
+    WorkflowStateMachine = class {
+      static {
+        __name(this, "WorkflowStateMachine");
+      }
+      /**
+       * Get current state from storage state
+       */
+      getCurrentState(storageState) {
+        const task = storageState?.currentTask;
+        if (!task) {
+          return "idle";
+        }
+        const status = task.status?.toLowerCase();
+        switch (status) {
+          case "in_progress":
+          case "working":
+            return "working";
+          case "paused":
+            return "paused";
+          case "completed":
+          case "done":
+            return "completed";
+          case "shipped":
+            return "shipped";
+          default:
+            return task ? "working" : "idle";
+        }
+      }
+      /**
+       * Check if a command is valid for the current state
+       */
+      canTransition(currentState, command) {
+        const stateConfig = WORKFLOW_STATES[currentState];
+        if (stateConfig.transitions.includes(command)) {
+          return { valid: true };
+        }
+        const validCommands = stateConfig.transitions.map((c) => `p. ${c}`).join(", ");
+        return {
+          valid: false,
+          error: `Cannot run 'p. ${command}' in ${currentState} state`,
+          suggestion: `Valid commands: ${validCommands}`
+        };
+      }
+      /**
+       * Get the next state after a command
+       */
+      getNextState(currentState, command) {
+        switch (command) {
+          case "task":
+            return "working";
+          case "done":
+            return "completed";
+          case "pause":
+            return "paused";
+          case "resume":
+            return "working";
+          case "ship":
+            return "shipped";
+          case "next":
+            return currentState;
+          // next doesn't change state
+          default:
+            return currentState;
+        }
+      }
+      /**
+       * Get state definition
+       */
+      getStateInfo(state) {
+        return WORKFLOW_STATES[state];
+      }
+      /**
+       * Get prompt for current state
+       */
+      getPrompt(state) {
+        return WORKFLOW_STATES[state].prompt;
+      }
+      /**
+       * Get valid commands for current state
+       */
+      getValidCommands(state) {
+        return WORKFLOW_STATES[state].transitions;
+      }
+      /**
+       * Format next steps for display
+       */
+      formatNextSteps(state) {
+        const stateConfig = WORKFLOW_STATES[state];
+        return stateConfig.transitions.map((cmd) => {
+          switch (cmd) {
+            case "task":
+              return "p. task <desc>  Start new task";
+            case "done":
+              return "p. done         Complete current task";
+            case "pause":
+              return "p. pause        Pause and switch context";
+            case "resume":
+              return "p. resume       Continue paused task";
+            case "ship":
+              return "p. ship         Ship the feature";
+            case "next":
+              return "p. next         View task queue";
+            default:
+              return `p. ${cmd}`;
+          }
+        });
+      }
+    };
+    workflowStateMachine = new WorkflowStateMachine();
+  }
+});
+
+// core/utils/next-steps.ts
+import chalk5 from "chalk";
+function showNextSteps(command, options = {}) {
+  if (options.quiet) return;
+  const resultingState = COMMAND_TO_STATE[command] || "idle";
+  const validCommands = workflowStateMachine.getValidCommands(resultingState);
+  if (validCommands.length === 0) return;
+  const steps = validCommands.map((cmd) => ({
+    cmd: `p. ${cmd}`,
+    desc: CMD_DESCRIPTIONS[cmd] || cmd
+  }));
+  console.log(chalk5.dim("\nNext:"));
+  for (const step of steps) {
+    const cmd = chalk5.cyan(step.cmd.padEnd(12));
+    console.log(chalk5.dim(`  ${cmd} \u2192 ${step.desc}`));
+  }
+}
+function showStateInfo(state) {
+  const info = workflowStateMachine.getStateInfo(state);
+  console.log(chalk5.dim(`\u{1F4CD} State: ${chalk5.white(state.toUpperCase())} - ${info.description}`));
+}
+var CMD_DESCRIPTIONS, COMMAND_TO_STATE;
+var init_next_steps = __esm({
+  "core/utils/next-steps.ts"() {
+    "use strict";
+    init_state_machine();
+    CMD_DESCRIPTIONS = {
+      task: "Start new task",
+      done: "Complete current task",
+      pause: "Pause and switch context",
+      resume: "Continue paused task",
+      ship: "Ship the feature",
+      next: "View task queue",
+      sync: "Analyze project",
+      bug: "Report a bug",
+      idea: "Capture an idea"
+    };
+    COMMAND_TO_STATE = {
+      task: "working",
+      done: "completed",
+      "done-subtask": "working",
+      // Still working on subtasks
+      pause: "paused",
+      resume: "working",
+      ship: "shipped",
+      next: "idle",
+      sync: "idle",
+      init: "idle",
+      bug: "working",
+      idea: "idle"
+    };
+    __name(showNextSteps, "showNextSteps");
+    __name(showStateInfo, "showStateInfo");
+  }
+});
+
 // core/domain/analyzer.ts
 import fs27 from "fs/promises";
 import path26 from "path";
@@ -11536,6 +11970,7 @@ var init_analysis2 = __esm({
     init_generator();
     init_command_installer();
     init_services();
+    init_next_steps();
     AnalysisCommands = class extends PrjctCommandsBase {
       static {
         __name(this, "AnalysisCommands");
@@ -11694,12 +12129,13 @@ var init_analysis2 = __esm({
        *
        * This eliminates the need for Claude to make 50+ individual tool calls.
        */
-      async sync(projectPath = process.cwd()) {
+      async sync(projectPath = process.cwd(), options = {}) {
         try {
           const initResult = await this.ensureProjectInit(projectPath);
           if (!initResult.success) return initResult;
+          const startTime = Date.now();
           console.log("\u{1F504} Syncing project...\n");
-          const result = await syncService.sync(projectPath);
+          const result = await syncService.sync(projectPath, { aiTools: options.aiTools });
           if (!result.success) {
             console.error("\u274C Sync failed:", result.error);
             return { success: false, error: result.error };
@@ -11726,6 +12162,15 @@ var init_analysis2 = __esm({
             console.log(`\u251C\u2500\u2500 ${file}`);
           }
           console.log("");
+          if (result.aiTools && result.aiTools.length > 0) {
+            const successTools = result.aiTools.filter((t) => t.success);
+            console.log(`\u{1F916} AI Tools Context (${successTools.length})`);
+            for (const tool of result.aiTools) {
+              const status = tool.success ? "\u2713" : "\u2717";
+              console.log(`\u251C\u2500\u2500 ${status} ${tool.outputFile} (${tool.toolId})`);
+            }
+            console.log("");
+          }
           const workflowAgents = result.agents.filter((a) => a.type === "workflow").map((a) => a.name);
           const domainAgents = result.agents.filter((a) => a.type === "domain").map((a) => a.name);
           console.log(`\u{1F916} Agents Regenerated (${result.agents.length})`);
@@ -11744,9 +12189,26 @@ var init_analysis2 = __esm({
           } else {
             console.log("\u2728 Repository is clean!\n");
           }
+          showNextSteps("sync");
+          const elapsed = Date.now() - startTime;
+          const contextFilesCount = result.contextFiles.length + (result.aiTools?.filter((t) => t.success).length || 0);
+          const agentCount = result.agents.length;
+          console.log("\u2500".repeat(45));
+          console.log(`\u{1F4CA} Sync Summary`);
+          console.log(`   Stack: ${result.stats.ecosystem} (${result.stats.frameworks.join(", ") || "no frameworks"})`);
+          console.log(`   Files: ${result.stats.fileCount} analyzed \u2192 ${contextFilesCount} context files`);
+          console.log(`   Agents: ${agentCount} (${result.agents.filter((a) => a.type === "domain").length} domain)`);
+          console.log(`   Time: ${(elapsed / 1e3).toFixed(1)}s`);
+          console.log("");
           return {
             success: true,
-            data: result
+            data: result,
+            metrics: {
+              elapsed,
+              contextFilesCount,
+              agentCount,
+              fileCount: result.stats.fileCount
+            }
           };
         } catch (error) {
           console.error("\u274C Error:", error.message);
@@ -11779,6 +12241,7 @@ var init_planning = __esm({
     init_storage2();
     init_author_detector();
     init_command_installer();
+    init_next_steps();
     _analysisCommands = null;
     __name(getAnalysisCommands, "getAnalysisCommands");
     PlanningCommands = class extends PrjctCommandsBase {
@@ -11796,7 +12259,7 @@ var init_planning = __esm({
             output_default.warn("already initialized");
             return { success: false, message: "Already initialized" };
           }
-          output_default.spin("initializing...");
+          output_default.step(1, 4, "Detecting author...");
           const detectedAuthor = await author_detector_default.detect();
           const author = {
             name: detectedAuthor.name || void 0,
@@ -11805,7 +12268,7 @@ var init_planning = __esm({
           };
           const config = await config_manager_default.createConfig(projectPath, author);
           const projectId = config.projectId;
-          output_default.spin("creating structure...");
+          output_default.step(2, 4, "Creating structure...");
           await path_manager_default.ensureProjectStructure(projectId);
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
           const baseFiles = {
@@ -11832,11 +12295,11 @@ var init_planning = __esm({
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
           if (hasCode || !isEmpty) {
-            output_default.spin("analyzing project...");
+            output_default.step(3, 4, "Analyzing project...");
             const analysis2 = await getAnalysisCommands();
             const analysisResult = await analysis2.analyze({}, projectPath);
             if (analysisResult.success) {
-              output_default.spin("generating agents...");
+              output_default.step(4, 4, "Generating agents...");
               await analysis2.sync(projectPath);
               output_default.done("initialized");
               return { success: true, mode: "existing", projectId };
@@ -11866,6 +12329,7 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           await command_installer_default.installGlobalConfig();
           output_default.done("initialized");
+          showNextSteps("init");
           return { success: true, projectId };
         } catch (error) {
           output_default.fail(error.message);
@@ -11969,6 +12433,7 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             timestamp: date_helper_default.getTimestamp()
           });
           output_default.done(`bug [${severity}] \u2192 ${agent}`);
+          showNextSteps("bug");
           return { success: true, bug: description, severity, agent };
         } catch (error) {
           output_default.fail(error.message);
@@ -12097,6 +12562,7 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
               timestamp: date_helper_default.getTimestamp()
             });
             output_default.done(`idea captured: ${description.slice(0, 40)}`);
+            showNextSteps("idea");
             return { success: true, mode: "capture", idea: description };
           }
         } catch (error) {
@@ -12121,8 +12587,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path29.join(globalPath2, "planning", "specs");
             try {
-              const fs34 = await import("fs/promises");
-              const files = await fs34.readdir(specsPath2);
+              const fs37 = await import("fs/promises");
+              const files = await fs37.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -12507,52 +12973,466 @@ var init_breakdown_service = __esm({
   }
 });
 
-// core/services/sync-service.ts
-import fs29 from "fs/promises";
+// core/ai-tools/registry.ts
+import { execSync as execSync4 } from "child_process";
+import fs29 from "fs";
 import path30 from "path";
-import { exec as exec5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var execAsync3, SyncService, syncService;
-var init_sync_service = __esm({
-  "core/services/sync-service.ts"() {
+import os12 from "os";
+function getAIToolConfig(id) {
+  return AI_TOOLS[id] || null;
+}
+function commandExists(cmd) {
+  try {
+    execSync4(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectInstalledTools(repoPath = process.cwd()) {
+  const detected = [];
+  if (commandExists("claude")) {
+    detected.push("claude");
+  }
+  if (commandExists("cursor") || fs29.existsSync(path30.join(repoPath, ".cursor"))) {
+    detected.push("cursor");
+  }
+  if (fs29.existsSync(path30.join(repoPath, ".github"))) {
+    detected.push("copilot");
+  }
+  if (commandExists("windsurf") || fs29.existsSync(path30.join(repoPath, ".windsurf"))) {
+    detected.push("windsurf");
+  }
+  if (fs29.existsSync(path30.join(repoPath, ".continue")) || fs29.existsSync(path30.join(os12.homedir(), ".continue"))) {
+    detected.push("continue");
+  }
+  return detected;
+}
+function resolveToolIds(mode, repoPath = process.cwd()) {
+  if (mode === "auto") {
+    const detected = detectInstalledTools(repoPath);
+    return detected.length > 0 ? detected : ["claude"];
+  }
+  if (mode === "all") {
+    return SUPPORTED_AI_TOOLS;
+  }
+  return mode.filter((id) => AI_TOOLS[id]);
+}
+var AI_TOOLS, DEFAULT_AI_TOOLS, SUPPORTED_AI_TOOLS;
+var init_registry = __esm({
+  "core/ai-tools/registry.ts"() {
     "use strict";
-    init_path_manager();
-    init_config_manager();
-    init_date_helper();
-    execAsync3 = promisify5(exec5);
-    SyncService = class {
-      static {
-        __name(this, "SyncService");
-      }
-      projectPath;
-      projectId = null;
-      globalPath = "";
-      cliVersion = "0.0.0";
-      constructor() {
-        this.projectPath = process.cwd();
+    AI_TOOLS = {
+      claude: {
+        id: "claude",
+        name: "Claude Code",
+        outputFile: "CLAUDE.md",
+        outputPath: "global",
+        maxTokens: 3e3,
+        format: "detailed",
+        description: "Anthropic Claude Code CLI"
+      },
+      cursor: {
+        id: "cursor",
+        name: "Cursor",
+        outputFile: ".cursorrules",
+        outputPath: "repo",
+        maxTokens: 2e3,
+        format: "concise",
+        description: "Cursor AI Editor"
+      },
+      copilot: {
+        id: "copilot",
+        name: "GitHub Copilot",
+        outputFile: ".github/copilot-instructions.md",
+        outputPath: "repo",
+        maxTokens: 1500,
+        format: "minimal",
+        description: "GitHub Copilot"
+      },
+      windsurf: {
+        id: "windsurf",
+        name: "Windsurf",
+        outputFile: ".windsurfrules",
+        outputPath: "repo",
+        maxTokens: 2e3,
+        format: "concise",
+        description: "Codeium Windsurf Editor"
+      },
+      continue: {
+        id: "continue",
+        name: "Continue.dev",
+        outputFile: ".continue/config.json",
+        outputPath: "repo",
+        maxTokens: 1500,
+        format: "json",
+        description: "Continue.dev open-source AI assistant"
       }
-      /**
-       * Main sync method - does everything in one call
-       */
-      async sync(projectPath = process.cwd()) {
-        this.projectPath = projectPath;
-        try {
-          this.projectId = await config_manager_default.getProjectId(projectPath);
-          if (!this.projectId) {
-            return {
-              success: false,
-              projectId: "",
-              cliVersion: "",
-              git: this.emptyGitData(),
-              stats: this.emptyStats(),
-              commands: this.emptyCommands(),
-              stack: this.emptyStack(),
-              agents: [],
-              skills: [],
-              contextFiles: [],
-              error: "No prjct project. Run p. init first."
-            };
-          }
+    };
+    DEFAULT_AI_TOOLS = ["claude", "cursor", "copilot", "windsurf"];
+    SUPPORTED_AI_TOOLS = Object.keys(AI_TOOLS);
+    __name(getAIToolConfig, "getAIToolConfig");
+    __name(commandExists, "commandExists");
+    __name(detectInstalledTools, "detectInstalledTools");
+    __name(resolveToolIds, "resolveToolIds");
+  }
+});
+
+// core/ai-tools/formatters.ts
+function formatForClaude(ctx, config) {
+  return `# ${ctx.name} - Project Rules
+<!-- projectId: ${ctx.projectId} -->
+<!-- Generated: ${(/* @__PURE__ */ new Date()).toISOString()} -->
+<!-- Ecosystem: ${ctx.ecosystem} | Type: ${ctx.projectType} -->
+
+## THIS PROJECT (${ctx.ecosystem})
+
+**Type:** ${ctx.projectType}
+**Path:** ${ctx.repoPath}
+
+### Commands (USE THESE, NOT OTHERS)
+
+| Action | Command |
+|--------|---------|
+| Install dependencies | \`${ctx.commands.install}\` |
+| Run dev server | \`${ctx.commands.dev}\` |
+| Run tests | \`${ctx.commands.test}\` |
+| Build | \`${ctx.commands.build}\` |
+| Lint | \`${ctx.commands.lint}\` |
+| Format | \`${ctx.commands.format}\` |
+
+### Code Conventions
+
+- **Languages**: ${ctx.languages.join(", ") || "Not detected"}
+- **Frameworks**: ${ctx.frameworks.join(", ") || "Not detected"}
+
+---
+
+## PRJCT RULES
+
+### Path Resolution
+**ALL prjct writes go to**: \`~/.prjct-cli/projects/${ctx.projectId}/\`
+- NEVER write to \`.prjct/\`
+- NEVER write to \`./\` for prjct data
+
+### Workflow
+\`\`\`
+p. sync \u2192 p. task "desc" \u2192 [work] \u2192 p. done \u2192 p. ship
+\`\`\`
+
+| Command | Action |
+|---------|--------|
+| \`p. sync\` | Re-analyze project |
+| \`p. task X\` | Start task |
+| \`p. done\` | Complete subtask |
+| \`p. ship X\` | Ship feature |
+
+---
+
+## PROJECT STATE
+
+| Field | Value |
+|-------|-------|
+| Name | ${ctx.name} |
+| Version | ${ctx.version} |
+| Ecosystem | ${ctx.ecosystem} |
+| Branch | ${ctx.branch} |
+| Files | ~${ctx.fileCount} |
+| Commits | ${ctx.commits} |
+
+---
+
+## AGENTS
+
+Load from \`~/.prjct-cli/projects/${ctx.projectId}/agents/\`:
+
+**Workflow**: ${ctx.agents.workflow.join(", ")}
+**Domain**: ${ctx.agents.domain.join(", ") || "none"}
+`;
+}
+function formatForCursor(ctx, config) {
+  const rules = [];
+  rules.push(`You are working on ${ctx.name}, a ${ctx.projectType} ${ctx.ecosystem} project.`);
+  rules.push("");
+  rules.push("## Tech Stack");
+  if (ctx.languages.length > 0) {
+    rules.push(`- Languages: ${ctx.languages.join(", ")}`);
+  }
+  if (ctx.frameworks.length > 0) {
+    rules.push(`- Frameworks: ${ctx.frameworks.join(", ")}`);
+  }
+  rules.push("");
+  rules.push("## Commands");
+  rules.push(`- Install: \`${ctx.commands.install}\``);
+  rules.push(`- Dev: \`${ctx.commands.dev}\``);
+  rules.push(`- Test: \`${ctx.commands.test}\``);
+  rules.push(`- Build: \`${ctx.commands.build}\``);
+  rules.push("");
+  rules.push("## Code Style");
+  rules.push(`- Follow ${ctx.ecosystem} conventions`);
+  rules.push("- Match existing code patterns in this project");
+  rules.push("- Use idiomatic constructs for the language");
+  rules.push("");
+  rules.push("## Best Practices");
+  rules.push("- Write clean, readable code");
+  rules.push("- Add comments only for complex logic");
+  rules.push("- Keep functions small and focused");
+  rules.push("- Handle errors appropriately");
+  rules.push("- Write tests for new functionality");
+  return rules.join("\n");
+}
+function formatForCopilot(ctx, config) {
+  const lines = [];
+  lines.push("# Copilot Instructions");
+  lines.push("");
+  lines.push(`This is ${ctx.name}, a ${ctx.ecosystem} project.`);
+  lines.push("");
+  lines.push("## Project Info");
+  lines.push(`- Type: ${ctx.projectType}`);
+  lines.push(`- Stack: ${ctx.frameworks.join(", ") || ctx.ecosystem}`);
+  lines.push("");
+  lines.push("## Conventions");
+  lines.push(`- Follow ${ctx.ecosystem} conventions`);
+  lines.push("- Match existing code patterns");
+  lines.push("- Keep code clean and readable");
+  lines.push("");
+  lines.push("## Commands");
+  lines.push(`- Test: \`${ctx.commands.test}\``);
+  lines.push(`- Build: \`${ctx.commands.build}\``);
+  return lines.join("\n");
+}
+function formatForWindsurf(ctx, config) {
+  const rules = [];
+  rules.push(`# ${ctx.name}`);
+  rules.push("");
+  rules.push(`${ctx.projectType} project using ${ctx.ecosystem}.`);
+  rules.push("");
+  rules.push("## Stack");
+  rules.push(`- ${ctx.languages.join(", ")}`);
+  if (ctx.frameworks.length > 0) {
+    rules.push(`- ${ctx.frameworks.join(", ")}`);
+  }
+  rules.push("");
+  rules.push("## Commands");
+  rules.push(`\`\`\`bash`);
+  rules.push(`# Install`);
+  rules.push(ctx.commands.install);
+  rules.push(`# Dev`);
+  rules.push(ctx.commands.dev);
+  rules.push(`# Test`);
+  rules.push(ctx.commands.test);
+  rules.push(`# Build`);
+  rules.push(ctx.commands.build);
+  rules.push(`\`\`\``);
+  rules.push("");
+  rules.push("## Rules");
+  rules.push(`- Follow ${ctx.ecosystem} conventions`);
+  rules.push("- Match existing project patterns");
+  rules.push("- Clean code, minimal comments");
+  rules.push("- Test new functionality");
+  return rules.join("\n");
+}
+function formatForContinue(ctx, config) {
+  const systemMessage = [
+    `You are working on ${ctx.name}, a ${ctx.projectType} ${ctx.ecosystem} project.`,
+    "",
+    `Stack: ${ctx.languages.join(", ")}${ctx.frameworks.length > 0 ? ` with ${ctx.frameworks.join(", ")}` : ""}`,
+    "",
+    "Commands:",
+    `- Install: ${ctx.commands.install}`,
+    `- Dev: ${ctx.commands.dev}`,
+    `- Test: ${ctx.commands.test}`,
+    `- Build: ${ctx.commands.build}`,
+    "",
+    `Follow ${ctx.ecosystem} conventions. Match existing code patterns.`
+  ].join("\n");
+  const continueConfig = {
+    systemMessage,
+    models: [],
+    contextProviders: [
+      { name: "code" },
+      { name: "docs" },
+      { name: "diff" },
+      { name: "terminal" },
+      { name: "problems" },
+      { name: "folder" },
+      { name: "codebase" }
+    ],
+    slashCommands: [
+      { name: "edit", description: "Edit selected code" },
+      { name: "comment", description: "Add comments to code" },
+      { name: "share", description: "Export conversation" },
+      { name: "cmd", description: "Run terminal command" }
+    ],
+    customCommands: [
+      {
+        name: "test",
+        prompt: `Write tests for the selected code. Use the project's testing conventions. Test command: ${ctx.commands.test}`
+      }
+    ]
+  };
+  return JSON.stringify(continueConfig, null, 2);
+}
+function getFormatter(toolId) {
+  const formatters = {
+    claude: formatForClaude,
+    cursor: formatForCursor,
+    copilot: formatForCopilot,
+    windsurf: formatForWindsurf,
+    continue: formatForContinue
+  };
+  return formatters[toolId] || null;
+}
+var init_formatters = __esm({
+  "core/ai-tools/formatters.ts"() {
+    "use strict";
+    __name(formatForClaude, "formatForClaude");
+    __name(formatForCursor, "formatForCursor");
+    __name(formatForCopilot, "formatForCopilot");
+    __name(formatForWindsurf, "formatForWindsurf");
+    __name(formatForContinue, "formatForContinue");
+    __name(getFormatter, "getFormatter");
+  }
+});
+
+// core/ai-tools/generator.ts
+import fs30 from "fs/promises";
+import path31 from "path";
+async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
+  const results = [];
+  for (const toolId of toolIds) {
+    const config = getAIToolConfig(toolId);
+    if (!config) {
+      results.push({
+        toolId,
+        outputFile: "",
+        outputPath: "",
+        success: false,
+        error: `Unknown tool: ${toolId}`
+      });
+      continue;
+    }
+    const result = await generateForTool(context2, config, globalPath, repoPath);
+    results.push(result);
+  }
+  return results;
+}
+async function generateForTool(context2, config, globalPath, repoPath) {
+  const formatter = getFormatter(config.id);
+  if (!formatter) {
+    return {
+      toolId: config.id,
+      outputFile: config.outputFile,
+      outputPath: "",
+      success: false,
+      error: `No formatter for: ${config.id}`
+    };
+  }
+  try {
+    const content = formatter(context2, config);
+    let outputPath;
+    if (config.outputPath === "repo") {
+      outputPath = path31.join(repoPath, config.outputFile);
+    } else {
+      outputPath = path31.join(globalPath, "context", config.outputFile);
+    }
+    await fs30.mkdir(path31.dirname(outputPath), { recursive: true });
+    await fs30.writeFile(outputPath, content, "utf-8");
+    return {
+      toolId: config.id,
+      outputFile: config.outputFile,
+      outputPath,
+      success: true
+    };
+  } catch (error) {
+    return {
+      toolId: config.id,
+      outputFile: config.outputFile,
+      outputPath: "",
+      success: false,
+      error: error.message
+    };
+  }
+}
+var init_generator2 = __esm({
+  "core/ai-tools/generator.ts"() {
+    "use strict";
+    init_registry();
+    init_formatters();
+    __name(generateAIToolContexts, "generateAIToolContexts");
+    __name(generateForTool, "generateForTool");
+  }
+});
+
+// core/ai-tools/index.ts
+var init_ai_tools = __esm({
+  "core/ai-tools/index.ts"() {
+    "use strict";
+    init_registry();
+    init_formatters();
+    init_generator2();
+  }
+});
+
+// core/services/sync-service.ts
+import fs31 from "fs/promises";
+import path32 from "path";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execAsync3, SyncService, syncService;
+var init_sync_service = __esm({
+  "core/services/sync-service.ts"() {
+    "use strict";
+    init_path_manager();
+    init_config_manager();
+    init_date_helper();
+    init_ai_tools();
+    execAsync3 = promisify5(exec5);
+    SyncService = class {
+      static {
+        __name(this, "SyncService");
+      }
+      projectPath;
+      projectId = null;
+      globalPath = "";
+      cliVersion = "0.0.0";
+      constructor() {
+        this.projectPath = process.cwd();
+      }
+      /**
+       * Main sync method - does everything in one call
+       */
+      async sync(projectPath = process.cwd(), options = {}) {
+        this.projectPath = projectPath;
+        let aiToolIds;
+        if (!options.aiTools || options.aiTools.length === 0) {
+          aiToolIds = DEFAULT_AI_TOOLS;
+        } else if (options.aiTools[0] === "auto") {
+          aiToolIds = detectInstalledTools(projectPath);
+          if (aiToolIds.length === 0) aiToolIds = ["claude"];
+        } else if (options.aiTools[0] === "all") {
+          aiToolIds = resolveToolIds("all", projectPath);
+        } else {
+          aiToolIds = options.aiTools;
+        }
+        try {
+          this.projectId = await config_manager_default.getProjectId(projectPath);
+          if (!this.projectId) {
+            return {
+              success: false,
+              projectId: "",
+              cliVersion: "",
+              git: this.emptyGitData(),
+              stats: this.emptyStats(),
+              commands: this.emptyCommands(),
+              stack: this.emptyStack(),
+              agents: [],
+              skills: [],
+              contextFiles: [],
+              aiTools: [],
+              error: "No prjct project. Run p. init first."
+            };
+          }
           this.globalPath = path_manager_default.getGlobalProjectPath(this.projectId);
           this.cliVersion = await this.getCliVersion();
           await this.ensureDirectories();
@@ -12563,6 +13443,31 @@ var init_sync_service = __esm({
           const agents = await this.generateAgents(stack, stats);
           const skills = this.configureSkills(agents);
           const contextFiles = await this.generateContextFiles(git, stats, commands, agents);
+          const projectContext = {
+            projectId: this.projectId,
+            name: stats.name,
+            version: stats.version,
+            ecosystem: stats.ecosystem,
+            projectType: stats.projectType,
+            languages: stats.languages,
+            frameworks: stats.frameworks,
+            repoPath: this.projectPath,
+            branch: git.branch,
+            fileCount: stats.fileCount,
+            commits: git.commits,
+            hasChanges: git.hasChanges,
+            commands,
+            agents: {
+              workflow: agents.filter((a) => a.type === "workflow").map((a) => a.name),
+              domain: agents.filter((a) => a.type === "domain").map((a) => a.name)
+            }
+          };
+          const aiToolResults = await generateAIToolContexts(
+            projectContext,
+            this.globalPath,
+            this.projectPath,
+            aiToolIds
+          );
           await this.updateProjectJson(git, stats);
           await this.updateStateJson(stats, stack);
           await this.logToMemory(git, stats);
@@ -12576,7 +13481,12 @@ var init_sync_service = __esm({
             stack,
             agents,
             skills,
-            contextFiles
+            contextFiles,
+            aiTools: aiToolResults.map((r) => ({
+              toolId: r.toolId,
+              outputFile: r.outputFile,
+              success: r.success
+            }))
           };
         } catch (error) {
           return {
@@ -12590,6 +13500,7 @@ var init_sync_service = __esm({
             agents: [],
             skills: [],
             contextFiles: [],
+            aiTools: [],
             error: error.message
           };
         }
@@ -12600,7 +13511,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         for (const dir of dirs) {
-          await fs29.mkdir(path30.join(this.globalPath, dir), { recursive: true });
+          await fs31.mkdir(path32.join(this.globalPath, dir), { recursive: true });
         }
       }
       // ==========================================================================
@@ -12670,7 +13581,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path30.basename(this.projectPath),
+          name: path32.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -12686,8 +13597,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path30.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs29.readFile(pkgPath, "utf-8"));
+          const pkgPath = path32.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs31.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -12797,8 +13708,8 @@ var init_sync_service = __esm({
           frameworks: []
         };
         try {
-          const pkgPath = path30.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs29.readFile(pkgPath, "utf-8"));
+          const pkgPath = path32.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs31.readFile(pkgPath, "utf-8"));
           const deps = { ...pkg.dependencies, ...pkg.devDependencies };
           if (deps.react || deps.vue || deps.svelte || deps["@angular/core"]) {
             stack.hasFrontend = true;
@@ -12831,12 +13742,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path30.join(this.globalPath, "agents");
+        const agentsPath = path32.join(this.globalPath, "agents");
         try {
-          const files = await fs29.readdir(agentsPath);
+          const files = await fs31.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs29.unlink(path30.join(agentsPath, file));
+              await fs31.unlink(path32.join(agentsPath, file));
             }
           }
         } catch {
@@ -12873,7 +13784,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path30.join(
+          const templatePath = path32.join(
             __dirname,
             "..",
             "..",
@@ -12882,16 +13793,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs29.readFile(templatePath, "utf-8");
+          content = await fs31.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs29.writeFile(path30.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs31.writeFile(path32.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path30.join(
+          const templatePath = path32.join(
             __dirname,
             "..",
             "..",
@@ -12900,14 +13811,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs29.readFile(templatePath, "utf-8");
+          content = await fs31.readFile(templatePath, "utf-8");
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
           content = content.replace("{ecosystem}", stats.ecosystem);
         } catch {
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs29.writeFile(path30.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs31.writeFile(path32.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -12975,8 +13886,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
           })),
           agentSkillMap: Object.fromEntries(skills.map((s) => [s.agent, s.skill]))
         };
-        fs29.writeFile(
-          path30.join(this.globalPath, "config", "skills.json"),
+        fs31.writeFile(
+          path32.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -12987,7 +13898,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // CONTEXT FILE GENERATION
       // ==========================================================================
       async generateContextFiles(git, stats, commands, agents) {
-        const contextPath = path30.join(this.globalPath, "context");
+        const contextPath = path32.join(this.globalPath, "context");
         const files = [];
         await this.generateClaudeMd(contextPath, git, stats, commands, agents);
         files.push("context/CLAUDE.md");
@@ -13073,13 +13984,13 @@ Load from \`~/.prjct-cli/projects/${this.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        await fs29.writeFile(path30.join(contextPath, "CLAUDE.md"), content, "utf-8");
+        await fs31.writeFile(path32.join(contextPath, "CLAUDE.md"), content, "utf-8");
       }
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path30.join(this.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs29.readFile(statePath, "utf-8"));
+          const statePath = path32.join(this.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs31.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -13095,41 +14006,41 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await fs29.writeFile(path30.join(contextPath, "now.md"), content, "utf-8");
+        await fs31.writeFile(path32.join(contextPath, "now.md"), content, "utf-8");
       }
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path30.join(this.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs29.readFile(queuePath, "utf-8"));
+          const queuePath = path32.join(this.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs31.readFile(queuePath, "utf-8"));
         } catch {
         }
         const content = `# NEXT
 
 ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ""}`).join("\n") : "_Empty queue_"}
 `;
-        await fs29.writeFile(path30.join(contextPath, "next.md"), content, "utf-8");
+        await fs31.writeFile(path32.join(contextPath, "next.md"), content, "utf-8");
       }
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path30.join(this.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs29.readFile(ideasPath, "utf-8"));
+          const ideasPath = path32.join(this.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs31.readFile(ideasPath, "utf-8"));
         } catch {
         }
         const content = `# IDEAS
 
 ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [${i.priority}]` : ""}`).join("\n") : "_No ideas captured yet_"}
 `;
-        await fs29.writeFile(path30.join(contextPath, "ideas.md"), content, "utf-8");
+        await fs31.writeFile(path32.join(contextPath, "ideas.md"), content, "utf-8");
       }
       async generateShippedMd(contextPath) {
         let shipped = {
           shipped: []
         };
         try {
-          const shippedPath = path30.join(this.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs29.readFile(shippedPath, "utf-8"));
+          const shippedPath = path32.join(this.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs31.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -13138,16 +14049,16 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await fs29.writeFile(path30.join(contextPath, "shipped.md"), content, "utf-8");
+        await fs31.writeFile(path32.join(contextPath, "shipped.md"), content, "utf-8");
       }
       // ==========================================================================
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path30.join(this.globalPath, "project.json");
+        const projectJsonPath = path32.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs29.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs31.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -13166,16 +14077,16 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
           createdAt: existing.createdAt || date_helper_default.getTimestamp(),
           lastSync: date_helper_default.getTimestamp()
         };
-        await fs29.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs31.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path30.join(this.globalPath, "storage", "state.json");
+        const statePath = path32.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs29.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs31.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -13202,13 +14113,13 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
           lastAction: "Synced project",
           nextAction: 'Run `p. task "description"` to start working'
         };
-        await fs29.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs31.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
       }
       // ==========================================================================
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path30.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path32.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -13217,14 +14128,14 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs29.appendFile(memoryPath, JSON.stringify(event) + "\n", "utf-8");
+        await fs31.appendFile(memoryPath, JSON.stringify(event) + "\n", "utf-8");
       }
       // ==========================================================================
       // HELPERS
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs29.access(path30.join(this.projectPath, filename));
+          await fs31.access(path32.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -13232,8 +14143,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
       }
       async getCliVersion() {
         try {
-          const pkgPath = path30.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs29.readFile(pkgPath, "utf-8"));
+          const pkgPath = path32.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs31.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -13378,6 +14289,886 @@ var init_base = __esm({
   }
 });
 
+// core/utils/keychain.ts
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+async function getCredential(key) {
+  if (process.platform !== "darwin") {
+    return getEnvFallback(key);
+  }
+  try {
+    const { stdout } = await execAsync4(
+      `security find-generic-password -s "${SERVICE_NAME}" -a "${key}" -w 2>/dev/null`
+    );
+    return stdout.trim() || null;
+  } catch (_error) {
+    return getEnvFallback(key);
+  }
+}
+function getEnvFallback(key) {
+  const envMap = {
+    "linear-api-key": "LINEAR_API_KEY",
+    "jira-api-token": "JIRA_API_TOKEN"
+  };
+  const envVar = envMap[key];
+  return process.env[envVar] || null;
+}
+var execAsync4, SERVICE_NAME;
+var init_keychain = __esm({
+  "core/utils/keychain.ts"() {
+    "use strict";
+    execAsync4 = promisify6(exec6);
+    SERVICE_NAME = "prjct-cli";
+    __name(getCredential, "getCredential");
+    __name(getEnvFallback, "getEnvFallback");
+  }
+});
+
+// core/integrations/linear/client.ts
+import { LinearClient as LinearSDK } from "@linear/sdk";
+var LINEAR_STATUS_MAP, LINEAR_PRIORITY_MAP, PRIORITY_TO_LINEAR, LinearProvider, linearProvider;
+var init_client = __esm({
+  "core/integrations/linear/client.ts"() {
+    "use strict";
+    init_keychain();
+    LINEAR_STATUS_MAP = {
+      backlog: "backlog",
+      unstarted: "todo",
+      started: "in_progress",
+      completed: "done",
+      canceled: "cancelled",
+      cancelled: "cancelled"
+    };
+    LINEAR_PRIORITY_MAP = {
+      0: "none",
+      1: "urgent",
+      2: "high",
+      3: "medium",
+      4: "low"
+    };
+    PRIORITY_TO_LINEAR = {
+      none: 0,
+      urgent: 1,
+      high: 2,
+      medium: 3,
+      low: 4
+    };
+    LinearProvider = class {
+      static {
+        __name(this, "LinearProvider");
+      }
+      name = "linear";
+      displayName = "Linear";
+      sdk = null;
+      config = null;
+      /**
+       * Check if provider is configured
+       */
+      isConfigured() {
+        return this.sdk !== null && this.config?.enabled === true;
+      }
+      /**
+       * Initialize with config
+       * Looks for API key in: 1) config.apiKey, 2) macOS Keychain, 3) LINEAR_API_KEY env var
+       */
+      async initialize(config) {
+        this.config = config;
+        const apiKey = config.apiKey || await getCredential("linear-api-key");
+        if (!apiKey) {
+          throw new Error(
+            "LINEAR_API_KEY not configured. Run `p. linear setup` to configure."
+          );
+        }
+        this.sdk = new LinearSDK({ apiKey });
+        try {
+          const viewer = await this.sdk.viewer;
+          console.error(`[linear] Connected as ${viewer.name} (${viewer.email})`);
+        } catch (error) {
+          this.sdk = null;
+          throw new Error(`Linear connection failed: ${error.message}`);
+        }
+      }
+      /**
+       * Get issues assigned to current user
+       * Filters by configured team if defaultTeamId is set
+       */
+      async fetchAssignedIssues(options) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const viewer = await this.sdk.viewer;
+        const filter = {};
+        if (!options?.includeCompleted) {
+          filter.state = { type: { nin: ["completed", "canceled"] } };
+        }
+        if (this.config?.defaultTeamId) {
+          filter.team = { id: { eq: this.config.defaultTeamId } };
+        }
+        const assignedIssues = await viewer.assignedIssues({
+          first: options?.limit || 50,
+          filter: Object.keys(filter).length > 0 ? filter : void 0
+        });
+        return Promise.all(
+          assignedIssues.nodes.map((issue) => this.mapIssue(issue))
+        );
+      }
+      /**
+       * Get issues from a team
+       */
+      async fetchTeamIssues(teamId, options) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const team = await this.sdk.team(teamId);
+        const issues = await team.issues({
+          first: options?.limit || 50,
+          filter: options?.includeCompleted ? void 0 : { state: { type: { nin: ["completed", "canceled"] } } }
+        });
+        return Promise.all(issues.nodes.map((issue) => this.mapIssue(issue)));
+      }
+      /**
+       * Get a single issue by ID or identifier (e.g., "PRJ-123")
+       */
+      async fetchIssue(id) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        try {
+          if (id.includes("-") && /^[A-Z]+-\d+$/.test(id)) {
+            const match = id.match(/^([A-Z]+)-(\d+)$/);
+            if (!match) return null;
+            const [, teamKey, numberStr] = match;
+            const issueNumber = parseInt(numberStr, 10);
+            const teams = await this.sdk.teams({ first: 50 });
+            const team = teams.nodes.find((t) => t.key === teamKey);
+            if (!team) return null;
+            const issues = await team.issues({
+              first: 1,
+              filter: { number: { eq: issueNumber } }
+            });
+            if (issues.nodes.length > 0) {
+              return this.mapIssue(issues.nodes[0]);
+            }
+            return null;
+          }
+          const issue = await this.sdk.issue(id);
+          return this.mapIssue(issue);
+        } catch (_error) {
+          return null;
+        }
+      }
+      /**
+       * Create a new issue
+       */
+      async createIssue(input) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const teamId = input.teamId || this.config?.defaultTeamId;
+        if (!teamId) {
+          throw new Error("Team ID required for creating issues");
+        }
+        const payload = await this.sdk.createIssue({
+          teamId,
+          title: input.title,
+          description: input.description,
+          priority: input.priority ? PRIORITY_TO_LINEAR[input.priority] : void 0,
+          projectId: input.projectId || this.config?.defaultProjectId,
+          assigneeId: input.assigneeId,
+          labelIds: input.labels ? await this.resolveLabelIds(teamId, input.labels) : void 0
+        });
+        const createdIssue = await payload.issue;
+        if (!createdIssue) {
+          throw new Error("Failed to create issue");
+        }
+        return this.mapIssue(createdIssue);
+      }
+      /**
+       * Update an issue
+       */
+      async updateIssue(id, input) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const issue = await this.fetchIssue(id);
+        if (!issue) {
+          throw new Error(`Issue ${id} not found`);
+        }
+        const updatePayload = {};
+        if (input.title !== void 0) updatePayload.title = input.title;
+        if (input.description !== void 0) updatePayload.description = input.description;
+        if (input.priority !== void 0) updatePayload.priority = PRIORITY_TO_LINEAR[input.priority];
+        if (input.assigneeId !== void 0) updatePayload.assigneeId = input.assigneeId;
+        if (input.stateId !== void 0) updatePayload.stateId = input.stateId;
+        if (input.projectId !== void 0) updatePayload.projectId = input.projectId;
+        if (input.labels !== void 0 && issue.team) {
+          updatePayload.labelIds = await this.resolveLabelIds(issue.team.id, input.labels);
+        }
+        await this.sdk.updateIssue(issue.id, updatePayload);
+        const updated = await this.fetchIssue(issue.id);
+        if (!updated) {
+          throw new Error("Failed to fetch updated issue");
+        }
+        return updated;
+      }
+      /**
+       * Mark issue as in progress
+       */
+      async markInProgress(id) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const issue = await this.fetchIssue(id);
+        if (!issue) throw new Error(`Issue ${id} not found`);
+        const linearIssue = await this.sdk.issue(issue.id);
+        const team = await linearIssue.team;
+        if (!team) throw new Error("Issue has no team");
+        const states = await team.states();
+        const startedState = states.nodes.find((s) => s.type === "started");
+        if (startedState) {
+          await this.sdk.updateIssue(issue.id, { stateId: startedState.id });
+        }
+      }
+      /**
+       * Mark issue as done
+       */
+      async markDone(id) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const issue = await this.fetchIssue(id);
+        if (!issue) throw new Error(`Issue ${id} not found`);
+        const linearIssue = await this.sdk.issue(issue.id);
+        const team = await linearIssue.team;
+        if (!team) throw new Error("Issue has no team");
+        const states = await team.states();
+        const doneState = states.nodes.find((s) => s.type === "completed");
+        if (doneState) {
+          await this.sdk.updateIssue(issue.id, { stateId: doneState.id });
+        }
+      }
+      /**
+       * Add a comment to an issue
+       */
+      async addComment(id, body) {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const issue = await this.fetchIssue(id);
+        if (!issue) throw new Error(`Issue ${id} not found`);
+        await this.sdk.createComment({
+          issueId: issue.id,
+          body
+        });
+      }
+      /**
+       * Get available teams
+       */
+      async getTeams() {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const teams = await this.sdk.teams({ first: 50 });
+        return teams.nodes.map((team) => ({
+          id: team.id,
+          name: team.name,
+          key: team.key
+        }));
+      }
+      /**
+       * Get available projects
+       */
+      async getProjects() {
+        if (!this.sdk) throw new Error("Linear not initialized");
+        const projects = await this.sdk.projects({ first: 50 });
+        return projects.nodes.map((project) => ({
+          id: project.id,
+          name: project.name
+        }));
+      }
+      // =============================================================================
+      // Private Helpers
+      // =============================================================================
+      /**
+       * Map Linear issue to normalized Issue
+       */
+      async mapIssue(linearIssue) {
+        const state = await linearIssue.state;
+        const assignee = await linearIssue.assignee;
+        const team = await linearIssue.team;
+        const project = await linearIssue.project;
+        const labels = await linearIssue.labels();
+        return {
+          id: linearIssue.id,
+          externalId: linearIssue.identifier,
+          provider: "linear",
+          title: linearIssue.title,
+          description: linearIssue.description || void 0,
+          status: LINEAR_STATUS_MAP[state?.type || "backlog"] || "backlog",
+          priority: LINEAR_PRIORITY_MAP[linearIssue.priority] || "none",
+          type: this.inferType(linearIssue.title, labels.nodes.map((l) => l.name)),
+          assignee: assignee ? {
+            id: assignee.id,
+            name: assignee.name,
+            email: assignee.email
+          } : void 0,
+          labels: labels.nodes.map((l) => l.name),
+          team: team ? {
+            id: team.id,
+            name: team.name,
+            key: team.key
+          } : void 0,
+          project: project ? {
+            id: project.id,
+            name: project.name
+          } : void 0,
+          url: linearIssue.url,
+          createdAt: linearIssue.createdAt.toISOString(),
+          updatedAt: linearIssue.updatedAt.toISOString(),
+          raw: linearIssue
+        };
+      }
+      /**
+       * Infer issue type from title and labels
+       */
+      inferType(title, labels) {
+        const titleLower = title.toLowerCase();
+        const labelsLower = labels.map((l) => l.toLowerCase());
+        if (labelsLower.includes("bug") || titleLower.includes("fix") || titleLower.includes("bug")) {
+          return "bug";
+        }
+        if (labelsLower.includes("feature") || titleLower.includes("add") || titleLower.includes("implement")) {
+          return "feature";
+        }
+        if (labelsLower.includes("improvement") || titleLower.includes("improve") || titleLower.includes("enhance")) {
+          return "improvement";
+        }
+        if (labelsLower.includes("chore") || titleLower.includes("chore") || titleLower.includes("deps")) {
+          return "chore";
+        }
+        return "task";
+      }
+      /**
+       * Resolve label names to IDs
+       */
+      async resolveLabelIds(teamId, labelNames) {
+        if (!this.sdk) return [];
+        const team = await this.sdk.team(teamId);
+        const labels = await team.labels();
+        return labels.nodes.filter((label) => labelNames.includes(label.name)).map((label) => label.id);
+      }
+    };
+    linearProvider = new LinearProvider();
+  }
+});
+
+// core/integrations/linear/cache.ts
+function clearLinearCache() {
+  issueCache.clear();
+  assignedIssuesCache.clear();
+  teamsCache.clear();
+  projectsCache.clear();
+}
+function getLinearCacheStats() {
+  return {
+    issues: issueCache.stats(),
+    assignedIssues: assignedIssuesCache.stats(),
+    teams: teamsCache.stats(),
+    projects: projectsCache.stats()
+  };
+}
+var LINEAR_CACHE_TTL, issueCache, assignedIssuesCache, teamsCache, projectsCache;
+var init_cache2 = __esm({
+  "core/integrations/linear/cache.ts"() {
+    "use strict";
+    init_cache();
+    LINEAR_CACHE_TTL = 5 * 60 * 1e3;
+    issueCache = new TTLCache({
+      ttl: LINEAR_CACHE_TTL,
+      maxSize: 100
+    });
+    assignedIssuesCache = new TTLCache({
+      ttl: LINEAR_CACHE_TTL,
+      maxSize: 10
+    });
+    teamsCache = new TTLCache({
+      ttl: LINEAR_CACHE_TTL,
+      maxSize: 5
+    });
+    projectsCache = new TTLCache({
+      ttl: LINEAR_CACHE_TTL,
+      maxSize: 5
+    });
+    __name(clearLinearCache, "clearLinearCache");
+    __name(getLinearCacheStats, "getLinearCacheStats");
+  }
+});
+
+// core/integrations/linear/service.ts
+var LinearService, linearService;
+var init_service = __esm({
+  "core/integrations/linear/service.ts"() {
+    "use strict";
+    init_client();
+    init_cache2();
+    LinearService = class {
+      static {
+        __name(this, "LinearService");
+      }
+      initialized = false;
+      userId = null;
+      /**
+       * Check if service is ready
+       */
+      isReady() {
+        return this.initialized && linearProvider.isConfigured();
+      }
+      /**
+       * Initialize the service with config
+       * Must be called before any operations
+       */
+      async initialize(config) {
+        if (this.initialized) return;
+        await linearProvider.initialize(config);
+        this.initialized = true;
+      }
+      /**
+       * Initialize from API key directly
+       * Convenience method for simple setup
+       */
+      async initializeFromApiKey(apiKey, teamId) {
+        const config = {
+          enabled: true,
+          provider: "linear",
+          apiKey,
+          defaultTeamId: teamId,
+          syncOn: { task: true, done: true, ship: true },
+          enrichment: { enabled: true, updateProvider: true }
+        };
+        await this.initialize(config);
+      }
+      /**
+       * Get issues assigned to current user (cached)
+       */
+      async fetchAssignedIssues(options) {
+        this.ensureInitialized();
+        const cacheKey = `assigned:${this.userId || "me"}`;
+        const cached = assignedIssuesCache.get(cacheKey);
+        if (cached) {
+          return cached;
+        }
+        const issues = await linearProvider.fetchAssignedIssues(options);
+        assignedIssuesCache.set(cacheKey, issues);
+        for (const issue of issues) {
+          issueCache.set(`issue:${issue.id}`, issue);
+          issueCache.set(`issue:${issue.externalId}`, issue);
+        }
+        return issues;
+      }
+      /**
+       * Get issues from a team (cached)
+       */
+      async fetchTeamIssues(teamId, options) {
+        this.ensureInitialized();
+        const cacheKey = `team:${teamId}`;
+        const cached = assignedIssuesCache.get(cacheKey);
+        if (cached) {
+          return cached;
+        }
+        const issues = await linearProvider.fetchTeamIssues(teamId, options);
+        assignedIssuesCache.set(cacheKey, issues);
+        for (const issue of issues) {
+          issueCache.set(`issue:${issue.id}`, issue);
+          issueCache.set(`issue:${issue.externalId}`, issue);
+        }
+        return issues;
+      }
+      /**
+       * Get a single issue by ID or identifier (cached)
+       * Accepts UUID or identifier like "PRJ-123"
+       */
+      async fetchIssue(id) {
+        this.ensureInitialized();
+        const cacheKey = `issue:${id}`;
+        const cached = issueCache.get(cacheKey);
+        if (cached) {
+          return cached;
+        }
+        const issue = await linearProvider.fetchIssue(id);
+        if (issue) {
+          issueCache.set(`issue:${issue.id}`, issue);
+          issueCache.set(`issue:${issue.externalId}`, issue);
+        }
+        return issue;
+      }
+      /**
+       * Create a new issue (invalidates assigned cache)
+       */
+      async createIssue(input) {
+        this.ensureInitialized();
+        const issue = await linearProvider.createIssue(input);
+        issueCache.set(`issue:${issue.id}`, issue);
+        issueCache.set(`issue:${issue.externalId}`, issue);
+        assignedIssuesCache.clear();
+        return issue;
+      }
+      /**
+       * Update an issue (invalidates cache for that issue)
+       */
+      async updateIssue(id, input) {
+        this.ensureInitialized();
+        const issue = await linearProvider.updateIssue(id, input);
+        issueCache.set(`issue:${issue.id}`, issue);
+        issueCache.set(`issue:${issue.externalId}`, issue);
+        return issue;
+      }
+      /**
+       * Mark issue as in progress (invalidates cache)
+       */
+      async markInProgress(id) {
+        this.ensureInitialized();
+        await linearProvider.markInProgress(id);
+        issueCache.delete(`issue:${id}`);
+        assignedIssuesCache.clear();
+      }
+      /**
+       * Mark issue as done (invalidates cache)
+       */
+      async markDone(id) {
+        this.ensureInitialized();
+        await linearProvider.markDone(id);
+        issueCache.delete(`issue:${id}`);
+        assignedIssuesCache.clear();
+      }
+      /**
+       * Add a comment to an issue
+       */
+      async addComment(id, body) {
+        this.ensureInitialized();
+        await linearProvider.addComment(id, body);
+      }
+      /**
+       * Get available teams (cached)
+       */
+      async getTeams() {
+        this.ensureInitialized();
+        const cached = teamsCache.get("teams");
+        if (cached) {
+          return cached;
+        }
+        const teams = await linearProvider.getTeams();
+        teamsCache.set("teams", teams);
+        return teams;
+      }
+      /**
+       * Get available projects (cached)
+       */
+      async getProjects() {
+        this.ensureInitialized();
+        const cached = projectsCache.get("projects");
+        if (cached) {
+          return cached;
+        }
+        const projects = await linearProvider.getProjects();
+        projectsCache.set("projects", projects);
+        return projects;
+      }
+      /**
+       * Clear all caches
+       */
+      clearCache() {
+        clearLinearCache();
+      }
+      /**
+       * Get cache statistics for debugging
+       */
+      getCacheStats() {
+        return getLinearCacheStats();
+      }
+      /**
+       * Ensure service is initialized
+       */
+      ensureInitialized() {
+        if (!this.initialized) {
+          throw new Error(
+            "Linear service not initialized. Call linearService.initialize() first or run `p. linear setup`."
+          );
+        }
+      }
+    };
+    linearService = new LinearService();
+  }
+});
+
+// core/integrations/linear/sync.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_STALE_AFTER, LinearSync, linearSync;
+var init_sync = __esm({
+  "core/integrations/linear/sync.ts"() {
+    "use strict";
+    init_service();
+    init_schemas();
+    init_issues();
+    DEFAULT_STALE_AFTER = 30 * 60 * 1e3;
+    LinearSync = class {
+      static {
+        __name(this, "LinearSync");
+      }
+      /**
+       * Pull all assigned issues from Linear and store in issues.json
+       * This is the main sync operation - call on `p. sync`
+       */
+      async pullAll(projectId) {
+        const storagePath = join2(getProjectPath2(projectId), "storage");
+        const issuesPath = join2(storagePath, "issues.json");
+        if (!existsSync(storagePath)) {
+          await mkdir(storagePath, { recursive: true });
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const errors = [];
+        try {
+          const issues = await linearService.fetchAssignedIssues({ limit: 100 });
+          const issuesMap = {};
+          for (const issue of issues) {
+            try {
+              issuesMap[issue.externalId] = this.toCachedIssue(issue, timestamp);
+            } catch (err) {
+              errors.push({
+                issueId: issue.externalId || issue.id,
+                error: err.message
+              });
+            }
+          }
+          const issuesJson = {
+            provider: "linear",
+            lastSync: timestamp,
+            staleAfter: DEFAULT_STALE_AFTER,
+            issues: issuesMap
+          };
+          await writeFile2(issuesPath, JSON.stringify(issuesJson, null, 2));
+          return {
+            provider: "linear",
+            fetched: issues.length,
+            updated: Object.keys(issuesMap).length,
+            errors,
+            timestamp
+          };
+        } catch (err) {
+          errors.push({
+            issueId: "all",
+            error: err.message
+          });
+          return {
+            provider: "linear",
+            fetched: 0,
+            updated: 0,
+            errors,
+            timestamp
+          };
+        }
+      }
+      /**
+       * Get issue from local cache, fetch from API if not found or stale
+       * Local-first approach for performance
+       */
+      async getIssue(projectId, identifier) {
+        const issuesJson = await this.loadIssues(projectId);
+        if (issuesJson && issuesJson.issues[identifier]) {
+          const cachedIssue = issuesJson.issues[identifier];
+          const fetchedAt = new Date(cachedIssue.fetchedAt).getTime();
+          const now = Date.now();
+          const issueStaleness = 10 * 60 * 1e3;
+          if (now - fetchedAt < issueStaleness) {
+            return cachedIssue;
+          }
+        }
+        try {
+          const issue = await linearService.fetchIssue(identifier);
+          if (!issue) return null;
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const cachedIssue = this.toCachedIssue(issue, timestamp);
+          await this.updateIssueInCache(projectId, identifier, cachedIssue);
+          return cachedIssue;
+        } catch {
+          if (issuesJson?.issues[identifier]) {
+            return issuesJson.issues[identifier];
+          }
+          return null;
+        }
+      }
+      /**
+       * Get issue from local cache ONLY (no API call)
+       * Use for fast lookups when you know the issue should be cached
+       */
+      async getIssueLocal(projectId, identifier) {
+        const issuesJson = await this.loadIssues(projectId);
+        return issuesJson?.issues[identifier] || null;
+      }
+      /**
+       * Push local status change to Linear
+       * Called when task status changes (in_progress, done)
+       */
+      async pushStatus(projectId, identifier, status) {
+        if (status === "in_progress") {
+          await linearService.markInProgress(identifier);
+        } else if (status === "done") {
+          await linearService.markDone(identifier);
+        }
+        const issuesJson = await this.loadIssues(projectId);
+        if (issuesJson?.issues[identifier]) {
+          const cachedStatus = status === "done" ? "done" : "in_progress";
+          issuesJson.issues[identifier].status = cachedStatus;
+          issuesJson.issues[identifier].fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await this.saveIssues(projectId, issuesJson);
+        }
+      }
+      /**
+       * Check if the local issues cache is stale
+       * Staleness = lastSync is older than staleAfter threshold
+       */
+      async isStale(projectId) {
+        const issuesJson = await this.loadIssues(projectId);
+        if (!issuesJson || !issuesJson.lastSync) {
+          return true;
+        }
+        const lastSyncTime = new Date(issuesJson.lastSync).getTime();
+        const now = Date.now();
+        const staleAfter = issuesJson.staleAfter || DEFAULT_STALE_AFTER;
+        return now - lastSyncTime > staleAfter;
+      }
+      /**
+       * Get sync status for display
+       */
+      async getSyncStatus(projectId) {
+        const issuesJson = await this.loadIssues(projectId);
+        if (!issuesJson) {
+          return {
+            hasCache: false,
+            lastSync: null,
+            issueCount: 0,
+            isStale: true
+          };
+        }
+        return {
+          hasCache: true,
+          lastSync: issuesJson.lastSync || null,
+          issueCount: Object.keys(issuesJson.issues).length,
+          isStale: await this.isStale(projectId)
+        };
+      }
+      /**
+       * List all cached issues
+       */
+      async listCachedIssues(projectId) {
+        const issuesJson = await this.loadIssues(projectId);
+        if (!issuesJson) return [];
+        return Object.values(issuesJson.issues);
+      }
+      // =============================================================================
+      // Private Helpers
+      // =============================================================================
+      /**
+       * Load issues.json from disk
+       */
+      async loadIssues(projectId) {
+        const issuesPath = join2(getProjectPath2(projectId), "storage", "issues.json");
+        if (!existsSync(issuesPath)) {
+          return null;
+        }
+        try {
+          const content = await readFile2(issuesPath, "utf-8");
+          return parseIssues(JSON.parse(content));
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Save issues.json to disk
+       */
+      async saveIssues(projectId, issuesJson) {
+        const storagePath = join2(getProjectPath2(projectId), "storage");
+        const issuesPath = join2(storagePath, "issues.json");
+        if (!existsSync(storagePath)) {
+          await mkdir(storagePath, { recursive: true });
+        }
+        await writeFile2(issuesPath, JSON.stringify(issuesJson, null, 2));
+      }
+      /**
+       * Update a single issue in the cache
+       */
+      async updateIssueInCache(projectId, identifier, issue) {
+        let issuesJson = await this.loadIssues(projectId);
+        if (!issuesJson) {
+          issuesJson = createEmptyIssues("linear");
+        }
+        issuesJson.issues[identifier] = issue;
+        await this.saveIssues(projectId, issuesJson);
+      }
+      /**
+       * Convert API Issue to CachedIssue format
+       */
+      toCachedIssue(issue, timestamp) {
+        return {
+          id: issue.id,
+          identifier: issue.externalId,
+          title: issue.title,
+          description: issue.description,
+          status: issue.status,
+          priority: issue.priority,
+          type: issue.type,
+          assignee: issue.assignee,
+          labels: issue.labels,
+          team: issue.team,
+          project: issue.project,
+          url: issue.url,
+          createdAt: issue.createdAt,
+          updatedAt: issue.updatedAt,
+          fetchedAt: timestamp
+        };
+      }
+    };
+    linearSync = new LinearSync();
+  }
+});
+
+// core/integrations/linear/index.ts
+var init_linear = __esm({
+  "core/integrations/linear/index.ts"() {
+    "use strict";
+    init_client();
+    init_service();
+    init_sync();
+    init_cache2();
+  }
+});
+
+// core/utils/project-credentials.ts
+import fs32 from "fs";
+import path33 from "path";
+import os13 from "os";
+function getCredentialsPath(projectId) {
+  return path33.join(
+    os13.homedir(),
+    ".prjct-cli",
+    "projects",
+    projectId,
+    "config",
+    "credentials.json"
+  );
+}
+async function getProjectCredentials(projectId) {
+  const credPath = getCredentialsPath(projectId);
+  if (!fs32.existsSync(credPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs32.readFileSync(credPath, "utf-8"));
+  } catch (error) {
+    console.error("[project-credentials] Failed to read credentials:", error.message);
+    return {};
+  }
+}
+async function getLinearApiKey(projectId) {
+  const projectCreds = await getProjectCredentials(projectId);
+  if (projectCreds.linear?.apiKey) {
+    return projectCreds.linear.apiKey;
+  }
+  return getCredential("linear-api-key");
+}
+var init_project_credentials = __esm({
+  "core/utils/project-credentials.ts"() {
+    "use strict";
+    init_keychain();
+    __name(getCredentialsPath, "getCredentialsPath");
+    __name(getProjectCredentials, "getProjectCredentials");
+    __name(getLinearApiKey, "getLinearApiKey");
+  }
+});
+
 // core/commands/workflow.ts
 var WorkflowCommands;
 var init_workflow = __esm({
@@ -13388,6 +15179,9 @@ var init_workflow = __esm({
     init_storage2();
     init_template_executor();
     init_command_executor();
+    init_next_steps();
+    init_linear();
+    init_project_credentials();
     WorkflowCommands = class extends PrjctCommandsBase {
       static {
         __name(this, "WorkflowCommands");
@@ -13410,23 +15204,39 @@ var init_workflow = __esm({
               output_default.fail(result.error || "Failed to execute task");
               return { success: false, error: result.error };
             }
+            let linearId;
+            let taskDescription = task;
+            const linearPattern = /^[A-Z]+-\d+$/;
+            if (linearPattern.test(task)) {
+              try {
+                const creds = await getProjectCredentials(projectId);
+                const apiKey = await getLinearApiKey(projectId);
+                if (apiKey && creds.linear?.teamId) {
+                  await linearService.initializeFromApiKey(
+                    apiKey,
+                    creds.linear.teamId
+                  );
+                  const issue = await linearService.fetchIssue(task);
+                  if (issue) {
+                    linearId = task;
+                    taskDescription = `${task}: ${issue.title}`;
+                    await linearService.markInProgress(task);
+                  }
+                }
+              } catch {
+              }
+            }
             await stateStorage.startTask(projectId, {
               id: generateUUID(),
-              description: task,
-              sessionId: generateUUID()
+              description: taskDescription,
+              sessionId: generateUUID(),
+              linearId
             });
-            if (result.orchestratorContext) {
-              const oc = result.orchestratorContext;
-              const agentsList2 = oc.agents.map((a) => a.name).join(", ") || "none";
-              const domainsList = oc.detectedDomains.join(", ");
-              console.log(`\u{1F3AF} Orchestrator: ${domainsList} \u2192 [${agentsList2}]`);
-              if (oc.requiresFragmentation && oc.subtasks) {
-                console.log(`   \u2192 ${oc.subtasks.length} subtasks created`);
-              }
-            }
             const availableAgents = await templateExecutor.getAvailableAgents(projectPath);
             const agentsList = availableAgents.length > 0 ? availableAgents.join(", ") : "none (run p. sync)";
-            output_default.done(`${task} [specialists: ${agentsList}]`);
+            output_default.done(`${task}`);
+            showStateInfo("working");
+            showNextSteps("task");
             await this.logToMemory(projectPath, "task_started", {
               task,
               agenticMode: true,
@@ -13481,7 +15291,29 @@ var init_workflow = __esm({
             duration = date_helper_default.calculateDuration(started);
           }
           await stateStorage.completeTask(projectId);
-          output_default.done(`${task}${duration ? ` (${duration})` : ""}`);
+          const linearId = currentTask.linearId;
+          if (linearId) {
+            try {
+              const creds = await getProjectCredentials(projectId);
+              const apiKey = await getLinearApiKey(projectId);
+              if (apiKey && creds.linear?.teamId) {
+                await linearService.initializeFromApiKey(
+                  apiKey,
+                  creds.linear.teamId
+                );
+                await linearService.markDone(linearId);
+                output_default.done(`${task}${duration ? ` (${duration})` : ""} \u2192 Linear \u2713`);
+              } else {
+                output_default.done(`${task}${duration ? ` (${duration})` : ""}`);
+              }
+            } catch {
+              output_default.done(`${task}${duration ? ` (${duration})` : ""}`);
+            }
+          } else {
+            output_default.done(`${task}${duration ? ` (${duration})` : ""}`);
+          }
+          showStateInfo("completed");
+          showNextSteps("done");
           await this.logToMemory(projectPath, "task_completed", {
             task,
             duration,
@@ -13511,6 +15343,7 @@ var init_workflow = __esm({
             return { success: true, message: "Queue is empty" };
           }
           output_default.done(`${tasks.length} task${tasks.length !== 1 ? "s" : ""} queued`);
+          showNextSteps("next");
           return { success: true, tasks, count: tasks.length };
         } catch (error) {
           output_default.fail(error.message);
@@ -13537,6 +15370,8 @@ var init_workflow = __esm({
           await stateStorage.pauseTask(projectId, reason2);
           const taskDesc = currentTask.description.slice(0, 40);
           output_default.done(`paused: ${taskDesc}${reason2 ? ` (${reason2})` : ""}`);
+          showStateInfo("paused");
+          showNextSteps("pause");
           await this.logToMemory(projectPath, "task_paused", {
             task: currentTask.description,
             reason: reason2,
@@ -13571,6 +15406,8 @@ var init_workflow = __esm({
             return { success: false, message: "No paused task found" };
           }
           output_default.done(`resumed: ${resumed.description.slice(0, 40)}`);
+          showStateInfo("working");
+          showNextSteps("resume");
           await this.logToMemory(projectPath, "task_resumed", {
             task: resumed.description,
             timestamp: date_helper_default.getTimestamp()
@@ -13586,18 +15423,18 @@ var init_workflow = __esm({
 });
 
 // core/utils/project-commands.ts
-import path31 from "path";
+import path34 from "path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists(path31.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path31.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path31.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path31.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path31.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path34.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path34.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path34.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path34.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path34.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -13613,7 +15450,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path31.join(projectPath, "package.json");
+  const pkgPath = path34.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -13630,27 +15467,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path31.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path34.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path31.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path34.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path31.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path34.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path31.join(projectPath, "go.mod"))) {
+  if (await fileExists(path34.join(projectPath, "go.mod"))) {
     return { stack: "go", test: { tool: "go", command: "go test ./..." } };
   }
   const files = await listFiles(projectPath);
   if (files.some((f) => f.endsWith(".sln") || f.endsWith(".csproj") || f.endsWith(".fsproj"))) {
     return { stack: "dotnet", test: { tool: "dotnet", command: "dotnet test" } };
   }
-  if (await fileExists(path31.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path34.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path31.join(projectPath, "gradlew")) && (await fileExists(path31.join(projectPath, "build.gradle")) || await fileExists(path31.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path34.join(projectPath, "gradlew")) && (await fileExists(path34.join(projectPath, "build.gradle")) || await fileExists(path34.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -13667,7 +15504,7 @@ var init_project_commands = __esm({
 });
 
 // core/commands/shipping.ts
-import path32 from "path";
+import path35 from "path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -13677,6 +15514,7 @@ var init_shipping = __esm({
     init_project_commands();
     init_base();
     init_storage2();
+    init_next_steps();
     ShippingCommands = class extends PrjctCommandsBase {
       static {
         __name(this, "ShippingCommands");
@@ -13719,17 +15557,17 @@ ${result.stderr}`.trim();
             const currentTask = await stateStorage.getCurrentTask(projectId);
             featureName = currentTask?.description || "current work";
           }
-          output_default.spin(`shipping ${featureName}...`);
+          output_default.step(1, 5, `Linting ${featureName}...`);
           const lintResult = await this._runLint(projectPath);
-          output_default.spin("running tests...");
+          output_default.step(2, 5, "Running tests...");
           const testResult = await this._runTests(projectPath);
-          output_default.spin("updating version...");
+          output_default.step(3, 5, "Updating version...");
           const newVersion = await this._bumpVersion(projectPath);
           await this._updateChangelog(featureName, newVersion, projectPath);
-          output_default.spin("committing...");
+          output_default.step(4, 5, "Committing...");
           const commitResult = await this._createShipCommit(featureName, projectPath);
           if (commitResult.success) {
-            output_default.spin("pushing...");
+            output_default.step(5, 5, "Pushing...");
             await this._gitPush(projectPath);
           }
           await shippedStorage.addShipped(projectId, {
@@ -13753,6 +15591,7 @@ ${result.stderr}`.trim();
             });
           }
           output_default.done(`v${newVersion} shipped`);
+          showNextSteps("ship");
           return { success: true, feature: featureName, version: newVersion };
         } catch (error) {
           output_default.fail(error.message);
@@ -13796,7 +15635,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path32.join(projectPath, "package.json");
+          const pkgPath = path35.join(projectPath, "package.json");
           const pkg = await file_helper_exports.readJson(pkgPath, { version: "0.0.0" });
           const oldVersion = pkg?.version || "0.0.0";
           const [major, minor, patch] = oldVersion.split(".").map(Number);
@@ -13818,7 +15657,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path32.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path35.join(projectPath, "CHANGELOG.md");
           const changelog = await file_helper_exports.readFile(changelogPath, "# Changelog\n\n");
           const entry = `## [${version}] - ${date_helper_default.formatDate(/* @__PURE__ */ new Date())}
 
@@ -13877,7 +15716,7 @@ Designed for [Claude](https://www.anthropic.com/claude)`;
 
 // core/commands/registry.ts
 var CommandRegistry, commandRegistry;
-var init_registry = __esm({
+var init_registry2 = __esm({
   "core/commands/registry.ts"() {
     "use strict";
     init_config_manager();
@@ -14214,12 +16053,12 @@ var init_registry = __esm({
 });
 
 // core/commands/analytics.ts
-import path33 from "path";
+import path36 from "path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
     "use strict";
-    init_registry();
+    init_registry2();
     init_base();
     init_storage2();
     AnalyticsCommands = class extends PrjctCommandsBase {
@@ -14239,7 +16078,7 @@ var init_analytics = __esm({
             output_default.fail("no project ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path33.basename(projectPath);
+          const projectName = path36.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -14477,7 +16316,7 @@ ${catInfo?.title || cat}:`);
 });
 
 // core/commands/cleanup.ts
-import path34 from "path";
+import path37 from "path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -14493,7 +16332,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path34.basename(filePath));
+          results.rotated.push(path37.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -14600,7 +16439,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path35 from "path";
+import path38 from "path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -14612,7 +16451,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
     const designTarget = target || "system";
     output_default.spin(`designing ${designType}...`);
     const projectId = await config_manager_default.getProjectId(projectPath);
-    const designsPath = path35.join(
+    const designsPath = path38.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -14652,7 +16491,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path35.join(designsPath, designFileName);
+    const designFilePath = path38.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -14676,7 +16515,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path36 from "path";
+import path39 from "path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -14728,14 +16567,14 @@ async function undo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path36.join(
+    const snapshotsPath = path39.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
     await file_helper_exports.ensureDir(snapshotsPath);
-    const { execSync: execSync4 } = await import("child_process");
+    const { execSync: execSync5 } = await import("child_process");
     try {
-      const status = execSync4("git status --porcelain", {
+      const status = execSync5("git status --porcelain", {
         cwd: projectPath,
         encoding: "utf-8"
       }).trim();
@@ -14745,11 +16584,11 @@ async function undo(projectPath = process.cwd()) {
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const stashMessage = `prjct-undo-${timestamp}`;
-      execSync4(`git stash push -m "${stashMessage}"`, {
+      execSync5(`git stash push -m "${stashMessage}"`, {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path36.join(snapshotsPath, "history.json");
+      const snapshotFile = path39.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -14789,11 +16628,11 @@ async function redo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path36.join(
+    const snapshotsPath = path39.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path36.join(snapshotsPath, "history.json");
+    const snapshotFile = path39.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -14809,9 +16648,9 @@ async function redo(projectPath = process.cwd()) {
       output_default.warn("nothing to redo");
       return { success: false, message: "Nothing to redo" };
     }
-    const { execSync: execSync4 } = await import("child_process");
+    const { execSync: execSync5 } = await import("child_process");
     try {
-      const stashList = execSync4("git stash list", {
+      const stashList = execSync5("git stash list", {
         cwd: projectPath,
         encoding: "utf-8"
       }).trim();
@@ -14824,7 +16663,7 @@ async function redo(projectPath = process.cwd()) {
         output_default.warn("no prjct undo point found");
         return { success: false, message: "No prjct undo point found" };
       }
-      execSync4("git stash pop", {
+      execSync5("git stash pop", {
         cwd: projectPath,
         encoding: "utf-8"
       });
@@ -14852,11 +16691,11 @@ async function history(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path36.join(
+    const snapshotsPath = path39.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path36.join(snapshotsPath, "history.json");
+    const snapshotFile = path39.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -14962,9 +16801,9 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import path37 from "path";
-import fs30 from "fs";
-import chalk4 from "chalk";
+import path40 from "path";
+import fs33 from "fs";
+import chalk6 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
   "core/commands/setup.ts"() {
@@ -15084,7 +16923,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path37.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path40.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -15142,11 +16981,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs30.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs33.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs30.existsSync(settingsPath)) {
+          if (fs33.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs30.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs33.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -15154,7 +16993,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs30.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs33.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -15164,41 +17003,41 @@ echo "\u26A1 prjct"
        * Show beautiful ASCII art with quick start
        */
       showAsciiArt() {
-        console.log(chalk4.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+        console.log(chalk6.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
         console.log("");
-        console.log(chalk4.bold.cyan("   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557"));
-        console.log(chalk4.bold.cyan("   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D"));
-        console.log(chalk4.bold.cyan("   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551        \u2588\u2588\u2551"));
-        console.log(chalk4.bold.cyan("   \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588   \u2588\u2588\u2551\u2588\u2588\u2551        \u2588\u2588\u2551"));
-        console.log(chalk4.bold.cyan("   \u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551"));
-        console.log(chalk4.bold.cyan("   \u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D"));
+        console.log(chalk6.bold.cyan("   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557"));
+        console.log(chalk6.bold.cyan("   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D"));
+        console.log(chalk6.bold.cyan("   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551\u2588\u2588\u2551        \u2588\u2588\u2551"));
+        console.log(chalk6.bold.cyan("   \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588   \u2588\u2588\u2551\u2588\u2588\u2551        \u2588\u2588\u2551"));
+        console.log(chalk6.bold.cyan("   \u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551"));
+        console.log(chalk6.bold.cyan("   \u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D"));
         console.log("");
-        console.log(`   ${chalk4.bold.cyan("prjct")}${chalk4.magenta("/")}${chalk4.green("cli")}  ${chalk4.dim.white("v" + VERSION + " installed")}`);
+        console.log(`   ${chalk6.bold.cyan("prjct")}${chalk6.magenta("/")}${chalk6.green("cli")}  ${chalk6.dim.white("v" + VERSION + " installed")}`);
         console.log("");
-        console.log(`   ${chalk4.yellow("\u26A1")} Ship faster with zero friction`);
-        console.log(`   ${chalk4.green("\u{1F4DD}")} From idea to technical tasks in minutes`);
-        console.log(`   ${chalk4.cyan("\u{1F916}")} Perfect context for AI agents`);
+        console.log(`   ${chalk6.yellow("\u26A1")} Ship faster with zero friction`);
+        console.log(`   ${chalk6.green("\u{1F4DD}")} From idea to technical tasks in minutes`);
+        console.log(`   ${chalk6.cyan("\u{1F916}")} Perfect context for AI agents`);
         console.log("");
-        console.log(chalk4.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+        console.log(chalk6.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
         console.log("");
-        console.log(chalk4.bold.cyan("\u{1F680} Quick Start"));
-        console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk6.bold.cyan("\u{1F680} Quick Start"));
+        console.log(chalk6.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
         console.log("");
-        console.log(`  ${chalk4.bold("1.")} Initialize your project:`);
-        console.log(`     ${chalk4.green("cd your-project && prjct init")}`);
+        console.log(`  ${chalk6.bold("1.")} Initialize your project:`);
+        console.log(`     ${chalk6.green("cd your-project && prjct init")}`);
         console.log("");
-        console.log(`  ${chalk4.bold("2.")} Start your first task:`);
-        console.log(`     ${chalk4.green('prjct task "build auth"')}`);
+        console.log(`  ${chalk6.bold("2.")} Start your first task:`);
+        console.log(`     ${chalk6.green('prjct task "build auth"')}`);
         console.log("");
-        console.log(`  ${chalk4.bold("3.")} Ship & celebrate:`);
-        console.log(`     ${chalk4.green('prjct ship "user login"')}`);
+        console.log(`  ${chalk6.bold("3.")} Ship & celebrate:`);
+        console.log(`     ${chalk6.green('prjct ship "user login"')}`);
         console.log("");
-        console.log(chalk4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(chalk6.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
         console.log("");
-        console.log(`  ${chalk4.dim("Documentation:")} ${chalk4.cyan("https://prjct.app")}`);
-        console.log(`  ${chalk4.dim("Report issues:")} ${chalk4.cyan("https://github.com/jlopezlira/prjct-cli/issues")}`);
+        console.log(`  ${chalk6.dim("Documentation:")} ${chalk6.cyan("https://prjct.app")}`);
+        console.log(`  ${chalk6.dim("Report issues:")} ${chalk6.cyan("https://github.com/jlopezlira/prjct-cli/issues")}`);
         console.log("");
-        console.log(chalk4.bold.magenta("Happy shipping! \u{1F680}"));
+        console.log(chalk6.bold.magenta("Happy shipping! \u{1F680}"));
         console.log("");
       }
     };
@@ -15206,8 +17045,8 @@ echo "\u26A1 prjct"
 });
 
 // core/commands/context.ts
-import fs31 from "fs/promises";
-import path38 from "path";
+import fs34 from "fs/promises";
+import path41 from "path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -15333,8 +17172,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path38.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs31.readFile(analysisPath, "utf-8");
+          const analysisPath = path41.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs34.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -15457,8 +17296,8 @@ var init_commands = __esm({
       async analyze(options = {}, projectPath = process.cwd()) {
         return this.analysis.analyze(options, projectPath);
       }
-      async sync(projectPath = process.cwd()) {
-        return this.analysis.sync(projectPath);
+      async sync(projectPath = process.cwd(), options = {}) {
+        return this.analysis.sync(projectPath, options);
       }
       // ========== Context Commands ==========
       async context(input = null, projectPath = process.cwd()) {
@@ -15848,7 +17687,7 @@ var workflow, planning, shipping, analytics, maintenance, analysis, setup, conte
 var init_register = __esm({
   "core/commands/register.ts"() {
     "use strict";
-    init_registry();
+    init_registry2();
     init_command_data();
     init_workflow();
     init_planning();
@@ -15877,7 +17716,7 @@ var init_commands2 = __esm({
   "core/commands/index.ts"() {
     "use strict";
     init_commands();
-    init_registry();
+    init_registry2();
     init_register();
     init_types2();
   }
@@ -15888,7 +17727,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.41.0",
+      version: "0.43.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -15993,9 +17832,9 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import fs32 from "fs";
-import path39 from "path";
-import os12 from "os";
+import fs35 from "fs";
+import path42 from "path";
+import os14 from "os";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
   if (["-v", "--version", "version"].includes(commandName)) {
@@ -16068,7 +17907,9 @@ Use 'prjct --help' to see available commands.`);
         redo: /* @__PURE__ */ __name(() => commands.redo(), "redo"),
         history: /* @__PURE__ */ __name(() => commands.history(), "history"),
         // Setup
-        sync: /* @__PURE__ */ __name(() => commands.sync(), "sync"),
+        sync: /* @__PURE__ */ __name(() => commands.sync(process.cwd(), {
+          aiTools: options.agents ? String(options.agents).split(",") : void 0
+        }), "sync"),
         start: /* @__PURE__ */ __name(() => commands.start(), "start"),
         // Context (for Claude templates)
         context: /* @__PURE__ */ __name((p) => commands.context(p), "context")
@@ -16114,12 +17955,12 @@ function parseCommandArgs(cmd, rawArgs) {
 }
 function displayVersion(version) {
   const detection = detectAllProviders();
-  const claudeCommandPath = path39.join(os12.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path39.join(os12.homedir(), ".gemini", "commands", "p.toml");
-  const claudeConfigured = fs32.existsSync(claudeCommandPath);
-  const geminiConfigured = fs32.existsSync(geminiCommandPath);
-  const cursorConfigured = fs32.existsSync(path39.join(process.cwd(), ".cursor", "commands", "sync.md"));
-  const cursorExists = fs32.existsSync(path39.join(process.cwd(), ".cursor"));
+  const claudeCommandPath = path42.join(os14.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path42.join(os14.homedir(), ".gemini", "commands", "p.toml");
+  const claudeConfigured = fs35.existsSync(claudeCommandPath);
+  const geminiConfigured = fs35.existsSync(geminiCommandPath);
+  const cursorConfigured = fs35.existsSync(path42.join(process.cwd(), ".cursor", "commands", "sync.md"));
+  const cursorExists = fs35.existsSync(path42.join(process.cwd(), ".cursor"));
   console.log(`
 ${CYAN2}p/${RESET2} prjct v${version}
 ${DIM3}Context layer for AI coding agents${RESET2}
@@ -16217,7 +18058,7 @@ var init_core = __esm({
   "core/index.ts"() {
     "use strict";
     init_commands2();
-    init_registry();
+    init_registry2();
     init_register();
     init_output();
     init_ai_provider();
@@ -16243,9 +18084,9 @@ var init_core = __esm({
 // bin/prjct.ts
 init_version();
 init_editors_config();
-import fs33 from "fs";
-import path40 from "path";
-import os13 from "os";
+import fs36 from "fs";
+import path43 from "path";
+import os15 from "os";
 
 // core/server/server.ts
 import { Hono as Hono3 } from "hono";
@@ -16985,17 +18826,17 @@ __name(startServer, "startServer");
 init_config_manager();
 init_ai_provider();
 function checkRoutersInstalled() {
-  const home = os13.homedir();
+  const home = os15.homedir();
   const detection = detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path40.join(home, ".claude", "commands", "p.md");
-    if (!fs33.existsSync(claudeRouter)) {
+    const claudeRouter = path43.join(home, ".claude", "commands", "p.md");
+    if (!fs36.existsSync(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path40.join(home, ".gemini", "commands", "p.toml");
-    if (!fs33.existsSync(geminiRouter)) {
+    const geminiRouter = path43.join(home, ".gemini", "commands", "p.toml");
+    if (!fs36.existsSync(geminiRouter)) {
       return false;
     }
   }
@@ -17041,7 +18882,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path40.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path43.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -17053,14 +18894,14 @@ if (args[0] === "start" || args[0] === "setup") {
   }
 } else if (args[0] === "version" || args[0] === "-v" || args[0] === "--version") {
   const detection = detectAllProviders();
-  const home = os13.homedir();
+  const home = os15.homedir();
   const cwd = process.cwd();
-  const claudeConfigured = fs33.existsSync(path40.join(home, ".claude", "commands", "p.md"));
-  const geminiConfigured = fs33.existsSync(path40.join(home, ".gemini", "commands", "p.toml"));
-  const cursorDetected = fs33.existsSync(path40.join(cwd, ".cursor"));
-  const cursorConfigured = fs33.existsSync(path40.join(cwd, ".cursor", "rules", "prjct.mdc"));
-  const windsurfDetected = fs33.existsSync(path40.join(cwd, ".windsurf"));
-  const windsurfConfigured = fs33.existsSync(path40.join(cwd, ".windsurf", "rules", "prjct.md"));
+  const claudeConfigured = fs36.existsSync(path43.join(home, ".claude", "commands", "p.md"));
+  const geminiConfigured = fs36.existsSync(path43.join(home, ".gemini", "commands", "p.toml"));
+  const cursorDetected = fs36.existsSync(path43.join(cwd, ".cursor"));
+  const cursorConfigured = fs36.existsSync(path43.join(cwd, ".cursor", "rules", "prjct.mdc"));
+  const windsurfDetected = fs36.existsSync(path43.join(cwd, ".windsurf"));
+  const windsurfConfigured = fs36.existsSync(path43.join(cwd, ".windsurf", "rules", "prjct.md"));
   const GREEN4 = "\x1B[32m";
   console.log(`
 ${CYAN3}p/${RESET3} prjct v${VERSION}
@@ -17099,9 +18940,9 @@ ${DIM4}Run 'prjct init' to configure (Cursor/Windsurf IDE)${RESET3}
 ${CYAN3}https://prjct.app${RESET3}
 `);
 } else {
-  const configPath = path40.join(os13.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path43.join(os15.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = checkRoutersInstalled();
-  if (!fs33.existsSync(configPath) || !routersInstalled) {
+  if (!fs36.existsSync(configPath) || !routersInstalled) {
     console.log(`
 ${CYAN3}${BOLD2}  Welcome to prjct!${RESET3}