@tekmidian/pai 0.5.7 → 0.6.1

package/ARCHITECTURE.md

@@ -21,6 +21,8 @@ Claude Code Session
     │               ↓
     │       PostgreSQL + pgvector
     │       (chunks, embeddings, files, FTS)
+    │       ├── Observation Store (PostgreSQL)
+    │       │       classify → store → query → inject
     │
     ├── Registry (SQLite)
     │       ~/.pai/registry.db
@@ -28,7 +30,8 @@ Claude Code Session
     │
     └── CLI (pai)
             project, session, registry, memory,
-            daemon, obsidian, zettel, backup, restore, setup
+            daemon, obsidian, zettel, observation,
+            backup, restore, setup
 ```
 
 ### Key Components
@@ -92,15 +95,22 @@ docker run -d \
 pai setup
 ```
 
-The interactive wizard walks through seven steps:
+The interactive wizard walks through 14 steps:
 
-1. PostgreSQL connection (host, port, credentials)
-2. Embedding model selection (Snowflake Arctic recommended)
-3. Indexing interval (default: 5 minutes)
+1. Welcome and version check
+2. Storage backend selection (SQLite or PostgreSQL)
+3. Embedding model configuration
 4. CLAUDE.md template installation
-5. Projects root directory
-6. Obsidian vault location (optional)
-7. MCP server registration with Claude Code
+5. PAI skill installation
+6. Steering rules installation
+7. Hook system deployment
+8. TypeScript hook compilation
+9. Claude Code settings configuration
+10. Daemon installation
+11. MCP server registration
+12. Directory creation
+13. Initial indexing
+14. Verification
 
 ### 4. Install the Daemon
 
@@ -140,7 +150,7 @@ If both commands return healthy output, PAI is running. Open a new Claude Code s
 
 ## MCP Server
 
-PAI exposes 7 tools to Claude Code via a daemon-backed MCP shim. The shim speaks stdio (what Claude Code expects) and proxies each request to the background daemon over NDJSON on a Unix socket.
+PAI exposes 9 tools, 18 on-demand prompts (skills), and 11 reference resources to Claude Code via a daemon-backed MCP shim. The shim speaks stdio (what Claude Code expects) and proxies each request to the background daemon over NDJSON on a Unix socket.
 
 ```
 Claude Code (stdio)
@@ -161,12 +171,8 @@ Claude Code (stdio)
 | `session_list` | List session notes, optionally filtered by project |
 | `registry_search` | Search project metadata (names, paths, tags) |
 | `project_detect` | Identify which project a given path belongs to |
-| `zettel_explore` | BFS traversal of wikilink graph from a seed note |
-| `zettel_surprise` | Find semantically distant but graph-close notes |
-| `zettel_converse` | Hybrid search with graph expansion and cross-domain connections |
-| `zettel_themes` | Cluster vault notes into thematic groups by embedding similarity |
-| `zettel_health` | Audit vault for broken links, orphans, and isolated clusters |
-| `zettel_suggest` | Suggest link targets weighted by semantics, tags, and graph neighborhood |
+| `project_health` | Audit all registered paths for moved or deleted directories |
+| `project_todo` | Read a project's TODO.md and continuation prompt |
 
 ### Tool Reference
 
@@ -184,17 +190,52 @@ Claude Code (stdio)
 
 **`project_detect(path?)`** — Given a filesystem path (defaults to CWD), returns the matching project.
 
-**`zettel_explore(note, depth?, direction?)`** — BFS walk from a seed note across `vault_links`. Returns a subgraph of neighboring notes with each edge classified as `sequential` or `associative`. `direction`: `outbound` (default), `inbound`, or `both`.
+**`project_health(category?)`** — Audits all registered projects to find moved or deleted directories. Categorizes each as `active` (path exists), `stale` (path missing but candidate found nearby), or `dead` (path missing, no candidate). Also reports TODO.md presence and continuation prompts.
 
-**`zettel_surprise(note, limit?)`** — Returns notes that are semantically dissimilar to `note` but reachable within a short graph distance. Scored as `cosine_similarity × log2(graph_distance + 1)`. Useful for lateral discovery.
+**`project_todo(project?)`** — Reads a project's TODO.md without needing the exact file path. Searches Notes/TODO.md, .claude/Notes/TODO.md, tasks/todo.md, and project-root TODO.md in order. Surfaces any `## Continue` section at the top for quick context recovery.
 
-**`zettel_converse(query, limit?)`** — Runs a hybrid memory search, expands the result set via graph neighborhood, then surfaces cross-domain connections — notes from unrelated clusters that are semantically close to the query.
+### On-Demand Prompts (Skills)
 
-**`zettel_themes(min_cluster_size?)`** — Clusters all vault embeddings using agglomerative single-linkage clustering. Returns thematic groups with representative note titles and cluster size.
+The MCP server registers 18 prompts that Claude can invoke as on-demand skills. Each prompt provides a focused workflow with instructions, examples, and constraints — loaded only when needed to conserve context.
 
-**`zettel_health()`** — Full structural audit of the vault. Reports broken links (target not in `vault_files`), orphaned notes (no inbound or outbound edges), notes missing embeddings, and isolated clusters detected via union-find.
-
-**`zettel_suggest(note, limit?)`** — Ranks candidate link targets for a given note. Score is a weighted sum: semantic embedding similarity (0.5), shared tags (0.2), graph neighborhood overlap with existing links (0.3).
+| Prompt | Purpose |
+|--------|---------|
+| `art` | Visual art direction and creative guidance |
+| `createskill` | Scaffold new PAI skills |
+| `journal` | Structured journaling workflow |
+| `name` | Session and project naming conventions |
+| `observability` | Observation system usage and querying |
+| `plan` | Forward-looking planning from TODOs and recent activity |
+| `research` | Structured research methodology |
+| `review` | Retrospective review of work over a time period |
+| `route` | Session note routing across projects |
+| `search-history` | Search history analysis and patterns |
+| `sessions` | Session lifecycle management |
+| `share` | Generate social media posts from recent work |
+| `story-explanation` | Narrative explanations of technical concepts |
+| `vault-connect` | Suggest and create vault connections |
+| `vault-context` | Use vault as conversational context |
+| `vault-emerge` | Detect emerging themes in the vault |
+| `vault-orphans` | Find and fix orphaned vault notes |
+| `vault-trace` | Trace idea lineage through vault links |
+
+### Reference Resources
+
+11 resources available via `pai://` URIs. Claude reads these on demand for reference documentation.
+
+| URI | Content |
+|-----|---------|
+| `pai://aesthetic` | Visual and output style guidelines |
+| `pai://constitution` | Core philosophy and principles |
+| `pai://history-system` | Search history tracking system |
+| `pai://hook-system` | Hook architecture and development guide |
+| `pai://mcp-dev-guide` | MCP server development patterns |
+| `pai://prompting` | Prompt engineering best practices |
+| `pai://prosody-agent-template` | Voice agent template |
+| `pai://prosody-guide` | Voice and prosody guidelines |
+| `pai://skill-system` | Skill authoring reference |
+| `pai://terminal-tabs` | Terminal tab management |
+| `pai://voice` | Voice configuration reference |
 
 ### Installation
 
@@ -389,12 +430,27 @@ pai zettel health
 pai zettel suggest "My Seed Note" --limit 5
 ```
 
+### Observation Management
+
+| Subcommand | Description |
+|------------|-------------|
+| `observation list` | List recent observations with optional filters |
+| `observation search <query>` | Search observations by title or narrative text |
+| `observation stats` | Show totals, breakdowns by type and project |
+
+```bash
+pai observation list --type decision --limit 10
+pai observation list --project my-app
+pai observation search "database migration"
+pai observation stats
+```
+
 ### Other Commands
 
 ```bash
 pai backup                    # Backup registry, config, and Postgres
 pai restore <path>            # Restore from backup (--no-postgres to skip DB)
-pai setup                     # Interactive 7-step setup wizard
+pai setup                     # Interactive 14-step setup wizard
 pai search "query"            # Quick full-text search shortcut
 ```
 
@@ -531,6 +587,8 @@ Claude Code Event
 | `post-compact-inject.mjs` | SessionStart (compact) | Reads saved state and injects into post-compaction context |
 | `security-validator.mjs` | PreToolUse (Bash) | Validates shell commands against security rules |
 | `capture-all-events.mjs` | All events | Observability — logs every hook event to session timeline |
+| `observe.mjs` | PostToolUse | Classifies tool calls into typed observations (decision/bugfix/feature/refactor/discovery/change) |
+| `inject-observations.mjs` | SessionStart | Injects recent observation context (compact index + timeline) |
 | `context-compression-hook.mjs` | PreCompact | Extracts session state, saves checkpoint, writes temp file for relay |
 | `capture-tool-output.mjs` | PostToolUse | Records tool inputs/outputs for observability dashboard |
 | `update-tab-on-action.mjs` | PostToolUse | Updates terminal tab title based on current activity |
@@ -704,6 +762,47 @@ These tables are populated by `src/memory/vault-indexer.ts` and queried by all s
 | `detail` | TEXT | Human-readable description |
 | `checked_at` | BIGINT | Timestamp of the audit run |
 
+### Observation Tables (PostgreSQL)
+
+These tables are populated by the PostToolUse hook classifier and queried by the CLI and MCP tools.
+
+**`pai_observations`** — Classified tool call events:
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `id` | SERIAL | Primary key |
+| `session_id` | TEXT | Claude Code session identifier |
+| `project_id` | INTEGER | Owning project (nullable) |
+| `project_slug` | TEXT | Project slug for display |
+| `type` | TEXT | Classification: decision, bugfix, feature, refactor, discovery, change |
+| `title` | TEXT | Human-readable observation title |
+| `narrative` | TEXT | Extended description (nullable) |
+| `tool_name` | TEXT | Claude Code tool that triggered the observation |
+| `tool_input_summary` | TEXT | Abbreviated tool input |
+| `files_read` | JSONB | Array of file paths read |
+| `files_modified` | JSONB | Array of file paths modified |
+| `concepts` | JSONB | Extracted concept tags |
+| `content_hash` | TEXT | SHA-256 hash for 30-second deduplication window |
+| `created_at` | TIMESTAMPTZ | Observation timestamp |
+
+**`pai_session_summaries`** — Structured end-of-session summaries:
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `id` | SERIAL | Primary key |
+| `session_id` | TEXT | Claude Code session identifier (unique) |
+| `project_id` | INTEGER | Owning project (nullable) |
+| `project_slug` | TEXT | Project slug for display |
+| `request` | TEXT | What was requested |
+| `investigated` | TEXT | What was investigated |
+| `learned` | TEXT | What was learned |
+| `completed` | TEXT | What was completed |
+| `next_steps` | TEXT | Recommended next steps |
+| `observation_count` | INTEGER | Number of observations in the session |
+| `created_at` | TIMESTAMPTZ | Summary timestamp |
+
+**Indexes:** B-tree on project_id, session_id, type, created_at DESC, content_hash.
+
 **Content Tiers:**
 
 | Tier | Description | Example |
@@ -752,37 +851,89 @@ bun run lint     # tsc --noEmit
 | Output | Purpose |
 |--------|---------|
 | `dist/cli/index.mjs` | `pai` CLI |
-| `dist/mcp/index.mjs` | Direct MCP server (legacy) |
 | `dist/daemon/index.mjs` | Daemon server |
 | `dist/daemon-mcp/index.mjs` | MCP shim (stdio → daemon socket) |
+| `dist/hooks/*.mjs` | Compiled lifecycle hooks |
 
 ### Source Structure
 
 ```
 src/
-├── cli/commands/    # CLI command implementations
-│   └── zettel.ts    # `pai zettel` with 6 subcommands
-├── daemon/          # Daemon server and index scheduler
-├── daemon-mcp/      # MCP shim (stdio → daemon socket)
-├── federation/      # Federation schema definitions
-├── hooks/           # Lifecycle hooks (pre-compact, session-stop)
-├── mcp/             # Direct MCP server (legacy)
-├── memory/          # Indexer, chunker, embeddings, search, reranker
-│   ├── reranker.ts  # Cross-encoder reranking (Xenova/ms-marco-MiniLM-L-6-v2)
-│   └── vault-indexer.ts  # Obsidian vault indexing into v3 vault tables
-├── obsidian/        # Obsidian vault bridge
-│   └── vault-fixer.ts    # Repairs broken wikilinks and orphaned entries
-├── registry/        # Registry migrations and queries
-├── session/         # Session slug generator
-├── storage/         # Storage backend interface (SQLite/Postgres)
-└── zettelkasten/    # Luhmann-inspired graph + semantic operations
-    ├── explore.ts   # BFS traversal classifying sequential/associative edges
-    ├── surprise.ts  # Serendipitous bridge discovery via cosine × graph distance
-    ├── converse.ts  # Hybrid search → graph expansion → cross-domain connections
-    ├── themes.ts    # Agglomerative embedding clustering for thematic groups
-    ├── health.ts    # SQL-driven vault audit with union-find cluster detection
-    ├── suggest.ts   # Weighted link suggestions (semantic + tags + graph)
-    └── index.ts     # Barrel export for all zettelkasten operations
+├── cli/
+│   ├── commands/           # CLI command modules
+│   │   ├── backup.ts
+│   │   ├── daemon.ts
+│   │   ├── memory.ts
+│   │   ├── observation.ts
+│   │   ├── obsidian.ts
+│   │   ├── project.ts
+│   │   ├── registry.ts
+│   │   ├── session.ts
+│   │   ├── setup/          # 14-step interactive wizard
+│   │   │   ├── steps/      # 01-welcome through 15-verify
+│   │   │   └── index.ts
+│   │   └── zettel.ts
+│   └── index.ts            # CLI entry point
+├── daemon/
+│   ├── daemon/             # Daemon server internals
+│   │   ├── dispatcher.ts   # Tool dispatch (zettel, observation, memory)
+│   │   ├── handler.ts      # NDJSON request handler
+│   │   └── server.ts       # Socket server
+│   ├── indexer/            # Background index scheduler
+│   ├── config.ts           # Runtime configuration
+│   └── index.ts            # Daemon entry point
+├── daemon-mcp/
+│   ├── instructions.ts     # MCP server instructions (~1.5KB routing table)
+│   ├── prompts/            # 18 on-demand skill prompts
+│   ├── resources/          # 11 reference resources (pai:// URIs)
+│   └── index.ts            # MCP shim entry point (stdio → socket)
+├── hooks/
+│   └── ts/                 # TypeScript hook sources by event
+│       ├── PreCompact/
+│       ├── PreToolUse/
+│       ├── PostToolUse/
+│       ├── SessionStart/
+│       ├── Stop/
+│       └── UserPromptSubmit/
+├── mcp/
+│   └── tools/              # Shared tool implementations
+│       ├── memory.ts
+│       ├── observations.ts
+│       ├── projects.ts
+│       ├── registry.ts
+│       ├── sessions.ts
+│       └── zettel.ts
+├── memory/
+│   ├── chunker/            # Text chunking strategies
+│   ├── embeddings.ts       # Snowflake Arctic embedding generation
+│   ├── indexer.ts          # File indexer with change detection
+│   ├── reranker.ts         # Cross-encoder reranking (ms-marco-MiniLM)
+│   ├── search.ts           # Multi-mode search (keyword/semantic/hybrid)
+│   └── vault-indexer.ts    # Obsidian vault indexing
+├── observations/           # Automatic observation capture
+│   ├── classifier.ts       # Rule-based tool call classifier
+│   ├── store.ts            # PostgreSQL persistence with deduplication
+│   └── schema.sql          # DDL for observation tables
+├── obsidian/               # Obsidian vault bridge
+│   └── vault-fixer.ts      # Repairs broken wikilinks and orphans
+├── registry/               # SQLite registry queries and migrations
+├── session/                # Session slug generator
+├── storage/                # Pluggable storage backend
+│   ├── factory.ts          # Backend selection (SQLite/PostgreSQL)
+│   ├── interface.ts        # StorageInterface contract
+│   ├── postgres.ts         # PostgreSQL + pgvector backend
+│   └── sqlite.ts           # SQLite backend
+├── utils/                  # Shared utilities
+│   ├── hash.ts             # SHA-256 hashing
+│   └── stop-words.ts       # Stop word lists for search
+├── zettelkasten/           # Luhmann-inspired operations
+│   ├── explore.ts          # BFS traversal
+│   ├── surprise.ts         # Serendipitous bridge discovery
+│   ├── converse.ts         # Hybrid search + graph expansion
+│   ├── themes.ts           # Embedding clustering
+│   ├── health.ts           # Vault structural audit
+│   └── suggest.ts          # Weighted link suggestions
+└── index.ts                # Package entry point
 ```
 
 ### Important Notes

package/FEATURE.md

@@ -28,13 +28,13 @@ different direction: persistent memory, session continuity, and deep Claude Code
 | **Persistent session memory** | No | Yes — auto-indexed, 449K+ chunks |
 | **Session registry** | No | Yes — SQLite, tracks 77+ projects |
 | **Background daemon** | No | Yes — launchd, IPC via Unix socket |
-| **MCP server** | No | Yes — 7+ tools exposed to Claude Code |
+| **MCP server** | No | Yes — 9 tools, 18 prompts, 11 resources exposed to Claude Code |
 | **Keyword search (BM25)** | No | Yes — GIN full-text index, PostgreSQL |
 | **Semantic search (vector)** | No | Yes — pgvector HNSW, Snowflake Arctic 768-dim |
 | **Multi-backend storage** | No | Yes — SQLite (simple) or PostgreSQL (full) |
 | **Obsidian vault bridge** | No | Yes — symlinks + auto-generated topic pages |
 | **Project lifecycle** | No | Yes — promote, archive, move, detect from cwd |
-| **Setup wizard** | No | Yes — idempotent 7-step interactive wizard |
+| **Setup wizard** | No | Yes — idempotent 14-step interactive wizard |
 | **Hook system** | No | Yes — pre-compact, session-stop, auto-cleanup |
 | **Backup / restore** | No | Yes — timestamped pg_dump + registry export |
 | **Multi-session concurrency** | n/a | Yes — daemon multiplexes Claude sessions |

package/README.md

@@ -35,6 +35,27 @@ Install PAI and Claude remembers. Ask it what you were working on. Ask it to fin
 - "What did I do today?" — daily review across all projects
 - "Journal this thought" — capture freeform reflections with timestamps
 - "Plan my week" — forward-looking priorities based on open TODOs and recent activity
+- "What themes are emerging in my work?" — spot patterns across sessions and projects
+
+### Sharing Your Work
+
+- "Share on LinkedIn today" — generates a professional post about what you shipped, with real numbers and technical substance
+- "Tweet about the vault migration" — punchy X/Twitter post or thread, with option to post directly
+- "Share on Bluesky this week" — conversational technical post for the Bluesky audience
+- Platform-aware formatting: LinkedIn gets hashtags and narrative, X gets threads and hooks, Bluesky gets conversational tone
+
+### Tracking Your Activity
+
+- "What changes did I make to the daemon today?" — automatic observation capture tracks every tool call
+- "Show me all decisions from the last session" — observations are classified: decision, bugfix, feature, refactor, discovery, change
+- "What files did I modify in the PAI project this week?" — searchable timeline of every edit, commit, and search
+- "Show observation stats" — totals, breakdowns by type and project, with visual bar charts
+
+### Continuing Where You Left Off
+
+- "Go" — reads your TODO.md continuation prompt and picks up exactly where the last session stopped
+- "What was I working on?" — progressive context injection loads recent observations at session start
+- "Continue the daemon refactor" — session summaries give Claude full context without re-explaining
 
 ### Keeping Things Safe
 
@@ -97,7 +118,7 @@ PAI runs hooks at every stage of a Claude Code session:
 | **User Prompt** | Cleans up temp files, updates terminal tab titles |
 | **Pre-Compact** | Saves session state checkpoint, sends notification |
 | **Post-Compact** | Injects preserved state back into Claude's context |
-| **Tool Use** | Captures tool outputs for observability |
+| **Tool Use** | Classifies tool calls into structured observations (decision/bugfix/feature/refactor/discovery/change) |
 | **Session End** | Summarizes work done, finalizes session note |
 | **Stop** | Writes work items to session note, sends notification |
 
@@ -105,6 +126,67 @@ All hooks are TypeScript compiled to `.mjs` modules. They run as separate proces
 
 ---
 
+## Automatic Observation Capture
+
+PAI automatically classifies and stores every significant tool call during your sessions. When you edit a file, run a command, or make a decision, PAI captures it as a structured observation — building a searchable timeline of everything you've done across all projects.
+
+### How it works
+
+A PostToolUse hook fires after every Claude Code tool call. A rule-based classifier (no AI needed, under 50ms) categorizes each action:
+
+| Type | What triggers it | Examples |
+|------|-----------------|----------|
+| **decision** | Git commits, config changes | `git commit`, writing to config files |
+| **bugfix** | Test runs, error investigation | `npm test`, debugging commands |
+| **feature** | New file creation, feature work | Creating components, adding endpoints |
+| **refactor** | Code restructuring | Renaming, moving files, reorganizing |
+| **discovery** | File reads, searches | Reading code, grep searches, glob patterns |
+| **change** | File edits | Editing source files, updating configs |
+
+Observations are stored in PostgreSQL with content-hash deduplication (30-second window) to prevent duplicates from rapid tool calls.
+
+### Progressive context injection
+
+At session start, PAI injects recent observations as layered context:
+
+1. **Compact index** (~100 tokens) — observation type counts and active projects
+2. **Timeline** (~500 tokens) — recent observations with timestamps
+3. **On-demand** — full details available via MCP tools
+
+This means Claude starts every session already knowing what you were working on, without you re-explaining anything.
+
+### Searching observations
+
+Ask Claude naturally:
+
+```
+"What changes did I make to the daemon today?"
+"Show me all decisions from the last session"
+"What files did I modify in the PAI project this week?"
+```
+
+Or use the CLI:
+
+```bash
+# List recent observations
+pai observation list
+
+# Filter by type
+pai observation list --type decision
+
+# Filter by project
+pai observation list --project pai
+
+# Show stats
+pai observation stats
+```
+
+### Session summaries
+
+When a session ends, PAI generates a structured summary capturing what was requested, investigated, learned, completed, and what the next steps are. These summaries feed into the progressive context system, giving future sessions a concise picture of past work.
+
+---
+
 ## Auto-Compact Context Window
 
 Claude Code can automatically compact your context window when it fills up, preventing session interruptions mid-task. PAI's statusline shows you at a glance whether auto-compact is active.
@@ -342,7 +424,9 @@ External URLs (`https://`, `mailto:`, etc.) are excluded — only relative paths
 
 PAI works great alongside these tools (also by the same author):
 
+- **[AIBroker](https://github.com/mnott/AIBroker)** — Unified message bridge for Claude Code (WhatsApp, Telegram, PAILot — text and voice routing)
 - **[Whazaa](https://github.com/mnott/Whazaa)** — WhatsApp bridge for Claude Code (voice notes, screenshots, session routing)
+- **[Telex](https://github.com/mnott/Telex)** — Telegram bridge for Claude Code (text and voice messaging)
 - **[Coogle](https://github.com/mnott/Coogle)** — Google Workspace MCP daemon (Gmail, Calendar, Drive multiplexing)
 - **[DEVONthink MCP](https://github.com/mnott/devonthink-mcp)** — DEVONthink integration for document search and archival
 
@@ -352,6 +436,8 @@ PAI works great alongside these tools (also by the same author):
 
 PAI Knowledge OS is inspired by [Daniel Miessler](https://github.com/danielmiessler)'s concept of Personal AI Infrastructure and his [Fabric](https://github.com/danielmiessler/fabric) project — a Python CLI for augmenting human capabilities with reusable AI prompt patterns. Fabric is excellent and solves a different problem; PAI takes the same philosophy in a different direction: persistent memory, session continuity, and deep Claude Code integration. See [FEATURE.md](FEATURE.md) for a detailed comparison.
 
+The automatic observation capture system — classifying tool calls into structured observations with progressive context injection — is inspired by [claude-mem](https://github.com/thedotmack/claude-mem) by [thedotmack](https://github.com/thedotmack). claude-mem demonstrated that automatic memory capture during Claude Code sessions dramatically improves continuity. PAI adapts this concept with a rule-based classifier, PostgreSQL storage, and three-layer progressive disclosure.
+
 ---
 
 ## License

package/dist/{auto-route-BG6I_4B1.mjs → auto-route-C-DrW6BL.mjs}

@@ -1,5 +1,5 @@
 import { r as readPaiMarker } from "./pai-marker-CXQPX2P6.mjs";
-import { t as detectProject } from "./detect-BU3Nx_2L.mjs";
+import { t as detectProject } from "./detect-CdaA48EI.mjs";
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 
@@ -26,7 +26,7 @@ async function autoRoute(registryDb, federation, cwd, context) {
 	const markerResult = findMarkerUpward(registryDb, target);
 	if (markerResult) return markerResult;
 	if (context && context.trim().length > 0) {
-		const { detectTopicShift } = await import("./detector-Bp-2SM3x.mjs").then((n) => n.n);
+		const { detectTopicShift } = await import("./detector-jGBuYQJM.mjs").then((n) => n.n);
 		const topicResult = await detectTopicShift(registryDb, federation, {
 			context,
 			threshold: .5
@@ -83,4 +83,4 @@ function formatAutoRouteJson(result) {
 
 //#endregion
 export { autoRoute, formatAutoRouteJson };
-//# sourceMappingURL=auto-route-BG6I_4B1.mjs.map
+//# sourceMappingURL=auto-route-C-DrW6BL.mjs.map

package/dist/{auto-route-BG6I_4B1.mjs.map → auto-route-C-DrW6BL.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"auto-route-BG6I_4B1.mjs","names":[],"sources":["../src/session/auto-route.ts"],"sourcesContent":["/**\n * Auto-route: automatic project routing suggestion on session start.\n *\n * Given a working directory (and optional conversation context), determine\n * which registered project the session belongs to.\n *\n * Strategy (in priority order):\n *   1. Path match   — exact or parent-directory match in the project registry\n *   2. Marker walk  — walk up from cwd looking for Notes/PAI.md, resolve slug\n *   3. Topic match  — BM25 keyword search against memory (requires context text)\n *\n * The function is stateless and works with direct DB access (no daemon\n * required), making it fast and safe to call during session startup.\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend } from \"../storage/interface.js\";\nimport { resolve, dirname } from \"node:path\";\nimport { existsSync } from \"node:fs\";\nimport { readPaiMarker } from \"../registry/pai-marker.js\";\nimport { detectProject } from \"../cli/commands/detect.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type AutoRouteMethod = \"path\" | \"marker\" | \"topic\";\n\nexport interface AutoRouteResult {\n  /** Project slug */\n  slug: string;\n  /** Human-readable project name */\n  display_name: string;\n  /** Absolute path to the project root */\n  root_path: string;\n  /** How the project was detected */\n  method: AutoRouteMethod;\n  /** Confidence [0,1]: 1.0 for path/marker matches, BM25 fraction for topic */\n  confidence: number;\n}\n\n// ---------------------------------------------------------------------------\n// Core function\n// ---------------------------------------------------------------------------\n\n/**\n * Determine which project a session should be routed to.\n *\n * @param registryDb  Open PAI registry database\n * @param federation  Memory storage backend (needed only for topic fallback)\n * @param cwd         Working directory to detect from (defaults to process.cwd())\n * @param context     Optional conversation text for topic-based fallback\n * @returns           Best project match, or null if nothing matched\n */\nexport async function autoRoute(\n  registryDb: Database,\n  federation: Database | StorageBackend,\n  cwd?: string,\n  context?: string\n): Promise<AutoRouteResult | null> {\n  const target = resolve(cwd ?? process.cwd());\n\n  // -------------------------------------------------------------------------\n  // Strategy 1: Path match via registry\n  // -------------------------------------------------------------------------\n\n  const pathMatch = detectProject(registryDb, target);\n\n  if (pathMatch) {\n    return {\n      slug: pathMatch.slug,\n      display_name: pathMatch.display_name,\n      root_path: pathMatch.root_path,\n      method: \"path\",\n      confidence: 1.0,\n    };\n  }\n\n  // -------------------------------------------------------------------------\n  // Strategy 2: PAI.md marker file walk\n  //\n  // Walk up from cwd, checking <dir>/Notes/PAI.md at each level.\n  // Once found, resolve the slug against the registry to get full project info.\n  // -------------------------------------------------------------------------\n\n  const markerResult = findMarkerUpward(registryDb, target);\n  if (markerResult) {\n    return markerResult;\n  }\n\n  // -------------------------------------------------------------------------\n  // Strategy 3: Topic detection (requires context text)\n  // -------------------------------------------------------------------------\n\n  if (context && context.trim().length > 0) {\n    // Lazy import to avoid bundler pulling in daemon/index.mjs at module load time\n    const { detectTopicShift } = await import(\"../topics/detector.js\");\n    const topicResult = await detectTopicShift(registryDb, federation, {\n      context,\n      threshold: 0.5, // Lower threshold for initial routing (vs shift detection)\n    });\n\n    if (topicResult.suggestedProject && topicResult.confidence > 0) {\n      // Look up the full project info from the registry\n      const projectRow = registryDb\n        .prepare(\n          \"SELECT slug, display_name, root_path FROM projects WHERE slug = ? AND status != 'archived'\"\n        )\n        .get(topicResult.suggestedProject) as\n        | { slug: string; display_name: string; root_path: string }\n        | undefined;\n\n      if (projectRow) {\n        return {\n          slug: projectRow.slug,\n          display_name: projectRow.display_name,\n          root_path: projectRow.root_path,\n          method: \"topic\",\n          confidence: topicResult.confidence,\n        };\n      }\n    }\n  }\n\n  return null;\n}\n\n// ---------------------------------------------------------------------------\n// Marker walk helper\n// ---------------------------------------------------------------------------\n\n/**\n * Walk up the directory tree from `startDir`, checking each level for a\n * `Notes/PAI.md` file. If found, read the slug and look up the project.\n *\n * Stops at the filesystem root or after 20 levels (safety guard).\n */\nfunction findMarkerUpward(\n  registryDb: Database,\n  startDir: string\n): AutoRouteResult | null {\n  let current = startDir;\n  let depth = 0;\n\n  while (depth < 20) {\n    const markerPath = `${current}/Notes/PAI.md`;\n\n    if (existsSync(markerPath)) {\n      const marker = readPaiMarker(current);\n\n      if (marker && marker.status !== \"archived\") {\n        // Resolve slug to full project info in the registry\n        const projectRow = registryDb\n          .prepare(\n            \"SELECT slug, display_name, root_path FROM projects WHERE slug = ? AND status != 'archived'\"\n          )\n          .get(marker.slug) as\n          | { slug: string; display_name: string; root_path: string }\n          | undefined;\n\n        if (projectRow) {\n          return {\n            slug: projectRow.slug,\n            display_name: projectRow.display_name,\n            root_path: projectRow.root_path,\n            method: \"marker\",\n            confidence: 1.0,\n          };\n        }\n      }\n    }\n\n    const parent = dirname(current);\n    if (parent === current) break; // Reached filesystem root\n    current = parent;\n    depth++;\n  }\n\n  return null;\n}\n\n// ---------------------------------------------------------------------------\n// Format helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Format an AutoRouteResult as a human-readable string for CLI output.\n */\nexport function formatAutoRoute(result: AutoRouteResult): string {\n  const lines: string[] = [\n    `slug:         ${result.slug}`,\n    `display_name: ${result.display_name}`,\n    `root_path:    ${result.root_path}`,\n    `method:       ${result.method}`,\n    `confidence:   ${(result.confidence * 100).toFixed(0)}%`,\n  ];\n  return lines.join(\"\\n\");\n}\n\n/**\n * Format an AutoRouteResult as JSON for machine consumption.\n */\nexport function formatAutoRouteJson(result: AutoRouteResult): string {\n  return JSON.stringify(result, null, 2);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsDA,eAAsB,UACpB,YACA,YACA,KACA,SACiC;CACjC,MAAM,SAAS,QAAQ,OAAO,QAAQ,KAAK,CAAC;CAM5C,MAAM,YAAY,cAAc,YAAY,OAAO;AAEnD,KAAI,UACF,QAAO;EACL,MAAM,UAAU;EAChB,cAAc,UAAU;EACxB,WAAW,UAAU;EACrB,QAAQ;EACR,YAAY;EACb;CAUH,MAAM,eAAe,iBAAiB,YAAY,OAAO;AACzD,KAAI,aACF,QAAO;AAOT,KAAI,WAAW,QAAQ,MAAM,CAAC,SAAS,GAAG;EAExC,MAAM,EAAE,qBAAqB,MAAM,OAAO;EAC1C,MAAM,cAAc,MAAM,iBAAiB,YAAY,YAAY;GACjE;GACA,WAAW;GACZ,CAAC;AAEF,MAAI,YAAY,oBAAoB,YAAY,aAAa,GAAG;GAE9D,MAAM,aAAa,WAChB,QACC,6FACD,CACA,IAAI,YAAY,iBAAiB;AAIpC,OAAI,WACF,QAAO;IACL,MAAM,WAAW;IACjB,cAAc,WAAW;IACzB,WAAW,WAAW;IACtB,QAAQ;IACR,YAAY,YAAY;IACzB;;;AAKP,QAAO;;;;;;;;AAaT,SAAS,iBACP,YACA,UACwB;CACxB,IAAI,UAAU;CACd,IAAI,QAAQ;AAEZ,QAAO,QAAQ,IAAI;AAGjB,MAAI,WAFe,GAAG,QAAQ,eAEJ,EAAE;GAC1B,MAAM,SAAS,cAAc,QAAQ;AAErC,OAAI,UAAU,OAAO,WAAW,YAAY;IAE1C,MAAM,aAAa,WAChB,QACC,6FACD,CACA,IAAI,OAAO,KAAK;AAInB,QAAI,WACF,QAAO;KACL,MAAM,WAAW;KACjB,cAAc,WAAW;KACzB,WAAW,WAAW;KACtB,QAAQ;KACR,YAAY;KACb;;;EAKP,MAAM,SAAS,QAAQ,QAAQ;AAC/B,MAAI,WAAW,QAAS;AACxB,YAAU;AACV;;AAGF,QAAO;;;;;AAwBT,SAAgB,oBAAoB,QAAiC;AACnE,QAAO,KAAK,UAAU,QAAQ,MAAM,EAAE"}
+{"version":3,"file":"auto-route-C-DrW6BL.mjs","names":[],"sources":["../src/session/auto-route.ts"],"sourcesContent":["/**\n * Auto-route: automatic project routing suggestion on session start.\n *\n * Given a working directory (and optional conversation context), determine\n * which registered project the session belongs to.\n *\n * Strategy (in priority order):\n *   1. Path match   — exact or parent-directory match in the project registry\n *   2. Marker walk  — walk up from cwd looking for Notes/PAI.md, resolve slug\n *   3. Topic match  — BM25 keyword search against memory (requires context text)\n *\n * The function is stateless and works with direct DB access (no daemon\n * required), making it fast and safe to call during session startup.\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend } from \"../storage/interface.js\";\nimport { resolve, dirname } from \"node:path\";\nimport { existsSync } from \"node:fs\";\nimport { readPaiMarker } from \"../registry/pai-marker.js\";\nimport { detectProject } from \"../cli/commands/detect.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type AutoRouteMethod = \"path\" | \"marker\" | \"topic\";\n\nexport interface AutoRouteResult {\n  /** Project slug */\n  slug: string;\n  /** Human-readable project name */\n  display_name: string;\n  /** Absolute path to the project root */\n  root_path: string;\n  /** How the project was detected */\n  method: AutoRouteMethod;\n  /** Confidence [0,1]: 1.0 for path/marker matches, BM25 fraction for topic */\n  confidence: number;\n}\n\n// ---------------------------------------------------------------------------\n// Core function\n// ---------------------------------------------------------------------------\n\n/**\n * Determine which project a session should be routed to.\n *\n * @param registryDb  Open PAI registry database\n * @param federation  Memory storage backend (needed only for topic fallback)\n * @param cwd         Working directory to detect from (defaults to process.cwd())\n * @param context     Optional conversation text for topic-based fallback\n * @returns           Best project match, or null if nothing matched\n */\nexport async function autoRoute(\n  registryDb: Database,\n  federation: Database | StorageBackend,\n  cwd?: string,\n  context?: string\n): Promise<AutoRouteResult | null> {\n  const target = resolve(cwd ?? process.cwd());\n\n  // -------------------------------------------------------------------------\n  // Strategy 1: Path match via registry\n  // -------------------------------------------------------------------------\n\n  const pathMatch = detectProject(registryDb, target);\n\n  if (pathMatch) {\n    return {\n      slug: pathMatch.slug,\n      display_name: pathMatch.display_name,\n      root_path: pathMatch.root_path,\n      method: \"path\",\n      confidence: 1.0,\n    };\n  }\n\n  // -------------------------------------------------------------------------\n  // Strategy 2: PAI.md marker file walk\n  //\n  // Walk up from cwd, checking <dir>/Notes/PAI.md at each level.\n  // Once found, resolve the slug against the registry to get full project info.\n  // -------------------------------------------------------------------------\n\n  const markerResult = findMarkerUpward(registryDb, target);\n  if (markerResult) {\n    return markerResult;\n  }\n\n  // -------------------------------------------------------------------------\n  // Strategy 3: Topic detection (requires context text)\n  // -------------------------------------------------------------------------\n\n  if (context && context.trim().length > 0) {\n    // Lazy import to avoid bundler pulling in daemon/index.mjs at module load time\n    const { detectTopicShift } = await import(\"../topics/detector.js\");\n    const topicResult = await detectTopicShift(registryDb, federation, {\n      context,\n      threshold: 0.5, // Lower threshold for initial routing (vs shift detection)\n    });\n\n    if (topicResult.suggestedProject && topicResult.confidence > 0) {\n      // Look up the full project info from the registry\n      const projectRow = registryDb\n        .prepare(\n          \"SELECT slug, display_name, root_path FROM projects WHERE slug = ? AND status != 'archived'\"\n        )\n        .get(topicResult.suggestedProject) as\n        | { slug: string; display_name: string; root_path: string }\n        | undefined;\n\n      if (projectRow) {\n        return {\n          slug: projectRow.slug,\n          display_name: projectRow.display_name,\n          root_path: projectRow.root_path,\n          method: \"topic\",\n          confidence: topicResult.confidence,\n        };\n      }\n    }\n  }\n\n  return null;\n}\n\n// ---------------------------------------------------------------------------\n// Marker walk helper\n// ---------------------------------------------------------------------------\n\n/**\n * Walk up the directory tree from `startDir`, checking each level for a\n * `Notes/PAI.md` file. If found, read the slug and look up the project.\n *\n * Stops at the filesystem root or after 20 levels (safety guard).\n */\nfunction findMarkerUpward(\n  registryDb: Database,\n  startDir: string\n): AutoRouteResult | null {\n  let current = startDir;\n  let depth = 0;\n\n  while (depth < 20) {\n    const markerPath = `${current}/Notes/PAI.md`;\n\n    if (existsSync(markerPath)) {\n      const marker = readPaiMarker(current);\n\n      if (marker && marker.status !== \"archived\") {\n        // Resolve slug to full project info in the registry\n        const projectRow = registryDb\n          .prepare(\n            \"SELECT slug, display_name, root_path FROM projects WHERE slug = ? AND status != 'archived'\"\n          )\n          .get(marker.slug) as\n          | { slug: string; display_name: string; root_path: string }\n          | undefined;\n\n        if (projectRow) {\n          return {\n            slug: projectRow.slug,\n            display_name: projectRow.display_name,\n            root_path: projectRow.root_path,\n            method: \"marker\",\n            confidence: 1.0,\n          };\n        }\n      }\n    }\n\n    const parent = dirname(current);\n    if (parent === current) break; // Reached filesystem root\n    current = parent;\n    depth++;\n  }\n\n  return null;\n}\n\n// ---------------------------------------------------------------------------\n// Format helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Format an AutoRouteResult as a human-readable string for CLI output.\n */\nexport function formatAutoRoute(result: AutoRouteResult): string {\n  const lines: string[] = [\n    `slug:         ${result.slug}`,\n    `display_name: ${result.display_name}`,\n    `root_path:    ${result.root_path}`,\n    `method:       ${result.method}`,\n    `confidence:   ${(result.confidence * 100).toFixed(0)}%`,\n  ];\n  return lines.join(\"\\n\");\n}\n\n/**\n * Format an AutoRouteResult as JSON for machine consumption.\n */\nexport function formatAutoRouteJson(result: AutoRouteResult): string {\n  return JSON.stringify(result, null, 2);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsDA,eAAsB,UACpB,YACA,YACA,KACA,SACiC;CACjC,MAAM,SAAS,QAAQ,OAAO,QAAQ,KAAK,CAAC;CAM5C,MAAM,YAAY,cAAc,YAAY,OAAO;AAEnD,KAAI,UACF,QAAO;EACL,MAAM,UAAU;EAChB,cAAc,UAAU;EACxB,WAAW,UAAU;EACrB,QAAQ;EACR,YAAY;EACb;CAUH,MAAM,eAAe,iBAAiB,YAAY,OAAO;AACzD,KAAI,aACF,QAAO;AAOT,KAAI,WAAW,QAAQ,MAAM,CAAC,SAAS,GAAG;EAExC,MAAM,EAAE,qBAAqB,MAAM,OAAO;EAC1C,MAAM,cAAc,MAAM,iBAAiB,YAAY,YAAY;GACjE;GACA,WAAW;GACZ,CAAC;AAEF,MAAI,YAAY,oBAAoB,YAAY,aAAa,GAAG;GAE9D,MAAM,aAAa,WAChB,QACC,6FACD,CACA,IAAI,YAAY,iBAAiB;AAIpC,OAAI,WACF,QAAO;IACL,MAAM,WAAW;IACjB,cAAc,WAAW;IACzB,WAAW,WAAW;IACtB,QAAQ;IACR,YAAY,YAAY;IACzB;;;AAKP,QAAO;;;;;;;;AAaT,SAAS,iBACP,YACA,UACwB;CACxB,IAAI,UAAU;CACd,IAAI,QAAQ;AAEZ,QAAO,QAAQ,IAAI;AAGjB,MAAI,WAFe,GAAG,QAAQ,eAEJ,EAAE;GAC1B,MAAM,SAAS,cAAc,QAAQ;AAErC,OAAI,UAAU,OAAO,WAAW,YAAY;IAE1C,MAAM,aAAa,WAChB,QACC,6FACD,CACA,IAAI,OAAO,KAAK;AAInB,QAAI,WACF,QAAO;KACL,MAAM,WAAW;KACjB,cAAc,WAAW;KACzB,WAAW,WAAW;KACtB,QAAQ;KACR,YAAY;KACb;;;EAKP,MAAM,SAAS,QAAQ,QAAQ;AAC/B,MAAI,WAAW,QAAS;AACxB,YAAU;AACV;;AAGF,QAAO;;;;;AAwBT,SAAgB,oBAAoB,QAAiC;AACnE,QAAO,KAAK,UAAU,QAAQ,MAAM,EAAE"}