prjct-cli 0.53.0 → 0.54.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## [0.54.0] - 2026-01-30
+
+### Features
+
+- Add showMetrics config option - PRJ-70 (#82)
+- Selective memory retrieval based on task relevance - PRJ-107 (#81)
+- Add session stats to p. stats command - PRJ-89 (#80)
+
+
+## [0.55.1] - 2026-01-30
+
+### Added
+
+- **showMetrics config option** (PRJ-70)
+  - Add `showMetrics` boolean to `LocalConfig` (prjct.config.json)
+  - Defaults to `true` for new projects and existing projects without setting
+  - Added `getShowMetrics()` and `setShowMetrics()` to ConfigManager
+
+
+## [0.55.0] - 2026-01-30
+
+### Features
+
+- Selective memory retrieval based on task relevance - PRJ-107
+
+
+## [0.55.0] - 2026-01-30
+
+### Added
+
+- **Selective memory retrieval based on task relevance** (PRJ-107)
+  - Added `getRelevantMemoriesWithMetrics()` for domain-based filtering
+  - Relevance scoring considers: domain match (25pts), tag match (20pts), recency (15pts), confidence (20pts), keywords (15pts), user triggered (5pts)
+  - Returns retrieval metrics: total, considered, returned, filtering ratio, avg score
+  - New types: `RelevantMemoryQuery`, `ScoredMemory`, `MemoryRetrievalResult`, `TaskDomain`
+  - Integrates with PRJ-104 confidence scoring
+
+
+## [0.54.0] - 2026-01-30
+
+### Features
+
+- Session stats in p. stats command - PRJ-89
+
+
+## [0.54.0] - 2026-01-30
+
+### Added
+
+- **Session stats in `p. stats` command** (PRJ-89)
+  - Shows today's activity: duration, tasks completed, features shipped
+  - Displays agents used during the session with frequency
+  - Shows learned patterns: decisions, preferences, workflows
+  - Enhanced JSON and export modes include session data
+  - Added `getRecentEvents()` to memoryService
+
+
 ## [0.53.0] - 2026-01-30
 
 ### Features

package/core/agentic/memory-system.ts

@@ -30,9 +30,13 @@ export type {
   MemoryContext,
   MemoryContextParams,
   MemoryDatabase,
+  MemoryRetrievalResult,
   MemoryTag,
   Patterns,
   Preference,
+  RelevantMemoryQuery,
+  ScoredMemory,
+  TaskDomain,
   Workflow,
 } from '../types/memory'
 
@@ -44,9 +48,13 @@ import type {
   Memory,
   MemoryContext,
   MemoryDatabase,
+  MemoryRetrievalResult,
   MemoryTag,
   Patterns,
   Preference,
+  RelevantMemoryQuery,
+  ScoredMemory,
+  TaskDomain,
   Workflow,
 } from '../types/memory'
 
@@ -690,6 +698,202 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
       .map(({ _score, ...memory }) => memory as Memory)
   }
 
+  /**
+   * Enhanced memory retrieval with domain-based filtering and metrics.
+   * Implements selective memory retrieval based on task relevance.
+   * @see PRJ-107
+   */
+  async getRelevantMemoriesWithMetrics(
+    projectId: string,
+    query: RelevantMemoryQuery
+  ): Promise<MemoryRetrievalResult> {
+    const db = await this.load(projectId)
+    const totalMemories = db.memories.length
+
+    if (totalMemories === 0) {
+      return {
+        memories: [],
+        metrics: {
+          totalMemories: 0,
+          memoriesConsidered: 0,
+          memoriesReturned: 0,
+          filteringRatio: 0,
+          avgRelevanceScore: 0,
+        },
+      }
+    }
+
+    const maxResults = query.maxResults ?? 10
+    const minRelevance = query.minRelevance ?? 10
+
+    // Score all memories
+    const scored: ScoredMemory[] = db.memories.map((memory) => {
+      const breakdown = {
+        domainMatch: 0,
+        tagMatch: 0,
+        recency: 0,
+        confidence: 0,
+        keywords: 0,
+        userTriggered: 0,
+      }
+
+      // Domain match scoring (0-25 points)
+      if (query.taskDomain) {
+        const domainTags = this._getDomainTags(query.taskDomain)
+        const matchingTags = (memory.tags || []).filter((tag) => domainTags.includes(tag))
+        breakdown.domainMatch = Math.min(25, matchingTags.length * 10)
+      }
+
+      // Tag match from command context (0-20 points)
+      if (query.commandName) {
+        const commandTags = this._getCommandTags(query.commandName)
+        const matchingTags = (memory.tags || []).filter((tag) => commandTags.includes(tag))
+        breakdown.tagMatch = Math.min(20, matchingTags.length * 8)
+      }
+
+      // Recency scoring (0-15 points)
+      const age = Date.now() - new Date(memory.updatedAt).getTime()
+      const daysSinceUpdate = age / (1000 * 60 * 60 * 24)
+      breakdown.recency = Math.max(0, Math.round(15 - daysSinceUpdate * 0.5))
+
+      // Confidence scoring (0-20 points) - PRJ-104 integration
+      if (memory.confidence) {
+        breakdown.confidence =
+          memory.confidence === 'high' ? 20 : memory.confidence === 'medium' ? 12 : 5
+      } else if (memory.observationCount) {
+        // Fallback to observation count
+        breakdown.confidence = Math.min(20, memory.observationCount * 3)
+      }
+
+      // Keyword matching (0-15 points)
+      if (query.taskDescription) {
+        const keywords = this._extractKeywordsFromText(query.taskDescription)
+        let keywordScore = 0
+        for (const keyword of keywords) {
+          if (memory.content.toLowerCase().includes(keyword)) keywordScore += 2
+          if (memory.title.toLowerCase().includes(keyword)) keywordScore += 3
+        }
+        breakdown.keywords = Math.min(15, keywordScore)
+      }
+
+      // User triggered bonus (0-5 points)
+      if (memory.userTriggered) {
+        breakdown.userTriggered = 5
+      }
+
+      const relevanceScore =
+        breakdown.domainMatch +
+        breakdown.tagMatch +
+        breakdown.recency +
+        breakdown.confidence +
+        breakdown.keywords +
+        breakdown.userTriggered
+
+      return {
+        ...memory,
+        relevanceScore,
+        scoreBreakdown: breakdown,
+      }
+    })
+
+    // Filter by minimum relevance
+    const considered = scored.filter((m) => m.relevanceScore >= minRelevance)
+
+    // Sort by relevance and take top N
+    const sorted = considered.sort((a, b) => b.relevanceScore - a.relevanceScore)
+    const returned = sorted.slice(0, maxResults)
+
+    // Calculate average relevance
+    const avgRelevanceScore =
+      returned.length > 0
+        ? Math.round(returned.reduce((sum, m) => sum + m.relevanceScore, 0) / returned.length)
+        : 0
+
+    return {
+      memories: returned,
+      metrics: {
+        totalMemories,
+        memoriesConsidered: considered.length,
+        memoriesReturned: returned.length,
+        filteringRatio: totalMemories > 0 ? returned.length / totalMemories : 0,
+        avgRelevanceScore,
+      },
+    }
+  }
+
+  /**
+   * Map task domain to relevant memory tags.
+   * @see PRJ-107
+   */
+  private _getDomainTags(domain: TaskDomain): MemoryTag[] {
+    const domainTagMap: Record<TaskDomain, MemoryTag[]> = {
+      frontend: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.FILE_STRUCTURE, MEMORY_TAGS.ARCHITECTURE],
+      backend: [
+        MEMORY_TAGS.CODE_STYLE,
+        MEMORY_TAGS.ARCHITECTURE,
+        MEMORY_TAGS.DEPENDENCIES,
+        MEMORY_TAGS.TECH_STACK,
+      ],
+      devops: [MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.DEPENDENCIES],
+      docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION],
+      testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE],
+      database: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.NAMING_CONVENTION],
+      general: Object.values(MEMORY_TAGS) as MemoryTag[],
+    }
+    return domainTagMap[domain] || []
+  }
+
+  /**
+   * Map command to relevant memory tags.
+   * @see PRJ-107
+   */
+  private _getCommandTags(commandName: string): MemoryTag[] {
+    const commandTags: Record<string, MemoryTag[]> = {
+      ship: [MEMORY_TAGS.COMMIT_STYLE, MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR],
+      feature: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+      done: [MEMORY_TAGS.SHIP_WORKFLOW],
+      analyze: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE],
+      spec: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+      task: [MEMORY_TAGS.BRANCH_NAMING, MEMORY_TAGS.CODE_STYLE],
+      sync: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.DEPENDENCIES],
+      test: [MEMORY_TAGS.TEST_BEHAVIOR],
+      bug: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.TEST_BEHAVIOR],
+    }
+    return commandTags[commandName] || []
+  }
+
+  /**
+   * Extract keywords from text for matching.
+   */
+  private _extractKeywordsFromText(text: string): string[] {
+    const words = text.toLowerCase().split(/\s+/)
+    const stopWords = new Set([
+      'the',
+      'a',
+      'an',
+      'is',
+      'are',
+      'to',
+      'for',
+      'and',
+      'or',
+      'in',
+      'on',
+      'at',
+      'by',
+      'with',
+      'from',
+      'as',
+      'it',
+      'this',
+      'that',
+      'be',
+      'have',
+      'has',
+    ])
+    return words.filter((w) => w.length > 2 && !stopWords.has(w))
+  }
+
   private _extractContextTags(context: MemoryContext): string[] {
     const tags: string[] = []
 
@@ -863,6 +1067,18 @@ export class MemorySystem {
     return this._semanticMemories.getMemoryStats(projectId)
   }
 
+  /**
+   * Get relevant memories with domain-based filtering and metrics.
+   * Implements selective memory retrieval based on task relevance.
+   * @see PRJ-107
+   */
+  getRelevantMemoriesWithMetrics(
+    projectId: string,
+    query: RelevantMemoryQuery
+  ): Promise<MemoryRetrievalResult> {
+    return this._semanticMemories.getRelevantMemoriesWithMetrics(projectId, query)
+  }
+
   // ===========================================================================
   // TIER 1: Session Memory
   // ===========================================================================

package/core/commands/analysis.ts

@@ -5,11 +5,12 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import prompts from 'prompts'
+import memorySystem from '../agentic/memory-system'
 import { generateContext } from '../context/generator'
 import analyzer from '../domain/analyzer'
 import commandInstaller from '../infrastructure/command-installer'
 import { formatCost } from '../schemas/metrics'
-import { syncService } from '../services'
+import { memoryService, syncService } from '../services'
 import { formatDiffPreview, formatFullDiff, generateSyncDiff } from '../services/diff-generator'
 import { metricsStorage } from '../storage/metrics-storage'
 import type { AnalyzeOptions, CommandResult, ProjectContext } from '../types'
@@ -439,13 +440,17 @@ export class AnalysisCommands extends PrjctCommandsBase {
   }
 
   /**
-   * /p:stats - Value dashboard showing accumulated savings and impact
+   * /p:stats - Session summary and value dashboard
    *
    * Displays:
+   * - Session activity (tasks completed, features shipped today)
+   * - Patterns learned (from memory system)
    * - Token savings (total, compression rate, estimated cost)
    * - Performance metrics (sync count, avg duration)
    * - Agent usage breakdown
    * - 30-day trend visualization
+   *
+   * @see PRJ-89
    */
   async stats(
     projectPath: string = process.cwd(),
@@ -464,9 +469,17 @@ export class AnalysisCommands extends PrjctCommandsBase {
       const summary = await metricsStorage.getSummary(projectId)
       const dailyStats = await metricsStorage.getDailyStats(projectId, 30)
 
+      // Get session activity (today's events)
+      const sessionActivity = await this._getSessionActivity(projectId)
+
+      // Get learned patterns
+      const patternsSummary = await memorySystem.getPatternsSummary(projectId)
+
       // JSON output mode
       if (options.json) {
         const jsonOutput = {
+          session: sessionActivity,
+          patterns: patternsSummary,
           totalTokensSaved: summary.totalTokensSaved,
           estimatedCostSaved: summary.estimatedCostSaved,
           compressionRate: summary.compressionRate,
@@ -485,8 +498,6 @@ export class AnalysisCommands extends PrjctCommandsBase {
       const globalPath = pathManager.getGlobalProjectPath(projectId)
       let projectName = 'Unknown'
       try {
-        const fs = require('node:fs/promises')
-        const path = require('node:path')
         const projectJson = JSON.parse(
           await fs.readFile(path.join(globalPath, 'project.json'), 'utf-8')
         )
@@ -508,13 +519,40 @@ export class AnalysisCommands extends PrjctCommandsBase {
       // ASCII Dashboard
       console.log('')
       console.log('╭─────────────────────────────────────────────────╮')
-      console.log('│  📊 prjct-cli Value Dashboard                   │')
+      console.log('│  📊 prjct-cli Stats Dashboard                   │')
       console.log(
         `│  Project: ${projectName.padEnd(20).slice(0, 20)} | Since: ${firstSyncDate.padEnd(12).slice(0, 12)} │`
       )
       console.log('╰─────────────────────────────────────────────────╯')
       console.log('')
 
+      // Session Activity Section (PRJ-89)
+      console.log("🎯 TODAY'S ACTIVITY")
+      if (sessionActivity.sessionDuration) {
+        console.log(`   Duration:        ${sessionActivity.sessionDuration}`)
+      }
+      console.log(`   Tasks completed: ${sessionActivity.tasksCompleted}`)
+      console.log(`   Features shipped: ${sessionActivity.featuresShipped}`)
+      if (sessionActivity.agentsUsed.length > 0) {
+        const agentStr = sessionActivity.agentsUsed
+          .slice(0, 3)
+          .map((a) => `${a.name} (${a.count}×)`)
+          .join(', ')
+        console.log(`   Agents used:     ${agentStr}`)
+      }
+      console.log('')
+
+      // Learned Patterns Section (PRJ-89)
+      if (patternsSummary.decisions > 0 || patternsSummary.preferences > 0) {
+        console.log('🧠 PATTERNS LEARNED')
+        console.log(
+          `   Decisions:    ${patternsSummary.learnedDecisions} confirmed (${patternsSummary.decisions} total)`
+        )
+        console.log(`   Preferences:  ${patternsSummary.preferences} saved`)
+        console.log(`   Workflows:    ${patternsSummary.workflows} tracked`)
+        console.log('')
+      }
+
       // Token Savings Section
       console.log('💰 TOKEN SAVINGS')
       console.log(`   Total saved:     ${this._formatTokens(summary.totalTokensSaved)} tokens`)
@@ -532,7 +570,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       // Agent Usage Section
       if (summary.topAgents.length > 0) {
-        console.log('🤖 AGENT USAGE')
+        console.log('🤖 AGENT USAGE (all time)')
         const totalUsage = summary.topAgents.reduce((sum, a) => sum + a.usageCount, 0)
         for (const agent of summary.topAgents) {
           const pct = totalUsage > 0 ? ((agent.usageCount / totalUsage) * 100).toFixed(0) : 0
@@ -568,7 +606,9 @@ export class AnalysisCommands extends PrjctCommandsBase {
           summary,
           dailyStats,
           projectName,
-          firstSyncDate
+          firstSyncDate,
+          sessionActivity,
+          patternsSummary
         )
         console.log(markdown)
         return { success: true, data: { markdown } }
@@ -576,7 +616,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       return {
         success: true,
-        data: summary,
+        data: { ...summary, session: sessionActivity, patterns: patternsSummary },
       }
     } catch (error) {
       console.error('❌ Error:', (error as Error).message)
@@ -584,6 +624,76 @@ export class AnalysisCommands extends PrjctCommandsBase {
     }
   }
 
+  /**
+   * Get session activity stats from today's events
+   * @see PRJ-89
+   */
+  private async _getSessionActivity(projectId: string): Promise<{
+    sessionDuration: string | null
+    tasksCompleted: number
+    featuresShipped: number
+    agentsUsed: { name: string; count: number }[]
+  }> {
+    try {
+      // Get today's events from memory
+      const recentHistory = await memoryService.getRecentEvents(projectId, 100)
+
+      const today = new Date().toISOString().split('T')[0]
+      const todayEvents = recentHistory.filter((e) => {
+        const ts = (e.timestamp || e.ts) as string | undefined
+        return ts?.startsWith(today)
+      })
+
+      // Calculate session duration (time between first and last event today)
+      let sessionDuration: string | null = null
+      if (todayEvents.length >= 2) {
+        const timestamps = todayEvents
+          .map((e) => new Date((e.timestamp || e.ts) as string).getTime())
+          .filter((t) => !Number.isNaN(t))
+          .sort((a, b) => a - b)
+
+        if (timestamps.length >= 2) {
+          const durationMs = timestamps[timestamps.length - 1] - timestamps[0]
+          sessionDuration = dateHelper.formatDuration(durationMs)
+        }
+      }
+
+      // Count tasks completed today
+      const tasksCompleted = todayEvents.filter((e) => e.action === 'task_completed').length
+
+      // Count features shipped today
+      const featuresShipped = todayEvents.filter((e) => e.action === 'feature_shipped').length
+
+      // Count agent usage from sync events
+      const agentCounts = new Map<string, number>()
+      for (const event of todayEvents) {
+        if (event.action === 'sync' && Array.isArray(event.subagents)) {
+          for (const agent of event.subagents as string[]) {
+            agentCounts.set(agent, (agentCounts.get(agent) || 0) + 1)
+          }
+        }
+      }
+
+      const agentsUsed = Array.from(agentCounts.entries())
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count)
+
+      return {
+        sessionDuration,
+        tasksCompleted,
+        featuresShipped,
+        agentsUsed,
+      }
+    } catch {
+      return {
+        sessionDuration: null,
+        tasksCompleted: 0,
+        featuresShipped: 0,
+        agentsUsed: [],
+      }
+    }
+  }
+
   // =========== Stats Helper Methods ===========
 
   private _formatTokens(tokens: number): string {
@@ -631,15 +741,62 @@ export class AnalysisCommands extends PrjctCommandsBase {
     },
     _dailyStats: { date: string; tokensSaved: number; syncs: number }[],
     projectName: string,
-    firstSyncDate: string
+    firstSyncDate: string,
+    sessionActivity?: {
+      sessionDuration: string | null
+      tasksCompleted: number
+      featuresShipped: number
+      agentsUsed: { name: string; count: number }[]
+    },
+    patternsSummary?: {
+      decisions: number
+      learnedDecisions: number
+      workflows: number
+      preferences: number
+    }
   ): string {
     const lines: string[] = []
 
-    lines.push(`# ${projectName} - Value Dashboard`)
+    lines.push(`# ${projectName} - Stats Dashboard`)
     lines.push('')
     lines.push(`_Generated: ${new Date().toLocaleString()} | Tracking since: ${firstSyncDate}_`)
     lines.push('')
 
+    // Session Activity (PRJ-89)
+    if (sessionActivity) {
+      lines.push("## 🎯 Today's Activity")
+      lines.push('')
+      lines.push(`| Metric | Value |`)
+      lines.push(`|--------|-------|`)
+      if (sessionActivity.sessionDuration) {
+        lines.push(`| Duration | ${sessionActivity.sessionDuration} |`)
+      }
+      lines.push(`| Tasks completed | ${sessionActivity.tasksCompleted} |`)
+      lines.push(`| Features shipped | ${sessionActivity.featuresShipped} |`)
+      if (sessionActivity.agentsUsed.length > 0) {
+        const agentStr = sessionActivity.agentsUsed
+          .slice(0, 3)
+          .map((a) => `${a.name} (${a.count}×)`)
+          .join(', ')
+        lines.push(`| Agents used | ${agentStr} |`)
+      }
+      lines.push('')
+    }
+
+    // Patterns Learned (PRJ-89)
+    if (patternsSummary && (patternsSummary.decisions > 0 || patternsSummary.preferences > 0)) {
+      lines.push('## 🧠 Patterns Learned')
+      lines.push('')
+      lines.push(`| Type | Count |`)
+      lines.push(`|------|-------|`)
+      lines.push(
+        `| Decisions | ${patternsSummary.learnedDecisions} confirmed (${patternsSummary.decisions} total) |`
+      )
+      lines.push(`| Preferences | ${patternsSummary.preferences} |`)
+      lines.push(`| Workflows | ${patternsSummary.workflows} |`)
+      lines.push('')
+    }
+
     lines.push('## 💰 Token Savings')
     lines.push('')
     lines.push(`| Metric | Value |`)

package/core/infrastructure/config-manager.ts

@@ -148,6 +148,7 @@ class ConfigManager {
     const localConfig: LocalConfig = {
       projectId,
       dataPath: displayPath,
+      showMetrics: true, // PRJ-70: default to true for new projects
     }
 
     await this.writeConfig(projectPath, localConfig)
@@ -318,6 +319,29 @@ class ConfigManager {
     return this.validateConfig(config)
   }
 
+  /**
+   * Get showMetrics setting from config.
+   * Defaults to true for new or existing projects without the setting.
+   * @see PRJ-70
+   */
+  async getShowMetrics(projectPath: string): Promise<boolean> {
+    const config = await this.readConfig(projectPath)
+    // Default to true if not set
+    return config?.showMetrics ?? true
+  }
+
+  /**
+   * Set showMetrics setting in config.
+   * @see PRJ-70
+   */
+  async setShowMetrics(projectPath: string, showMetrics: boolean): Promise<void> {
+    const config = await this.readConfig(projectPath)
+    if (config) {
+      config.showMetrics = showMetrics
+      await this.writeConfig(projectPath, config)
+    }
+  }
+
   /**
    * Get configuration with defaults
    * Returns LOCAL config only (projectId, dataPath)

package/core/services/memory-service.ts

@@ -112,6 +112,27 @@ export class MemoryService {
       }
     }
   }
+
+  /**
+   * Get recent events by projectId (for stats dashboard)
+   * @see PRJ-89
+   */
+  async getRecentEvents(
+    projectId: string,
+    limit: number = 100
+  ): Promise<Record<string, unknown>[]> {
+    try {
+      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
+      const entries = await jsonlHelper.readJsonLines<Record<string, unknown>>(memoryPath)
+      return entries.slice(-limit)
+    } catch (error) {
+      // ENOENT or parse error - return empty
+      if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
+        console.error(`Memory read error: ${(error as Error).message}`)
+      }
+      return []
+    }
+  }
 }
 
 export const memoryService = new MemoryService()

package/core/types/config.ts

@@ -12,6 +12,12 @@ import type { IntegrationsConfig } from './integrations'
 export interface LocalConfig {
   projectId: string
   dataPath: string
+  /**
+   * Whether to show metrics in command output.
+   * Defaults to true for new projects.
+   * @see PRJ-70
+   */
+  showMetrics?: boolean
 }
 
 /**

package/core/types/memory.ts

@@ -75,6 +75,76 @@ export interface MemoryQuery {
   since?: string
 }
 
+/**
+ * Domain types for task context.
+ * @see PRJ-107
+ */
+export type TaskDomain =
+  | 'frontend'
+  | 'backend'
+  | 'devops'
+  | 'docs'
+  | 'testing'
+  | 'database'
+  | 'general'
+
+/**
+ * Enhanced query parameters for selective memory retrieval.
+ * @see PRJ-107
+ */
+export interface RelevantMemoryQuery {
+  /** Task domain for context-aware retrieval */
+  taskDomain?: TaskDomain
+  /** Task description for keyword matching */
+  taskDescription?: string
+  /** Command being executed */
+  commandName?: string
+  /** Maximum results to return */
+  maxResults?: number
+  /** Minimum relevance score threshold (0-100) */
+  minRelevance?: number
+}
+
+/**
+ * Memory with relevance score attached.
+ * @see PRJ-107
+ */
+export interface ScoredMemory extends Memory {
+  /** Relevance score (0-100) */
+  relevanceScore: number
+  /** Breakdown of score components */
+  scoreBreakdown?: {
+    domainMatch: number
+    tagMatch: number
+    recency: number
+    confidence: number
+    keywords: number
+    userTriggered: number
+  }
+}
+
+/**
+ * Result of selective memory retrieval with metrics.
+ * @see PRJ-107
+ */
+export interface MemoryRetrievalResult {
+  /** Relevant memories sorted by score */
+  memories: ScoredMemory[]
+  /** Retrieval metrics */
+  metrics: {
+    /** Total memories in database */
+    totalMemories: number
+    /** Memories that passed threshold */
+    memoriesConsidered: number
+    /** Memories returned */
+    memoriesReturned: number
+    /** Filtering ratio (returned/total) */
+    filteringRatio: number
+    /** Average relevance score of returned memories */
+    avgRelevanceScore: number
+  }
+}
+
 /**
  * Memory database structure.
  */

package/core/utils/output.ts

@@ -235,10 +235,10 @@ const out: Output = {
     const border = '─'.repeat(maxLen + 2)
 
     console.log(chalk.dim(`┌${border}┐`))
-    console.log(chalk.dim('│') + ` ${chalk.bold(title.padEnd(maxLen))} ` + chalk.dim('│'))
+    console.log(`${chalk.dim('│')} ${chalk.bold(title.padEnd(maxLen))} ${chalk.dim('│')}`)
     console.log(chalk.dim(`├${border}┤`))
     for (const line of lines) {
-      console.log(chalk.dim('│') + ` ${line.padEnd(maxLen)} ` + chalk.dim('│'))
+      console.log(`${chalk.dim('│')} ${line.padEnd(maxLen)} ${chalk.dim('│')}`)
     }
     console.log(chalk.dim(`└${border}┘`))
     return this

package/dist/bin/prjct.mjs

@@ -1595,7 +1595,9 @@ var init_config_manager = __esm({
         const now = getTimestamp();
         const localConfig = {
           projectId,
-          dataPath: displayPath
+          dataPath: displayPath,
+          showMetrics: true
+          // PRJ-70: default to true for new projects
         };
         await this.writeConfig(projectPath, localConfig);
         const globalConfig = {
@@ -1734,6 +1736,26 @@ var init_config_manager = __esm({
         const config = await this.readConfig(projectPath);
         return this.validateConfig(config);
       }
+      /**
+       * Get showMetrics setting from config.
+       * Defaults to true for new or existing projects without the setting.
+       * @see PRJ-70
+       */
+      async getShowMetrics(projectPath) {
+        const config = await this.readConfig(projectPath);
+        return config?.showMetrics ?? true;
+      }
+      /**
+       * Set showMetrics setting in config.
+       * @see PRJ-70
+       */
+      async setShowMetrics(projectPath, showMetrics) {
+        const config = await this.readConfig(projectPath);
+        if (config) {
+          config.showMetrics = showMetrics;
+          await this.writeConfig(projectPath, config);
+        }
+      }
       /**
        * Get configuration with defaults
        * Returns LOCAL config only (projectId, dataPath)
@@ -2235,10 +2257,10 @@ var init_output = __esm({
         const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
         const border = "\u2500".repeat(maxLen + 2);
         console.log(chalk2.dim(`\u250C${border}\u2510`));
-        console.log(chalk2.dim("\u2502") + ` ${chalk2.bold(title.padEnd(maxLen))} ` + chalk2.dim("\u2502"));
+        console.log(`${chalk2.dim("\u2502")} ${chalk2.bold(title.padEnd(maxLen))} ${chalk2.dim("\u2502")}`);
         console.log(chalk2.dim(`\u251C${border}\u2524`));
         for (const line of lines) {
-          console.log(chalk2.dim("\u2502") + ` ${line.padEnd(maxLen)} ` + chalk2.dim("\u2502"));
+          console.log(`${chalk2.dim("\u2502")} ${line.padEnd(maxLen)} ${chalk2.dim("\u2502")}`);
         }
         console.log(chalk2.dim(`\u2514${border}\u2518`));
         return this;
@@ -9064,6 +9086,159 @@ var init_memory_system = __esm({
         });
         return scored.filter((m) => m._score > 0).sort((a, b) => b._score - a._score).slice(0, limit).map(({ _score, ...memory }) => memory);
       }
+      /**
+       * Enhanced memory retrieval with domain-based filtering and metrics.
+       * Implements selective memory retrieval based on task relevance.
+       * @see PRJ-107
+       */
+      async getRelevantMemoriesWithMetrics(projectId, query) {
+        const db = await this.load(projectId);
+        const totalMemories = db.memories.length;
+        if (totalMemories === 0) {
+          return {
+            memories: [],
+            metrics: {
+              totalMemories: 0,
+              memoriesConsidered: 0,
+              memoriesReturned: 0,
+              filteringRatio: 0,
+              avgRelevanceScore: 0
+            }
+          };
+        }
+        const maxResults = query.maxResults ?? 10;
+        const minRelevance = query.minRelevance ?? 10;
+        const scored = db.memories.map((memory) => {
+          const breakdown = {
+            domainMatch: 0,
+            tagMatch: 0,
+            recency: 0,
+            confidence: 0,
+            keywords: 0,
+            userTriggered: 0
+          };
+          if (query.taskDomain) {
+            const domainTags = this._getDomainTags(query.taskDomain);
+            const matchingTags = (memory.tags || []).filter((tag) => domainTags.includes(tag));
+            breakdown.domainMatch = Math.min(25, matchingTags.length * 10);
+          }
+          if (query.commandName) {
+            const commandTags = this._getCommandTags(query.commandName);
+            const matchingTags = (memory.tags || []).filter((tag) => commandTags.includes(tag));
+            breakdown.tagMatch = Math.min(20, matchingTags.length * 8);
+          }
+          const age = Date.now() - new Date(memory.updatedAt).getTime();
+          const daysSinceUpdate = age / (1e3 * 60 * 60 * 24);
+          breakdown.recency = Math.max(0, Math.round(15 - daysSinceUpdate * 0.5));
+          if (memory.confidence) {
+            breakdown.confidence = memory.confidence === "high" ? 20 : memory.confidence === "medium" ? 12 : 5;
+          } else if (memory.observationCount) {
+            breakdown.confidence = Math.min(20, memory.observationCount * 3);
+          }
+          if (query.taskDescription) {
+            const keywords = this._extractKeywordsFromText(query.taskDescription);
+            let keywordScore = 0;
+            for (const keyword of keywords) {
+              if (memory.content.toLowerCase().includes(keyword)) keywordScore += 2;
+              if (memory.title.toLowerCase().includes(keyword)) keywordScore += 3;
+            }
+            breakdown.keywords = Math.min(15, keywordScore);
+          }
+          if (memory.userTriggered) {
+            breakdown.userTriggered = 5;
+          }
+          const relevanceScore = breakdown.domainMatch + breakdown.tagMatch + breakdown.recency + breakdown.confidence + breakdown.keywords + breakdown.userTriggered;
+          return {
+            ...memory,
+            relevanceScore,
+            scoreBreakdown: breakdown
+          };
+        });
+        const considered = scored.filter((m) => m.relevanceScore >= minRelevance);
+        const sorted = considered.sort((a, b) => b.relevanceScore - a.relevanceScore);
+        const returned = sorted.slice(0, maxResults);
+        const avgRelevanceScore = returned.length > 0 ? Math.round(returned.reduce((sum, m) => sum + m.relevanceScore, 0) / returned.length) : 0;
+        return {
+          memories: returned,
+          metrics: {
+            totalMemories,
+            memoriesConsidered: considered.length,
+            memoriesReturned: returned.length,
+            filteringRatio: totalMemories > 0 ? returned.length / totalMemories : 0,
+            avgRelevanceScore
+          }
+        };
+      }
+      /**
+       * Map task domain to relevant memory tags.
+       * @see PRJ-107
+       */
+      _getDomainTags(domain) {
+        const domainTagMap = {
+          frontend: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.FILE_STRUCTURE, MEMORY_TAGS.ARCHITECTURE],
+          backend: [
+            MEMORY_TAGS.CODE_STYLE,
+            MEMORY_TAGS.ARCHITECTURE,
+            MEMORY_TAGS.DEPENDENCIES,
+            MEMORY_TAGS.TECH_STACK
+          ],
+          devops: [MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.DEPENDENCIES],
+          docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION],
+          testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE],
+          database: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.NAMING_CONVENTION],
+          general: Object.values(MEMORY_TAGS)
+        };
+        return domainTagMap[domain] || [];
+      }
+      /**
+       * Map command to relevant memory tags.
+       * @see PRJ-107
+       */
+      _getCommandTags(commandName) {
+        const commandTags = {
+          ship: [MEMORY_TAGS.COMMIT_STYLE, MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR],
+          feature: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+          done: [MEMORY_TAGS.SHIP_WORKFLOW],
+          analyze: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE],
+          spec: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+          task: [MEMORY_TAGS.BRANCH_NAMING, MEMORY_TAGS.CODE_STYLE],
+          sync: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.DEPENDENCIES],
+          test: [MEMORY_TAGS.TEST_BEHAVIOR],
+          bug: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.TEST_BEHAVIOR]
+        };
+        return commandTags[commandName] || [];
+      }
+      /**
+       * Extract keywords from text for matching.
+       */
+      _extractKeywordsFromText(text) {
+        const words = text.toLowerCase().split(/\s+/);
+        const stopWords = /* @__PURE__ */ new Set([
+          "the",
+          "a",
+          "an",
+          "is",
+          "are",
+          "to",
+          "for",
+          "and",
+          "or",
+          "in",
+          "on",
+          "at",
+          "by",
+          "with",
+          "from",
+          "as",
+          "it",
+          "this",
+          "that",
+          "be",
+          "have",
+          "has"
+        ]);
+        return words.filter((w) => w.length > 2 && !stopWords.has(w));
+      }
       _extractContextTags(context2) {
         const tags = [];
         const commandTags = {
@@ -9184,6 +9359,14 @@ Context: ${context2}` : ""}`,
       getMemoryStats(projectId) {
         return this._semanticMemories.getMemoryStats(projectId);
       }
+      /**
+       * Get relevant memories with domain-based filtering and metrics.
+       * Implements selective memory retrieval based on task relevance.
+       * @see PRJ-107
+       */
+      getRelevantMemoriesWithMetrics(projectId, query) {
+        return this._semanticMemories.getRelevantMemoriesWithMetrics(projectId, query);
+      }
       // ===========================================================================
       // TIER 1: Session Memory
       // ===========================================================================
@@ -15163,6 +15346,22 @@ var init_memory_service = __esm({
           }
         }
       }
+      /**
+       * Get recent events by projectId (for stats dashboard)
+       * @see PRJ-89
+       */
+      async getRecentEvents(projectId, limit = 100) {
+        try {
+          const memoryPath = path_manager_default.getFilePath(projectId, "memory", "context.jsonl");
+          const entries = await jsonl_helper_default.readJsonLines(memoryPath);
+          return entries.slice(-limit);
+        } catch (error) {
+          if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
+            console.error(`Memory read error: ${error.message}`);
+          }
+          return [];
+        }
+      }
     };
     memoryService = new MemoryService();
   }
@@ -16633,6 +16832,7 @@ var AnalysisCommands;
 var init_analysis2 = __esm({
   "core/commands/analysis.ts"() {
     "use strict";
+    init_memory_system();
     init_generator();
     init_analyzer2();
     init_command_installer();
@@ -16972,13 +17172,17 @@ ${formatFullDiff(diff)}`);
         };
       }
       /**
-       * /p:stats - Value dashboard showing accumulated savings and impact
+       * /p:stats - Session summary and value dashboard
        *
        * Displays:
+       * - Session activity (tasks completed, features shipped today)
+       * - Patterns learned (from memory system)
        * - Token savings (total, compression rate, estimated cost)
        * - Performance metrics (sync count, avg duration)
        * - Agent usage breakdown
        * - 30-day trend visualization
+       *
+       * @see PRJ-89
        */
       async stats(projectPath = process.cwd(), options = {}) {
         try {
@@ -16990,8 +17194,12 @@ ${formatFullDiff(diff)}`);
           }
           const summary = await metricsStorage.getSummary(projectId);
           const dailyStats = await metricsStorage.getDailyStats(projectId, 30);
+          const sessionActivity = await this._getSessionActivity(projectId);
+          const patternsSummary = await memory_system_default.getPatternsSummary(projectId);
           if (options.json) {
             const jsonOutput = {
+              session: sessionActivity,
+              patterns: patternsSummary,
               totalTokensSaved: summary.totalTokensSaved,
               estimatedCostSaved: summary.estimatedCostSaved,
               compressionRate: summary.compressionRate,
@@ -17008,10 +17216,8 @@ ${formatFullDiff(diff)}`);
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
           let projectName = "Unknown";
           try {
-            const fs47 = __require("node:fs/promises");
-            const path56 = __require("node:path");
             const projectJson = JSON.parse(
-              await fs47.readFile(path56.join(globalPath, "project.json"), "utf-8")
+              await fs34.readFile(path35.join(globalPath, "project.json"), "utf-8")
             );
             projectName = projectJson.name || "Unknown";
           } catch {
@@ -17024,12 +17230,32 @@ ${formatFullDiff(diff)}`);
           }) : "N/A";
           console.log("");
           console.log("\u256D\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\u256E");
-          console.log("\u2502  \u{1F4CA} prjct-cli Value Dashboard                   \u2502");
+          console.log("\u2502  \u{1F4CA} prjct-cli Stats Dashboard                   \u2502");
           console.log(
             `\u2502  Project: ${projectName.padEnd(20).slice(0, 20)} | Since: ${firstSyncDate.padEnd(12).slice(0, 12)} \u2502`
           );
           console.log("\u2570\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\u256F");
           console.log("");
+          console.log("\u{1F3AF} TODAY'S ACTIVITY");
+          if (sessionActivity.sessionDuration) {
+            console.log(`   Duration:        ${sessionActivity.sessionDuration}`);
+          }
+          console.log(`   Tasks completed: ${sessionActivity.tasksCompleted}`);
+          console.log(`   Features shipped: ${sessionActivity.featuresShipped}`);
+          if (sessionActivity.agentsUsed.length > 0) {
+            const agentStr = sessionActivity.agentsUsed.slice(0, 3).map((a) => `${a.name} (${a.count}\xD7)`).join(", ");
+            console.log(`   Agents used:     ${agentStr}`);
+          }
+          console.log("");
+          if (patternsSummary.decisions > 0 || patternsSummary.preferences > 0) {
+            console.log("\u{1F9E0} PATTERNS LEARNED");
+            console.log(
+              `   Decisions:    ${patternsSummary.learnedDecisions} confirmed (${patternsSummary.decisions} total)`
+            );
+            console.log(`   Preferences:  ${patternsSummary.preferences} saved`);
+            console.log(`   Workflows:    ${patternsSummary.workflows} tracked`);
+            console.log("");
+          }
           console.log("\u{1F4B0} TOKEN SAVINGS");
           console.log(`   Total saved:     ${this._formatTokens(summary.totalTokensSaved)} tokens`);
           console.log(
@@ -17042,7 +17268,7 @@ ${formatFullDiff(diff)}`);
           console.log(`   Avg sync time:   ${this._formatDuration(summary.avgSyncDuration)}`);
           console.log("");
           if (summary.topAgents.length > 0) {
-            console.log("\u{1F916} AGENT USAGE");
+            console.log("\u{1F916} AGENT USAGE (all time)");
             const totalUsage = summary.topAgents.reduce((sum, a) => sum + a.usageCount, 0);
             for (const agent of summary.topAgents) {
               const pct = totalUsage > 0 ? (agent.usageCount / totalUsage * 100).toFixed(0) : 0;
@@ -17071,20 +17297,68 @@ ${formatFullDiff(diff)}`);
               summary,
               dailyStats,
               projectName,
-              firstSyncDate
+              firstSyncDate,
+              sessionActivity,
+              patternsSummary
             );
             console.log(markdown);
             return { success: true, data: { markdown } };
           }
           return {
             success: true,
-            data: summary
+            data: { ...summary, session: sessionActivity, patterns: patternsSummary }
           };
         } catch (error) {
           console.error("\u274C Error:", error.message);
           return { success: false, error: error.message };
         }
       }
+      /**
+       * Get session activity stats from today's events
+       * @see PRJ-89
+       */
+      async _getSessionActivity(projectId) {
+        try {
+          const recentHistory = await memoryService.getRecentEvents(projectId, 100);
+          const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const todayEvents = recentHistory.filter((e) => {
+            const ts = e.timestamp || e.ts;
+            return ts?.startsWith(today);
+          });
+          let sessionDuration = null;
+          if (todayEvents.length >= 2) {
+            const timestamps = todayEvents.map((e) => new Date(e.timestamp || e.ts).getTime()).filter((t) => !Number.isNaN(t)).sort((a, b) => a - b);
+            if (timestamps.length >= 2) {
+              const durationMs = timestamps[timestamps.length - 1] - timestamps[0];
+              sessionDuration = date_helper_default.formatDuration(durationMs);
+            }
+          }
+          const tasksCompleted = todayEvents.filter((e) => e.action === "task_completed").length;
+          const featuresShipped = todayEvents.filter((e) => e.action === "feature_shipped").length;
+          const agentCounts = /* @__PURE__ */ new Map();
+          for (const event of todayEvents) {
+            if (event.action === "sync" && Array.isArray(event.subagents)) {
+              for (const agent of event.subagents) {
+                agentCounts.set(agent, (agentCounts.get(agent) || 0) + 1);
+              }
+            }
+          }
+          const agentsUsed = Array.from(agentCounts.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+          return {
+            sessionDuration,
+            tasksCompleted,
+            featuresShipped,
+            agentsUsed
+          };
+        } catch {
+          return {
+            sessionDuration: null,
+            tasksCompleted: 0,
+            featuresShipped: 0,
+            agentsUsed: []
+          };
+        }
+      }
       // =========== Stats Helper Methods ===========
       _formatTokens(tokens) {
         if (tokens >= 1e6) {
@@ -17111,12 +17385,40 @@ ${formatFullDiff(diff)}`);
           return chars[idx];
         }).join("");
       }
-      _generateStatsMarkdown(summary, _dailyStats, projectName, firstSyncDate) {
+      _generateStatsMarkdown(summary, _dailyStats, projectName, firstSyncDate, sessionActivity, patternsSummary) {
         const lines = [];
-        lines.push(`# ${projectName} - Value Dashboard`);
+        lines.push(`# ${projectName} - Stats Dashboard`);
         lines.push("");
         lines.push(`_Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()} | Tracking since: ${firstSyncDate}_`);
         lines.push("");
+        if (sessionActivity) {
+          lines.push("## \u{1F3AF} Today's Activity");
+          lines.push("");
+          lines.push(`| Metric | Value |`);
+          lines.push(`|--------|-------|`);
+          if (sessionActivity.sessionDuration) {
+            lines.push(`| Duration | ${sessionActivity.sessionDuration} |`);
+          }
+          lines.push(`| Tasks completed | ${sessionActivity.tasksCompleted} |`);
+          lines.push(`| Features shipped | ${sessionActivity.featuresShipped} |`);
+          if (sessionActivity.agentsUsed.length > 0) {
+            const agentStr = sessionActivity.agentsUsed.slice(0, 3).map((a) => `${a.name} (${a.count}\xD7)`).join(", ");
+            lines.push(`| Agents used | ${agentStr} |`);
+          }
+          lines.push("");
+        }
+        if (patternsSummary && (patternsSummary.decisions > 0 || patternsSummary.preferences > 0)) {
+          lines.push("## \u{1F9E0} Patterns Learned");
+          lines.push("");
+          lines.push(`| Type | Count |`);
+          lines.push(`|------|-------|`);
+          lines.push(
+            `| Decisions | ${patternsSummary.learnedDecisions} confirmed (${patternsSummary.decisions} total) |`
+          );
+          lines.push(`| Preferences | ${patternsSummary.preferences} |`);
+          lines.push(`| Workflows | ${patternsSummary.workflows} |`);
+          lines.push("");
+        }
         lines.push("## \u{1F4B0} Token Savings");
         lines.push("");
         lines.push(`| Metric | Value |`);
@@ -24714,7 +25016,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.53.0",
+      version: "0.54.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

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