Add command packs, remove dead modules, bump to 1.11.0

- Add `stackmemory setup-commands` CLI for installing Claude Code slash commands
- Ship core pack: /start, /stop, /restart, /next (+ 4 internal deps)
- Prompt for command install during `stackmemory onboard`
- Include packs/ in npm files array
- Remove unused team, cord, merge, and shared-context modules (-9.9K lines)

Author: StackMemory Bot (CLI)

README.md

@@ -14,7 +14,7 @@ Lossless, project-scoped memory for AI coding tools. **[Website](https://stackme
 StackMemory is a **production-ready memory runtime** for AI coding tools that preserves full project context across sessions:
 
 - **Zero-config setup** — `stackmemory init` just works
-- **56 MCP tools** for Claude Code integration (context, tasks, Linear, traces, discovery, cord, team, planning, providers, and more)
+- **73 MCP tools** for Claude Code integration (context, tasks, Linear, traces, discovery, cord, team, planning, providers, and more)
 - **FTS5 full-text search** with BM25 scoring and hybrid retrieval
 - **Full Linear integration** with bidirectional sync and OAuth/API key support
 - **Context persistence** that survives `/clear` operations
@@ -97,6 +97,16 @@ stackmemory doctor
 
 Restart Claude Code and StackMemory MCP tools will be available.
 
+### Also available as `croissant-ai`
+
+[croissant.ai](https://croissant.ai) wraps StackMemory as a business-facing CLI for executive intelligence. Install via `npx croissant-ai` — all unknown commands forward to StackMemory automatically.
+
+```bash
+npx croissant-ai ask "What's our MRR?"   # croissant.ai query API
+npx croissant-ai memory capture           # → stackmemory capture
+npx croissant-ai init                     # → stackmemory init (fallback)
+```
+
 ### Wrapper Scripts
 
 StackMemory ships wrapper scripts that launch your coding tool with StackMemory context pre-loaded:
@@ -132,6 +142,44 @@ Runs as an MCP server. Editors (e.g., Claude Code) call StackMemory on each inte
 
 ---
 
+## Command Packs
+
+StackMemory ships installable command packs for Claude Code — curated slash commands that integrate session lifecycle management directly into your workflow.
+
+### Core Pack
+
+The **core** pack provides session lifecycle commands that use StackMemory for context persistence:
+
+| Command | Description |
+|---------|-------------|
+| `/start` | Boot a session — load memory, restore handoff, show git state, suggest next work |
+| `/stop` | End a session — summarize, capture handoff, review learnings |
+| `/restart` | Chain `/stop` → `/clear` → `/start` in one command |
+| `/next` | Suggest what to work on based on context |
+
+Internal dependencies (installed automatically): `/summary`, `/capture`, `/learn`, `/restore`
+
+```bash
+# Install core commands
+stackmemory setup-commands
+
+# List available packs
+stackmemory setup-commands --list
+
+# Preview what would be installed
+stackmemory setup-commands --dry-run
+
+# Reinstall (overwrite existing)
+stackmemory setup-commands --force
+
+# Remove installed commands
+stackmemory setup-commands --uninstall
+```
+
+Commands are symlinked to `~/.claude/commands/` and available immediately in Claude Code.
+
+---
+
 ## Skills System
 
 StackMemory ships Claude Code skills that integrate directly into your workflow. Skills are invoked via `/skill-name` in Claude Code or `stackmemory skills <name>` from the CLI.
@@ -272,42 +320,61 @@ claude-sm
 
 ---
 
-## RLM (Recursive Language Model) Orchestration
+## RLM-Aware Harness
+
+StackMemory includes an RLM (Recursive Language Model) system inspired by [predict-rlm](https://github.com/Trampoline-AI/predict-rlm) — three layers that make agents self-harnessing:
+
+### Layer 1: Context-as-REPL
+
+Agents access tenant data programmatically via tool functions instead of prose handoffs:
+
+- `search_knowledge(query, topK)` — vector search over tenant data
+- `read_context(query)` — knowledge graph entity/relationship queries
+- `list_runs(threadId)` — prior run history with status summaries
+- `get_run_events(runId)` — event stream replay for a specific run
+- `query_interrupts(threadId)` — pending approvals and blocks
+- `llm_summarize(prompt)` — sub-LLM (Haiku) for quick synthesis
+
+### Layer 2: Typed Dispatch
+
+Signature-based sub-agent spawning with validated I/O contracts:
+
+| Signature | Persona | Inputs | Outputs |
+|-----------|---------|--------|---------|
+| `ImplementFeature` | eng | spec, context_files | branch, changed_files, test_passed |
+| `FixBug` | eng | description, error_log | branch, changed_files, root_cause |
+| `ReviewPR` | eng | pr_url, focus_areas | verdict, comments, risk_level |
+| `Investigate` | data | question, data_sources | findings, evidence, confidence |
+| `Summarize` | data | content, format | summary, key_points |
+
+Parent runs dispatch typed sub-runs via `dispatchSubRun()` and collect validated results via `collectSubRun()` with timeout handling.
+
+### Layer 3: Critic + Self-Decomposition
 
-StackMemory includes an RLM system that handles complex tasks through recursive decomposition and parallel execution using Claude Code's Task tool.
+LLM quality gate that evaluates run output (ported from predict-rlm's critic pattern):
 
-### Key Features
+- **Score >= 80**: Pass — run ships as-is
+- **Score 50-79**: Revise — creates a new run with critic feedback appended
+- **Score < 50**: Decompose — dispatches typed sub-runs to break down the task
 
-- **Recursive Task Decomposition**: Breaks complex tasks into manageable subtasks
-- **Parallel Subagent Execution**: Run multiple specialized agents concurrently
-- **8 Specialized Agent Types**: Planning, Code, Testing, Linting, Review, Improve, Context, Publish
-- **Multi-Stage Review**: Iterative improvement cycles with quality scoring (0-1 scale)
-- **Automatic Test Generation**: Unit, integration, and E2E test creation
+Loop control: max 3 revisions, max depth 2 for decomposition.
 
-### Usage
+### Legacy RLM Orchestrator
+
+The original RLM system remains available for direct use:
 
 ```bash
-# Basic usage
 stackmemory skills rlm "Your complex task description"
-
-# With options
-stackmemory skills rlm "Refactor authentication system" \
-  --max-parallel 8 \
-  --review-stages 5 \
-  --quality-threshold 0.9 \
-  --test-mode all
+stackmemory skills rlm "Refactor auth" --max-parallel 8 --quality-threshold 0.9
 ```
 
-### Configuration Options
-
 | Option | Description | Default |
 |--------|-------------|---------|
 | `--max-parallel` | Maximum concurrent subagents | 5 |
 | `--max-recursion` | Maximum recursion depth | 4 |
 | `--review-stages` | Number of review iterations | 3 |
 | `--quality-threshold` | Target quality score (0-1) | 0.85 |
 | `--test-mode` | Test generation mode (unit/integration/e2e/all) | all |
-| `--verbose` | Show all recursive operations | false |
 
 **Note**: RLM requires Claude Code Max plan for unlimited subagent execution.
 
@@ -417,7 +484,7 @@ Options: `--until`, `--until-not`, `--until-empty`, `--until-non-empty`, `--unti
 ## Documentation
 
 - [Getting Started](./docs/GETTING_STARTED.md) — Quick start guide (5 minutes)
-- [MCP Tools Reference](https://stackmemoryai.github.io/stackmemory/tools.html) — All 56 MCP tools
+- [MCP Tools Reference](https://stackmemoryai.github.io/stackmemory/tools.html) — All 73 MCP tools
 - [CLI Reference](./docs/cli.md) — Full command reference
 - [Setup Guide](./docs/SETUP.md) — Advanced setup options
 - [Development Guide](./docs/DEVELOPMENT.md) — Contributing and development
@@ -429,6 +496,20 @@ Options: `--until`, `--until-not`, `--until-empty`, `--until-non-empty`, `--unti
 
 ---
 
+## Substrate: The Three-Layer Vision
+
+StackMemory is the foundation of a three-layer architecture for AI-native development:
+
+| Layer | Product | Status | Purpose |
+|-------|---------|--------|---------|
+| **L1** | StackMemory | Shipped (v1.10.6) | Context persistence — lossless memory across sessions |
+| **L2** | Substrate Desktop | Shipping | Agent orchestration — multi-agent coordination with worktree isolation |
+| **L3** | Substrate Cloud | Design | Multiplayer development — shared context across teams and agents |
+
+Grounded in distributed systems theory: FLP impossibility, Byzantine→Crash conversion via test hooks, Chandra-Toueg failure detectors for agent liveness. See [COORDINATION_THEORY.md](./docs/architecture/COORDINATION_THEORY.md).
+
+---
+
 ## License
 
 Licensed under the [Business Source License 1.1](./LICENSE). You can use, modify, and self-host StackMemory freely. The one restriction: you may not offer it as a competing hosted service. The license converts to MIT after 4 years per release.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.10.6",
+  "version": "1.11.0",
   "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.",
   "engines": {
     "node": ">=20.0.0",
@@ -45,6 +45,7 @@
     "scripts/verify-dist.cjs",
     "scripts/smoke-init-db.sh",
     "templates",
+    "packs",
     "README.md",
     "LICENSE"
   ],

package.json

@@ -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
+```

packs/core/commands/capture.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

packs/core/commands/learn.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.