@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/docs/README.md

@@ -0,0 +1,42 @@
+# StackMemory Documentation
+
+## Quick Start
+
+- **[Setup Guide](SETUP.md)** - Installation, Railway deployment, Linear/Claude integration
+- **[Features](FEATURES.md)** - Context persistence, TUI, storage, browser testing  
+- **[Development](DEVELOPMENT.md)** - Testing, architecture, quality gates, security
+- **[API Reference](API_REFERENCE.md)** - Commands, MCP tools, REST endpoints
+
+## Core Documents
+
+- **[SPEC.md](SPEC.md)** - Technical specification and system architecture
+- **[AGENTS.md](AGENTS.md)** - Agent system and skill management
+- **[BM25+RLM Search](BM25-RLM-10DAY-FINAL.md)** - Next-gen code search (10-day implementation)
+
+## Specialized Areas
+
+### Architecture
+- [Technical Architecture](architecture/TECHNICAL_ARCHITECTURE.md) - System design patterns
+- [Deployment](architecture/DEPLOYMENT.md) - Infrastructure and scaling
+- [Multi-Project Support](architecture/MULTI_PROJECT.md) - Project isolation
+
+### Integrations
+- [Linear Integration](integrations/) - Task management sync
+- [Browser MCP](integrations/) - Web testing capabilities
+- [Database Migration](postgres-migration-plan.md) - PostgreSQL transition
+
+### Development
+- [Session Persistence](session-persistence-design.md) - Context survival design
+- [Query Language](query-language.md) - Context query syntax
+- [Testing Agent](testing-agent.md) - Automated testing framework
+
+## Archives
+Historical documentation in [archives/](archives/) - implementation summaries, security reports, migration guides.
+
+## Documentation Standards
+
+- Technical accuracy over marketing language
+- Real metrics and benchmarks
+- Practical code examples
+- Version-specific information
+- Clear troubleshooting guides

package/docs/guides/README_INSTALL.md

@@ -0,0 +1,208 @@
+# 🚀 StackMemory Quick Installation
+
+## One-Command Install (Global for ALL Claude Instances)
+
+```bash
+# Clone and install globally
+git clone https://github.com/yourusername/stackmemory.git
+cd stackmemory
+./install.sh
+```
+
+**That's it!** StackMemory is now available in:
+- ✅ ALL Claude Code instances
+- ✅ ANY git repository  
+- ✅ Automatically starts with Claude
+
+---
+
+## 🎯 What the Installer Does
+
+1. **Installs globally** to `~/.stackmemory`
+2. **Configures Claude Code** MCP automatically
+3. **Creates `stackmemory` command** available everywhere
+4. **Auto-detects** git repositories
+5. **No manual configuration needed**
+
+---
+
+## 📝 After Installation
+
+### Restart Claude Code
+Close and reopen Claude Code to load the MCP server.
+
+### Test It Works
+In Claude Code, ask:
+- "What's the project context?"
+- "Add decision: We're using PostgreSQL"
+- "Start task: Implementing authentication"
+
+### Use in Any Git Repo
+```bash
+cd your-project
+stackmemory init    # One-time setup
+stackmemory status  # Check what's stored
+stackmemory test    # Run quality tests
+```
+
+---
+
+## 🔧 Manual Installation (Alternative)
+
+If the installer doesn't work, manually configure:
+
+### 1. Find your Claude config directory:
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/claude/claude_desktop_config.json`
+
+### 2. Add this configuration:
+```json
+{
+  "mcpServers": {
+    "stackmemory": {
+      "command": "node",
+      "args": ["/path/to/stackmemory/dist/src/mcp-server.js"],
+      "env": {
+        "STACKMEMORY_GLOBAL": "true"
+      }
+    }
+  }
+}
+```
+
+### 3. Build StackMemory:
+```bash
+cd stackmemory
+npm install
+npm run build
+```
+
+### 4. Restart Claude Code
+
+---
+
+## 🧪 Test Suite
+
+Run the test to verify context quality:
+
+```bash
+# In any project with StackMemory initialized
+stackmemory test
+```
+
+This will:
+- Simulate multiple sessions
+- Test context recall accuracy
+- Measure relevance over time
+- Generate performance report
+- Export CSV with detailed metrics
+
+### Reading Test Results
+
+```
+📊 Test Results Summary
+
+Overall Performance:
+  Recall Accuracy:    ████████░░ 82.3%
+  Context Relevance:  ██████░░░░ 61.5%
+  Importance Stability: ████████░░ 85.2%
+  Avg Response Time:  15ms
+
+Learning Curve:
+  Session 1→2: 📈 +15.2% improvement
+  Session 2→3: 📈 +8.7% improvement
+```
+
+---
+
+## 🌍 Global Commands
+
+Once installed, these commands work anywhere:
+
+| Command | Description |
+|---------|-------------|
+| `stackmemory` | Start MCP server in current directory |
+| `stackmemory init` | Initialize in current git repo |
+| `stackmemory status` | Show stored contexts and metrics |
+| `stackmemory test` | Run quality test suite |
+
+---
+
+## 🔍 Verify Installation
+
+Check if properly installed:
+
+```bash
+# Check command exists
+which stackmemory
+
+# Check Claude config
+cat ~/Library/Application\ Support/Claude/claude_desktop_config.json | grep stackmemory
+
+# Test in a git repo
+cd any-git-repo
+stackmemory init
+stackmemory status
+```
+
+---
+
+## ⚡ Performance Metrics
+
+After a week of usage, check metrics:
+
+```bash
+stackmemory status
+```
+
+You'll see:
+- **Top contexts by importance** (what matters most)
+- **Access patterns** (what's used frequently)
+- **Attention scores** (what influences responses)
+- **Decay indicators** (what's becoming stale)
+
+---
+
+## 🐛 Troubleshooting
+
+### Claude Code doesn't see StackMemory
+1. Check config file location
+2. Restart Claude Code completely
+3. Check logs: `tail -f /tmp/stackmemory.log`
+
+### Command not found
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+source ~/.bashrc
+```
+
+### Permission denied
+```bash
+chmod +x ~/.local/bin/stackmemory
+```
+
+---
+
+## 📊 Monitoring Context Quality
+
+The system tracks:
+- **Recall accuracy**: Can it remember decisions?
+- **Relevance**: Is retrieved context useful?
+- **Learning rate**: Does it improve over time?
+
+View metrics:
+```bash
+sqlite3 ~/.stackmemory/attention.db "SELECT * FROM learned_importance ORDER BY importance DESC LIMIT 10;"
+```
+
+---
+
+## 🚀 That's It!
+
+StackMemory is now running globally across all your Claude Code instances. It will:
+- ✅ Learn what context matters
+- ✅ Improve over time
+- ✅ Work in every git repository
+- ✅ Share context across sessions
+
+No further configuration needed!

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.10.5",
-  "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
+  "version": "1.14.0",
+  "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with MCP tools, FTS5 search, cloud sync, trace optimization, Claude/Codex/OpenCode/Gemini wrappers, skill packs, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0"
@@ -15,13 +15,16 @@
     "claude-sm": "bin/claude-sm",
     "claude-smd": "bin/claude-smd",
     "opencode-sm": "bin/opencode-sm",
-    "gemini-sm": "bin/gemini-sm"
+    "gemini-sm": "bin/gemini-sm",
+    "hermes-sm": "bin/hermes-sm",
+    "hermes-smd": "bin/hermes-smd"
   },
   "files": [
     "bin",
     "dist/src",
     "scripts/git-hooks",
     "scripts/hooks",
+    "scripts/portal",
     "scripts/setup",
     "scripts/setup.sh",
     "scripts/install.sh",
@@ -39,12 +42,13 @@
     "scripts/codex-wrapper.sh",
     "scripts/opencode-wrapper.sh",
     "scripts/stackmemory-daemon.sh",
-    "scripts/ralph-loop-implementation.js",
     "scripts/setup-claude-integration.sh",
     "scripts/setup-claude-integration.js",
     "scripts/verify-dist.cjs",
     "scripts/smoke-init-db.sh",
     "templates",
+    "packs",
+    "docs/guides/README_INSTALL.md",
     "README.md",
     "LICENSE"
   ],
@@ -57,7 +61,7 @@
     "url": "https://github.com/stackmemoryai/stackmemory/issues"
   },
   "author": "StackMemory AI",
-  "license": "BUSL-1.1",
+  "license": "PolyForm-Noncommercial-1.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -114,6 +118,11 @@
     "test:run": "vitest run",
     "test:pre-publish": "./scripts/test-pre-publish-quick.sh",
     "test:pre-commit": "vitest related --run --reporter=dot --silent --bail=1",
+    "determinism:smoke": "node --import tsx src/cli/index.ts bench determinism --task \"Determinism probe\" --runs 5",
+    "determinism:watch": "node --import tsx src/cli/index.ts bench determinism --task \"Determinism probe\" --runs 3 --watch",
+    "determinism:latest": "node --import tsx src/cli/index.ts bench determinism --latest --json",
+    "determinism:test": "npx vitest run src/orchestrators/multimodal/__tests__/determinism.test.ts --reporter=dot",
+    "determinism:pre-commit": "bash scripts/determinism-pre-commit.sh",
     "prepublishOnly": "npm run build && npm run verify:dist && npm run test:pre-publish",
     "quality": "npm run lint && npm run test:run && npm run build",
     "dev": "tsx watch src/integrations/mcp/server.ts",
@@ -128,14 +137,15 @@
     "daemons:stop": "node scripts/claude-sm-autostart.js stop",
     "daemon:session": "node dist/daemon/session-daemon.js",
     "daemon:session:start": "node dist/daemon/session-daemon.js --session-id",
-    "diffmem:start": "PYTHONPATH=packages/diffmem/src packages/diffmem/.venv/bin/uvicorn diffmem.server:app --host 127.0.0.1 --port 8000",
-    "diffmem:setup": "cd packages/diffmem && python3 -m venv .venv && .venv/bin/pip install -r requirements-server.txt -e .",
     "daemon:start": "node dist/daemon/unified-daemon.js",
     "daemon:stop": "node dist/cli/index.js daemon stop",
     "daemon:status": "node dist/cli/index.js daemon status",
     "sync:start": "node scripts/background-sync-manager.js",
     "sync:setup": "./scripts/setup-background-sync.sh",
     "eval:cord": "npx tsx scripts/evals/cord-vs-flat-eval.ts",
+    "gepa:eval": "node scripts/gepa/eval-phases.js",
+    "gepa:eval:json": "node scripts/gepa/eval-phases.js --json",
+    "gepa:mine": "node scripts/gepa/gold/mine-traces.js",
     "prepare": "echo 'Prepare step completed'",
     "verify:dist": "node scripts/verify-dist.cjs",
     "test:smoke-db": "bash scripts/smoke-init-db.sh",
@@ -147,6 +157,7 @@
     "@anthropic-ai/tokenizer": "^0.0.4",
     "@aws-sdk/client-s3": "^3.958.0",
     "@browsermcp/mcp": "^0.1.3",
+    "@google-cloud/bigquery": "^7.9.4",
     "@google-cloud/storage": "^7.18.0",
     "@linear/sdk": "^68.1.0",
     "@modelcontextprotocol/sdk": "^1.25.3",
@@ -154,7 +165,7 @@
     "@types/blessed": "^0.1.27",
     "@types/inquirer": "^9.0.9",
     "@types/pg": "^8.16.0",
-    "better-sqlite3": "^9.6.0",
+    "better-sqlite3": "^12.10.0",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^11.1.0",
@@ -167,11 +178,13 @@
     "helmet": "^8.1.0",
     "ignore": "^7.0.5",
     "inquirer": "^9.3.8",
+    "js-tiktoken": "^1.0.21",
     "msgpackr": "^1.10.1",
     "node-pty": "^1.1.0",
     "open": "^11.0.0",
     "ora": "^9.0.0",
     "pg": "^8.17.1",
+    "raindrop-ai": "^0.1.1",
     "rate-limiter-flexible": "^9.0.1",
     "shell-escape": "^0.2.0",
     "socket.io": "^4.6.0",
@@ -209,9 +222,14 @@
     ]
   },
   "optionalDependencies": {
+    "@browserbasehq/stagehand": "^3.4.0",
     "@xenova/transformers": "^2.17.2",
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
-    "chokidar": "^5.0.0"
+    "chokidar": "^5.0.0",
+    "playwright": "^1.60.0"
+  },
+  "overrides": {
+    "better-sqlite3": "^12.10.0"
   }
 }

package/packs/coding/python-fastapi/instructions.md

@@ -0,0 +1,60 @@
+# coding/python-fastapi
+
+## Python Conventions
+
+- **Python 3.11+.** Use modern syntax: `match/case`, `type` aliases, `ExceptionGroup`.
+- **Type hints everywhere.** All function signatures, return types, and class attributes. Use `from __future__ import annotations` for forward references.
+- **Pydantic v2 for data validation.** `BaseModel` for schemas, `model_validator` for complex validation. Never use raw dicts for API I/O.
+- **Async by default.** Use `async def` for route handlers and DB operations. Use `asyncio.gather` for concurrent I/O.
+- **No global mutable state.** Use dependency injection via FastAPI's `Depends()`.
+- **Naming.** snake_case for functions/variables. PascalCase for classes. UPPER_SNAKE for constants.
+
+## FastAPI Patterns
+
+- **Router per domain.** `app/routers/users.py`, `app/routers/items.py`. Mount with `app.include_router()`.
+- **Pydantic schemas for I/O.** Separate `Create`, `Update`, `Response` schemas. Never expose ORM models directly.
+- **Dependency injection.** DB sessions, auth, config — all via `Depends()`. Define in `app/dependencies.py`.
+- **Status codes.** Use `status.HTTP_201_CREATED` for creates, `HTTP_204_NO_CONTENT` for deletes. Raise `HTTPException` with proper codes.
+- **Background tasks.** Use `BackgroundTasks` for fire-and-forget. Use Celery/ARQ for durable jobs.
+- **Middleware.** CORS, request logging, error handling. Define in `app/middleware.py`.
+
+## Project Structure
+
+```
+app/
+  main.py           # FastAPI app instance + startup
+  core/
+    config.py       # Settings via pydantic-settings
+    security.py     # Auth utilities
+  routers/          # APIRouter modules
+  models/           # SQLAlchemy/SQLModel ORM models
+  schemas/          # Pydantic request/response models
+  dependencies.py   # Shared Depends() callables
+  middleware.py      # Middleware stack
+tests/
+  conftest.py       # Fixtures (test client, DB)
+  test_*.py         # Test modules
+```
+
+## Database
+
+- **SQLAlchemy 2.0 style.** `select()` not `query()`. Mapped classes with `Mapped[]` annotations.
+- **Alembic for migrations.** Auto-generate with `alembic revision --autogenerate`. Never edit the DB schema manually.
+- **Session management.** Async sessions via `async_sessionmaker`. Yield in dependency.
+- **Connection pooling.** Configure `pool_size`, `max_overflow` in production.
+
+## Testing
+
+- **pytest + httpx.** Use `AsyncClient` with `app` for integration tests.
+- **Fixtures for DB.** Create test database, run migrations, yield session, rollback.
+- **Factory pattern for test data.** Use `factory_boy` or simple fixture functions.
+- **Test the API, not internals.** Call endpoints via client, assert response shape + status.
+
+## Common Anti-Patterns to Catch
+
+- Synchronous DB calls in async handlers → blocks the event loop
+- Raw SQL without parameterization → SQL injection risk
+- Returning ORM models from endpoints → use Pydantic response models
+- Missing `async` on route handlers with I/O → blocks worker threads
+- Hardcoded secrets → use environment variables via pydantic-settings
+- Missing input validation → always validate via Pydantic schemas

package/packs/coding/python-fastapi/pack.yaml

@@ -0,0 +1,28 @@
+name: coding/python-fastapi
+version: 1.0.0
+description: Python + FastAPI conventions, patterns, and guardrails for AI coding agents
+author: stackmemory
+license: MIT
+runtime:
+  type: local
+ingestion:
+  sources: []
+ontology:
+  entities:
+    - endpoint
+    - model
+    - schema
+    - dependency
+    - middleware
+  relations:
+    - handles
+    - validates
+    - depends-on
+mcp:
+  tools: []
+examples:
+  - input: "Create a CRUD API endpoint"
+    output: "Use Pydantic models for request/response, dependency injection for DB session, proper HTTP status codes, async handlers"
+  - input: "How should I structure a FastAPI project?"
+    output: "app/ with routers/, models/, schemas/, dependencies/, core/ (config, security). Use APIRouter per domain."
+instructions: instructions.md

package/packs/coding/typescript-react/instructions.md

@@ -0,0 +1,47 @@
+# coding/typescript-react
+
+## TypeScript Conventions
+
+- **Strict mode always.** `"strict": true` in tsconfig.json. No `any` unless genuinely unavoidable — use `unknown` and narrow.
+- **ESM imports.** Always add `.js` extension to relative imports in ESM projects. Use `type` imports for type-only references.
+- **Prefer interfaces** for object shapes. Use `type` for unions, intersections, and mapped types.
+- **No enums.** Use `as const` objects or union types instead. Enums have runtime cost and poor tree-shaking.
+- **Error handling.** Return `undefined` over throwing. If you must throw, use typed error classes. Never `catch (e: any)`.
+- **Naming.** PascalCase for types/interfaces/components. camelCase for variables/functions. UPPER_SNAKE for constants.
+
+## React Patterns
+
+- **Functional components only.** No class components.
+- **Custom hooks for data fetching.** Extract `useQuery`/`useMutation` patterns into `use*` hooks. Never fetch in component body.
+- **State management.** useState for local, useReducer for complex local, Context for cross-tree, Zustand/Jotai for global.
+- **Memoization.** Don't prematurely memo. Use `React.memo` only when profiler shows re-render cost. `useMemo`/`useCallback` for referential stability when passed to children.
+- **Keys.** Never use array index as key. Use stable IDs from data.
+- **Error boundaries.** Wrap route-level components. Use `react-error-boundary` library.
+
+## File Structure
+
+```
+src/
+  components/     # Shared UI components
+  features/       # Feature-scoped modules (components + hooks + types)
+  hooks/          # Shared custom hooks
+  lib/            # Non-React utilities
+  types/          # Shared type definitions
+  routes/         # Route components (if not using file-based routing)
+```
+
+## Testing
+
+- **Vitest or Jest** for unit tests. React Testing Library for component tests.
+- **Test behavior, not implementation.** Query by role/text, not test-id.
+- **No snapshot tests** unless testing serialized output.
+- **Mock at boundaries.** Mock API calls (MSW), not internal modules.
+
+## Common Anti-Patterns to Catch
+
+- `useEffect` with missing dependencies → use ESLint exhaustive-deps rule
+- Prop drilling > 2 levels → extract to Context or composition
+- Giant components > 200 lines → split into smaller components
+- Inline styles → use CSS modules, Tailwind, or styled-components
+- `any` type assertions → narrow with type guards
+- Non-null assertions (`!`) → handle the null case explicitly

package/packs/coding/typescript-react/pack.yaml

@@ -0,0 +1,28 @@
+name: coding/typescript-react
+version: 1.0.0
+description: TypeScript + React conventions, patterns, and guardrails for AI coding agents
+author: stackmemory
+license: MIT
+runtime:
+  type: local
+ingestion:
+  sources: []
+ontology:
+  entities:
+    - component
+    - hook
+    - context
+    - route
+    - api-endpoint
+  relations:
+    - renders
+    - depends-on
+    - provides
+mcp:
+  tools: []
+examples:
+  - input: "Create a React component that fetches data"
+    output: "Use a custom hook with useEffect + useState, handle loading/error states, return typed JSX"
+  - input: "How should I structure my TypeScript types?"
+    output: "Prefer interfaces for object shapes, use type for unions/intersections, export from a types.ts barrel file"
+instructions: instructions.md

package/packs/core/commands/capture.md

@@ -0,0 +1,32 @@
+# /capture — Save session context via StackMemory
+
+Run `stackmemory capture` to commit current work and generate a handoff prompt for the next session.
+
+## Usage
+
+`$ARGUMENTS` — optional flags passed directly to `stackmemory capture`.
+
+## Behavior
+
+1. Run `stackmemory capture $ARGUMENTS`
+2. Display the generated handoff prompt
+3. If `--copy` flag is present, confirm the prompt was copied to clipboard
+
+## Common flags
+
+| Flag | Effect |
+|------|--------|
+| `-m "message"` | Custom commit message |
+| `--no-commit` | Skip git commit, just generate handoff |
+| `--copy` | Copy handoff prompt to clipboard |
+| `--format ultra` | Ultra-compact pipe-delimited format |
+| `--format verbose` | Full markdown format |
+
+## Examples
+
+```
+/capture                          # Default capture with auto-format
+/capture -m "privacy policy PR"   # With custom message
+/capture --copy                   # Capture and copy to clipboard
+/capture --no-commit --copy       # Just generate handoff, no commit
+```

package/packs/core/commands/learn.md

@@ -0,0 +1,73 @@
+# /learn — Review session and identify what to update
+
+Run /summary internally, then audit what scripts, skills, commands, or memories need updating based on this session's work.
+
+## Execution
+
+### Phase 1: Session Review (silent)
+
+Internally run the /summary logic — review conversation history for all actions, decisions, patterns, and corrections. Do NOT output the summary separately.
+
+### Phase 2: Audit (parallel)
+
+Compare session activity against persistent artifacts:
+
+1. **Memory** — Read `MEMORY.md` from project memory dir
+   - Any new patterns, gotchas, or decisions that should be saved?
+   - Any existing memories now stale or contradicted by this session?
+   - Any user corrections/feedback worth persisting?
+
+2. **CLAUDE.md** — Read project and global CLAUDE.md
+   - Any new commands, paths, or conventions discovered?
+   - Any documented patterns that are now wrong?
+
+3. **Skills/Commands** — Glob `~/.claude/commands/*.md` and project `.claude/commands/*.md`
+   - Any skills that broke or need updating?
+   - Any new workflow worth turning into a skill?
+
+4. **Scripts** — Check `scripts/`, `.husky/`, hook files
+   - Any scripts created or modified this session?
+   - Any hooks that failed and need fixing?
+
+5. **Wiki** — If wiki exists, check for stale articles
+   - Any new entities or concepts from this session?
+
+### Phase 3: Report
+
+Output in this format:
+
+```
+## Session Learnings
+
+**What happened:**
+- [1-line per action/outcome]
+
+**Updates needed:**
+
+| Target | Action | Detail |
+|--------|--------|--------|
+| memory/X.md | create/update/delete | [what and why] |
+| CLAUDE.md | update | [section + change] |
+| commands/X.md | create/update | [what] |
+| scripts/X | update | [what] |
+| wiki/X.md | create/update | [what] |
+
+**No action needed:**
+- [artifacts reviewed but current]
+```
+
+### Phase 4: Execute (with confirmation)
+
+Ask: "Apply these updates? (all / pick / skip)"
+
+- **all**: Apply every update in the table
+- **pick**: Let user select which ones
+- **skip**: Report only, no changes
+
+## Rules
+
+- Don't create memories for ephemeral task details — only durable learnings
+- Don't update CLAUDE.md for one-off patterns — only if it'll recur
+- Bias toward updating existing memories over creating new ones
+- Keep the report under 30 lines — dense, not verbose
+- If nothing needs updating, say so in one line and stop

package/packs/core/commands/next.md

@@ -0,0 +1,36 @@
+# /next — What should I do next?
+
+Read context and suggest the highest-impact next action.
+
+## Context to gather (parallel)
+
+1. **Git state**: `git status`, `git branch --show-current`, `git log --oneline -3`
+2. **Open PR for branch**: `/opt/homebrew/bin/gh pr view --json title,state,reviews,checks 2>/dev/null`
+3. **GHA status**: `/opt/homebrew/bin/gh run list --branch $(git branch --show-current) --limit 1 --json status,conclusion,name 2>/dev/null`
+4. **Memory**: Read `MEMORY.md` and `project_todos_queue.md` from the project memory directory
+5. **Uncommitted work**: `git diff --stat HEAD`
+
+## Decision logic
+
+Evaluate in priority order. Pick the FIRST that applies:
+
+1. **Uncommitted changes exist** → suggest commit or continue current work
+2. **PR open + CI failing** → suggest fix CI failures
+3. **PR open + Greptile comments** → suggest `/greptile-fix`
+4. **PR open + CI passing + no reviews** → suggest waiting or starting next task
+5. **On feature branch, no PR** → suggest `/pr`
+6. **On master, clean** → suggest next task from queue (pick highest priority unchecked item)
+
+## Output format
+
+```
+## Next up
+
+[One sentence: what to do and why]
+
+A) [Primary action — the recommendation]
+B) [Alternative action]
+C) [Skip — pick something else from queue]
+```
+
+Always present A/B/C options. Keep it to 5 lines max. No preamble.