lm-assist 0.1.66 → 0.1.67

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
   "plugins": [
     {
       "name": "lm-assist",
-      "version": "0.1.66",
+      "version": "0.1.67",
       "source": "./",
       "description": "Auto-build knowledge from Claude Code sessions and inject it as context. Inspect sessions with deep views into agents, tasks, teams, plans, and tool calls. Access and control all Claude Code terminals from any device via web browser. Includes MCP server (search, detail, feedback), context-injection hook, and 6 slash commands.",
       "category": "productivity",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lm-assist",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "description": "Knowledge management, session inspector, and web terminal control for Claude Code",
   "author": {
     "name": "langmartai"

package/README.md

@@ -215,6 +215,8 @@ Then in Claude Code, run `/plugin install .` and `/assist-setup`.
 | MCP server | Yes (via plugin) | `search`, `detail`, `feedback` tools |
 | Context hook | Yes (via plugin) | Knowledge injection (optional) |
 | Slash commands | Yes (via plugin) | 6 `/assist-*` commands |
+| Skills | Yes (via plugin) | `observe` (auto-triggered observability) + `route` (cross-project routing) |
+| Slash commands | Yes (via plugin) | 9 commands: `/sessions`, `/summary`, `/run` + 6 `/assist-*` |
 | Statusline | Optional | Git branch, context %, rate limits, process stats |
 
 ## Services
@@ -231,31 +233,148 @@ lm-assist status      # Health check + process info
 lm-assist upgrade     # Upgrade to latest version
 ```
 
-## Key API Endpoints
+## Skills & Commands
 
-| Category | Endpoints | Highlights |
-|----------|-----------|------------|
-| **Sessions** | 27 | List, detail, delta fetch, batch-check, conversation, subagents, forks, DAG |
-| **Monitor** | 6 | Running executions, summary, abort, SSE stream |
-| **Projects** | 12 | List projects, sessions per project, git info, worktree detection |
-| **Terminal** | 13 | ttyd start/stop/status, WebSocket proxy, tmux attach |
-| **Tasks** | 22 | Task lists, aggregated tasks, ready tasks, dependency tracking |
-| **Knowledge** | 21 | List, search, generate, review (optional — can be disabled) |
-| **Vectors** | 6 | Semantic search, index, reindex (optional) |
+lm-assist ships with **2 auto-triggered skills** and **9 slash commands** that work inside Claude Code.
 
-All endpoints support `ifModifiedSince` for efficient polling. Session data supports three indexing dimensions: `lineIndex` (JSONL position), `turnIndex` (conversation turn), and `userPromptIndex` (user message count).
+### Skills (auto-triggered)
+
+Skills activate automatically when Claude detects relevant intent — no slash command needed.
 
-## Slash Commands
+| Skill | Triggers on | What it does |
+|-------|------------|--------------|
+| **observe** | "what's running?", "session costs", "show subagents", "run this on project X" | Full observability — monitor sessions, debug agents, control executions, manage summaries |
+| **route** | Prompt mentions another project's features or codebase | Cross-project routing — evaluates whether to stay, resume, fork, queue, or start new |
+
+### Commands
 
 | Command | Description |
 |---------|-------------|
+| `/sessions` | Session list with costs, turns, running status |
+| `/summary` | Summarize current session, generate display name, record learning |
+| `/run <prompt>` | Execute an agent with pre-flight checks |
 | `/assist` | Open the web UI in your browser |
 | `/assist-status` | Show status of all components |
 | `/assist-setup` | Start services and verify integrations |
-| `/assist-search <query>` | Search the knowledge base |
+| `/assist-search` | Search the knowledge base |
 | `/assist-logs` | View context-inject hook logs |
 | `/assist-mcp-logs` | View MCP tool call logs |
 
+### Use Cases with Examples
+
+**"What sessions are running and how much have they cost?"**
+```
+> /sessions
+Sessions (3 running, 415 total)
+───────────────────────────────────────────────────────────────────────
+Status  Name                         Project            Model      Cost  Turns
+───────────────────────────────────────────────────────────────────────
+[RUN]   observability-platform-build  lm-assist          opus    $307.66  1462
+[RUN]   trade-delta-analysis          lm-unified-trade   opus    $153.20   822
+[RUN]   anti-kelly-system             lm-unified-trade   opus     $35.49   433
+        two-track-dashboard           lm-unified-trade   opus    $107.43   516
+        skill-validation-test         lm-assist          opus      $0.63    11
+───────────────────────────────────────────────────────────────────────
+Total cost: $604.41
+```
+
+**"Summarize what this session has been doing"**
+```
+> /summary
+Session Summary
+═══════════════
+Name:    observability-platform-build
+Project: lm-assist
+Turns:   1462 | Cost: $307.66
+Status:  in progress
+
+What this session is about:
+  Building the lm-assist observability platform — session summaries,
+  cross-project routing, prompt queue, auto-learning.
+
+What was accomplished:
+  • Session slug/customTitle parsing from Claude Code JSONL
+  • Knowledge system kill switch (saves ~100MB)
+  • Observability skill + routing skill + 3 new commands
+  • Persistent session summaries with delta tracking
+  • Universal prompt queue with source/target context
+  • Auto-learning signals that evolve routing over time
+```
+
+**"Fix the delta analysis bug in the trading pipeline"**
+
+The route skill auto-detects this belongs to another project:
+```
+This task appears to belong to lm-unified-trade, not the current project.
+
+Relevant session found: trade-delta-analysis
+Summary: Implemented delta analysis mode for /trade-analyze command...
+Status: idle (not running)
+
+Recommendation: RESUME
+Reason: This session built all existing delta modes and knows the spec,
+flag table, and pre-launch copy patterns.
+
+To resume:  claude --resume 36a30ba6-4bd1-4587-8bb3-c1d21a2ab616
+```
+
+**"Run a security review on this project"**
+```
+> /run review all API endpoints for security vulnerabilities
+Checking running executions... OK: none running.
+
+Execution started: agent-1774468578687-1p2cnh
+  Session: nifty-wishing-boole
+  Status: running
+  Monitor with: /sessions
+  Web UI: http://localhost:3848
+```
+
+**"What's the cost breakdown by project?"**
+
+The observe skill activates:
+```
+Project costs:
+  lm-assist              $308.29  (80 sessions)
+  lm-unified-trade       $892.15  (440 sessions)
+  LangMartDesign          $45.20  (12 sessions)
+  tier-agent              $23.50  (15 sessions)
+```
+
+### Session Intelligence
+
+lm-assist learns from every interaction to route prompts smarter over time:
+
+- **Session summaries** — LLM-generated descriptions stored with delta tracking. Updated incrementally as sessions grow.
+- **Project summaries** — Comprehensive reference generated by agents that explore each project's CLAUDE.md, scripts, configs, and codebase.
+- **Prompt queue** — When a session is busy, new work is queued with full context (original intent, formatted prompt, routing reason, context hint).
+- **Auto-learning** — Keywords, commands, and routing patterns accumulate with frequency counts. After a few interactions, routing skips deep scans entirely.
+
+```
+Learning context for lm-unified-trade:
+  Frequently mentioned: delta analysis(3x), anti-kelly(2x), regime analysis(1x)
+  Areas worked in: analysis pipeline(1x)
+  Routing patterns: delta analysis → trade-delta-analysis session
+```
+
+## Key API Endpoints
+
+| Category | Endpoints | Highlights |
+|----------|-----------|------------|
+| **Sessions** | 27 | List, detail, delta fetch, batch-check, conversation, subagents, forks, DAG |
+| **Monitor** | 6 | Running executions, summary, abort, SSE stream |
+| **Projects** | 12 | List projects, sessions per project, git info, worktree detection, costs |
+| **Terminal** | 13 | ttyd start/stop/status, WebSocket proxy, tmux attach |
+| **Tasks** | 22 | Task lists, aggregated tasks, ready tasks, dependency tracking |
+| **Summaries** | 10 | Session summaries, project summaries, needs-update check |
+| **Queue** | 10 | Prompt queue with source/target, priority, dispatch/complete lifecycle |
+| **Learning** | 4 | Record signals, query by project, learning context generation |
+| **Search** | 4 | Session content search, recent sessions, vector search |
+| **Skills** | 9 | Skills analytics, chains, traces, per-session breakdown |
+| **Knowledge** | 21 | List, search, generate, review (optional — can be disabled) |
+
+All endpoints support `ifModifiedSince` for efficient polling. Session data supports three indexing dimensions: `lineIndex` (JSONL position), `turnIndex` (conversation turn), and `userPromptIndex` (user message count).
+
 ## Configuration
 
 No API key needed — lm-assist works entirely with your local Claude Code session data. Optionally copy `.env.example` to `.env`:

package/commands/sessions.md

@@ -12,76 +12,91 @@ Show recent Claude Code sessions with costs, turns, model, and running status.
 - No arguments: show sessions across all projects
 - `$ARGUMENTS[0]`: filter by project name (partial match)
 
-## Steps
+## Execution
 
-1. **Check API health:**
-```bash
-curl -s --max-time 2 http://localhost:3100/health
-```
-If not healthy, tell the user to start lm-assist with `lm-assist start` or `/assist-setup`.
+Run this single script. It handles health check, session fetch, and execution monitoring in one call:
 
-2. **Fetch sessions:**
 ```bash
-curl -s --max-time 5 http://localhost:3100/projects/sessions | python3 -c "
-import sys,json
-data = json.load(sys.stdin).get('data',{})
-sessions = data.get('sessions',[])
-total = data.get('total', len(sessions))
-
-# Filter by project if argument provided
-project_filter = '''$ARGUMENTS[0]'''.strip()
-if project_filter:
-    sessions = [s for s in sessions if project_filter.lower() in (s.get('projectPath','') + s.get('projectName','')).lower()]
-
-# Separate running from completed
-running = [s for s in sessions if s.get('isRunning')]
-rest = [s for s in sessions if not s.get('isRunning')][:10 - len(running)]
-show = running + rest
-
-print(f'Sessions ({len(show)} of {total})')
-if project_filter:
-    print(f'Filtered: {project_filter}')
-print('─' * 95)
-fmt = '{:<7} {:<28} {:<18} {:<8} {:>8} {:>6}'
-print(fmt.format('Status', 'Name', 'Project', 'Model', 'Cost', 'Turns'))
-print('─' * 95)
-for s in show:
-    status = '[RUN]' if s.get('isRunning') else ''
-    name = (s.get('customTitle') or s.get('slug') or s['sessionId'][:12])[:26]
-    project = (s.get('projectPath','').split('/')[-1] or '-')[:16]
-    model = (s.get('model','') or '-').replace('claude-','').replace('opus-4-6','opus').replace('sonnet-4-6','sonnet')[:7]
-    cost = f'\${s[\"totalCostUsd\"]:.2f}' if s.get('totalCostUsd') else '-'
-    turns = str(s.get('numTurns','')) or '-'
-    print(fmt.format(status, name, project, model, cost, turns))
-"
-```
+node -e "
+const http = require('http');
+const filter = process.argv[1] || '';
 
-3. **Check running executions:**
-```bash
-curl -s --max-time 3 http://localhost:3100/monitor/executions | python3 -c "
-import sys,json
-execs = json.load(sys.stdin).get('data',{}).get('executions',[])
-running = [e for e in execs if e.get('isRunning')]
-if running:
-    print(f'\nRunning Executions ({len(running)}):')
-    for e in running:
-        eid = e.get('executionId','')[:12]
-        turns = e.get('turnCount',0)
-        cost = e.get('costUsd',0)
-        elapsed = (e.get('elapsedMs',0) or 0) // 1000
-        mins = elapsed // 60
-        secs = elapsed % 60
-        print(f'  {eid}  T:{turns}  \${cost:.2f}  {mins}m{secs}s')
-"
-```
+function api(path) {
+  return new Promise((resolve) => {
+    const req = http.get('http://localhost:3100' + path, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(null); } });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
 
-## Output
+(async () => {
+  const health = await api('/health');
+  if (!health?.success) {
+    console.log('lm-assist API is not running.\nStart with: lm-assist start\nOr run: /assist-setup');
+    return;
+  }
 
-Present the table output from the python script directly. Do NOT reformat as markdown — show it as-is from the terminal output.
+  const data = await api('/projects/sessions');
+  if (!data?.data?.sessions) { console.log('Failed to fetch sessions.'); return; }
 
-If the API is not running, show:
-```
-lm-assist API is not running.
-Start with: lm-assist start
-Or run: /assist-setup
+  let sessions = data.data.sessions;
+  const total = data.data.total || sessions.length;
+
+  if (filter) {
+    sessions = sessions.filter(s => ((s.projectPath || '') + (s.projectName || '')).toLowerCase().includes(filter.toLowerCase()));
+  }
+
+  const running = sessions.filter(s => s.isRunning);
+  const rest = sessions.filter(s => !s.isRunning).slice(0, 15);
+  const show = [...running, ...rest];
+
+  console.log('Sessions (' + running.length + ' running, ' + total + ' total)');
+  if (filter) console.log('Filtered: ' + filter);
+  console.log('\u2500'.repeat(95));
+  const hdr = (s,n) => (s + ' '.repeat(n)).slice(0,n);
+  const rgt = (s,n) => (' '.repeat(n) + s).slice(-n);
+  console.log(hdr('Status',7) + hdr('Name',28) + hdr('Project',18) + hdr('Model',8) + rgt('Cost',8) + rgt('Turns',6));
+  console.log('\u2500'.repeat(95));
+
+  for (const s of show) {
+    const status = s.isRunning ? '[RUN]' : '';
+    const name = (s.customTitle || s.slug || s.sessionId.slice(0,12)).slice(0,26);
+    const project = ((s.projectPath || '').split('/').pop() || '-').slice(0,16);
+    const model = (s.model || '-').replace('claude-','').replace('opus-4-6','opus').replace('sonnet-4-6','sonnet').slice(0,7);
+    const cost = s.totalCostUsd ? '\$' + s.totalCostUsd.toFixed(2) : '-';
+    const turns = String(s.numTurns || '-');
+    console.log(hdr(status,7) + hdr(name,28) + hdr(project,18) + hdr(model,8) + rgt(cost,8) + rgt(turns,6));
+  }
+
+  // Running executions
+  const exData = await api('/monitor/executions');
+  if (exData?.data?.executions) {
+    const re = exData.data.executions.filter(e => e.isRunning);
+    if (re.length) {
+      console.log('\nRunning Executions (' + re.length + '):');
+      for (const e of re) {
+        const eid = (e.executionId || '').slice(0,12);
+        const t = e.turnCount || 0;
+        const c = (e.costUsd || 0).toFixed(2);
+        const elapsed = Math.floor((e.elapsedMs || 0) / 1000);
+        const mins = Math.floor(elapsed / 60);
+        const secs = elapsed % 60;
+        console.log('  ' + eid + '  T:' + t + '  \$' + c + '  ' + mins + 'm' + secs + 's');
+      }
+    }
+  }
+
+  const totalCost = sessions.reduce((a, s) => a + (s.totalCostUsd || 0), 0);
+  console.log('\u2500'.repeat(95));
+  console.log('Total cost: \$' + totalCost.toFixed(2));
+})();
+" -- "$ARGUMENTS[0]"
 ```
+
+## Output
+
+Present the script output directly. Do NOT reformat as markdown — show it as-is from the terminal.

package/commands/summary.md

@@ -7,99 +7,160 @@ description: Summarize the current session — what we're working on, what was d
 
 Generate or refresh a summary of THIS session. Shows what we're working on, what was accomplished, and current state. Used by the routing system to ensure new prompts stay in the right session.
 
-## Steps
+## Step 1: Gather all session data
 
-1. **Get the current session ID:**
-```bash
-echo "Session ID: $CLAUDE_SESSION_ID"
-echo "Project: $PWD"
-```
+Run this single script to collect session ID, existing summary, conversation, and metadata:
 
-2. **Check if a summary already exists for this session:**
 ```bash
-curl -s --max-time 3 "http://localhost:3100/sessions/$CLAUDE_SESSION_ID/summary" | python3 -c "
-import sys,json
-d = json.load(sys.stdin).get('data')
-if d and d.get('summary'):
-    print(f'Existing summary (built to turn {d.get(\"lastTurnIndex\",0)}):')
-    print(f'  Display name: {d.get(\"displayName\",\"(none)\")}')
-    print(f'  Summary: {d.get(\"summary\")}')
-else:
-    print('No summary exists yet.')
+node -e "
+const http = require('http');
+const cwd = process.cwd();
+const projectName = cwd.split('/').pop();
+
+function api(path, timeout = 5000) {
+  return new Promise((resolve) => {
+    const req = http.get('http://localhost:3100' + path, { timeout }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(null); } });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+(async () => {
+  const health = await api('/health');
+  if (!health?.success) {
+    console.log('ERROR: lm-assist API is not running. Start with: lm-assist start');
+    return;
+  }
+
+  // Detect current session — most recent for this project
+  const sessions = await api('/sessions?cwd=' + encodeURIComponent(cwd) + '&limit=3');
+  const sid = sessions?.data?.sessions?.[0]?.sessionId;
+  if (!sid) {
+    console.log('ERROR: Could not determine session ID');
+    return;
+  }
+
+  console.log('Session: ' + sid);
+  console.log('Project: ' + cwd);
+
+  // Existing summary
+  console.log('\n--- EXISTING SUMMARY ---');
+  const summary = await api('/sessions/' + sid + '/summary');
+  if (summary?.data?.summary) {
+    const d = summary.data;
+    console.log('Display name: ' + (d.displayName || '(none)'));
+    console.log('Last turn index: ' + (d.lastTurnIndex || 0));
+    console.log('Summary: ' + d.summary);
+  } else {
+    console.log('No summary exists yet.');
+  }
+
+  // Session metadata
+  console.log('\n--- SESSION METADATA ---');
+  const meta = await api('/sessions/' + sid);
+  if (meta?.data) {
+    const d = meta.data;
+    console.log('turns=' + (d.numTurns || 0));
+    console.log('cost=\$' + (d.totalCostUsd || 0).toFixed(2));
+    console.log('slug=' + (d.slug || ''));
+    console.log('customTitle=' + (d.customTitle || ''));
+    console.log('model=' + (d.model || ''));
+    console.log('status=' + (d.status || ''));
+  }
+
+  // Conversation (last 20 turns)
+  console.log('\n--- CONVERSATION ---');
+  const conv = await api('/sessions/' + sid + '/conversation?toolDetail=summary&lastN=20', 10000);
+  if (conv?.data?.messages?.length) {
+    const msgs = conv.data.messages;
+    console.log(msgs.length + ' messages in last 20 turns');
+    for (const m of msgs) {
+      const content = (m.content || '').slice(0, 200);
+      if (m.type === 'human' && content) console.log('  USER: ' + content);
+      else if (m.type === 'assistant' && content.length > 50) console.log('  CLAUDE: ' + content.slice(0, 150));
+    }
+  } else {
+    console.log('No conversation data available.');
+  }
+})();
 "
 ```
 
-3. **Read the conversation to understand what this session has done:**
+## Step 2: Generate the summary
 
-If no summary exists, read the full conversation. If a summary exists but is stale (new turns since last summary), read only the new turns.
-
-```bash
-# For new summary: read last 20 turns
-curl -s --max-time 5 "http://localhost:3100/sessions/$CLAUDE_SESSION_ID/conversation?toolDetail=summary&lastN=20" | python3 -c "
-import sys,json
-d = json.load(sys.stdin).get('data',{})
-messages = d.get('messages',[])
-print(f'{len(messages)} messages in last 20 turns')
-for m in messages:
-    role = m.get('type','')
-    content = (m.get('content','') or '')[:200]
-    if role == 'human' and content:
-        print(f'  USER: {content}')
-    elif role == 'assistant' and len(content) > 50:
-        print(f'  CLAUDE: {content[:150]}')
-"
-```
+Analyze the data from Step 1 and generate:
 
-4. **Generate the summary by analyzing what you just read from the conversation.**
+- **Summary text** — what this session is about, what was accomplished, current state, key context
+- **Display name** — 2-4 words, kebab-case (if no customTitle exists)
+- **Learning signals** — main topic keyword and area of project
 
-The summary must answer:
-- **What is this session about?** — the overall goal/theme
-- **What has been accomplished?** — key milestones, files changed, features built
-- **Current state?** — what we're working on RIGHT NOW, any blockers
-- **Key context** — important decisions made, patterns established, things to remember
+## Step 3: Save summary and record learning
 
-Also generate a **display name** (2-4 words, kebab-case) if this session doesn't already have a customTitle.
+Run this single script to save the summary AND record learning signals in one call. Replace the placeholder values with your generated content:
 
-5. **Get the current turn count for tracking:**
 ```bash
-curl -s --max-time 3 "http://localhost:3100/sessions/$CLAUDE_SESSION_ID" | python3 -c "
-import sys,json
-d = json.load(sys.stdin).get('data',{})
-print(f'turns={d.get(\"numTurns\",0)} cost=\${d.get(\"totalCostUsd\",0):.2f} slug={d.get(\"slug\",\"\")}')
-"
-```
+node -e "
+const http = require('http');
+const sessionId = process.argv[1];
+const cwd = process.cwd();
+const projectName = cwd.split('/').pop();
+
+// Replace these with generated values
+const summary = process.argv[2];
+const displayName = process.argv[3];
+const turnCount = parseInt(process.argv[4]) || 0;
+const keyword = process.argv[5];
+const area = process.argv[6];
+
+function apiPost(path, body, method = 'POST') {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify(body);
+    const url = new URL('http://localhost:3100' + path);
+    const req = http.request({ hostname: url.hostname, port: url.port, path: url.pathname, method, headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }, timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(null); } });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+(async () => {
+  // Save summary
+  const result = await apiPost('/sessions/' + sessionId + '/summary', {
+    summary, displayName, projectPath: cwd,
+    lastTurnIndex: turnCount, totalTurns: turnCount
+  }, 'PUT');
+  const saved = result?.success || false;
+
+  // Record learning signals
+  const learn = await apiPost('/learn', {
+    signals: [
+      { type: 'keyword', value: keyword, projectPath: cwd, projectName },
+      { type: 'area', value: area, projectPath: cwd }
+    ]
+  });
+  const learned = learn?.success || false;
 
-6. **Save the summary:**
-```bash
-curl -s -X PUT "http://localhost:3100/sessions/$CLAUDE_SESSION_ID/summary" \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "summary": "YOUR_GENERATED_SUMMARY",
-    "displayName": "YOUR_DISPLAY_NAME",
-    "slug": "SESSION_SLUG",
-    "projectPath": "PROJECT_PATH",
-    "lastTurnIndex": CURRENT_TURN_COUNT,
-    "totalTurns": CURRENT_TURN_COUNT
-  }'
+  console.log('Summary: ' + (saved ? 'saved' : 'failed') + ' | Learning: ' + (learned ? 'recorded' : 'failed'));
+})();
+" -- "SESSION_ID" "YOUR_GENERATED_SUMMARY" "YOUR_DISPLAY_NAME" "TURN_COUNT" "MAIN_TOPIC" "AREA_OF_PROJECT"
 ```
 
-7. **Rename the session** if it doesn't have a customTitle and you generated a displayName:
+## Step 4: Rename session (if needed)
+
+If the session doesn't have a customTitle, rename it:
 ```
 /rename YOUR_DISPLAY_NAME
 ```
 
-8. **Record learning signals** from what this session is about:
-```bash
-curl -s -X POST http://localhost:3100/learn \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "signals": [
-      {"type": "keyword", "value": "MAIN_TOPIC", "projectPath": "PROJECT_PATH", "projectName": "PROJECT_NAME"},
-      {"type": "area", "value": "AREA_OF_PROJECT", "projectPath": "PROJECT_PATH"}
-    ]
-  }'
-```
-
 ## Output
 
 Present the summary clearly:
@@ -116,16 +177,16 @@ What this session is about:
   OVERALL_GOAL_DESCRIPTION
 
 What was accomplished:
-  • MILESTONE_1
-  • MILESTONE_2
-  • MILESTONE_3
+  - MILESTONE_1
+  - MILESTONE_2
+  - MILESTONE_3
 
 Current state:
   WHAT_WE_ARE_DOING_NOW
 
 Key context:
-  • IMPORTANT_DECISION_1
-  • PATTERN_ESTABLISHED
+  - IMPORTANT_DECISION_1
+  - PATTERN_ESTABLISHED
 ```
 
 If `$ARGUMENTS` contains text, treat it as additional context to include in the summary (e.g., `/summary just finished the routing tests`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lm-assist",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "description": "Knowledge management, session inspector, and web terminal control for Claude Code",
   "license": "AGPL-3.0-or-later",
   "author": {

package/web/.next/BUILD_ID

@@ -1 +1 @@
-Zx5sHPa3X0Xd4H0apvz9y
+KmCZSVL96On-DixrWoKE4

package/web/.next/build-manifest.json

@@ -7,8 +7,8 @@
     "static/chunks/a6dad97d9634a72d.js"
   ],
   "lowPriorityFiles": [
-    "static/Zx5sHPa3X0Xd4H0apvz9y/_ssgManifest.js",
-    "static/Zx5sHPa3X0Xd4H0apvz9y/_buildManifest.js"
+    "static/KmCZSVL96On-DixrWoKE4/_ssgManifest.js",
+    "static/KmCZSVL96On-DixrWoKE4/_buildManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/36a05b7c4a79a899.js",

package/web/.next/fallback-build-manifest.json

@@ -5,8 +5,8 @@
   "devFiles": [],
   "polyfillFiles": [],
   "lowPriorityFiles": [
-    "static/Zx5sHPa3X0Xd4H0apvz9y/_ssgManifest.js",
-    "static/Zx5sHPa3X0Xd4H0apvz9y/_buildManifest.js"
+    "static/KmCZSVL96On-DixrWoKE4/_ssgManifest.js",
+    "static/KmCZSVL96On-DixrWoKE4/_buildManifest.js"
   ],
   "rootMainFiles": []
 }