prjct-cli 0.28.3 → 0.29.0

package/CHANGELOG.md

@@ -1,135 +1,43 @@
 # Changelog
 
-## [0.28.3] - 2026-01-11
-
-### Feature: Claude Code Synergy Optimization
-
-Major improvements to maximize prjct + Claude Code integration efficiency.
-
-**Skill Auto-Invocation (Phase 4 of /p:task):**
-- Skills are now automatically invoked when loading agents
-- Agent frontmatter `skills: [skill-name]` triggers `Skill("skill-name")`
-- Example: Loading `frontend.md` auto-activates `/frontend-design`
-
-**MCP Auto-Usage:**
-- Agents with `mcp: [context7]` auto-query documentation during tasks
-- Per-project MCP config at `{globalPath}/config/mcp-servers.json`
-- Seamless library documentation lookup during implementation
-
-**Think Blocks for Destructive Commands:**
-- `/p:ship` now includes mandatory `<think>` block
-- Pre-ship verification checklist (completeness, quality, git state)
-- Prevents shipping incomplete or broken code
-
-**Agent Auto-Refresh in /p:sync:**
-- Detects when dependencies change (package.json, etc.)
-- Regenerates stale agents (>7 days old)
-- Versions previous agents as `.backup` files
-- Logs refresh events to memory
-
-**Slash Command Registration:**
-- New `slash-commands.json` config for Claude Code integration
-- Enables command discovery and validation
-- Path: `{globalPath}/config/slash-commands.json`
-
-**Token Budget Analysis:**
-- Estimates context token usage during sync
-- Warns if approaching 80% of budget (160k tokens)
-- Auto-summarizes large agents if needed
-
-**Client Migration on Update:**
-- Setup now creates missing config files for existing projects
-- `slash-commands.json` auto-created for existing installations
-- Seamless upgrade experience for npm update users
-
-**New TypeScript Modules:**
-- `core/infrastructure/slash-command-registry.ts` - Command validation
-- `core/agentic/token-estimator.ts` - Token budget estimation
-
-**Template Context Optimization:**
-- Reduced main templates from 3,197 to 2,214 lines (-31%)
-- `sync.md`: 1,602 → 835 lines (-48%)
-- `global/CLAUDE.md`: 429 → 363 lines (-15%)
-- `task.md`: 397 → 336 lines (-15%)
-- `ship.md`: 769 → 680 lines (-12%)
-- New `templates/guides/` for on-demand documentation
-- New `templates/shared/validation.md` for reusable validation
-
-**Files Removed (Agentic Generation):**
-- Deleted hardcoded domain agents from `templates/subagents/domain/`
-- Deleted `.mcp.json` (now generated per-project)
-- Deleted `CLAUDE.md` from root (moved to templates/global/)
+## [0.28.0] - 2026-01-12
 
----
-
-## [0.28.2] - 2026-01-10
-
-### Feature: Agent Mentions and Major Cleanup
+### Feature: Per-Project Task Filtering for Status Bar
 
-**Agent Mentions (p.agent.{name}):**
-- New `agentId` field in agent frontmatter for identification
-- Users can invoke agents in prompts: `p.agent.backend help me...`
-- Format: `p.agent.workflow`, `p.agent.planner`, `p.agent.frontend`, etc.
+Extended API now supports filtering by current working directory, enabling the status bar to show project-specific tasks.
 
-**Deprecated Commands Removed:**
-- `/p:now` - Use `/p:task` instead
-- `/p:feature` - Use `/p:task` instead
-- `/p:work` - Use `/p:task` instead
+**New Endpoints:**
+- `GET /api/status-bar/compact?cwd=/path` - Filter by cwd
+- `GET /api/projects` - List all projects
+- `GET /api/projects/:id/full` - Project dashboard
+- `POST /api/projects/:id/task/{complete,pause,resume}`
+- `GET /api/stats/global` - Global statistics
 
-**Notion Integration Removed:**
-- Removed entire `core/integrations/notion/` directory
-- Removed Notion skills and MCP config
-- Cleaned up type references
+**How it works:**
+1. Status bar detects cwd from frontmost app (Terminal, VS Code, etc.)
+2. Calls `/api/status-bar/compact?cwd=/current/path`
+3. Server matches cwd to project's `repoPath`
+4. Returns only that project's task
 
-**Code Cleanup:**
-- Removed `executeWithoutProject()` deprecated method
-- Cleaned dead code in prompt-builder arrays
-- Removed ARCHITECTURE.md (outdated)
-
-**Ship Template Enhancement:**
-- Version bump now REQUIRED before PR creation
-- CHANGELOG.md update now REQUIRED before PR creation
-- Better categorization of changes (Added/Fixed/Changed)
+**Files:**
+- `core/server/routes-extended.ts` - New extended API routes
+- `core/server/server.ts` - Mount extended routes
+- `core/server/index.ts` - Export extended routes
 
 ---
 
-## [0.28.1] - 2026-01-10
-
-### Feature: @ Agent Mentions
+## [0.27.1] - 2026-01-12
 
-Direct agent invocation via @ notation in tasks.
+### Docs: Differentiation Strategy vs Coding Agents
 
-**New Capabilities:**
+Clarified prjct's positioning as a **workflow layer**, not a coding agent.
 
-1. **@ Agent Mentions**
-   - `p. task @frontend add button` - Loads frontend specialist directly
-   - `p. task @frontend @uxui dark mode` - Loads multiple agents
-   - Supports all prjct agents: `@frontend`, `@backend`, `@database`, `@uxui`, `@testing`, `@devops`
-
-2. **@ Claude Subagents**
-   - `@explore` - Fast codebase search (Task tool with subagent_type=Explore)
-   - `@general` - Complex multi-step research
-   - `@plan` - Architecture design and planning
-   - Example: `p. task @frontend @explore add button like existing ones`
-
-3. **Performance Improvements**
-   - Template cache: O(1) LRU using ES6 Map insertion order
-   - Agent loading: Parallel Promise.all() for faster startup
-   - Glob searches: Parallel execution in context estimation
-
-4. **Tool Permissions**
-   - Templates can specify `tool-permissions` in frontmatter
-   - Supports `allow`, `ask`, and `deny` rules per tool
-   - Example: `ship.md` now declares safe vs dangerous git commands
+**Changes:**
+- Added "What prjct is (and isn't)" section to README
+- Created COMPARISON.md documenting prjct vs OpenCode, Cursor, Jira, etc.
+- Clear messaging: prjct enhances Claude Code, doesn't compete with it
 
-**Files Changed:**
-- `core/agentic/command-executor.ts` - Parse @ mentions, load mentioned agents
-- `core/agentic/prompt-builder.ts` - Build subagent instructions, tool permissions
-- `core/agentic/template-loader.ts` - LRU cache optimization, tool-permissions parsing
-- `core/agentic/agent-router.ts` - `loadAgentsByMention()` method
-- `core/domain/agent-loader.ts` - Parallel agent loading
-- `core/domain/context-estimator.ts` - Parallel glob execution
-- `templates/commands/task.md` - @ mention documentation
+**Key insight:** prjct competes with Jira/Linear/Notion (workflow tools), not with OpenCode/Cursor/Copilot (coding agents). Use both together for maximum developer momentum.
 
 ---
 

package/CLAUDE.md

@@ -0,0 +1,170 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with prjct-cli.
+
+## Project Overview
+
+**prjct-cli** is a developer momentum tool. Track progress through natural language commands (`p. <command>`) without meetings or traditional PM overhead.
+
+## HOW PRJCT WORKS
+
+When user types `p. <command>`, load the template from `templates/commands/{command}.md` and execute it **intelligently** - templates are GUIDANCE, not rigid scripts.
+
+```
+p. sync     → Analyze project, generate domain agents
+p. task X   → Start task with classification + breakdown
+p. done     → Complete current subtask
+p. ship X   → Ship feature with PR + version bump
+```
+
+---
+
+## CRITICAL RULES
+
+### 1. Path Resolution (MOST IMPORTANT)
+**ALL writes go to global storage**: `~/.prjct-cli/projects/{projectId}/`
+- **NEVER** write to `.prjct/` (config only, read-only)
+- **NEVER** write to `./` (current directory)
+
+### 2. Before Any Command
+```
+1. Read .prjct/prjct.config.json → get projectId
+2. Set globalPath = ~/.prjct-cli/projects/{projectId}
+3. Execute using globalPath for all writes
+4. Log to {globalPath}/memory/events.jsonl
+```
+
+### 3. Timestamps & UUIDs
+```bash
+# Timestamp (NEVER hardcode)
+bun -e "console.log(new Date().toISOString())" 2>/dev/null || node -e "console.log(new Date().toISOString())"
+
+# UUID
+bun -e "console.log(crypto.randomUUID())" 2>/dev/null || node -e "console.log(require('crypto').randomUUID())"
+```
+
+### 4. Git Commit Footer (CRITICAL - ALWAYS INCLUDE)
+
+**Every commit MUST include the prjct signature:**
+
+```
+🤖 Generated with [p/](https://www.prjct.app/)
+Designed for [Claude](https://www.anthropic.com/claude)
+
+```
+
+**NON-NEGOTIABLE: The `🤖 Generated with [p/]` line identifies prjct-powered commits.**
+
+---
+
+## ARCHITECTURE: Write-Through Pattern
+
+```
+User Action → Storage (JSON) → Context (MD) → Sync Events
+```
+
+| Layer | Path | Purpose |
+|-------|------|---------|
+| **Storage** | `storage/*.json` | Source of truth |
+| **Context** | `context/*.md` | Claude-readable summaries |
+| **Memory** | `memory/events.jsonl` | Audit trail (append-only) |
+| **Agents** | `agents/*.md` | Domain specialists |
+
+### File Structure
+```
+~/.prjct-cli/projects/{projectId}/
+├── storage/
+│   ├── state.json      # Current task (SOURCE OF TRUTH)
+│   ├── queue.json      # Task queue
+│   └── shipped.json    # Shipped features
+├── context/
+│   ├── now.md          # Current task (generated)
+│   └── next.md         # Queue (generated)
+├── memory/
+│   └── events.jsonl    # Audit trail
+├── agents/             # Domain specialists
+└── sync/
+    └── pending.json    # Backend events
+```
+
+---
+
+## COMMANDS
+
+| Trigger | Purpose |
+|---------|---------|
+| `p. init` | Initialize project with deep analysis |
+| `p. sync` | Analyze repo, generate agents |
+| `p. task <desc>` | Start task with agentic classification |
+| `p. done` | Complete current subtask |
+| `p. ship [name]` | Ship with PR + version bump |
+| `p. pause` | Pause active task |
+| `p. resume` | Resume paused task |
+| `p. bug <desc>` | Report bug with auto-priority |
+
+### Workflow
+```
+p. sync → p. task "description" → [work] → p. done → p. ship
+```
+
+---
+
+## INTELLIGENT BEHAVIOR
+
+Templates provide guidance. Use your intelligence to:
+
+1. **Read before write** - Always read existing files first
+2. **Explore before coding** - Use Task(Explore) to understand codebase
+3. **Ask when uncertain** - Use AskUserQuestion to clarify
+4. **Load agents** - Read from `{globalPath}/agents/` for domain expertise
+5. **Adapt templates** - They're guidance, not rigid scripts
+6. **Log everything** - Append to memory/events.jsonl
+
+---
+
+## OUTPUT FORMAT
+
+Concise responses (< 4 lines):
+```
+✅ [What was done]
+
+[Key metrics]
+Next: [suggested action]
+```
+
+---
+
+## KEY RULES
+
+1. **Read files before editing** - Never assume structure
+2. **Use node/bun for timestamps** - Never hardcode dates
+3. **Follow template guidance** - But adapt intelligently
+4. **Log to memory** - Append to `memory/events.jsonl`
+5. **Suggest next actions** - Maintain user momentum
+6. **Use linked skills** - Agents have skills in frontmatter
+
+---
+
+## SKILL INTEGRATION (v0.27)
+
+Agents are linked to Claude Code skills from claude-plugins.dev.
+
+### Agent → Skill Mapping
+
+| Agent | Skill |
+|-------|-------|
+| `frontend.md` | `frontend-design` |
+| `uxui.md` | `frontend-design` |
+| `backend.md` | `javascript-typescript` |
+| `testing.md` | `developer-kit` |
+| `devops.md` | `developer-kit` |
+| `prjct-planner.md` | `feature-dev` |
+| `prjct-shipper.md` | `code-review` |
+
+### Usage
+
+- `p. sync` installs required skills automatically
+- `p. task` invokes skills based on task type
+- Skills config: `{globalPath}/config/skills.json`
+
+See `templates/agentic/skill-integration.md` for details.

package/README.md

@@ -22,7 +22,20 @@ Developer momentum tool for indie hackers and small teams.
 > - `p. I'm done`
 > - `p. ship the authentication`
 
-## 💬 p. Trigger - Zero Memorization
+## What prjct is (and isn't)
+
+**prjct is a workflow layer, not a coding agent.**
+
+| Coding Agents | prjct-cli |
+|---------------|-----------|
+| Write code for you | Tracks what you're building |
+| Replace your IDE | Enhances Claude Code |
+| Multi-provider (GPT, Claude, etc.) | 100% Claude-optimized |
+| Compete with Cursor, Copilot | Replaces Jira, Linear, Notion |
+
+**Use both together:** OpenCode/Cursor/Claude Code writes the code. prjct tracks your progress, maintains context between sessions, and keeps you focused.
+
+## p. Trigger - Zero Memorization
 
 **You don't need to memorize commands.** Just use the `p.` prefix and talk naturally!
 

package/core/agentic/agent-router.ts

@@ -104,21 +104,6 @@ class AgentRouter {
     }
   }
 
-  /**
-   * Load multiple agents by @ mention names
-   * @example loadAgentsByMention(["frontend", "uxui"]) -> [Agent, Agent]
-   */
-  async loadAgentsByMention(mentions: string[]): Promise<Agent[]> {
-    const agents: Agent[] = []
-    for (const name of mentions) {
-      const agent = await this.loadAgent(name)
-      if (agent) {
-        agents.push(agent)
-      }
-    }
-    return agents
-  }
-
   /**
    * Log agent usage to JSONL file
    */

package/core/agentic/command-executor.ts

@@ -18,7 +18,6 @@ import chainOfThought from './chain-of-thought'
 import memorySystem from './memory-system'
 import groundTruth from './ground-truth'
 import planMode from './plan-mode'
-import AgentRouter from './agent-router'
 
 import type {
   ExecutionResult,
@@ -108,18 +107,6 @@ export class CommandExecutor {
     }
 
     try {
-      // 0. Parse @ agent mentions from task input
-      const taskInput = (params.task as string) || (params.description as string) || ''
-      const { prjctAgents, claudeSubagents, cleanInput } = promptBuilder.parseAgentMentions(taskInput)
-
-      // Update params with clean input (without @ mentions)
-      if (prjctAgents.length > 0 || claudeSubagents.length > 0) {
-        if (params.task) params.task = cleanInput
-        if (params.description) params.description = cleanInput
-        params._mentionedAgents = prjctAgents
-        params._claudeSubagents = claudeSubagents
-      }
-
       // 1. Load template
       const template = await templateLoader.load(commandName)
 
@@ -208,62 +195,27 @@ export class CommandExecutor {
         )
       }
 
-      // 8.5. Load @ mentioned agents if any
-      let primaryAgent = null
-      if (prjctAgents.length > 0) {
-        const agentRouter = new AgentRouter()
-        await agentRouter.initialize(projectPath)
-        const loadedAgents = await agentRouter.loadAgentsByMention(prjctAgents)
-
-        if (loadedAgents.length > 0) {
-          primaryAgent = {
-            name: loadedAgents[0].name,
-            content: loadedAgents[0].content,
-            role: undefined,
-            skills: [],
-          }
-          console.log(`🤖 Loading agents: ${loadedAgents.map((a) => `@${a.name}`).join(', ')}`)
-        }
-      }
-
-      // 9. Build prompt - use mentioned agent or let Claude decide via templates
+      // 9. Build prompt - NO agent assignment here, Claude decides via templates
       const planInfo = {
         isPlanning: requiresPlanning || isInPlanningMode,
         requiresApproval: isDestructive && !params.approved,
         active: activePlan,
         allowedTools: planMode.getAllowedTools(isInPlanningMode, template.frontmatter['allowed-tools'] || []),
       }
-
-      // Build base prompt
-      let prompt = promptBuilder.build(
+      // Agent is null - Claude assigns via Task tool using agent-routing.md
+      const prompt = promptBuilder.build(
         template,
         context as Parameters<typeof promptBuilder.build>[1],
         state,
-        primaryAgent,
+        null,
         learnedPatterns,
         null,
         relevantMemories,
         planInfo
       )
 
-      // Add Claude subagent instructions if @ mentioned
-      if (claudeSubagents.length > 0) {
-        const subagentInstructions = promptBuilder.buildSubagentInstructions(claudeSubagents)
-        prompt = prompt + subagentInstructions
-        console.log(`🔧 Claude subagents requested: ${claudeSubagents.map((s) => `@${s}`).join(', ')}`)
-      }
-
-      // Add tool permissions from template if present
-      const toolPermissions = template.frontmatter['tool-permissions'] as Record<string, { allow?: string[]; ask?: string[]; deny?: string[] }> | undefined
-      if (toolPermissions) {
-        const permissionsSection = promptBuilder.buildToolPermissions(toolPermissions)
-        prompt = prompt + permissionsSection
-      }
-
       // Log agentic mode
-      if (!primaryAgent) {
-        console.log(`🤖 Agentic delegation enabled - Claude will assign agent via Task tool`)
-      }
+      console.log(`🤖 Agentic delegation enabled - Claude will assign agent via Task tool`)
 
       // Record successful attempt
       loopDetector.recordSuccess(commandName, loopContext)

package/core/agentic/index.ts

@@ -90,19 +90,9 @@ export { default as toolRegistry } from './tool-registry'
 export { default as templateLoader } from './template-loader'
 
 // ============ Utilities ============
-// Chain of thought, services, token estimation
+// Chain of thought, services
 export { default as chainOfThought } from './chain-of-thought'
 export { default as services } from './services'
-export {
-  default as tokenEstimator,
-  estimateTokens,
-  getTokenBudget,
-  estimateContext,
-  filterContext,
-  summarizeForTokens,
-  createContextSections,
-  formatEstimate,
-} from './token-estimator'
 
 // ============ Types ============
 // All types re-exported from ../types (canonical source)

package/core/agentic/prompt-builder.ts

@@ -283,7 +283,7 @@ class PromptBuilder {
 
     // Agent assignment (CONDITIONAL - only for code-modifying commands)
     const commandName = template.frontmatter?.name?.replace('p:', '') || ''
-    const agentCommands = ['task', 'design', 'fix', 'bug', 'test', 'cleanup', 'spec']
+    const agentCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'test', 'work', 'cleanup', 'spec']
     const needsAgent = agentCommands.includes(commandName)
 
     if (agent && needsAgent) {
@@ -332,7 +332,7 @@ class PromptBuilder {
     }
 
     // OPTIMIZED: Only include patterns for code-modifying commands
-    const codeCommands = ['task', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec']
+    const codeCommands = ['now', 'build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec', 'work']
     const needsPatterns = codeCommands.includes(commandName)
 
     // Include code patterns analysis for code-modifying commands
@@ -498,87 +498,6 @@ class PromptBuilder {
     return result || null
   }
 
-  /**
-   * Claude Code subagents that can be invoked via @ notation
-   */
-  private readonly CLAUDE_SUBAGENTS = ['explore', 'general', 'plan']
-
-  /**
-   * Parse @ agent mentions from input
-   * Separates prjct agents from Claude Code subagents
-   * @example "@frontend @explore add dark mode" -> { prjctAgents: ["frontend"], claudeSubagents: ["explore"], cleanInput: "add dark mode" }
-   */
-  parseAgentMentions(input: string): {
-    prjctAgents: string[]
-    claudeSubagents: string[]
-    cleanInput: string
-  } {
-    if (!input) return { prjctAgents: [], claudeSubagents: [], cleanInput: '' }
-
-    const mentionPattern = /@(\w+)/g
-    const prjctAgents: string[] = []
-    const claudeSubagents: string[] = []
-    let match
-
-    while ((match = mentionPattern.exec(input)) !== null) {
-      const name = match[1].toLowerCase()
-      if (this.CLAUDE_SUBAGENTS.includes(name)) {
-        claudeSubagents.push(name)
-      } else {
-        prjctAgents.push(name)
-      }
-    }
-
-    const cleanInput = input.replace(mentionPattern, '').trim()
-    return { prjctAgents, claudeSubagents, cleanInput }
-  }
-
-  /**
-   * Build Claude subagent instructions for the prompt
-   */
-  buildSubagentInstructions(claudeSubagents: string[]): string {
-    if (!claudeSubagents.length) return ''
-
-    const instructions = claudeSubagents.map((sub) => {
-      switch (sub) {
-        case 'explore':
-          return '- USE Task tool with subagent_type=Explore for fast codebase exploration'
-        case 'general':
-          return '- USE Task tool with subagent_type=general-purpose for complex multi-step research'
-        case 'plan':
-          return '- USE Task tool with subagent_type=Plan for architecture design'
-        default:
-          return null
-      }
-    }).filter(Boolean)
-
-    if (!instructions.length) return ''
-
-    return `
-## CLAUDE SUBAGENT INSTRUCTIONS
-${instructions.join('\n')}
-`
-  }
-
-  /**
-   * Build tool permissions section from template frontmatter
-   */
-  buildToolPermissions(toolPermissions: Record<string, { allow?: string[]; ask?: string[]; deny?: string[] }> | null): string {
-    if (!toolPermissions) return ''
-
-    const parts: string[] = ['\n## TOOL PERMISSIONS\n', 'Check these BEFORE executing:\n']
-
-    for (const [tool, rules] of Object.entries(toolPermissions)) {
-      parts.push(`\n**${tool}:**`)
-      if (rules.allow?.length) parts.push(`- ALLOW: ${rules.allow.join(', ')}`)
-      if (rules.ask?.length) parts.push(`- ASK USER: ${rules.ask.join(', ')}`)
-      if (rules.deny?.length) parts.push(`- NEVER: ${rules.deny.join(', ')}`)
-    }
-
-    parts.push('\n⚠️ DENY = Never execute. ASK = Confirm with user first.\n')
-    return parts.join('\n')
-  }
-
   /**
    * Build critical anti-hallucination rules section
    */