dino-spec 7.4.2 → 7.5.0

package/README.md

@@ -10,541 +10,159 @@
 <__|-|__|
 ```
 
-**dino-spec** is a CLI tool that brings structured, context-aware development to [Claude Code](https://claude.ai/code). It automatically maintains session state through hooks, ensuring Claude always has the context it needs.
+**dino-spec** brings structured, context-aware development to [Claude Code](https://claude.ai/code). It automatically maintains session state, provides 23 MCP tools, and enables intelligent context retrieval.
 
-## Why dino-spec?
-
-When working with AI coding assistants, projects often suffer from:
-
-- **Context loss** - AI forgets what you're building mid-conversation
-- **State blindness** - No awareness of test/build/lint status
-- **Unstructured iteration** - No clear progression from idea to implementation
-
-**dino-spec v7.3.0** solves these with:
+## Features
 
+- **MCP Integration** - 23 tools + 19 resources auto-configured during init
+- **Session State** - Automatic tracking of focus, test/build/lint status, blockers
+- **Persistent Memory** - Decisions, patterns, learnings survive across sessions
+- **Workflow Skills** - Phases from discovery to completion (`/dino.*`)
+- **Task Delegation** - Specialized agents with context handoffs
 - **Recursive Retrieval** - RLM-style query decomposition with quality feedback
-- **Context REPL** - Declarative DSL for model-driven context exploration
-- **Long-Running Agent Support** - Verification, feature tracking, bootstrapping, and git recovery
-- **Persistent Memory System** - Decisions, patterns, and learnings that survive compaction
-- **Context Engineering** - Research-backed memory decay, JIT retrieval, and attention management
-- **Progressive task delegation** - Automatic delegation to specialized agents with context handoffs
-- **Progressive context loading** - Minimal initial tokens, load context on-demand via MCP resources
-- **Automatic context** via Claude Code hooks that maintain session state
-- **Skill-based workflow** with phases from discovery to completion
-- **Session intelligence** that tracks focus, blockers, and progress
-
-## What's New in v7.3.0
-
-### Recursive Retrieval - Intelligent Query Decomposition
-
-RLM-style recursive retrieval with model-driven decomposition and quality feedback:
-
-**Key Features:**
-- **Auto-decomposition** - Splits complex queries into sub-queries by category, hop level, or search terms
-- **Hierarchical budgeting** - Priority-weighted token allocation with 20% synthesis reserve
-- **Quality scoring** - Evaluates relevance (0.4), completeness (0.3), consistency (0.2), novelty (0.1)
-- **Early stopping** - Halts on quality threshold or diminishing returns
-- **Full trajectory** - Tree/flat/summary views of execution path
-
-**Decomposition Patterns:**
-```javascript
-// By category - split across memory types
-"search patterns for error handling"
-→ patterns.search, decisions.search, learnings.search
-
-// By hop level - progressive graph exploration
-traverse(maxHops: 2)
-→ 1-hop traversal, 2-hop traversal
-
-// By terms - multi-term search expansion
-"error handling best practices"
-→ full query + individual term searches
-```
-
-**Strategies:**
-- `adaptive` - Quality-guided exploration (default)
-- `breadth-first` - Explore all sub-queries per level
-- `depth-first` - Follow each branch to completion
-
-**MCP Tool:** `dino_recursive_query` with budget/quality configuration
-
-Inspired by [Recursive Language Models (RLM)](https://arxiv.org/abs/2512.24601v1).
-
-## What's New in v7.2.0
-
-### Context REPL - Model-Driven Exploration
-
-Declarative DSL enabling Claude to autonomously query dino-spec context:
+- **Dynamic Partitioning** - Intelligent codebase segmentation (directory, feature, dependency, time)
+- **Context REPL** - Declarative DSL for model-driven exploration
 
-**Query Types:**
-- `select` - Filter and project from context variables
-- `search` - Semantic search with BM25 scoring
-- `aggregate` - Count, group, sum, avg operations
-- `traverse` - Graph traversal (1-2 hops)
-- `combine` - Union/chain multiple queries
-
-**Input Formats:**
-```javascript
-// JSON DSL
-{"type": "search", "from": "memories.patterns", "search": {"query": "error handling"}}
-
-// Natural language
-"search patterns for authentication"
+## Installation
 
-// Shorthand
-"memories.decisions:search:testing"
+```bash
+npm install -g dino-spec
 ```
 
-**Available Variables:**
-- `memories.*` - decisions, patterns, learnings, graph
-- `session.*` - focus, recentChanges, testStatus, blockers
-- `retrieval.*` - cache, rankedFiles
-- `drift.*` - score, signals
-- `projects.*` - profile, relationships
-
-**MCP Tool:** `dino_context_repl` with comprehensive query documentation
-
-Inspired by [Recursive Language Models (RLM)](https://arxiv.org/abs/2512.24601v1).
-
-## What's New in v7.1.0
-
-### Advanced Retrieval System
-
-Three new features for intelligent context management:
-
-| Feature | Purpose | Commands/Resources |
-|---------|---------|-------------------|
-| Retrieval Optimizer | LRU cache with relevance scoring | MCP: `dino_retrieval_optimize`, `dino://retrieval/ranked` |
-| Hybrid Retrieval | Upfront + autonomous exploration | `dino retrieve [query]` with strategy selection |
-| Recitation Scheduler | Track drift, auto-refresh summaries | MCP: `dino://recitation/schedule` |
-
-## What's New in v7.0.0
-
-### Long-Running Agent Support
-
-Based on research from [Anthropic: Effective Harnesses for Long-Running Agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents):
-
-| Feature | Purpose | Commands |
-|---------|---------|----------|
-| Verification Testing | Run baseline tests on session start | `dino session verify` |
-| Feature Tracking | JSON-based feature list with completion validation | `dino features list/add/start/complete` |
-| Initializer Agent | Bootstrap agent generates init-context.md | `dino bootstrap`, `dino init --bootstrap` |
-| Git Recovery | Create/restore checkpoints via git commits | `dino checkpoint create/list/restore` |
-
-## v6.8.0 Features
-
-### Memory System Enhancements
-
-| Feature | Purpose | Key Insight |
-|---------|---------|-------------|
-| Graph 2-Hop | Enhanced contextual recall | Traverse 2 hops for richer connections |
-| Memory Health | Health scoring dashboard | `dino memory stats --health` |
-| Memory Search | `dino memory search <pattern>` | Find memories by keyword |
-| Failure Auto-Pop | Extract test/build errors | Automatic failure registration |
-| Effectiveness Ranking | High-value patterns first | Validated patterns get priority |
-
-## v6.9.0 Features
-
-### Context Optimization
-
-Based on research from [Anthropic: Effective Context Engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents):
-
-| Feature | Purpose | Commands |
-|---------|---------|----------|
-| KV-Cache Health Analyzer | Detect cache-breaking patterns | `dino cache analyze` |
-| Tool Result Clearing | Identify stale tool outputs | Auto-detection in context |
-| Context Auditor | Analyze compression opportunities | `dino context audit` |
-
-## v6.7.0 Features
-
-### Context Engineering Improvements
-
-Based on research from [Anthropic](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents), [Manus](https://manus.im/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus), and [ProMem](https://arxiv.org/abs/2601.04463):
-
-| Feature | Purpose | Key Insight |
-|---------|---------|-------------|
-| Memory Decay | Remove stale memories | "Forgetting is feature engineering" |
-| Proactive Extraction | Capture valuable context | "Memory formation chooses what deserves retention" |
-| KV-Cache Optimization | Stable prompt prefix | 100:1 efficiency via prefix stability |
-| JIT Retrieval | Load context on-demand | Only inject relevant memories |
-| Failure Registry | Surface past failures | "Failure evidence should be prominent" |
-| Graph Memory | Relationship tracking | Connected recall via 1-hop traversal |
-
-### Memory System
+## Quick Start
 
-Persistent memories in `.dino/memories/`:
+```bash
+cd your-project
+dino init          # Analyze codebase, install hooks, configure MCP
 
+# MCP server is auto-configured for Claude Code
+# Use /mcp in Claude Code to verify
 ```
-.dino/memories/
-├── decisions.xml    # Architectural choices with rationale
-├── patterns.xml     # Learned coding preferences
-├── learnings.xml    # Session discoveries
-├── failures.json    # Error patterns and solutions
-└── graph.json       # Memory relationships
-```
-
-Access via MCP: `@dino://memories`, `@dino://decisions`
-
-### Memory Decay
-
-Memories decay over time to keep signal high:
-
-| Memory Type | Half-Life | Budget Cap |
-|-------------|-----------|------------|
-| Decisions | 30 days | 50 max |
-| Patterns | 14 days | 100 max |
-| Learnings | 7 days | 200 max |
-
-### Semantic Recall
 
-Intelligent memory retrieval based on context:
-
-```typescript
-// Automatically recalls relevant memories based on current work
-const memories = await semanticRecall({
-  query: "authentication flow",
-  focus: "src/auth/",
-  maxResults: 5
-});
-```
+## CLI Commands
 
-## What's New in v5.0.0
+| Command | Description |
+|---------|-------------|
+| `dino init` | Initialize project (hooks + MCP) |
+| `dino init --minimal` | Minimal CLAUDE.md with MCP resources |
+| `dino init --bootstrap` | Include project analysis summary |
+| `dino status` | Show session state and health |
+| `dino refresh` | Re-analyze codebase |
+| `dino update` | Update managed files |
+| `dino update --scope mcp` | Fix MCP configuration |
+| `dino memory list` | Show persistent memories |
+| `dino memory search <query>` | Search memories |
+| `dino retrieve <query>` | Hybrid file retrieval |
+| `dino mcp-serve` | Start MCP server (auto-managed) |
+
+## Workflow Skills
+
+Use in Claude Code with `/dino.<phase>`:
+
+| Phase | Skill | Purpose |
+|-------|-------|---------|
+| Discover | `/dino.discover` | Capture requirements |
+| Scout | `/dino.scout` | Research codebase |
+| Sniff | `/dino.sniff` | Clarify ambiguities |
+| Nest | `/dino.nest` | Plan implementation |
+| Hatch | `/dino.hatch` | Break into tasks |
+| Hunt | `/dino.hunt` | Execute implementation |
+| Aging | `/dino.aging` | Verify with tests |
+| Fossil | `/dino.fossil` | Archive and commit |
+
+Utilities: `/dino.status`, `/dino.focus`, `/dino.next`
 
-### Progressive Task Delegation
+## MCP Resources
 
-Automatically delegate complex tasks to specialized agents while preserving context:
+Access via `@dino://` in Claude Code:
 
-```
-User: "Implement caching for the API"
-         ↓
-┌────────────────────────────────────────────────┐
-│  @dino-analyst → @dino-architect → @dino-implementer  │
-│     (explore)      (design)         (implement)       │
-└────────────────────────────────────────────────┘
-```
+| Resource | Description |
+|----------|-------------|
+| `@dino://session` | Focus, blockers, test status |
+| `@dino://structure` | Project architecture |
+| `@dino://patterns` | Coding conventions |
+| `@dino://commands` | Build/test/lint commands |
+| `@dino://tasks` | Task registry and progress |
+| `@dino://handoff` | Agent handoff context |
+| `@dino://memories/summary` | All memories overview |
+| `@dino://retrieval/ranked` | Session-relevant files |
 
-Each agent creates **checkpoints** with their discoveries, which get passed to the next agent via **handoffs**. No re-reading the entire codebase!
+## MCP Tools
 
-#### MCP Tools for Task Management
+Key tools available via Claude Code:
 
 | Tool | Purpose |
 |------|---------|
-| `dino_task_create` | Create a task in the registry |
-| `dino_task_breakdown` | Split task into subtasks with roles |
-| `dino_checkpoint_create` | Save findings for handoff |
-| `dino_task_delegate` | Delegate to specialized agent |
-| `dino_task_status` | View task tree and progress |
-
-#### New Resources
-
-| Resource | Description |
-|----------|-------------|
-| `@dino://tasks` | Current task tree and progress |
-| `@dino://handoff` | Active handoff context |
+| `dino_status` | Get session state |
+| `dino_focus_set` | Set focus area |
+| `dino_memory_recall` | Semantic memory search |
+| `dino_context_repl` | Declarative context queries |
+| `dino_recursive_query` | RLM-style retrieval |
+| `dino_partition` | Intelligent codebase partitioning |
+| `dino_task_create` | Create task in registry |
+| `dino_plan_create` | Create implementation plan |
 
-### Specialized Agents
+## Specialized Agents
 
 | Agent | Role | Purpose |
 |-------|------|---------|
 | `@dino-analyst` | Explorer | Read-only codebase research |
-| `@dino-architect` | Planner | Design and planning (Opus) |
+| `@dino-architect` | Planner | Design and planning |
 | `@dino-implementer` | Implementer | Full implementation |
-| `@dino-tester` | Tester | Test writing and execution |
+| `@dino-tester` | Tester | Test writing/execution |
 | `@dino-reviewer` | Reviewer | Code review and QA |
 
-### Auto-Delegation Detection
-
-The `user-prompt-submit` hook detects complex prompts and suggests delegation:
-
-```
-[dino] Multi-step task detected. Suggested delegation: explorer -> planner -> implementer
-```
-
-## Previous: v4.0.0 Features
-
-### Progressive Context Loading
-
-Reduce initial context by ~59% with the new `--minimal` mode:
-
-```bash
-dino init --minimal
-```
-
-Instead of loading everything upfront, context is loaded on-demand:
-
-| Resource | Description | Access |
-|----------|-------------|--------|
-| `@dino://session` | Current session state | On-demand |
-| `@dino://structure` | Project architecture | On-demand |
-| `@dino://patterns` | Coding conventions | On-demand |
-| `@dino://commands` | Build/test/lint commands | On-demand |
-| `@dino://skills` | Available workflow skills | On-demand |
-
-### Smart Hooks
+## Memory System
 
-- **Context Router**: Session-start only outputs critical alerts (failing tests, blockers)
-- **Intent Detection**: User prompts trigger relevant resource suggestions
-- **Session Compaction**: Automatically archives old session data
-
-## Installation
-
-### From npm (recommended)
-
-```bash
-npm install -g dino-spec
-```
-
-### From GitHub
-
-```bash
-git clone https://github.com/xullul/dino-spec.git
-cd dino-spec
-pnpm install
-pnpm build
-npm link
-```
-
-## Quick Start
-
-```bash
-# Initialize in your project (standard mode)
-cd your-project
-dino init
-
-# Or use minimal mode for progressive context loading
-dino init --minimal
-
-# Check current session state
-dino status
-
-# Open Claude Code and use workflow skills:
-# /dino.discover, /dino.scout, /dino.hunt, etc.
-```
-
-## The Workflow
-
-Each phase builds on the previous, with automatic session tracking:
-
-```
-discover → scout → sniff → nest → hatch → hunt → aging → fossil
-```
-
-| Phase        | Skill            | Purpose                                      |
-| ------------ | ---------------- | -------------------------------------------- |
-| **Discover** | `/dino.discover` | Capture requirements from user prompts       |
-| **Scout**    | `/dino.scout`    | Research codebase and explore options        |
-| **Sniff**    | `/dino.sniff`    | Clarify ambiguities with targeted questions  |
-| **Nest**     | `/dino.nest`     | Plan implementation (uses Plan Mode)         |
-| **Hatch**    | `/dino.hatch`    | Break plan into actionable todos             |
-| **Hunt**     | `/dino.hunt`     | Execute implementation with tracking         |
-| **Aging**    | `/dino.aging`    | Verify with tests                            |
-| **Fossil**   | `/dino.fossil`   | Archive and commit completed work            |
-
-Utility skills: `/dino.status`, `/dino.focus`, `/dino.next`
-
-## CLI Commands
-
-```bash
-# Initialize
-dino init                  # Standard initialization
-dino init --minimal        # Minimal mode for progressive loading
-dino init --force          # Reinitialize, overwriting existing
-
-# Status and refresh
-dino status                # Show current session state
-dino refresh               # Re-analyze codebase and update context
-dino refresh --minimal     # Switch to minimal mode
-
-# Session management
-dino session read          # Display session state
-dino session update        # Update session (blockers, focus, etc.)
-
-# Hooks
-dino hooks setup           # Install Claude Code hooks
-dino hooks status          # Show hook configuration
-dino hooks list            # List all available hooks
-dino hooks enable <id>     # Enable a specific hook
-dino hooks disable <id>    # Disable a specific hook
-dino hooks remove          # Remove all hooks
-
-# Skill Store
-dino store list            # List installed skills
-dino store list --remote   # List available remote skills
-dino store search          # Interactive skill search and install
-dino store install <skill> # Install a skill
-dino store remove <skill>  # Remove a skill
-dino store sync            # Refresh remote manifests
-```
-
-## Skill Store
-
-The skill store provides a way to share and install workflow skills.
-
-### Interactive Search
-
-```bash
-dino store search
-```
-
-This launches an interactive search interface where you can:
-- Type to filter skills by name, description, or tags
-- See which skills are already installed (✓)
-- Select a skill to view details and install
-- Choose installation scope (local project or global)
-
-### Commands
-
-| Command | Description |
-|---------|-------------|
-| `dino store list` | List installed skills (local project) |
-| `dino store list -g` | List global installed skills |
-| `dino store list --remote` | List available skills from remote store |
-| `dino store search` | Interactive skill search and install |
-| `dino store search --list` | Non-interactive list mode |
-| `dino store install <skill>` | Install to local project |
-| `dino store install <skill> -g` | Install globally |
-| `dino store remove <skill>` | Remove from local project |
-| `dino store sync` | Refresh remote manifests |
-
-### Private Repositories
+Persistent memories in `.dino/memories/`:
 
-For private skill repositories, authenticate with GitHub:
+| Type | Half-Life | Purpose |
+|------|-----------|---------|
+| Decisions | 30 days | Architectural choices |
+| Patterns | 14 days | Coding preferences |
+| Learnings | 7 days | Session discoveries |
 
 ```bash
-# Option 1: Use gh CLI (recommended)
-gh auth login
-
-# Option 2: Set environment variable
-export GITHUB_TOKEN=your_token_here
+dino memory list              # View all memories
+dino memory search "auth"     # Search memories
+dino memory decay             # Clean stale memories
 ```
 
-The token needs `repo` scope for private repository access.
-
 ## Project Structure
 
-After `dino init`, your project will have:
-
 ```
 your-project/
-├── CLAUDE.md                    # Project context (auto-updated)
+├── CLAUDE.md                 # Project context
 ├── .claude/
-│   ├── skills/dino/             # Workflow skills
-│   │   ├── discover.md          # Discovery phase
-│   │   ├── scout.md             # Research phase
-│   │   ├── sniff.md             # Clarification phase
-│   │   ├── nest.md              # Planning phase
-│   │   ├── hatch.md             # Breakdown phase
-│   │   ├── hunt.md              # Implementation phase
-│   │   ├── aging.md             # Verification phase
-│   │   ├── fossil.md            # Completion phase
-│   │   ├── status.md            # Status utility
-│   │   ├── focus.md             # Focus utility
-│   │   └── next.md              # Next steps utility
-│   ├── rules/dino/              # Workflow rules
-│   └── agents/                  # Specialized agents
+│   ├── skills/dino/          # Workflow skills
+│   ├── rules/dino/           # Workflow rules
+│   └── agents/               # Specialized agents
 └── .dino/
-    ├── session.md               # Session state (focus, blockers, signals)
-    ├── structure.json           # Cached codebase analysis
-    ├── patterns.json            # Coding patterns (@dino://patterns)
-    ├── commands.json            # Commands (@dino://commands)
-    ├── config.json              # Configuration
-    ├── archive/                 # Session history archive
-    ├── tasks/                   # Task registry (v5.0.0)
-    ├── checkpoints/             # Agent checkpoints (v5.0.0)
-    ├── handoff/                 # Agent handoffs (v5.0.0)
-    └── memories/                # Persistent memory (v6.0.0)
-        ├── decisions.xml        # Architectural decisions
-        ├── patterns.xml         # Learned patterns
-        ├── learnings.xml        # Session discoveries
-        ├── failures.json        # Error registry (v6.6.0)
-        └── graph.json           # Memory relationships (v6.6.0)
+    ├── session.md            # Session state
+    ├── structure.json        # Codebase analysis
+    ├── tasks/                # Task registry
+    ├── checkpoints/          # Agent checkpoints
+    └── memories/             # Persistent memory
 ```
 
-## Session State
-
-The `.dino/session.md` file tracks:
-
-```markdown
-# Session State
-
-## Focus
-**src/core/** (high confidence, directory-cluster)
-
-## Test Status
-**Status:** passing
-**Counts:** 121 passed, 0 failed, 0 skipped
-
-## Build Status
-**Status:** passing
-
-## Blockers
-- Waiting for API response format decision
-
-## Progress
-- 2024-01-15 10:30: tests-fixed - All tests passing
-- 2024-01-15 10:15: build-fixed - Build errors resolved
-```
-
-Hooks automatically update this state based on your actions.
-
-## Hooks System (v4.0.0)
-
-Dino-spec integrates with Claude Code's hooks:
-
-| Hook | Purpose |
-|------|---------|
-| `SessionStart` | Output critical alerts only (context router) |
-| `SessionEnd` | Clean up on exit |
-| `PostEdit` | Track file changes with classification |
-| `PostTest` | Update test status |
-| `PostBuild` | Update build status |
-| `PostLint` | Update lint status |
-| `PreCompact` | Archive and compact session state |
-| `UserPromptSubmit` | Intent detection with resource suggestions |
-| `SubagentStart/Stop` | Track agent activity |
-
-The v4.0.0 hooks are optimized for minimal output:
-- **Session-start**: Only alerts on failures/blockers (silence when green)
-- **User-prompt-submit**: Suggests relevant `@dino://` resources based on intent
-
-## MCP Resources
-
-Access context on-demand using @ mentions in Claude Code:
+## Requirements
 
-```
-@dino://session    # Current focus, blockers, test status
-@dino://structure  # Project architecture and directories
-@dino://patterns   # Coding conventions and patterns
-@dino://commands   # Build, test, lint commands
-@dino://skills     # Available workflow skills
-@dino://history    # Recent file edit history
-@dino://tasks      # Task registry and progress (v5.0.0)
-@dino://handoff    # Active handoff context (v5.0.0)
-@dino://memories   # Full memory summary (v6.4.0)
-@dino://decisions  # Architectural decisions (v6.4.0)
-```
+- Node.js >= 20.0.0
+- Claude Code CLI
 
-## Minimal vs Standard Mode
+## Troubleshooting
 
-| Aspect | Standard | Minimal |
-|--------|----------|---------|
-| CLAUDE.md size | ~300 tokens | ~100 tokens |
-| Initial context | Full sections | Quick reference |
-| Architecture | Embedded | `@dino://structure` |
-| Patterns | Embedded | `@dino://patterns` |
-| Commands | Embedded | `@dino://commands` |
-| Best for | Quick reference | Large codebases |
+### MCP not showing in `/mcp`
 
-Switch between modes:
 ```bash
-dino refresh --minimal  # Switch to minimal
-dino refresh --full     # Switch to standard
-```
+# Windows
+claude mcp add-json --scope user dino '{"command":"cmd","args":["/c","npx","dino-spec","mcp-serve"]}'
 
-## Requirements
+# macOS/Linux
+claude mcp add --scope user dino -- npx dino-spec mcp-serve
+```
 
-- Node.js >= 20.0.0
-- Claude Code CLI
+Then restart Claude Code.
 
 ## License
 

package/dist/core/agents/__tests__/action-mask.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Action Mask Tests - v7.2.0
+ */
+export {};
+//# sourceMappingURL=action-mask.test.d.ts.map

package/dist/core/agents/__tests__/action-mask.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-mask.test.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/__tests__/action-mask.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}