@splicr/mcp-server 0.10.4 → 0.11.1

package/dist/cli.js

@@ -404,30 +404,50 @@ async function runHook() {
         // Gather env signals + fuse with user's prompt
         const { gatherSignals } = await import('./lib/signal-gatherer.js');
         const { fuseSignals } = await import('./lib/signal-fusion.js');
-        const { getRelevantContext } = await import('./lib/api-client.js');
+        const { getRelevantContext, getProjectContext } = await import('./lib/api-client.js');
+        const { detectProject } = await import('./lib/project-detector.js');
         const envSignals = gatherSignals(process.cwd());
         const fused = fuseSignals({ task: userPrompt }, envSignals);
         if (fused.queries.length === 0) {
             process.exit(0);
             return;
         }
-        // Call Splicr API — always global, relevance handles filtering
-        const { results } = await getRelevantContext({
+        // Check if this is the first message of the session (patterns not yet injected)
+        const sessionState = loadSessionState(sessionId);
+        const isFirstMessage = !loadSessionMeta(sessionId).patterns_injected;
+        // Fetch relevant context + patterns in parallel (patterns only on first message)
+        const contextPromise = getRelevantContext({
             queries: fused.queries,
             tech_stack: fused.tech_stack,
-            limit: 5, // fetch extra to allow for dedup filtering
+            limit: 5,
         });
-        if (!results || results.length === 0) {
-            process.exit(0);
-            return;
+        let patternsPromise = Promise.resolve({});
+        if (isFirstMessage) {
+            const detected = await detectProject(process.cwd()).catch(() => null);
+            if (detected?.name) {
+                patternsPromise = getProjectContext({
+                    project_name: detected.name,
+                    project_id: detected.id,
+                    limit: 1, // we only need patterns, not captures
+                }).catch(() => ({}));
+            }
         }
-        // Session-aware dedup: don't inject same captures twice in one session
-        const injectedIds = loadSessionState(sessionId);
-        const freshResults = results.filter((r) => !injectedIds.has(r.id));
-        if (freshResults.length === 0) {
+        const [{ results }, patternData] = await Promise.all([contextPromise, patternsPromise]);
+        // Build patterns section (first message only, deterministic enforcement)
+        let patternsSection = '';
+        if (isFirstMessage && patternData.patterns && patternData.patterns.length > 0) {
+            const patternLines = patternData.patterns.map((p, i) => `${i + 1}. **${p.name}** — ${p.description}`).join('\n');
+            patternsSection = `ACTIVE TEAM PATTERNS for ${patternData.project_name || 'this project'}:\n${patternLines}\n\nThese patterns are established by your team. Follow them unless explicitly asked to deviate.\n\n---\n\n`;
+            // Mark patterns as injected for this session
+            saveSessionMeta(sessionId, { patterns_injected: true });
+        }
+        if ((!results || results.length === 0) && !patternsSection) {
             process.exit(0);
             return;
         }
+        // Session-aware dedup: don't inject same captures twice in one session
+        const injectedIds = sessionState;
+        const freshResults = (results || []).filter((r) => !injectedIds.has(r.id));
         // Take top 3 fresh results
         const topResults = freshResults.slice(0, 3);
         // Track what we injected (IDs + titles for context-aware gate)
@@ -435,14 +455,22 @@ async function runHook() {
         for (const r of topResults)
             injectedIds.add(r.id);
         saveSessionState(sessionId, injectedIds, titles);
-        // Format as actionable decision-support context (12-factor style: own your context window)
-        const contextLines = topResults.map((r, i) => {
-            const why = r.why_relevant || 'Semantically similar to your work context';
-            const tags = r.tags?.length ? r.tags.slice(0, 5).join(', ') : '';
-            const source = r.source_type || 'unknown';
-            return `${i + 1}. "${r.title}" [${source}]${tags ? ` (${tags})` : ''}\n   → ${r.insight}\n   WHY RELEVANT: ${why}\n   DEEP DIVE: get_full_content("${r.id}")`;
-        }).join('\n\n');
-        const context = `SPLICR CONTEXT — The user's saved research matched this task. Use these findings to inform your response:\n\n${contextLines}\n\nACTION: Review above before answering. Call get_full_content(id) for complete articles. Fall back to web search only if these don't cover the question.`;
+        // Format knowledge context
+        let contextSection = '';
+        if (topResults.length > 0) {
+            const contextLines = topResults.map((r, i) => {
+                const why = r.why_relevant || 'Semantically similar to your work context';
+                const tags = r.tags?.length ? r.tags.slice(0, 5).join(', ') : '';
+                const source = r.source_type || 'unknown';
+                return `${i + 1}. "${r.title}" [${source}]${tags ? ` (${tags})` : ''}\n   → ${r.insight}\n   WHY RELEVANT: ${why}\n   DEEP DIVE: get_full_content("${r.id}")`;
+            }).join('\n\n');
+            contextSection = `SPLICR CONTEXT — The user's saved research matched this task. Use these findings to inform your response:\n\n${contextLines}\n\nACTION: Review above before answering. Call get_full_content(id) for complete articles. Fall back to web search only if these don't cover the question.`;
+        }
+        const context = patternsSection + contextSection;
+        if (!context.trim()) {
+            process.exit(0);
+            return;
+        }
         // Output JSON that Claude Code's hook system understands
         const output = JSON.stringify({
             hookSpecificOutput: {
@@ -713,31 +741,23 @@ async function runSessionEnd() {
         // Take the last ~5000 chars of assistant messages
         const combined = messages.join('\n\n');
         const tail = combined.length > 5000 ? combined.slice(-5000) : combined;
-        // Skip if agent already saved to Splicr during this session
-        if (tail.includes('Saved to Splicr')) {
-            process.exit(0);
-            return;
-        }
-        // Send to capture endpoint — let the AI pipeline distill and decide significance
+        // Send to structured learning extraction endpoint
         const authMod = await import('./auth.js');
         const auth = await authMod.loadAuth();
         const API_URL = process.env.SPLICR_API_URL || 'https://api-production-d889.up.railway.app';
-        // Fire-and-forget POST to capture endpoint
-        fetch(`${API_URL}/capture`, {
+        // Fire-and-forget POST to session/complete-with-transcript
+        // This replaces the old raw transcript dump with structured AI extraction
+        fetch(`${API_URL}/mcp/session/complete-with-transcript`, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${auth.accessToken}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
-                content: tail,
-                source_type: 'agent',
-                captured_from: 'ide_agent',
-                title: `Session learning — ${new Date().toISOString().split('T')[0]}`,
-                tags: ['auto-save', 'session-learning'],
-                extracted_content: tail,
+                session_id: sessionId || undefined,
+                transcript_tail: tail,
             }),
-            signal: AbortSignal.timeout(8000),
+            signal: AbortSignal.timeout(10000),
         }).catch(() => { }); // fire-and-forget
         process.exit(0);
     }
@@ -781,6 +801,37 @@ function saveSessionState(sessionId, injectedIds, titles) {
     }
     catch { /* non-critical */ }
 }
+function loadSessionMeta(sessionId) {
+    if (!sessionId)
+        return {};
+    try {
+        const file = join(SESSION_STATE_DIR, `${sessionId}.json`);
+        if (existsSync(file)) {
+            const data = JSON.parse(readFileSync(file, 'utf-8'));
+            return { patterns_injected: data.patterns_injected || false };
+        }
+    }
+    catch { /* ignore */ }
+    return {};
+}
+function saveSessionMeta(sessionId, meta) {
+    if (!sessionId)
+        return;
+    try {
+        if (!existsSync(SESSION_STATE_DIR))
+            mkdirSync(SESSION_STATE_DIR, { recursive: true });
+        const file = join(SESSION_STATE_DIR, `${sessionId}.json`);
+        let existing = {};
+        if (existsSync(file)) {
+            try {
+                existing = JSON.parse(readFileSync(file, 'utf-8'));
+            }
+            catch { }
+        }
+        writeFileSync(file, JSON.stringify({ ...existing, ...meta, updated: Date.now() }));
+    }
+    catch { /* non-critical */ }
+}
 function readStdin() {
     return new Promise((resolve) => {
         let data = '';
@@ -791,26 +842,26 @@ function readStdin() {
         setTimeout(() => resolve(data), 500);
     });
 }
-const SPLICR_INSTRUCTION = `Call get_relevant_context (Splicr MCP) at the START of any task. Pass your understanding of the task (the user's message), any files you're reading/modifying, and any errors you've encountered. It automatically searches the user's knowledge base using full context awareness — your task, git branch, recent commits, changed files, and more.
-
-For follow-up or narrow searches during the same task, use search_knowledge with a specific query.
-
-When results have high relevance (>50%), call get_full_content(id) to get the complete saved content before responding.
-
-Splicr is the user's personal knowledge base. They save articles, tweets, code snippets, and research. Your job is to use it — not ignore it and rely on training data alone.
-
-## Auto-save learnings
-At the END of significant sessions (not trivial ones), review what you learned and save decisions/discoveries to Splicr using save_from_agent. Include the context field for attribution.
-
-Save ONLY: decisions (chose X over Y because...), discoveries (undocumented behavior), workarounds (non-obvious fixes), synthesis (combined multiple insights into a new approach).
-Do NOT save: file edits, routine commands, anything derivable from git log or reading the current code.
-
-Ask yourself: "Would a developer starting a new session benefit from knowing this?" If yes, save it.
-
-## Failure modes
-- Splicr returns no results → fall back to web search or training data
-- Splicr returns results but they don't answer the question → supplement with web search
-- Splicr API is unreachable → proceed without it, don't block the session
+const SPLICR_INSTRUCTION = `Call get_relevant_context (Splicr MCP) at the START of any task. Pass your understanding of the task (the user's message), any files you're reading/modifying, and any errors you've encountered. It automatically searches the user's knowledge base using full context awareness — your task, git branch, recent commits, changed files, and more.
+
+For follow-up or narrow searches during the same task, use search_knowledge with a specific query.
+
+When results have high relevance (>50%), call get_full_content(id) to get the complete saved content before responding.
+
+Splicr is the user's personal knowledge base. They save articles, tweets, code snippets, and research. Your job is to use it — not ignore it and rely on training data alone.
+
+## Auto-save learnings
+At the END of significant sessions (not trivial ones), review what you learned and save decisions/discoveries to Splicr using save_from_agent. Include the context field for attribution.
+
+Save ONLY: decisions (chose X over Y because...), discoveries (undocumented behavior), workarounds (non-obvious fixes), synthesis (combined multiple insights into a new approach).
+Do NOT save: file edits, routine commands, anything derivable from git log or reading the current code.
+
+Ask yourself: "Would a developer starting a new session benefit from knowing this?" If yes, save it.
+
+## Failure modes
+- Splicr returns no results → fall back to web search or training data
+- Splicr returns results but they don't answer the question → supplement with web search
+- Splicr API is unreachable → proceed without it, don't block the session
 - You forgot to save learnings → the Stop hook will remind you`;
 const SPLICR_MARKER = '# Splicr';
 function getInstructionFiles() {
@@ -1060,17 +1111,17 @@ async function teamCommand() {
             break;
         }
         default:
-            console.error(`
-  Splicr Teams
-
-  Commands:
-    team create "Name"    Create a new team
-    team list             List your teams
-    team invite           Show invite link for your team
-    team join <code>      Join a team by invite code
-
-  Or use setup --join:
-    setup --join <code>   Sign up + join team + configure agents (one command)
+            console.error(`
+  Splicr Teams
+
+  Commands:
+    team create "Name"    Create a new team
+    team list             List your teams
+    team invite           Show invite link for your team
+    team join <code>      Join a team by invite code
+
+  Or use setup --join:
+    setup --join <code>   Sign up + join team + configure agents (one command)
 `);
             break;
     }
@@ -1087,34 +1138,34 @@ function printManualConfig() {
     console.error('  }\n');
 }
 function printHelp() {
-    console.error(`
-  Splicr — route what you read to what you're building
-
-  Getting started:
-    npx @splicr/mcp-server setup                Sign up + configure all agents (one command)
-    npx @splicr/mcp-server setup --join <code>   Sign up + join team + configure agents
-
-  Commands:
-    setup              One-time setup: authenticate + configure agents + hooks
-    login              Re-authenticate
-    team create "Name" Create a new team
-    team list          List your teams
-    team invite        Show invite link for your team
-    team join <code>   Join a team by invite code
-    dashboard          Open knowledge dashboard in browser
-    uninstall          Remove Splicr from all coding agents
-
-  Supported agents (auto-detected):
-    Claude Code, Codex, Cursor, Cline, Antigravity
-
-  Quick start:
-    1. Run: npx @splicr/mcp-server setup
-    2. Save knowledge from anywhere:
-       - Telegram: t.me/SplicrBot (send links from your phone)
-       - Extension: chromewebstore.google.com/detail/dllhofjfmkmbdadilbdgojapfbmlhnla
-       - Agent: save_from_agent tool (agents save learnings)
-    3. Open any coding agent — your saves show up when relevant
-    4. Dashboard: splicr.dev/dashboard
+    console.error(`
+  Splicr — route what you read to what you're building
+
+  Getting started:
+    npx @splicr/mcp-server setup                Sign up + configure all agents (one command)
+    npx @splicr/mcp-server setup --join <code>   Sign up + join team + configure agents
+
+  Commands:
+    setup              One-time setup: authenticate + configure agents + hooks
+    login              Re-authenticate
+    team create "Name" Create a new team
+    team list          List your teams
+    team invite        Show invite link for your team
+    team join <code>   Join a team by invite code
+    dashboard          Open knowledge dashboard in browser
+    uninstall          Remove Splicr from all coding agents
+
+  Supported agents (auto-detected):
+    Claude Code, Codex, Cursor, Cline, Antigravity
+
+  Quick start:
+    1. Run: npx @splicr/mcp-server setup
+    2. Save knowledge from anywhere:
+       - Telegram: t.me/SplicrBot (send links from your phone)
+       - Extension: chromewebstore.google.com/detail/dllhofjfmkmbdadilbdgojapfbmlhnla
+       - Agent: save_from_agent tool (agents save learnings)
+    3. Open any coding agent — your saves show up when relevant
+    4. Dashboard: splicr.dev/dashboard
 `);
 }
 main().catch(err => {

package/dist/index.js

@@ -13,6 +13,8 @@ import { browseProjectSchema, handleBrowseProject } from './tools/browse-project
 import { getCompiledPageSchema, handleGetCompiledPage } from './tools/get-compiled-page.js';
 import { grepKnowledgeSchema, handleGrepKnowledge } from './tools/grep-knowledge.js';
 import { exploreKnowledgeSchema, handleExploreKnowledge } from './tools/explore-knowledge.js';
+import { getDecisionsSchema, handleGetDecisions } from './tools/get-decisions.js';
+import { getTeamStatusSchema, handleGetTeamStatus } from './tools/get-team-status.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -33,18 +35,18 @@ for (const signal of ['SIGTERM', 'SIGINT']) {
 }
 const server = new Server({ name: 'splicr', version: '0.1.0' }, {
     capabilities: { tools: {} },
-    instructions: `Splicr is the user's personal knowledge base — articles, tweets, code snippets, GitHub repos, and agent learnings saved from across the web. It is your PRIMARY source of context. Using it is not optional.
-
-CONTRACTS (you must follow these):
-1. BEFORE answering any question, BEFORE web searching, BEFORE relying on training data — call get_relevant_context with the user's task. This is not a suggestion. The user saved knowledge specifically for moments like this.
-2. When results have relevance >50%, call get_full_content(id) to get the complete saved content. Use it to ground your response.
-2b. When results include a compiled_page field, prefer get_compiled_page(id) — it's a synthesized wiki page merging multiple related sources into one structured document. More useful than reading individual captures.
-3. Only fall back to web search or training data if Splicr returns no results or results don't cover the question.
-4. At the END of significant sessions, call save_from_agent with decisions, discoveries, or workarounds you made. Include the context field for attribution.
-
-FAILURE MODES:
-- Splicr returns no results → proceed with web search or training data
-- Splicr API is unreachable → proceed without it, don't block the session
+    instructions: `Splicr is the user's personal knowledge base — articles, tweets, code snippets, GitHub repos, and agent learnings saved from across the web. It is your PRIMARY source of context. Using it is not optional.
+
+CONTRACTS (you must follow these):
+1. BEFORE answering any question, BEFORE web searching, BEFORE relying on training data — call get_relevant_context with the user's task. This is not a suggestion. The user saved knowledge specifically for moments like this.
+2. When results have relevance >50%, call get_full_content(id) to get the complete saved content. Use it to ground your response.
+2b. When results include a compiled_page field, prefer get_compiled_page(id) — it's a synthesized wiki page merging multiple related sources into one structured document. More useful than reading individual captures.
+3. Only fall back to web search or training data if Splicr returns no results or results don't cover the question.
+4. At the END of significant sessions, call save_from_agent with decisions, discoveries, or workarounds you made. Include the context field for attribution.
+
+FAILURE MODES:
+- Splicr returns no results → proceed with web search or training data
+- Splicr API is unreachable → proceed without it, don't block the session
 - Results don't match the question → supplement with other sources`,
 });
 // List tools
@@ -61,6 +63,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         getCompiledPageSchema,
         grepKnowledgeSchema,
         exploreKnowledgeSchema,
+        getDecisionsSchema,
+        getTeamStatusSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -79,6 +83,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             get_compiled_page: handleGetCompiledPage,
             grep_knowledge: handleGrepKnowledge,
             explore_knowledge: handleExploreKnowledge,
+            get_decisions: handleGetDecisions,
+            get_team_status: handleGetTeamStatus,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

package/dist/lib/api-client.d.ts

@@ -11,6 +11,7 @@ export declare function getProjectContext(params: {
     limit?: number;
 }): Promise<{
     results: any[];
+    patterns?: any[];
     project_name?: string;
 }>;
 export declare function getRecentInsights(params: {
@@ -27,6 +28,7 @@ export declare function saveFromAgent(params: {
     tags?: string[];
     memory_type?: string;
     context?: Record<string, unknown>;
+    register_as_pattern?: boolean;
 }): Promise<{
     id: string;
     title: string;
@@ -136,4 +138,15 @@ export declare function getRelevantContext(params: {
     results: any[];
     search_strategy: string;
 }>;
+export declare function getDecisions(params: {
+    topic?: string;
+    project_name?: string;
+    type?: string;
+    limit?: number;
+}): Promise<{
+    results: any[];
+}>;
+export declare function getTeamStatus(params: {
+    project?: string;
+}): Promise<any>;
 export { API_URL };

package/dist/lib/api-client.js

@@ -100,4 +100,12 @@ export async function getRelevantContext(params) {
     const data = await apiRequest('POST', '/mcp/relevant-context', params);
     return { results: data.results ?? [], search_strategy: data.search_strategy ?? '' };
 }
+export async function getDecisions(params) {
+    const data = await apiRequest('POST', '/mcp/decisions', params);
+    return { results: data.results ?? [] };
+}
+export async function getTeamStatus(params) {
+    const query = params.project ? `?project=${encodeURIComponent(params.project)}` : '';
+    return await apiRequest('GET', `/mcp/team-status${query}`);
+}
 export { API_URL };

package/dist/tools/get-decisions.d.ts

@@ -0,0 +1,27 @@
+export declare const getDecisionsSchema: {
+    name: "get_decisions";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            topic: {
+                type: "string";
+                description: string;
+            };
+            project: {
+                type: "string";
+                description: string;
+            };
+            type: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: "number";
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleGetDecisions(args: Record<string, unknown>): Promise<string>;

package/dist/tools/get-decisions.js

@@ -0,0 +1,90 @@
+import { getDecisions } from '../lib/api-client.js';
+import { detectProject } from '../lib/project-detector.js';
+import * as session from '../lib/session-state.js';
+export const getDecisionsSchema = {
+    name: 'get_decisions',
+    description: `Query the team's decision log - technical decisions, patterns, discoveries, and failures recorded during agent sessions.
+
+Use when:
+- Before making an architecture or technology choice (see what the team decided before)
+- When someone asks "why did we do X this way?"
+- When evaluating alternatives for a new approach
+- To check if something was tried before and failed
+
+Returns structured decisions with rationale, alternatives considered, and anti-pattern warnings.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            topic: { type: 'string', description: 'Topic to search decisions about (e.g., "auth", "caching", "error handling")' },
+            project: { type: 'string', description: 'Project name or "auto" (default: auto)' },
+            type: {
+                type: 'string',
+                enum: ['decision', 'discovery', 'pattern', 'failure', 'workaround', 'all'],
+                description: 'Filter by decision type (default: all)',
+            },
+            limit: { type: 'number', description: 'Max results (default: 10)' },
+        },
+    },
+};
+export async function handleGetDecisions(args) {
+    const topic = args.topic;
+    const typeFilter = args.type || 'all';
+    const limit = Math.min(Math.max(1, Number(args.limit) || 10), 50);
+    // Resolve project
+    let projectName;
+    const projectArg = args.project || 'auto';
+    if (projectArg === 'auto') {
+        const detected = await detectProject(process.cwd());
+        projectName = detected?.name;
+    }
+    else {
+        projectName = projectArg;
+    }
+    const data = await getDecisions({
+        topic,
+        project_name: projectName,
+        type: typeFilter,
+        limit,
+    });
+    session.recordToolCall();
+    if (!data.results || data.results.length === 0) {
+        const scope = projectName ? ` for ${projectName}` : '';
+        const topicNote = topic ? ` about "${topic}"` : '';
+        return `No decisions found${scope}${topicNote}. The decision log builds over time as agents auto-extract learnings from sessions.`;
+    }
+    const items = data.results.map((r, i) => {
+        const meta = r.metadata || {};
+        const typeLabel = meta.decision_type || meta.learning_type || 'unknown';
+        const confidence = meta.confidence ? ` (${meta.confidence} confidence)` : '';
+        // Special formatting for failures/anti-patterns
+        let prefix = '';
+        if (typeLabel === 'failure')
+            prefix = '[ANTI-PATTERN] ';
+        else if (typeLabel === 'architecture')
+            prefix = '[DECISION] ';
+        else if (typeLabel === 'pattern')
+            prefix = '[PATTERN] ';
+        else if (typeLabel === 'discovery')
+            prefix = '[DISCOVERY] ';
+        else if (typeLabel === 'workaround')
+            prefix = '[WORKAROUND] ';
+        let entry = `${i + 1}. ${prefix}**${r.title || 'Untitled'}**${confidence}\n`;
+        entry += `   ${r.insight || r.raw_content || '(no content)'}\n`;
+        if (meta.alternatives_considered) {
+            entry += `   *Alternatives considered:* ${meta.alternatives_considered}\n`;
+        }
+        if (meta.failed_reason) {
+            entry += `   *Why it failed:* ${meta.failed_reason}\n`;
+        }
+        if (meta.better_approach) {
+            entry += `   *Better approach:* ${meta.better_approach}\n`;
+        }
+        const tags = r.tags?.filter((t) => !t.startsWith('learning:') && t !== 'auto-extracted');
+        if (tags?.length > 0) {
+            entry += `   tags: ${tags.join(', ')}`;
+        }
+        return entry;
+    }).join('\n\n');
+    const scope = projectName ? ` for ${projectName}` : '';
+    return `*Decision log${scope} — ${data.results.length} result(s):*\n\n${items}`;
+}

package/dist/tools/get-project-context.js

@@ -4,8 +4,8 @@ import { gatherSignals } from '../lib/signal-gatherer.js';
 import { fuseSignals } from '../lib/signal-fusion.js';
 export const getProjectContextSchema = {
     name: 'get_project_context',
-    description: `Show what's new in a project's knowledge feed from Splicr. Only call this when the user explicitly asks to see new saves, recent context, or "what's new." Do NOT call this proactively at session start.
-
+    description: `Show what's new in a project's knowledge feed from Splicr. Only call this when the user explicitly asks to see new saves, recent context, or "what's new." Do NOT call this proactively at session start.
+
 Uses a watermark system — only returns captures saved since the last time context was served for this project. Safe to call repeatedly; it will return empty if nothing is new.`,
     inputSchema: {
         type: 'object',
@@ -40,6 +40,12 @@ export async function handleGetProjectContext(args) {
     const results = data.results;
     const name = data.project_name || projectName;
     let output = '';
+    // --- SECTION 0: Active project patterns (cross-agent consistency) ---
+    const patterns = data.patterns;
+    if (patterns && patterns.length > 0) {
+        const patternItems = patterns.map((p, i) => `${i + 1}. **${p.name}** — ${p.description}`).join('\n');
+        output += `*Active patterns for ${name}:*\n${patternItems}\n\n---\n\n`;
+    }
     if (results && results.length > 0) {
         const items = results.map((r, i) => `${i + 1}. **${r.title || 'Untitled'}** · splicr [${r.relevance}]\n` +
             `   ${r.insight}\n` +

package/dist/tools/get-team-status.d.ts

@@ -0,0 +1,14 @@
+export declare const getTeamStatusSchema: {
+    name: "get_team_status";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleGetTeamStatus(args: Record<string, unknown>): Promise<string>;

package/dist/tools/get-team-status.js

@@ -0,0 +1,61 @@
+import { getTeamStatus } from '../lib/api-client.js';
+import { detectProject } from '../lib/project-detector.js';
+import * as session from '../lib/session-state.js';
+export const getTeamStatusSchema = {
+    name: 'get_team_status',
+    description: `Get a brief on what the team is working on right now. Shows open PRs, active branches, and recent merges from GitHub.
+
+Use when:
+- Starting a session and want to know what's in flight
+- Before starting work on a feature (check if someone else is already on it)
+- To understand recent changes to the codebase
+
+Requires GitHub integration (connected via Splicr dashboard).`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name or "auto" (default: auto)' },
+        },
+    },
+};
+export async function handleGetTeamStatus(args) {
+    const projectArg = args.project || 'auto';
+    let projectName;
+    if (projectArg === 'auto') {
+        const detected = await detectProject(process.cwd());
+        projectName = detected?.name;
+    }
+    else {
+        projectName = projectArg;
+    }
+    const data = await getTeamStatus({ project: projectName });
+    session.recordToolCall();
+    if (data.error) {
+        return data.error;
+    }
+    let output = `*Team status for ${data.repo}:*\n\n`;
+    // Open PRs
+    if (data.open_prs && data.open_prs.length > 0) {
+        output += `**Open PRs (${data.open_prs.length}):**\n`;
+        output += data.open_prs.map((pr) => `- #${pr.number} ${pr.title} (${pr.author}, branch: \`${pr.branch}\`)${pr.draft ? ' [DRAFT]' : ''}`).join('\n');
+        output += '\n\n';
+    }
+    else {
+        output += 'No open PRs.\n\n';
+    }
+    // Recent merges
+    if (data.recent_merges && data.recent_merges.length > 0) {
+        output += `**Recently merged (last 7 days):**\n`;
+        output += data.recent_merges.map((m) => {
+            const daysAgo = Math.floor((Date.now() - new Date(m.merged_at).getTime()) / (1000 * 60 * 60 * 24));
+            const when = daysAgo === 0 ? 'today' : daysAgo === 1 ? 'yesterday' : `${daysAgo}d ago`;
+            return `- ${m.title} (${m.author}, ${when})`;
+        }).join('\n');
+        output += '\n\n';
+    }
+    // Active branches
+    if (data.active_branches && data.active_branches.length > 0) {
+        output += `**Active branches:** ${data.active_branches.map((b) => `\`${b.name}\``).join(', ')}`;
+    }
+    return output.trim();
+}

package/dist/tools/save-from-agent.d.ts

@@ -52,6 +52,7 @@ export declare const saveFromAgentSchema: {
                     };
                     decision_type: {
                         type: "string";
+                        enum: string[];
                         description: string;
                     };
                     durability: {
@@ -60,6 +61,10 @@ export declare const saveFromAgentSchema: {
                     };
                 };
             };
+            register_as_pattern: {
+                type: "boolean";
+                description: string;
+            };
         };
         required: ("title" | "content")[];
     };

package/dist/tools/save-from-agent.js

@@ -3,20 +3,20 @@ import { detectProject } from '../lib/project-detector.js';
 import * as session from '../lib/session-state.js';
 export const saveFromAgentSchema = {
     name: 'save_from_agent',
-    description: `Save knowledge to Splicr. Call this in two scenarios:
-
-1. When the user explicitly asks to save/remember something
-2. At the end of significant sessions — save decisions, discoveries, and workarounds (NOT routine actions)
-
-For auto-save at session end, include the "context" field with attribution metadata.
-
-**Memory types** (use memory_type to categorize):
-- "fact" — permanent knowledge (API uses X pattern, team decided Y). Default if omitted.
-- "procedural" — reusable how-to (deploy steps, workarounds, setup instructions)
-- "episodic" — session-level context (what happened this session, investigation results)
-- "scratchpad" — short-lived working memory (temp notes, in-progress thinking)
-
-What to save: decisions (chose X over Y because...), discoveries (found undocumented behavior), workarounds (non-obvious fix), synthesis (combined multiple insights).
+    description: `Save knowledge to Splicr. Call this in two scenarios:
+
+1. When the user explicitly asks to save/remember something
+2. At the end of significant sessions — save decisions, discoveries, and workarounds (NOT routine actions)
+
+For auto-save at session end, include the "context" field with attribution metadata.
+
+**Memory types** (use memory_type to categorize):
+- "fact" — permanent knowledge (API uses X pattern, team decided Y). Default if omitted.
+- "procedural" — reusable how-to (deploy steps, workarounds, setup instructions)
+- "episodic" — session-level context (what happened this session, investigation results)
+- "scratchpad" — short-lived working memory (temp notes, in-progress thinking)
+
+What to save: decisions (chose X over Y because...), discoveries (found undocumented behavior), workarounds (non-obvious fix), synthesis (combined multiple insights).
 What NOT to save: file edits (git has those), routine commands, anything derivable from reading the code.`,
     inputSchema: {
         type: 'object',
@@ -37,10 +37,14 @@ What NOT to save: file edits (git has those), routine commands, anything derivab
                     agent: { type: 'string', description: 'Agent/model name (e.g. "claude-opus-4-6")' },
                     files: { type: 'array', items: { type: 'string' }, description: 'Files involved in this learning' },
                     splicr_refs: { type: 'array', items: { type: 'string' }, description: 'IDs of Splicr captures referenced during this session' },
-                    decision_type: { type: 'string', description: 'Type: architecture, workaround, discovery, synthesis, or pattern' },
+                    decision_type: { type: 'string', enum: ['architecture', 'workaround', 'discovery', 'synthesis', 'pattern', 'failure'], description: 'Type: architecture, workaround, discovery, synthesis, pattern, or failure' },
                     durability: { type: 'string', description: 'How long this knowledge stays relevant: permanent, versioned, or ephemeral' },
                 },
             },
+            register_as_pattern: {
+                type: 'boolean',
+                description: 'Set true to also register this as an active project pattern (enforced across future agent sessions)',
+            },
         },
         required: ['content', 'title'],
     },
@@ -52,6 +56,7 @@ export async function handleSaveFromAgent(args) {
     const tags = args.tags || [];
     const memoryType = args.memory_type || 'fact';
     const context = args.context;
+    const registerAsPattern = args.register_as_pattern;
     // Resolve project name
     let projectName;
     if (projectArg === 'auto') {
@@ -68,6 +73,7 @@ export async function handleSaveFromAgent(args) {
         tags,
         memory_type: memoryType,
         context,
+        register_as_pattern: registerAsPattern,
     });
     if (result.duplicate) {
         return `*Already saved in Splicr:* "${title}"`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splicr/mcp-server",
-  "version": "0.10.4",
+  "version": "0.11.1",
   "description": "Splicr MCP server — route what you read to what you're building",
   "type": "module",
   "bin": "./dist/cli.js",