prjct-cli 1.12.0 → 1.14.0

package/dist/bin/prjct.mjs

@@ -10383,6 +10383,76 @@ var init_state = __esm({
   }
 });
 
+// core/schemas/velocity.ts
+import { z as z15 } from "zod";
+var VelocityTrendSchema, SprintVelocitySchema, EstimationPatternSchema, CompletionProjectionSchema, VelocityMetricsSchema, VelocityConfigSchema, DEFAULT_VELOCITY_CONFIG, DEFAULT_VELOCITY_METRICS;
+var init_velocity = __esm({
+  "core/schemas/velocity.ts"() {
+    "use strict";
+    VelocityTrendSchema = z15.enum(["improving", "stable", "declining"]);
+    SprintVelocitySchema = z15.object({
+      sprintNumber: z15.number(),
+      startDate: z15.string(),
+      // ISO8601
+      endDate: z15.string(),
+      // ISO8601
+      pointsCompleted: z15.number(),
+      tasksCompleted: z15.number(),
+      avgVariance: z15.number(),
+      // Average estimation variance (%)
+      estimationAccuracy: z15.number()
+      // % of tasks within tolerance
+    });
+    EstimationPatternSchema = z15.object({
+      category: z15.string(),
+      // task type or domain
+      avgVariance: z15.number(),
+      // positive = over, negative = under
+      taskCount: z15.number()
+    });
+    CompletionProjectionSchema = z15.object({
+      totalPoints: z15.number(),
+      sprints: z15.number(),
+      estimatedDate: z15.string()
+      // ISO8601
+    });
+    VelocityMetricsSchema = z15.object({
+      sprints: z15.array(SprintVelocitySchema),
+      averageVelocity: z15.number(),
+      velocityTrend: VelocityTrendSchema,
+      estimationAccuracy: z15.number(),
+      // 0-100%
+      overEstimated: z15.array(EstimationPatternSchema),
+      underEstimated: z15.array(EstimationPatternSchema),
+      lastUpdated: z15.string()
+      // ISO8601
+    });
+    VelocityConfigSchema = z15.object({
+      sprintLengthDays: z15.number().min(1).max(90).default(7),
+      startDay: z15.enum(["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]).default("monday"),
+      windowSize: z15.number().min(1).max(52).default(6),
+      // number of sprints for rolling average
+      accuracyTolerance: z15.number().min(0).max(100).default(20)
+      // ±% for "accurate" estimate
+    });
+    DEFAULT_VELOCITY_CONFIG = {
+      sprintLengthDays: 7,
+      startDay: "monday",
+      windowSize: 6,
+      accuracyTolerance: 20
+    };
+    DEFAULT_VELOCITY_METRICS = {
+      sprints: [],
+      averageVelocity: 0,
+      velocityTrend: "stable",
+      estimationAccuracy: 0,
+      overEstimated: [],
+      underEstimated: [],
+      lastUpdated: ""
+    };
+  }
+});
+
 // core/schemas/index.ts
 var init_schemas2 = __esm({
   "core/schemas/index.ts"() {
@@ -10401,6 +10471,7 @@ var init_schemas2 = __esm({
     init_schemas();
     init_shipped();
     init_state();
+    init_velocity();
   }
 });
 
@@ -11374,6 +11445,457 @@ Context: ${context2}` : ""}`,
   }
 });
 
+// core/domain/velocity.ts
+function getSprintStart(date, config) {
+  const resolved = resolveConfig(config);
+  const startDayIdx = DAY_INDEX[resolved.startDay];
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  const currentDay = d.getDay();
+  const diff = (currentDay - startDayIdx + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  return d;
+}
+function getSprintEnd(sprintStart, config) {
+  const resolved = resolveConfig(config);
+  const end = new Date(sprintStart);
+  end.setDate(end.getDate() + resolved.sprintLengthDays - 1);
+  end.setHours(23, 59, 59, 999);
+  return end;
+}
+function getSprintNumber(date, earliestDate, config) {
+  const resolved = resolveConfig(config);
+  const sprintStart = getSprintStart(date, config);
+  const firstSprintStart = getSprintStart(earliestDate, config);
+  const diffMs = sprintStart.getTime() - firstSprintStart.getTime();
+  const diffDays = Math.round(diffMs / (1e3 * 60 * 60 * 24));
+  return Math.floor(diffDays / resolved.sprintLengthDays) + 1;
+}
+function calculateVelocity(outcomes, config = DEFAULT_VELOCITY_CONFIG) {
+  const resolved = resolveConfig(config);
+  if (outcomes.length === 0) {
+    return {
+      sprints: [],
+      averageVelocity: 0,
+      velocityTrend: "stable",
+      estimationAccuracy: 0,
+      overEstimated: [],
+      underEstimated: [],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const sprintBuckets = bucketBySprint(outcomes, config);
+  const sprints = buildSprintVelocities(sprintBuckets, resolved.accuracyTolerance);
+  const windowSprints = sprints.slice(-resolved.windowSize);
+  const averageVelocity = calculateAverageVelocity(windowSprints);
+  const velocityTrend = detectTrend(windowSprints);
+  const estimationAccuracy = calculateOverallAccuracy(outcomes, resolved.accuracyTolerance);
+  const { overEstimated, underEstimated } = detectEstimationPatterns(outcomes);
+  return {
+    sprints,
+    averageVelocity,
+    velocityTrend,
+    estimationAccuracy,
+    overEstimated,
+    underEstimated,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function projectCompletion(totalPoints, averageVelocity, config = DEFAULT_VELOCITY_CONFIG) {
+  const resolved = resolveConfig(config);
+  if (averageVelocity <= 0) {
+    return {
+      totalPoints,
+      sprints: 0,
+      estimatedDate: ""
+    };
+  }
+  const sprints = Math.ceil(totalPoints / averageVelocity);
+  const daysRemaining = sprints * resolved.sprintLengthDays;
+  const estimatedDate = /* @__PURE__ */ new Date();
+  estimatedDate.setDate(estimatedDate.getDate() + daysRemaining);
+  return {
+    totalPoints,
+    sprints,
+    estimatedDate: estimatedDate.toISOString()
+  };
+}
+function bucketBySprint(outcomes, config) {
+  const buckets = /* @__PURE__ */ new Map();
+  const dates = outcomes.map((o) => new Date(o.completedAt));
+  const earliest = new Date(Math.min(...dates.map((d) => d.getTime())));
+  for (const outcome of outcomes) {
+    const completedDate = new Date(outcome.completedAt);
+    const sprintNum = getSprintNumber(completedDate, earliest, config);
+    if (!buckets.has(sprintNum)) {
+      const start = getSprintStart(completedDate, config);
+      const end = getSprintEnd(start, config);
+      buckets.set(sprintNum, {
+        sprintNumber: sprintNum,
+        startDate: start,
+        endDate: end,
+        outcomes: []
+      });
+    }
+    buckets.get(sprintNum).outcomes.push(outcome);
+  }
+  return buckets;
+}
+function buildSprintVelocities(buckets, accuracyTolerance) {
+  const sprints = [];
+  for (const [, bucket] of buckets) {
+    const points = bucket.outcomes.reduce((sum, o) => {
+      return sum + derivePoints(o);
+    }, 0);
+    const variances = bucket.outcomes.filter((o) => o.variance).map((o) => parseVariancePercent(o));
+    const avgVariance = variances.length > 0 ? Math.round(variances.reduce((a, b) => a + b, 0) / variances.length) : 0;
+    const accurateCount = variances.filter((v) => Math.abs(v) <= accuracyTolerance).length;
+    const estimationAccuracy = variances.length > 0 ? Math.round(accurateCount / variances.length * 100) : 0;
+    sprints.push({
+      sprintNumber: bucket.sprintNumber,
+      startDate: bucket.startDate.toISOString(),
+      endDate: bucket.endDate.toISOString(),
+      pointsCompleted: points,
+      tasksCompleted: bucket.outcomes.length,
+      avgVariance,
+      estimationAccuracy
+    });
+  }
+  return sprints.sort((a, b) => a.sprintNumber - b.sprintNumber);
+}
+function detectTrend(sprints) {
+  if (sprints.length < 3) return "stable";
+  const points = sprints.map((s) => s.pointsCompleted);
+  const n = points.length;
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += i;
+    sumY += points[i];
+    sumXY += i * points[i];
+    sumX2 += i * i;
+  }
+  const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+  const avgVelocity = sumY / n;
+  if (avgVelocity === 0) return "stable";
+  const normalizedSlope = slope / avgVelocity;
+  if (normalizedSlope > 0.1) return "improving";
+  if (normalizedSlope < -0.1) return "declining";
+  return "stable";
+}
+function calculateOverallAccuracy(outcomes, tolerance) {
+  const withEstimates = outcomes.filter((o) => o.variance);
+  if (withEstimates.length === 0) return 0;
+  const accurate = withEstimates.filter((o) => {
+    const variancePct = parseVariancePercent(o);
+    return Math.abs(variancePct) <= tolerance;
+  });
+  return Math.round(accurate.length / withEstimates.length * 100);
+}
+function calculateAverageVelocity(sprints) {
+  if (sprints.length === 0) return 0;
+  const total = sprints.reduce((sum, s) => sum + s.pointsCompleted, 0);
+  return Math.round(total / sprints.length * 10) / 10;
+}
+function detectEstimationPatterns(outcomes) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const outcome of outcomes) {
+    if (!outcome.variance) continue;
+    const variancePct = parseVariancePercent(outcome);
+    const categories = outcome.tags && outcome.tags.length > 0 ? outcome.tags : ["uncategorized"];
+    for (const category of categories) {
+      if (!byCategory.has(category)) {
+        byCategory.set(category, { variances: [], count: 0 });
+      }
+      const entry = byCategory.get(category);
+      entry.variances.push(variancePct);
+      entry.count++;
+    }
+  }
+  const overEstimated = [];
+  const underEstimated = [];
+  for (const [category, data] of byCategory) {
+    if (data.count < 2) continue;
+    const avg = Math.round(data.variances.reduce((a, b) => a + b, 0) / data.variances.length);
+    if (avg > 10) {
+      underEstimated.push({ category, avgVariance: avg, taskCount: data.count });
+    } else if (avg < -10) {
+      overEstimated.push({ category, avgVariance: Math.abs(avg), taskCount: data.count });
+    }
+  }
+  overEstimated.sort((a, b) => b.avgVariance - a.avgVariance);
+  underEstimated.sort((a, b) => b.avgVariance - a.avgVariance);
+  return { overEstimated, underEstimated };
+}
+function parseVariancePercent(outcome) {
+  if (!outcome.variance) return 0;
+  const estimated = parseDurationMinutes(outcome.estimatedDuration);
+  const actual = parseDurationMinutes(outcome.actualDuration);
+  if (estimated <= 0) return 0;
+  return Math.round((actual - estimated) / estimated * 100);
+}
+function parseDurationMinutes(duration) {
+  let minutes = 0;
+  const hourMatch = duration.match(/(\d+)h/);
+  if (hourMatch) {
+    minutes += Number.parseInt(hourMatch[1], 10) * 60;
+  }
+  const minMatch = duration.match(/(\d+)m/);
+  if (minMatch) {
+    minutes += Number.parseInt(minMatch[1], 10);
+  }
+  const secMatch = duration.match(/(\d+)s/);
+  if (secMatch && minutes === 0) {
+    minutes = 1;
+  }
+  return minutes;
+}
+function formatVelocityContext(metrics) {
+  if (metrics.sprints.length === 0) {
+    return "No velocity data available yet.";
+  }
+  const lines = [];
+  lines.push(
+    `Project velocity: ${metrics.averageVelocity} pts/sprint (trend: ${metrics.velocityTrend})`
+  );
+  lines.push(`Estimation accuracy: ${metrics.estimationAccuracy}%`);
+  for (const pattern of metrics.underEstimated) {
+    lines.push(
+      `\u26A0 "${pattern.category}" tasks historically take ${pattern.avgVariance}% longer than estimated`
+    );
+  }
+  for (const pattern of metrics.overEstimated) {
+    lines.push(
+      `"${pattern.category}" tasks typically finish ${pattern.avgVariance}% faster than estimated`
+    );
+  }
+  return lines.join("\n");
+}
+function derivePoints(outcome) {
+  if (!outcome.estimatedDuration) return 0;
+  const minutes = parseDurationMinutes(outcome.estimatedDuration);
+  if (minutes <= 0) return 0;
+  let closest = FIBONACCI_MINUTES[0];
+  let smallestDiff = Number.POSITIVE_INFINITY;
+  for (const entry of FIBONACCI_MINUTES) {
+    const diff = Math.abs(entry.typical - minutes);
+    if (diff < smallestDiff) {
+      smallestDiff = diff;
+      closest = entry;
+    }
+  }
+  return closest.points;
+}
+function resolveConfig(config) {
+  return {
+    sprintLengthDays: config.sprintLengthDays ?? 7,
+    startDay: config.startDay ?? "monday",
+    windowSize: config.windowSize ?? 6,
+    accuracyTolerance: config.accuracyTolerance ?? 20
+  };
+}
+var DAY_INDEX, FIBONACCI_MINUTES;
+var init_velocity2 = __esm({
+  "core/domain/velocity.ts"() {
+    "use strict";
+    init_velocity();
+    DAY_INDEX = {
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
+    };
+    __name(getSprintStart, "getSprintStart");
+    __name(getSprintEnd, "getSprintEnd");
+    __name(getSprintNumber, "getSprintNumber");
+    __name(calculateVelocity, "calculateVelocity");
+    __name(projectCompletion, "projectCompletion");
+    __name(bucketBySprint, "bucketBySprint");
+    __name(buildSprintVelocities, "buildSprintVelocities");
+    __name(detectTrend, "detectTrend");
+    __name(calculateOverallAccuracy, "calculateOverallAccuracy");
+    __name(calculateAverageVelocity, "calculateAverageVelocity");
+    __name(detectEstimationPatterns, "detectEstimationPatterns");
+    __name(parseVariancePercent, "parseVariancePercent");
+    __name(parseDurationMinutes, "parseDurationMinutes");
+    __name(formatVelocityContext, "formatVelocityContext");
+    FIBONACCI_MINUTES = [
+      { points: 1, typical: 10 },
+      { points: 2, typical: 20 },
+      { points: 3, typical: 45 },
+      { points: 5, typical: 90 },
+      { points: 8, typical: 180 },
+      { points: 13, typical: 360 },
+      { points: 21, typical: 720 }
+    ];
+    __name(derivePoints, "derivePoints");
+    __name(resolveConfig, "resolveConfig");
+  }
+});
+
+// core/outcomes/recorder.ts
+import path24 from "node:path";
+var OUTCOMES_DIR, OUTCOMES_FILE, OutcomeRecorder, outcomeRecorder, recorder_default;
+var init_recorder = __esm({
+  "core/outcomes/recorder.ts"() {
+    "use strict";
+    init_path_manager();
+    init_schemas2();
+    init_file_helper();
+    OUTCOMES_DIR = "outcomes";
+    OUTCOMES_FILE = "outcomes.jsonl";
+    OutcomeRecorder = class {
+      static {
+        __name(this, "OutcomeRecorder");
+      }
+      /**
+       * Get outcomes directory path for a project.
+       */
+      getOutcomesDir(projectId) {
+        const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+        return path24.join(globalPath, OUTCOMES_DIR);
+      }
+      /**
+       * Get outcomes file path for a project.
+       */
+      getOutcomesPath(projectId) {
+        return path24.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
+      }
+      /**
+       * Record an outcome.
+       */
+      async record(projectId, input) {
+        const outcome = {
+          ...input,
+          id: generateUUID()
+        };
+        const outcomesPath = this.getOutcomesPath(projectId);
+        await ensureDir(path24.dirname(outcomesPath));
+        await appendLine(outcomesPath, JSON.stringify(outcome));
+        return outcome;
+      }
+      /**
+       * Get all outcomes for a project.
+       */
+      async getAll(projectId) {
+        const outcomesPath = this.getOutcomesPath(projectId);
+        if (!await fileExists2(outcomesPath)) {
+          return [];
+        }
+        const content = await readFile(outcomesPath);
+        if (!content.trim()) {
+          return [];
+        }
+        return content.trim().split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+      }
+      /**
+       * Get outcomes matching a filter.
+       */
+      async filter(projectId, filter) {
+        const all = await this.getAll(projectId);
+        return all.filter((outcome) => {
+          if (filter.sessionId && outcome.sessionId !== filter.sessionId) {
+            return false;
+          }
+          if (filter.command && outcome.command !== filter.command) {
+            return false;
+          }
+          if (filter.agent && outcome.agentUsed !== filter.agent) {
+            return false;
+          }
+          if (filter.fromDate && outcome.startedAt < filter.fromDate) {
+            return false;
+          }
+          if (filter.toDate && outcome.completedAt > filter.toDate) {
+            return false;
+          }
+          if (filter.minQuality && outcome.qualityScore < filter.minQuality) {
+            return false;
+          }
+          if (filter.tags && filter.tags.length > 0) {
+            const outcomeTags = outcome.tags || [];
+            if (!filter.tags.some((tag) => outcomeTags.includes(tag))) {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+      /**
+       * Get recent outcomes (last N).
+       */
+      async getRecent(projectId, count = 10) {
+        const all = await this.getAll(projectId);
+        return all.slice(-count);
+      }
+      /**
+       * Get outcomes for a specific command.
+       */
+      async getByCommand(projectId, command) {
+        return this.filter(projectId, { command });
+      }
+      /**
+       * Get outcomes for a specific agent.
+       */
+      async getByAgent(projectId, agent) {
+        return this.filter(projectId, { agent });
+      }
+      /**
+       * Calculate estimate accuracy.
+       */
+      async getEstimateAccuracy(projectId) {
+        const outcomes = await this.getAll(projectId);
+        if (outcomes.length === 0) {
+          return 0;
+        }
+        const accurate = outcomes.filter((o) => {
+          if (!o.variance) return false;
+          const variance = this.parseVariance(o.variance);
+          const estimated = this.parseDuration(o.estimatedDuration);
+          if (estimated === 0) return false;
+          return Math.abs(variance) / estimated <= 0.2;
+        });
+        return Math.round(accurate.length / outcomes.length * 100);
+      }
+      /**
+       * Parse variance string to minutes.
+       * "+30m" → 30, "-15m" → -15
+       */
+      parseVariance(variance) {
+        const match = variance.match(/^([+-])(\d+)([mh])$/);
+        if (!match) return 0;
+        const sign = match[1] === "-" ? -1 : 1;
+        const value = parseInt(match[2], 10);
+        const unit = match[3];
+        return sign * (unit === "h" ? value * 60 : value);
+      }
+      /**
+       * Parse duration string to minutes.
+       * "2h" → 120, "30m" → 30, "1h 30m" → 90
+       */
+      parseDuration(duration) {
+        let minutes = 0;
+        const hourMatch = duration.match(/(\d+)h/);
+        if (hourMatch) {
+          minutes += parseInt(hourMatch[1], 10) * 60;
+        }
+        const minMatch = duration.match(/(\d+)m/);
+        if (minMatch) {
+          minutes += parseInt(minMatch[1], 10);
+        }
+        return minutes;
+      }
+    };
+    outcomeRecorder = new OutcomeRecorder();
+    recorder_default = outcomeRecorder;
+  }
+});
+
 // core/storage/analysis-storage.ts
 import { createHash } from "node:crypto";
 var AnalysisStorage, analysisStorage;
@@ -11826,7 +12348,7 @@ var init_ideas_storage = __esm({
 // core/storage/index-storage.ts
 import crypto4 from "node:crypto";
 import fs26 from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 function getDefaultChecksums() {
   return {
     version: INDEX_VERSION,
@@ -11851,7 +12373,7 @@ var init_index_storage = __esm({
        * Get the index directory path for a project
        */
       getIndexPath(projectId) {
-        return path24.join(path_manager_default.getGlobalProjectPath(projectId), "index");
+        return path25.join(path_manager_default.getGlobalProjectPath(projectId), "index");
       }
       /**
        * Ensure index directory exists
@@ -11868,7 +12390,7 @@ var init_index_storage = __esm({
        * Read the project index
        */
       async readIndex(projectId) {
-        const filePath = path24.join(this.getIndexPath(projectId), "project-index.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "project-index.json");
         try {
           const content = await fs26.readFile(filePath, "utf-8");
           const index = JSON.parse(content);
@@ -11888,7 +12410,7 @@ var init_index_storage = __esm({
        */
       async writeIndex(projectId, index) {
         await this.ensureIndexDir(projectId);
-        const filePath = path24.join(this.getIndexPath(projectId), "project-index.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "project-index.json");
         await fs26.writeFile(filePath, JSON.stringify(index, null, 2), "utf-8");
       }
       /**
@@ -11905,7 +12427,7 @@ var init_index_storage = __esm({
        * Read file checksums
        */
       async readChecksums(projectId) {
-        const filePath = path24.join(this.getIndexPath(projectId), "checksums.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "checksums.json");
         try {
           const content = await fs26.readFile(filePath, "utf-8");
           return JSON.parse(content);
@@ -11921,7 +12443,7 @@ var init_index_storage = __esm({
        */
       async writeChecksums(projectId, checksums) {
         await this.ensureIndexDir(projectId);
-        const filePath = path24.join(this.getIndexPath(projectId), "checksums.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "checksums.json");
         await fs26.writeFile(filePath, JSON.stringify(checksums, null, 2), "utf-8");
       }
       /**
@@ -11965,7 +12487,7 @@ var init_index_storage = __esm({
        * Read file scores
        */
       async readScores(projectId) {
-        const filePath = path24.join(this.getIndexPath(projectId), "file-scores.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "file-scores.json");
         try {
           const content = await fs26.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
@@ -11982,7 +12504,7 @@ var init_index_storage = __esm({
        */
       async writeScores(projectId, scores) {
         await this.ensureIndexDir(projectId);
-        const filePath = path24.join(this.getIndexPath(projectId), "file-scores.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "file-scores.json");
         const data = {
           version: INDEX_VERSION,
           lastUpdated: getTimestamp(),
@@ -12000,7 +12522,7 @@ var init_index_storage = __esm({
         const indexPath = this.getIndexPath(projectId);
         try {
           const files = await fs26.readdir(indexPath);
-          await Promise.all(files.map((file) => fs26.unlink(path24.join(indexPath, file))));
+          await Promise.all(files.map((file) => fs26.unlink(path25.join(indexPath, file))));
         } catch (error) {
           if (!isNotFoundError(error)) {
             throw error;
@@ -12026,7 +12548,7 @@ var init_index_storage = __esm({
        * Read discovered domains for a project
        */
       async readDomains(projectId) {
-        const filePath = path24.join(this.getIndexPath(projectId), "domains.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "domains.json");
         try {
           const content = await fs26.readFile(filePath, "utf-8");
           const domains = JSON.parse(content);
@@ -12046,7 +12568,7 @@ var init_index_storage = __esm({
        */
       async writeDomains(projectId, domains) {
         await this.ensureIndexDir(projectId);
-        const filePath = path24.join(this.getIndexPath(projectId), "domains.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "domains.json");
         await fs26.writeFile(filePath, JSON.stringify(domains, null, 2), "utf-8");
       }
       // ==========================================================================
@@ -12056,7 +12578,7 @@ var init_index_storage = __esm({
        * Read categories cache
        */
       async readCategories(projectId) {
-        const filePath = path24.join(this.getIndexPath(projectId), "categories-cache.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "categories-cache.json");
         try {
           const content = await fs26.readFile(filePath, "utf-8");
           const cache2 = JSON.parse(content);
@@ -12076,7 +12598,7 @@ var init_index_storage = __esm({
        */
       async writeCategories(projectId, cache2) {
         await this.ensureIndexDir(projectId);
-        const filePath = path24.join(this.getIndexPath(projectId), "categories-cache.json");
+        const filePath = path25.join(this.getIndexPath(projectId), "categories-cache.json");
         await fs26.writeFile(filePath, JSON.stringify(cache2, null, 2), "utf-8");
       }
       /**
@@ -13542,7 +14064,7 @@ ${errors.join("\n")}`);
 // core/storage/storage.ts
 import fs27 from "node:fs/promises";
 import os8 from "node:os";
-import path25 from "node:path";
+import path26 from "node:path";
 function getStorage(projectId) {
   return new FileStorage(projectId);
 }
@@ -13560,7 +14082,7 @@ var init_storage = __esm({
       basePath;
       constructor(projectId) {
         this.projectId = projectId;
-        this.basePath = path25.join(os8.homedir(), ".prjct-cli/projects", projectId, "data");
+        this.basePath = path26.join(os8.homedir(), ".prjct-cli/projects", projectId, "data");
       }
       /**
        * Convert path array to file path
@@ -13569,16 +14091,16 @@ var init_storage = __esm({
        */
       pathToFile(pathArray) {
         if (pathArray.length === 1) {
-          return path25.join(this.basePath, `${pathArray[0]}.json`);
+          return path26.join(this.basePath, `${pathArray[0]}.json`);
         }
         const dir = `${pathArray[0]}s`;
         const rest = pathArray.slice(1);
         const filename = `${rest.join("/")}.json`;
-        return path25.join(this.basePath, dir, filename);
+        return path26.join(this.basePath, dir, filename);
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs27.mkdir(path25.dirname(filePath), { recursive: true });
+        await fs27.mkdir(path26.dirname(filePath), { recursive: true });
         await fs27.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
@@ -13604,7 +14126,7 @@ var init_storage = __esm({
         }
       }
       async list(prefix) {
-        const dir = path25.join(this.basePath, `${prefix[0]}s`);
+        const dir = path26.join(this.basePath, `${prefix[0]}s`);
         try {
           const files = await fs27.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
@@ -13651,7 +14173,7 @@ var init_storage = __esm({
        * Update collection index
        */
       async updateIndex(collection, id, action) {
-        const indexPath = path25.join(this.basePath, `${collection}s`, "index.json");
+        const indexPath = path26.join(this.basePath, `${collection}s`, "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
           const content = await fs27.readFile(indexPath, "utf-8");
@@ -13667,7 +14189,7 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs27.mkdir(path25.dirname(indexPath), { recursive: true });
+        await fs27.mkdir(path26.dirname(indexPath), { recursive: true });
         await fs27.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
@@ -13675,6 +14197,115 @@ var init_storage = __esm({
   }
 });
 
+// core/storage/velocity-storage.ts
+function formatTrendIcon(trend) {
+  switch (trend) {
+    case "improving":
+      return "\u2191";
+    case "declining":
+      return "\u2193";
+    default:
+      return "\u2192";
+  }
+}
+var VelocityStorage, velocityStorage;
+var init_velocity_storage = __esm({
+  "core/storage/velocity-storage.ts"() {
+    "use strict";
+    init_velocity();
+    init_storage_manager();
+    VelocityStorage = class extends StorageManager {
+      static {
+        __name(this, "VelocityStorage");
+      }
+      constructor() {
+        super("velocity.json");
+      }
+      getDefault() {
+        return {
+          metrics: DEFAULT_VELOCITY_METRICS,
+          lastUpdated: ""
+        };
+      }
+      getMdFilename() {
+        return "velocity.md";
+      }
+      getLayer() {
+        return "progress";
+      }
+      getEventType(action) {
+        return `velocity.${action}d`;
+      }
+      toMarkdown(data) {
+        const { metrics } = data;
+        const lines = ["# Velocity", ""];
+        if (metrics.sprints.length === 0) {
+          lines.push("_No velocity data yet. Complete tasks with estimates to build velocity history._");
+          lines.push("");
+          return lines.join("\n");
+        }
+        lines.push(`**Average**: ${metrics.averageVelocity} pts/sprint`);
+        lines.push(`**Trend**: ${formatTrendIcon(metrics.velocityTrend)} ${metrics.velocityTrend}`);
+        lines.push(`**Estimation Accuracy**: ${metrics.estimationAccuracy}%`);
+        lines.push("");
+        lines.push("## Sprint History");
+        lines.push("");
+        lines.push("| Sprint | Points | Tasks | Accuracy | Variance |");
+        lines.push("|--------|--------|-------|----------|----------|");
+        const recentSprints = metrics.sprints.slice(-6);
+        for (const sprint of recentSprints) {
+          lines.push(
+            `| ${sprint.sprintNumber} | ${sprint.pointsCompleted} | ${sprint.tasksCompleted} | ${sprint.estimationAccuracy}% | ${sprint.avgVariance > 0 ? "+" : ""}${sprint.avgVariance}% |`
+          );
+        }
+        lines.push("");
+        if (metrics.underEstimated.length > 0 || metrics.overEstimated.length > 0) {
+          lines.push("## Estimation Patterns");
+          lines.push("");
+          for (const p of metrics.underEstimated) {
+            lines.push(
+              `- \u26A0 **${p.category}**: underestimated by avg ${p.avgVariance}% (${p.taskCount} tasks)`
+            );
+          }
+          for (const p of metrics.overEstimated) {
+            lines.push(
+              `- \u2713 **${p.category}**: overestimated by avg ${p.avgVariance}% (${p.taskCount} tasks)`
+            );
+          }
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      // ===========================================================================
+      // Domain Methods
+      // ===========================================================================
+      /**
+       * Save computed velocity metrics.
+       */
+      async saveMetrics(projectId, metrics) {
+        await this.write(projectId, {
+          metrics,
+          lastUpdated: metrics.lastUpdated
+        });
+        await this.publishEntityEvent(projectId, "velocity", "updated", {
+          averageVelocity: metrics.averageVelocity,
+          trend: metrics.velocityTrend,
+          sprintCount: metrics.sprints.length
+        });
+      }
+      /**
+       * Get current velocity metrics.
+       */
+      async getMetrics(projectId) {
+        const data = await this.read(projectId);
+        return data.metrics;
+      }
+    };
+    __name(formatTrendIcon, "formatTrendIcon");
+    velocityStorage = new VelocityStorage();
+  }
+});
+
 // core/storage/index.ts
 var init_storage2 = __esm({
   "core/storage/index.ts"() {
@@ -13688,19 +14319,20 @@ var init_storage2 = __esm({
     init_state_storage();
     init_storage();
     init_storage_manager();
+    init_velocity_storage();
   }
 });
 
 // core/agentic/domain-classifier.ts
 import { createHash as createHash2 } from "node:crypto";
 import fs28 from "node:fs/promises";
-import path26 from "node:path";
+import path27 from "node:path";
 function hashDescription(description) {
   return createHash2("sha256").update(description.toLowerCase().trim()).digest("hex").slice(0, 16);
 }
 async function loadCache(globalPath) {
   try {
-    const cachePath = path26.join(globalPath, "storage", "classification-cache.json");
+    const cachePath = path27.join(globalPath, "storage", "classification-cache.json");
     const content = await fs28.readFile(cachePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
@@ -13711,7 +14343,7 @@ async function loadCache(globalPath) {
 }
 async function saveCache(globalPath, cache2) {
   try {
-    const cachePath = path26.join(globalPath, "storage", "classification-cache.json");
+    const cachePath = path27.join(globalPath, "storage", "classification-cache.json");
     await fs28.writeFile(cachePath, JSON.stringify(cache2, null, 2));
   } catch (error) {
     console.warn("[classifier] Failed to save cache:", getErrorMessage2(error));
@@ -14085,7 +14717,7 @@ var init_domain_classifier = __esm({
 
 // core/agentic/template-loader.ts
 import fs29 from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 function updateLruOrder(key) {
   const index = cacheOrder.indexOf(key);
   if (index > -1) cacheOrder.splice(index, 1);
@@ -14123,7 +14755,7 @@ async function load(commandName) {
     updateLruOrder(commandName);
     return cache.get(commandName);
   }
-  const templatePath = path27.join(TEMPLATES_DIR, `${commandName}.md`);
+  const templatePath = path28.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
     const rawContent = await fs29.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
@@ -14148,7 +14780,7 @@ var init_template_loader = __esm({
   "core/agentic/template-loader.ts"() {
     "use strict";
     init_errors();
-    TEMPLATES_DIR = path27.join(__dirname, "..", "..", "templates", "commands");
+    TEMPLATES_DIR = path28.join(__dirname, "..", "..", "templates", "commands");
     MAX_CACHE_SIZE = 50;
     cache = /* @__PURE__ */ new Map();
     cacheOrder = [];
@@ -14167,7 +14799,7 @@ var init_template_loader = __esm({
 import { exec as execCallback5 } from "node:child_process";
 import fs30 from "node:fs/promises";
 import os9 from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 import { promisify as promisify7 } from "node:util";
 var execAsync3, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
 var init_orchestrator_executor = __esm({
@@ -14176,8 +14808,11 @@ var init_orchestrator_executor = __esm({
     init_files_tool();
     init_recent_tool();
     init_signatures_tool();
+    init_velocity2();
     init_config_manager();
     init_path_manager();
+    init_recorder();
+    init_velocity();
     init_storage2();
     init_fs();
     init_domain_classifier();
@@ -14203,7 +14838,11 @@ var init_orchestrator_executor = __esm({
         const { domains, primary } = await this.detectDomains(taskDescription, projectId, repoAnalysis);
         const agents = await this.loadAgents(domains, projectId);
         const skills = await this.loadSkills(agents);
-        const realContext = await this.gatherRealContext(taskDescription, projectPath);
+        const [realContext, sealedAnalysis, velocityContext] = await Promise.all([
+          this.gatherRealContext(taskDescription, projectPath),
+          this.loadSealedAnalysis(projectId),
+          this.loadVelocityContext(projectId)
+        ]);
         const requiresFragmentation = this.shouldFragment(domains, taskDescription);
         let subtasks = null;
         if (requiresFragmentation && command === "task") {
@@ -14221,7 +14860,9 @@ var init_orchestrator_executor = __esm({
             ecosystem: repoAnalysis?.ecosystem || "unknown",
             conventions: repoAnalysis?.conventions || []
           },
-          realContext
+          realContext,
+          sealedAnalysis,
+          velocityContext
         };
       }
       /**
@@ -14301,12 +14942,52 @@ var init_orchestrator_executor = __esm({
           return { branch: "unknown", status: "git unavailable" };
         }
       }
+      /**
+       * Load sealed/active analysis from analysis storage (PRJ-260).
+       * Returns sealed if available, otherwise draft as fallback.
+       * Returns null if no analysis exists (graceful degradation).
+       */
+      async loadSealedAnalysis(projectId) {
+        try {
+          const analysis2 = await analysisStorage.getActive(projectId);
+          if (!analysis2) return null;
+          return {
+            languages: analysis2.languages,
+            frameworks: analysis2.frameworks,
+            packageManager: analysis2.packageManager,
+            sourceDir: analysis2.sourceDir,
+            testDir: analysis2.testDir,
+            fileCount: analysis2.fileCount,
+            patterns: analysis2.patterns,
+            antiPatterns: analysis2.antiPatterns,
+            status: analysis2.status ?? "draft",
+            commitHash: analysis2.commitHash
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Load velocity context for estimation guidance (PRJ-296).
+       * Returns formatted string for prompt injection, or null if no data.
+       */
+      async loadVelocityContext(projectId) {
+        try {
+          const outcomes = await recorder_default.getAll(projectId);
+          if (outcomes.length === 0) return null;
+          const metrics = calculateVelocity(outcomes, DEFAULT_VELOCITY_CONFIG);
+          if (metrics.sprints.length === 0) return null;
+          return formatVelocityContext(metrics);
+        } catch {
+          return null;
+        }
+      }
       /**
        * Load repo-analysis.json for project context
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path28.join(globalPath, "analysis", "repo-analysis.json");
+          const analysisPath = path29.join(globalPath, "analysis", "repo-analysis.json");
           const content = await fs30.readFile(analysisPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
@@ -14332,7 +15013,7 @@ var init_orchestrator_executor = __esm({
           hasDocker: false
         };
         try {
-          const statePath = path28.join(globalPath, "storage", "state.json");
+          const statePath = path29.join(globalPath, "storage", "state.json");
           const stateContent = await fs30.readFile(statePath, "utf-8");
           const state = JSON.parse(stateContent);
           if (state.domains) {
@@ -14367,7 +15048,7 @@ var init_orchestrator_executor = __esm({
        */
       async getAvailableAgentNames(globalPath) {
         try {
-          const agentsDir = path28.join(globalPath, "agents");
+          const agentsDir = path29.join(globalPath, "agents");
           const files = await fs30.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
@@ -14384,11 +15065,11 @@ var init_orchestrator_executor = __esm({
        */
       async loadAgents(domains, projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        const agentsDir = path28.join(globalPath, "agents");
+        const agentsDir = path29.join(globalPath, "agents");
         const agentPromises = domains.map(async (domain) => {
           const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`];
           for (const fileName of possibleNames) {
-            const filePath = path28.join(agentsDir, fileName);
+            const filePath = path29.join(agentsDir, fileName);
             try {
               const content = await fs30.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
@@ -14431,7 +15112,7 @@ var init_orchestrator_executor = __esm({
        * Uses parallel file reads for performance (PRJ-110).
        */
       async loadSkills(agents) {
-        const skillsDir = path28.join(os9.homedir(), ".claude", "skills");
+        const skillsDir = path29.join(os9.homedir(), ".claude", "skills");
         const skillToAgents = /* @__PURE__ */ new Map();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
@@ -14442,8 +15123,8 @@ var init_orchestrator_executor = __esm({
         }
         const skillPromises = Array.from(skillToAgents.keys()).map(
           async (skillName) => {
-            const flatPath = path28.join(skillsDir, `${skillName}.md`);
-            const subdirPath = path28.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path29.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path29.join(skillsDir, skillName, "SKILL.md");
             try {
               const content = await fs30.readFile(subdirPath, "utf-8");
               return { name: skillName, content, filePath: subdirPath };
@@ -14885,262 +15566,104 @@ var init_plan_mode = __esm({
           aborted: true,
           planId: plan.id,
           reason: reason2,
-          completedSteps: plan.steps.filter((s) => s.status === "completed").length,
-          totalSteps: plan.steps.length
-        };
-        this.activePlans.delete(projectId);
-        return summary;
-      }
-      /**
-       * Generate approval prompt for destructive commands (class method wrapper)
-       */
-      generateApprovalPrompt(commandName, context2) {
-        return generateApprovalPrompt(commandName, context2);
-      }
-      /**
-       * Format plan status for display
-       */
-      formatStatus(projectId) {
-        const plan = this.getActivePlan(projectId);
-        if (!plan) return "No active plan";
-        const statusEmoji = {
-          [PLAN_STATUS.GATHERING]: "\u{1F50D}",
-          [PLAN_STATUS.ANALYZING]: "\u{1F9E0}",
-          [PLAN_STATUS.PROPOSING]: "\u{1F4DD}",
-          [PLAN_STATUS.PENDING_APPROVAL]: "\u23F3",
-          [PLAN_STATUS.APPROVED]: "\u2705",
-          [PLAN_STATUS.EXECUTING]: "\u26A1",
-          [PLAN_STATUS.COMPLETED]: "\u{1F389}",
-          [PLAN_STATUS.REJECTED]: "\u274C",
-          [PLAN_STATUS.ABORTED]: "\u{1F6D1}"
-        };
-        const lines = [
-          `${statusEmoji[plan.status] || "\u{1F4CB}"} Plan: ${plan.command}`,
-          `Status: ${plan.status}`
-        ];
-        if (plan.status === PLAN_STATUS.EXECUTING) {
-          const progress = Math.round(plan.currentStep / plan.steps.length * 100);
-          lines.push(`Progress: ${plan.currentStep}/${plan.steps.length} (${progress}%)`);
-        }
-        return lines.join("\n");
-      }
-      /**
-       * Calculate duration between two timestamps
-       */
-      _calculateDuration(start, end) {
-        if (!start || !end) return null;
-        const ms = new Date(end).getTime() - new Date(start).getTime();
-        const seconds = Math.floor(ms / 1e3);
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        if (hours > 0) return `${hours}h ${minutes % 60}m`;
-        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-        return `${seconds}s`;
-      }
-    };
-    planMode = new PlanMode();
-    plan_mode_default = planMode;
-  }
-});
-
-// core/types/agentic.ts
-var init_agentic = __esm({
-  "core/types/agentic.ts"() {
-    "use strict";
-  }
-});
-
-// core/types/bus.ts
-var init_bus = __esm({
-  "core/types/bus.ts"() {
-    "use strict";
-  }
-});
-
-// core/integrations/issue-tracker/types.ts
-var init_types2 = __esm({
-  "core/integrations/issue-tracker/types.ts"() {
-    "use strict";
-  }
-});
-
-// core/types/integrations.ts
-var init_integrations = __esm({
-  "core/types/integrations.ts"() {
-    "use strict";
-    init_types2();
-  }
-});
-
-// core/types/index.ts
-var init_types3 = __esm({
-  "core/types/index.ts"() {
-    "use strict";
-    init_agentic();
-    init_bus();
-    init_errors2();
-    init_fs();
-    init_integrations();
-    init_memory();
-    init_server();
-  }
-});
-
-// core/outcomes/recorder.ts
-import path29 from "node:path";
-var OUTCOMES_DIR, OUTCOMES_FILE, OutcomeRecorder, outcomeRecorder, recorder_default;
-var init_recorder = __esm({
-  "core/outcomes/recorder.ts"() {
-    "use strict";
-    init_path_manager();
-    init_schemas2();
-    init_file_helper();
-    OUTCOMES_DIR = "outcomes";
-    OUTCOMES_FILE = "outcomes.jsonl";
-    OutcomeRecorder = class {
-      static {
-        __name(this, "OutcomeRecorder");
-      }
-      /**
-       * Get outcomes directory path for a project.
-       */
-      getOutcomesDir(projectId) {
-        const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        return path29.join(globalPath, OUTCOMES_DIR);
-      }
-      /**
-       * Get outcomes file path for a project.
-       */
-      getOutcomesPath(projectId) {
-        return path29.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
-      }
-      /**
-       * Record an outcome.
-       */
-      async record(projectId, input) {
-        const outcome = {
-          ...input,
-          id: generateUUID()
-        };
-        const outcomesPath = this.getOutcomesPath(projectId);
-        await ensureDir(path29.dirname(outcomesPath));
-        await appendLine(outcomesPath, JSON.stringify(outcome));
-        return outcome;
-      }
-      /**
-       * Get all outcomes for a project.
-       */
-      async getAll(projectId) {
-        const outcomesPath = this.getOutcomesPath(projectId);
-        if (!await fileExists2(outcomesPath)) {
-          return [];
-        }
-        const content = await readFile(outcomesPath);
-        if (!content.trim()) {
-          return [];
-        }
-        return content.trim().split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
-      }
-      /**
-       * Get outcomes matching a filter.
-       */
-      async filter(projectId, filter) {
-        const all = await this.getAll(projectId);
-        return all.filter((outcome) => {
-          if (filter.sessionId && outcome.sessionId !== filter.sessionId) {
-            return false;
-          }
-          if (filter.command && outcome.command !== filter.command) {
-            return false;
-          }
-          if (filter.agent && outcome.agentUsed !== filter.agent) {
-            return false;
-          }
-          if (filter.fromDate && outcome.startedAt < filter.fromDate) {
-            return false;
-          }
-          if (filter.toDate && outcome.completedAt > filter.toDate) {
-            return false;
-          }
-          if (filter.minQuality && outcome.qualityScore < filter.minQuality) {
-            return false;
-          }
-          if (filter.tags && filter.tags.length > 0) {
-            const outcomeTags = outcome.tags || [];
-            if (!filter.tags.some((tag) => outcomeTags.includes(tag))) {
-              return false;
-            }
-          }
-          return true;
-        });
-      }
-      /**
-       * Get recent outcomes (last N).
-       */
-      async getRecent(projectId, count = 10) {
-        const all = await this.getAll(projectId);
-        return all.slice(-count);
-      }
-      /**
-       * Get outcomes for a specific command.
-       */
-      async getByCommand(projectId, command) {
-        return this.filter(projectId, { command });
+          completedSteps: plan.steps.filter((s) => s.status === "completed").length,
+          totalSteps: plan.steps.length
+        };
+        this.activePlans.delete(projectId);
+        return summary;
       }
       /**
-       * Get outcomes for a specific agent.
+       * Generate approval prompt for destructive commands (class method wrapper)
        */
-      async getByAgent(projectId, agent) {
-        return this.filter(projectId, { agent });
+      generateApprovalPrompt(commandName, context2) {
+        return generateApprovalPrompt(commandName, context2);
       }
       /**
-       * Calculate estimate accuracy.
+       * Format plan status for display
        */
-      async getEstimateAccuracy(projectId) {
-        const outcomes = await this.getAll(projectId);
-        if (outcomes.length === 0) {
-          return 0;
+      formatStatus(projectId) {
+        const plan = this.getActivePlan(projectId);
+        if (!plan) return "No active plan";
+        const statusEmoji = {
+          [PLAN_STATUS.GATHERING]: "\u{1F50D}",
+          [PLAN_STATUS.ANALYZING]: "\u{1F9E0}",
+          [PLAN_STATUS.PROPOSING]: "\u{1F4DD}",
+          [PLAN_STATUS.PENDING_APPROVAL]: "\u23F3",
+          [PLAN_STATUS.APPROVED]: "\u2705",
+          [PLAN_STATUS.EXECUTING]: "\u26A1",
+          [PLAN_STATUS.COMPLETED]: "\u{1F389}",
+          [PLAN_STATUS.REJECTED]: "\u274C",
+          [PLAN_STATUS.ABORTED]: "\u{1F6D1}"
+        };
+        const lines = [
+          `${statusEmoji[plan.status] || "\u{1F4CB}"} Plan: ${plan.command}`,
+          `Status: ${plan.status}`
+        ];
+        if (plan.status === PLAN_STATUS.EXECUTING) {
+          const progress = Math.round(plan.currentStep / plan.steps.length * 100);
+          lines.push(`Progress: ${plan.currentStep}/${plan.steps.length} (${progress}%)`);
         }
-        const accurate = outcomes.filter((o) => {
-          if (!o.variance) return false;
-          const variance = this.parseVariance(o.variance);
-          const estimated = this.parseDuration(o.estimatedDuration);
-          if (estimated === 0) return false;
-          return Math.abs(variance) / estimated <= 0.2;
-        });
-        return Math.round(accurate.length / outcomes.length * 100);
-      }
-      /**
-       * Parse variance string to minutes.
-       * "+30m" → 30, "-15m" → -15
-       */
-      parseVariance(variance) {
-        const match = variance.match(/^([+-])(\d+)([mh])$/);
-        if (!match) return 0;
-        const sign = match[1] === "-" ? -1 : 1;
-        const value = parseInt(match[2], 10);
-        const unit = match[3];
-        return sign * (unit === "h" ? value * 60 : value);
+        return lines.join("\n");
       }
       /**
-       * Parse duration string to minutes.
-       * "2h" → 120, "30m" → 30, "1h 30m" → 90
+       * Calculate duration between two timestamps
        */
-      parseDuration(duration) {
-        let minutes = 0;
-        const hourMatch = duration.match(/(\d+)h/);
-        if (hourMatch) {
-          minutes += parseInt(hourMatch[1], 10) * 60;
-        }
-        const minMatch = duration.match(/(\d+)m/);
-        if (minMatch) {
-          minutes += parseInt(minMatch[1], 10);
-        }
-        return minutes;
+      _calculateDuration(start, end) {
+        if (!start || !end) return null;
+        const ms = new Date(end).getTime() - new Date(start).getTime();
+        const seconds = Math.floor(ms / 1e3);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) return `${hours}h ${minutes % 60}m`;
+        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+        return `${seconds}s`;
       }
     };
-    outcomeRecorder = new OutcomeRecorder();
-    recorder_default = outcomeRecorder;
+    planMode = new PlanMode();
+    plan_mode_default = planMode;
+  }
+});
+
+// core/types/agentic.ts
+var init_agentic = __esm({
+  "core/types/agentic.ts"() {
+    "use strict";
+  }
+});
+
+// core/types/bus.ts
+var init_bus = __esm({
+  "core/types/bus.ts"() {
+    "use strict";
+  }
+});
+
+// core/integrations/issue-tracker/types.ts
+var init_types2 = __esm({
+  "core/integrations/issue-tracker/types.ts"() {
+    "use strict";
+  }
+});
+
+// core/types/integrations.ts
+var init_integrations = __esm({
+  "core/types/integrations.ts"() {
+    "use strict";
+    init_types2();
+  }
+});
+
+// core/types/index.ts
+var init_types3 = __esm({
+  "core/types/index.ts"() {
+    "use strict";
+    init_agentic();
+    init_bus();
+    init_errors2();
+    init_fs();
+    init_integrations();
+    init_memory();
+    init_server();
   }
 });
 
@@ -15372,7 +15895,7 @@ var init_outcomes2 = __esm({
 });
 
 // core/agentic/anti-hallucination.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function buildAntiHallucinationBlock(truth) {
   const parts = [];
   parts.push("## CONSTRAINTS (Read Before Acting)\n");
@@ -15381,9 +15904,24 @@ function buildAntiHallucinationBlock(truth) {
   if (truth.framework) available.push(truth.framework);
   const techStack = truth.techStack ?? [];
   available.push(...techStack.filter((t) => t !== truth.framework));
+  const analysisLangs = truth.analysisLanguages ?? [];
+  const analysisFrameworks = truth.analysisFrameworks ?? [];
+  for (const lang of analysisLangs) {
+    if (!available.some((a) => a.toLowerCase() === lang.toLowerCase())) {
+      available.push(lang);
+    }
+  }
+  for (const fw of analysisFrameworks) {
+    if (!available.some((a) => a.toLowerCase() === fw.toLowerCase())) {
+      available.push(fw);
+    }
+  }
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(", ")}`);
   }
+  if (truth.analysisPackageManager) {
+    parts.push(`PACKAGE MANAGER: ${truth.analysisPackageManager}`);
+  }
   if (truth.domains) {
     const absent = Object.entries(truth.domains).filter(([, hasIt]) => !hasIt).map(([key]) => DOMAIN_LABELS[key]).filter(Boolean);
     if (absent.length > 0) {
@@ -15410,27 +15948,33 @@ var ProjectGroundTruthSchema, DOMAIN_LABELS;
 var init_anti_hallucination = __esm({
   "core/agentic/anti-hallucination.ts"() {
     "use strict";
-    ProjectGroundTruthSchema = z15.object({
+    ProjectGroundTruthSchema = z16.object({
       /** Project root path */
-      projectPath: z15.string(),
+      projectPath: z16.string(),
       /** Programming language (e.g., 'TypeScript', 'JavaScript', 'Python') */
-      language: z15.string().optional(),
+      language: z16.string().optional(),
       /** Primary framework (e.g., 'Hono', 'Next.js', 'Express') */
-      framework: z15.string().optional(),
+      framework: z16.string().optional(),
       /** Technology stack items (e.g., ['Hono', 'Zod', 'Vitest']) */
-      techStack: z15.array(z15.string()).default([]),
+      techStack: z16.array(z16.string()).default([]),
       /** Domain flags from sealed analysis */
-      domains: z15.object({
-        hasFrontend: z15.boolean().default(false),
-        hasBackend: z15.boolean().default(false),
-        hasDatabase: z15.boolean().default(false),
-        hasTesting: z15.boolean().default(false),
-        hasDocker: z15.boolean().default(false)
+      domains: z16.object({
+        hasFrontend: z16.boolean().default(false),
+        hasBackend: z16.boolean().default(false),
+        hasDatabase: z16.boolean().default(false),
+        hasTesting: z16.boolean().default(false),
+        hasDocker: z16.boolean().default(false)
       }).optional(),
       /** Total files in project */
-      fileCount: z15.number().optional(),
+      fileCount: z16.number().optional(),
       /** Available agent names (e.g., ['backend', 'testing']) */
-      availableAgents: z15.array(z15.string()).default([])
+      availableAgents: z16.array(z16.string()).default([]),
+      /** Sealed analysis languages — used to ground available tech (PRJ-260) */
+      analysisLanguages: z16.array(z16.string()).default([]),
+      /** Sealed analysis frameworks — used to ground available tech (PRJ-260) */
+      analysisFrameworks: z16.array(z16.string()).default([]),
+      /** Package manager from sealed analysis (PRJ-260) */
+      analysisPackageManager: z16.string().optional()
     });
     DOMAIN_LABELS = {
       hasFrontend: "Frontend (UI/components)",
@@ -15444,21 +15988,21 @@ var init_anti_hallucination = __esm({
 });
 
 // core/schemas/command-context.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var CommandContextEntrySchema, CommandContextConfigSchema;
 var init_command_context = __esm({
   "core/schemas/command-context.ts"() {
     "use strict";
-    CommandContextEntrySchema = z16.object({
-      agents: z16.boolean(),
-      patterns: z16.boolean(),
-      checklist: z16.boolean(),
-      modules: z16.array(z16.string())
+    CommandContextEntrySchema = z17.object({
+      agents: z17.boolean(),
+      patterns: z17.boolean(),
+      checklist: z17.boolean(),
+      modules: z17.array(z17.string())
     });
-    CommandContextConfigSchema = z16.object({
-      version: z16.string(),
-      description: z16.string().optional(),
-      commands: z16.record(z16.string(), CommandContextEntrySchema).refine((commands) => "*" in commands, {
+    CommandContextConfigSchema = z17.object({
+      version: z17.string(),
+      description: z17.string().optional(),
+      commands: z17.record(z17.string(), CommandContextEntrySchema).refine((commands) => "*" in commands, {
         message: 'Config must include a "*" wildcard entry for unknown commands'
       })
     });
@@ -15650,7 +16194,7 @@ var init_command_context2 = __esm({
 
 // core/agentic/environment-block.ts
 import os10 from "node:os";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function detectRuntime2() {
   if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
     return "bun";
@@ -15690,25 +16234,25 @@ var EnvironmentBlockInputSchema;
 var init_environment_block = __esm({
   "core/agentic/environment-block.ts"() {
     "use strict";
-    EnvironmentBlockInputSchema = z17.object({
+    EnvironmentBlockInputSchema = z18.object({
       /** Project display name */
-      projectName: z17.string(),
+      projectName: z18.string(),
       /** Absolute path to project root */
-      projectPath: z17.string(),
+      projectPath: z18.string(),
       /** Whether the project is a git repository */
-      isGitRepo: z17.boolean().default(true),
+      isGitRepo: z18.boolean().default(true),
       /** Current git branch name */
-      gitBranch: z17.string().optional(),
+      gitBranch: z18.string().optional(),
       /** Operating system platform (auto-detected if not provided) */
-      platform: z17.string().optional(),
+      platform: z18.string().optional(),
       /** JavaScript runtime (auto-detected if not provided) */
-      runtime: z17.string().optional(),
+      runtime: z18.string().optional(),
       /** Current date in ISO format (auto-generated if not provided) */
-      date: z17.string().optional(),
+      date: z18.string().optional(),
       /** AI model identifier (e.g., 'opus', 'sonnet', '2.5-pro') */
-      model: z17.string().optional(),
+      model: z18.string().optional(),
       /** AI provider name (e.g., 'claude', 'gemini', 'cursor') */
-      provider: z17.string().optional()
+      provider: z18.string().optional()
     });
     __name(detectRuntime2, "detectRuntime");
     __name(normalizePlatform, "normalizePlatform");
@@ -16174,14 +16718,57 @@ ${envBlock}
 `);
         }
         if (orchestratorContext) {
+          const sa = orchestratorContext.sealedAnalysis;
           parts.push("\n## PROJECT ANALYSIS (Sealed)\n");
           parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}
 `);
           parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}
 `);
           parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(", ")}
-
 `);
+          if (sa) {
+            if (sa.languages.length > 0) {
+              parts.push(`**Languages**: ${sa.languages.join(", ")}
+`);
+            }
+            if (sa.frameworks.length > 0) {
+              parts.push(`**Frameworks**: ${sa.frameworks.join(", ")}
+`);
+            }
+            if (sa.packageManager) {
+              parts.push(`**Package Manager**: ${sa.packageManager}
+`);
+            }
+            if (sa.sourceDir) {
+              parts.push(`**Source Dir**: ${sa.sourceDir}
+`);
+            }
+            if (sa.testDir) {
+              parts.push(`**Test Dir**: ${sa.testDir}
+`);
+            }
+            parts.push(`**Files Analyzed**: ${sa.fileCount}
+`);
+            parts.push(
+              `**Analysis Status**: ${sa.status}${sa.commitHash ? ` (commit: ${sa.commitHash.slice(0, 8)})` : ""}
+`
+            );
+            if (sa.patterns.length > 0) {
+              parts.push("\n### Code Patterns (Follow These)\n");
+              for (const p of sa.patterns) {
+                parts.push(`- **${p.name}**: ${p.description}${p.location ? ` (${p.location})` : ""}
+`);
+              }
+            }
+            if (sa.antiPatterns.length > 0) {
+              parts.push("\n### Anti-Patterns (Avoid These)\n");
+              for (const ap of sa.antiPatterns) {
+                parts.push(`- **${ap.issue}** in \`${ap.file}\` \u2014 ${ap.suggestion}
+`);
+              }
+            }
+          }
+          parts.push("\n");
         }
         const needsPatterns = commandContext.patterns;
         const codePatternsContent = state?.codePatterns || "";
@@ -16282,13 +16869,18 @@ Show changes, list affected files, ask for confirmation.
           );
         }
         if (projectPath) {
+          const sa = orchestratorContext?.sealedAnalysis;
           const groundTruth2 = {
             projectPath,
             language: orchestratorContext?.project?.ecosystem,
             techStack: orchestratorContext?.project?.conventions || [],
             domains: this.extractDomains(state),
             fileCount: context2.files?.length || context2.filteredSize || 0,
-            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || []
+            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
+            // Inject sealed analysis data for enriched grounding (PRJ-260)
+            analysisLanguages: sa?.languages || [],
+            analysisFrameworks: sa?.frameworks || [],
+            analysisPackageManager: sa?.packageManager
           };
           parts.push(`
 ${buildAntiHallucinationBlock(groundTruth2)}
@@ -16351,6 +16943,11 @@ Read files before modifying.
           parts.push(relevantState);
           parts.push("\n");
         }
+        if (orchestratorContext?.velocityContext) {
+          parts.push("\n### VELOCITY (Historical Estimation Data)\n\n");
+          parts.push(orchestratorContext.velocityContext);
+          parts.push("\n\n");
+        }
         if (learnedPatterns && Object.keys(learnedPatterns).some((k) => learnedPatterns[k])) {
           parts.push("\n## PROJECT DEFAULTS (apply automatically)\n");
           for (const [key, value] of Object.entries(learnedPatterns)) {
@@ -26288,6 +26885,23 @@ var init_command_data = __esm({
           "Command duration breakdown"
         ]
       },
+      {
+        name: "velocity",
+        group: "core",
+        description: "Sprint-based velocity dashboard with trend detection and projections",
+        usage: { claude: "/p:velocity", terminal: "prjct velocity [backlogPoints]" },
+        params: "[backlogPoints]",
+        implemented: true,
+        hasTemplate: false,
+        requiresProject: true,
+        features: [
+          "Sprint-by-sprint velocity breakdown",
+          "Trend detection (improving/stable/declining)",
+          "Estimation accuracy tracking",
+          "Over/under estimation pattern detection",
+          "Completion projections for backlog"
+        ]
+      },
       {
         name: "suggest",
         group: "core",
@@ -29556,6 +30170,122 @@ Generated with [p/](https://www.prjct.app/)`;
   }
 });
 
+// core/commands/velocity.ts
+import chalk19 from "chalk";
+var VelocityCommands;
+var init_velocity3 = __esm({
+  "core/commands/velocity.ts"() {
+    "use strict";
+    init_velocity2();
+    init_recorder();
+    init_velocity();
+    init_velocity_storage();
+    init_fs();
+    init_base();
+    VelocityCommands = class extends PrjctCommandsBase {
+      static {
+        __name(this, "VelocityCommands");
+      }
+      /**
+       * prjct velocity - Velocity dashboard
+       */
+      async velocity(backlogPoints = "0", projectPath = process.cwd()) {
+        try {
+          const initResult = await this.ensureProjectInit(projectPath);
+          if (!initResult.success) return initResult;
+          const projectId = await config_manager_default.getProjectId(projectPath);
+          if (!projectId) {
+            output_default.failWithHint("NO_PROJECT_ID");
+            return { success: false, error: "No project ID found" };
+          }
+          const config = await this.loadVelocityConfig(projectPath);
+          const outcomes = await recorder_default.getAll(projectId);
+          if (outcomes.length === 0) {
+            console.log(`
+${chalk19.dim("No velocity data yet.")}`);
+            console.log(`${chalk19.dim("Complete tasks with estimates to build velocity history.")}
+`);
+            return { success: true, message: "No data" };
+          }
+          const metrics = calculateVelocity(outcomes, config);
+          await velocityStorage.saveMetrics(projectId, metrics);
+          console.log(
+            `
+${chalk19.cyan("Sprint Velocity")} ${chalk19.dim(`(last ${config.windowSize ?? 6} sprints)`)}`
+          );
+          console.log("\u2550".repeat(60));
+          const recentSprints = metrics.sprints.slice(-(config.windowSize ?? 6));
+          for (const sprint of recentSprints) {
+            const accuracyColor = sprint.estimationAccuracy >= 80 ? chalk19.green : sprint.estimationAccuracy >= 60 ? chalk19.yellow : chalk19.red;
+            console.log(
+              `  Sprint ${String(sprint.sprintNumber).padStart(2)}: ${chalk19.bold(`${sprint.pointsCompleted} pts`)} | ${sprint.tasksCompleted} tasks | accuracy: ${accuracyColor(`${sprint.estimationAccuracy}%`)}`
+            );
+          }
+          console.log("");
+          const trendIcon = metrics.velocityTrend === "improving" ? chalk19.green("\u2191") : metrics.velocityTrend === "declining" ? chalk19.red("\u2193") : chalk19.dim("\u2192");
+          console.log(
+            `  Average: ${chalk19.bold(`${metrics.averageVelocity} pts/sprint`)} | Trend: ${trendIcon} ${metrics.velocityTrend}`
+          );
+          console.log(
+            `  Estimation accuracy: ${chalk19.bold(`${metrics.estimationAccuracy}%`)} ${chalk19.dim(`(\xB1${config.accuracyTolerance ?? 20}% tolerance)`)}`
+          );
+          if (metrics.underEstimated.length > 0 || metrics.overEstimated.length > 0) {
+            console.log(`
+  ${chalk19.dim("Patterns:")}`);
+            for (const p of metrics.underEstimated) {
+              console.log(
+                `    ${chalk19.yellow("\u26A0")} ${p.category} tasks underestimated by avg ${chalk19.bold(`${p.avgVariance}%`)}`
+              );
+            }
+            for (const p of metrics.overEstimated) {
+              console.log(
+                `    ${chalk19.green("\u2713")} ${p.category} tasks estimated within ${chalk19.bold(`${p.avgVariance}%`)}`
+              );
+            }
+          }
+          const points = parseInt(backlogPoints, 10);
+          if (points > 0 && metrics.averageVelocity > 0) {
+            const projection = projectCompletion(points, metrics.averageVelocity, config);
+            const dateStr = projection.estimatedDate ? new Date(projection.estimatedDate).toLocaleDateString("en-US", {
+              month: "short",
+              day: "numeric",
+              year: "numeric"
+            }) : "unknown";
+            console.log(`
+  ${chalk19.dim("Projection:")}`);
+            console.log(`    Backlog: ${chalk19.bold(`${points} pts`)} remaining`);
+            console.log(
+              `    At current velocity: ~${projection.sprints} sprints (${projection.sprints * (config.sprintLengthDays ?? 7)} days)`
+            );
+            console.log(`    Estimated completion: ${chalk19.bold(dateStr)}`);
+          }
+          console.log("\u2550".repeat(60));
+          console.log("");
+          return { success: true };
+        } catch (error) {
+          output_default.fail(getErrorMessage2(error));
+          return { success: false, error: getErrorMessage2(error) };
+        }
+      }
+      /**
+       * Load velocity config from project or use defaults.
+       * Velocity config can be added to prjct.config.json as { velocity: { sprintLengthDays, ... } }
+       */
+      async loadVelocityConfig(projectPath) {
+        try {
+          const config = await config_manager_default.readConfig(projectPath);
+          const raw = config;
+          if (raw?.velocity && typeof raw.velocity === "object") {
+            return { ...DEFAULT_VELOCITY_CONFIG, ...raw.velocity };
+          }
+        } catch {
+        }
+        return DEFAULT_VELOCITY_CONFIG;
+      }
+    };
+  }
+});
+
 // core/domain/fibonacci.ts
 var FIBONACCI_POINTS, DEFAULT_MINUTES_MAP, isValidPoint, pointsToMinutes, formatMinutes, pointsToTimeRange;
 var init_fibonacci = __esm({
@@ -30859,6 +31589,7 @@ var init_commands = __esm({
     init_planning();
     init_setup2();
     init_shipping();
+    init_velocity3();
     init_workflow();
     PrjctCommands = class {
       static {
@@ -30873,6 +31604,7 @@ var init_commands = __esm({
       maintenance;
       analysis;
       setupCmds;
+      velocityCmds;
       contextCmds;
       // Shared state
       agent;
@@ -30888,6 +31620,7 @@ var init_commands = __esm({
         this.maintenance = new MaintenanceCommands();
         this.analysis = new AnalysisCommands();
         this.setupCmds = new SetupCommands();
+        this.velocityCmds = new VelocityCommands();
         this.contextCmds = new ContextCommands();
         this.agent = null;
         this.agentInfo = null;
@@ -30938,6 +31671,10 @@ var init_commands = __esm({
       async perf(period = "7", projectPath = process.cwd()) {
         return this.performanceCmds.perf(period, projectPath);
       }
+      // ========== Velocity Commands ==========
+      async velocity(backlogPoints = "0", projectPath = process.cwd()) {
+        return this.velocityCmds.velocity(backlogPoints, projectPath);
+      }
       // ========== Maintenance Commands ==========
       async cleanup(options = {}, projectPath = process.cwd()) {
         return this.maintenance.cleanup(options, projectPath);
@@ -31037,6 +31774,7 @@ function registerAllCommands() {
   commandRegistry.registerMethod("dash", analytics, "dash", getMeta("dash"));
   commandRegistry.registerMethod("help", analytics, "help", getMeta("help"));
   commandRegistry.registerMethod("perf", performance, "perf", getMeta("perf"));
+  commandRegistry.registerMethod("velocity", velocityCmd, "velocity", getMeta("velocity"));
   commandRegistry.registerMethod("cleanup", maintenance, "cleanup", getMeta("cleanup"));
   commandRegistry.registerMethod("design", maintenance, "design", getMeta("design"));
   commandRegistry.registerMethod("recover", maintenance, "recover", getMeta("recover"));
@@ -31054,7 +31792,7 @@ function registerAllCommands() {
   commandRegistry.registerMethod("uninstall", uninstallCmd, "uninstall", getMeta("uninstall"));
   commandRegistry.registerMethod("context", context, "context", getMeta("context"));
 }
-var workflow, planning, shipping, analytics, performance, maintenance, analysis, setup, context, uninstallCmd;
+var workflow, planning, shipping, analytics, performance, maintenance, analysis, setup, context, velocityCmd, uninstallCmd;
 var init_register = __esm({
   "core/commands/register.ts"() {
     "use strict";
@@ -31069,6 +31807,7 @@ var init_register = __esm({
     init_setup2();
     init_shipping();
     init_uninstall();
+    init_velocity3();
     init_workflow();
     workflow = new WorkflowCommands();
     planning = new PlanningCommands();
@@ -31079,6 +31818,7 @@ var init_register = __esm({
     analysis = new AnalysisCommands();
     setup = new SetupCommands();
     context = new ContextCommands();
+    velocityCmd = new VelocityCommands();
     uninstallCmd = new UninstallCommands();
     __name(registerCategories, "registerCategories");
     __name(registerAllCommands, "registerAllCommands");
@@ -31102,7 +31842,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.12.0",
+      version: "1.14.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -31210,7 +31950,7 @@ var require_package = __commonJS({
 var core_exports = {};
 import os20 from "node:os";
 import path66 from "node:path";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
   if (["-v", "--version", "version"].includes(commandName)) {
@@ -31302,6 +32042,7 @@ async function main() {
         }), "status"),
         help: /* @__PURE__ */ __name((p) => commands.help(p || ""), "help"),
         perf: /* @__PURE__ */ __name((p) => commands.perf(p || "7"), "perf"),
+        velocity: /* @__PURE__ */ __name((p) => commands.velocity(p || "0"), "velocity"),
         // Maintenance
         recover: /* @__PURE__ */ __name(() => commands.recover(), "recover"),
         undo: /* @__PURE__ */ __name(() => commands.undo(), "undo"),
@@ -31431,41 +32172,41 @@ async function displayVersion(version) {
   ]);
   const antigravityDetection = await detectAntigravity();
   console.log(`
-${chalk19.cyan("p/")} prjct v${version}
-${chalk19.dim("Context layer for AI coding agents")}
+${chalk20.cyan("p/")} prjct v${version}
+${chalk20.dim("Context layer for AI coding agents")}
 
-${chalk19.dim("Providers:")}`);
+${chalk20.dim("Providers:")}`);
   if (detection.claude.installed) {
-    const status = claudeConfigured ? chalk19.green("\u2713 ready") : chalk19.yellow("\u25CF installed");
+    const status = claudeConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF installed");
     const ver = detection.claude.version ? ` (v${detection.claude.version})` : "";
-    console.log(`  Claude Code   ${status}${chalk19.dim(ver)}`);
+    console.log(`  Claude Code   ${status}${chalk20.dim(ver)}`);
   } else {
-    console.log(`  Claude Code   ${chalk19.dim("\u25CB not installed")}`);
+    console.log(`  Claude Code   ${chalk20.dim("\u25CB not installed")}`);
   }
   if (detection.gemini.installed) {
-    const status = geminiConfigured ? chalk19.green("\u2713 ready") : chalk19.yellow("\u25CF installed");
+    const status = geminiConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF installed");
     const ver = detection.gemini.version ? ` (v${detection.gemini.version})` : "";
-    console.log(`  Gemini CLI    ${status}${chalk19.dim(ver)}`);
+    console.log(`  Gemini CLI    ${status}${chalk20.dim(ver)}`);
   } else {
-    console.log(`  Gemini CLI    ${chalk19.dim("\u25CB not installed")}`);
+    console.log(`  Gemini CLI    ${chalk20.dim("\u25CB not installed")}`);
   }
   if (antigravityDetection.installed) {
-    const status = antigravityDetection.skillInstalled ? chalk19.green("\u2713 ready") : chalk19.yellow("\u25CF detected");
-    const hint = antigravityDetection.skillInstalled ? "" : ` ${chalk19.dim("(run prjct start)")}`;
+    const status = antigravityDetection.skillInstalled ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF detected");
+    const hint = antigravityDetection.skillInstalled ? "" : ` ${chalk20.dim("(run prjct start)")}`;
     console.log(`  Antigravity   ${status}${hint}`);
   } else {
-    console.log(`  Antigravity   ${chalk19.dim("\u25CB not installed")}`);
+    console.log(`  Antigravity   ${chalk20.dim("\u25CB not installed")}`);
   }
   if (cursorConfigured) {
-    console.log(`  Cursor IDE    ${chalk19.green("\u2713 ready")} ${chalk19.dim("(use /sync, /task)")}`);
+    console.log(`  Cursor IDE    ${chalk20.green("\u2713 ready")} ${chalk20.dim("(use /sync, /task)")}`);
   } else if (cursorExists) {
-    console.log(`  Cursor IDE    ${chalk19.yellow("\u25CF detected")} ${chalk19.dim("(run prjct init)")}`);
+    console.log(`  Cursor IDE    ${chalk20.yellow("\u25CF detected")} ${chalk20.dim("(run prjct init)")}`);
   } else {
-    console.log(`  Cursor IDE    ${chalk19.dim("\u25CB no .cursor/ folder")}`);
+    console.log(`  Cursor IDE    ${chalk20.dim("\u25CB no .cursor/ folder")}`);
   }
   console.log(`
-${chalk19.dim("Run 'prjct start' for Claude/Gemini, 'prjct init' for Cursor")}
-${chalk19.cyan("https://prjct.app")}
+${chalk20.dim("Run 'prjct start' for Claude/Gemini, 'prjct init' for Cursor")}
+${chalk20.cyan("https://prjct.app")}
 `);
 }
 function displayHelp() {
@@ -31567,7 +32308,7 @@ init_config_manager();
 init_editors_config();
 import os21 from "node:os";
 import path67 from "node:path";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 
 // core/server/server.ts
 import { Hono as Hono3 } from "hono";
@@ -32569,51 +33310,51 @@ if (args[0] === "start" || args[0] === "setup") {
     fileExists(path67.join(cwd, ".windsurf", "rules", "prjct.md"))
   ]);
   console.log(`
-${chalk20.cyan("p/")} prjct v${VERSION}
-${chalk20.dim("Context layer for AI coding agents")}
+${chalk21.cyan("p/")} prjct v${VERSION}
+${chalk21.dim("Context layer for AI coding agents")}
 
-${chalk20.dim("Providers:")}`);
+${chalk21.dim("Providers:")}`);
   if (detection.claude.installed) {
-    const status = claudeConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF installed");
+    const status = claudeConfigured ? chalk21.green("\u2713 ready") : chalk21.yellow("\u25CF installed");
     const ver = detection.claude.version ? ` (v${detection.claude.version})` : "";
-    console.log(`  Claude Code   ${status}${chalk20.dim(ver)}`);
+    console.log(`  Claude Code   ${status}${chalk21.dim(ver)}`);
   } else {
-    console.log(`  Claude Code   ${chalk20.dim("\u25CB not installed")}`);
+    console.log(`  Claude Code   ${chalk21.dim("\u25CB not installed")}`);
   }
   if (detection.gemini.installed) {
-    const status = geminiConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF installed");
+    const status = geminiConfigured ? chalk21.green("\u2713 ready") : chalk21.yellow("\u25CF installed");
     const ver = detection.gemini.version ? ` (v${detection.gemini.version})` : "";
-    console.log(`  Gemini CLI    ${status}${chalk20.dim(ver)}`);
+    console.log(`  Gemini CLI    ${status}${chalk21.dim(ver)}`);
   } else {
-    console.log(`  Gemini CLI    ${chalk20.dim("\u25CB not installed")}`);
+    console.log(`  Gemini CLI    ${chalk21.dim("\u25CB not installed")}`);
   }
   if (cursorDetected) {
-    const status = cursorConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF detected");
-    console.log(`  Cursor IDE    ${status}${chalk20.dim(" (project)")}`);
+    const status = cursorConfigured ? chalk21.green("\u2713 ready") : chalk21.yellow("\u25CF detected");
+    console.log(`  Cursor IDE    ${status}${chalk21.dim(" (project)")}`);
   } else {
-    console.log(`  Cursor IDE    ${chalk20.dim("\u25CB not detected")}`);
+    console.log(`  Cursor IDE    ${chalk21.dim("\u25CB not detected")}`);
   }
   if (windsurfDetected) {
-    const status = windsurfConfigured ? chalk20.green("\u2713 ready") : chalk20.yellow("\u25CF detected");
-    console.log(`  Windsurf IDE  ${status}${chalk20.dim(" (project)")}`);
+    const status = windsurfConfigured ? chalk21.green("\u2713 ready") : chalk21.yellow("\u25CF detected");
+    console.log(`  Windsurf IDE  ${status}${chalk21.dim(" (project)")}`);
   } else {
-    console.log(`  Windsurf IDE  ${chalk20.dim("\u25CB not detected")}`);
+    console.log(`  Windsurf IDE  ${chalk21.dim("\u25CB not detected")}`);
   }
   console.log(`
-${chalk20.dim("Run 'prjct start' to configure (CLI providers)")}
-${chalk20.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
-${chalk20.cyan("https://prjct.app")}
+${chalk21.dim("Run 'prjct start' to configure (CLI providers)")}
+${chalk21.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
+${chalk21.cyan("https://prjct.app")}
 `);
 } else {
   const configPath = path67.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`
-${chalk20.cyan.bold("  Welcome to prjct!")}
+${chalk21.cyan.bold("  Welcome to prjct!")}
 
-  Run ${chalk20.bold("prjct start")} to configure your AI providers.
+  Run ${chalk21.bold("prjct start")} to configure your AI providers.
 
-  ${chalk20.dim(`This is a one-time setup that lets you choose between
+  ${chalk21.dim(`This is a one-time setup that lets you choose between
   Claude Code, Gemini CLI, or both.`)}
 `);
     process.exitCode = 0;
@@ -32622,7 +33363,7 @@ ${chalk20.cyan.bold("  Welcome to prjct!")}
       const lastVersion = await editors_config_default.getLastVersion();
       if (lastVersion && lastVersion !== VERSION) {
         console.log(`
-${chalk20.yellow("\u2139")} Updating prjct v${lastVersion} \u2192 v${VERSION}...
+${chalk21.yellow("\u2139")} Updating prjct v${lastVersion} \u2192 v${VERSION}...
 `);
         const { default: setup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
         await setup2.run();