gitmem-mcp 1.0.2 → 1.0.4

package/dist/services/triple-writer.js

@@ -20,30 +20,21 @@ const HALF_LIFE_PROCESS = 9999;
  * Canonical persona name map.
  * Raw personas_involved values may contain full names or contextual suffixes.
  * This ensures consistent node identity in the knowledge graph.
+ *
+ * Users can populate this with their own team/persona names.
+ * Keys are lowercase, values are canonical display names.
  */
-const CANONICAL_PERSONA_NAMES = {
-    "elena vos": "Elena",
-    "elena": "Elena",
-    "marcus thorne": "Marcus",
-    "marcus": "Marcus",
-    "reiko tanaka": "Reiko",
-    "reiko": "Reiko",
-    "jax": "Jax",
-    "jax dimitri": "Jax",
-    "jax reed": "Jax",
-    "chris crawford": "Chris Crawford",
-    "chris": "Chris Crawford",
-};
+const CANONICAL_PERSONA_NAMES = {};
 /**
  * Normalize a persona label to its canonical form.
  * Strips contextual suffixes like " - UX navigation clarity" or ": Prefers non-invasive..."
  * Then maps to canonical short name if known.
  *
  * Examples:
- *   "Elena Vos" → "Elena"
- *   "Marcus - Architectural pattern" → "Marcus"
- *   "Elena: Prefers non-invasive instrumentation" → "Elena"
- *   "Chris Crawford - Process decision" → "Chris Crawford"
+ *   "Alice Smith" → "Alice" (if mapped)
+ *   "Bob - Architectural pattern" → "Bob" (if mapped)
+ *   "Alice: Prefers non-invasive instrumentation" → "Alice" (if mapped)
+ *   "Unknown Developer - Process decision" → "Unknown Developer" (passthrough)
  */
 export function normalizePersonaLabel(raw) {
     // Strip contextual suffix after " - " or ": "
@@ -54,11 +45,11 @@ export function normalizePersonaLabel(raw) {
     const canonical = CANONICAL_PERSONA_NAMES[name.toLowerCase()];
     return canonical || name;
 }
-/** Set of canonical persona names (Orchestra team members + human). */
+/** Set of canonical persona names (team members). */
 const KNOWN_PERSONAS = new Set(Object.values(CANONICAL_PERSONA_NAMES));
 /**
- * Determine if a name refers to an Orchestra persona vs an agent.
- * Returns true for Elena, Marcus, Reiko, Jax, Chris Crawford.
+ * Determine if a name refers to a known persona vs an agent.
+ * Returns true for names in the CANONICAL_PERSONA_NAMES map.
  */
 function isPersonaName(name) {
     return KNOWN_PERSONAS.has(normalizePersonaLabel(name));

package/dist/services/variant-assignment.d.ts

@@ -1,7 +1,7 @@
 /**
  * Scar Variant Assignment Service
- * OD-525: Integrates variant assignment into enforcement engine
- * OD-547: Switched from issue-keyed to agent-keyed assignment
+ * Integrates variant assignment into enforcement engine
+ * Switched from issue-keyed to agent-keyed assignment
  *
  * Handles:
  * - Random variant assignment for scars with variants
@@ -29,7 +29,7 @@ export interface ScarVariant {
 }
 /**
  * Assignment record
- * OD-547: Primary key is (agent_id, scar_id), issue_id/session_id are metadata
+ * Primary key is (agent_id, scar_id), issue_id/session_id are metadata
  */
 export interface VariantAssignment {
     id: string;
@@ -55,12 +55,12 @@ export interface ScarWithVariant {
 export declare function getActiveVariants(scarId: string): Promise<ScarVariant[]>;
 /**
  * Get existing assignment for an agent + scar pair
- * OD-547: Changed from issue-keyed to agent-keyed lookup
+ * Changed from issue-keyed to agent-keyed lookup
  */
 export declare function getExistingAssignment(agentId: string, scarId: string): Promise<VariantAssignment | null>;
 /**
  * Create random variant assignment
- * OD-547: Agent-keyed with optional issue/session metadata
+ * Agent-keyed with optional issue/session metadata
  */
 export declare function createVariantAssignment(agentId: string, scarId: string, variants: ScarVariant[], metadata?: {
     issueId?: string;
@@ -70,7 +70,7 @@ export declare function createVariantAssignment(agentId: string, scarId: string,
  * Get or create variant assignment for a scar
  * This is the main entry point for enforcement integration
  *
- * OD-547: Changed from issue-keyed to agent-keyed assignment.
+ * Changed from issue-keyed to agent-keyed assignment.
  * Agent identity is always available, so variants are always assigned.
  *
  * @param agentId - Agent identity (e.g., 'CLI', 'DAC', 'CODA-1')

package/dist/services/variant-assignment.js

@@ -1,7 +1,7 @@
 /**
  * Scar Variant Assignment Service
- * OD-525: Integrates variant assignment into enforcement engine
- * OD-547: Switched from issue-keyed to agent-keyed assignment
+ * Integrates variant assignment into enforcement engine
+ * Switched from issue-keyed to agent-keyed assignment
  *
  * Handles:
  * - Random variant assignment for scars with variants
@@ -9,6 +9,7 @@
  * - Legacy scar fallback (scars without variants use original description)
  * - Blind testing (agent doesn't know which variant they received)
  */
+import { randomInt } from "crypto";
 import * as supabase from "./supabase-client.js";
 /**
  * Get active variants for a scar
@@ -35,7 +36,7 @@ export async function getActiveVariants(scarId) {
 }
 /**
  * Get existing assignment for an agent + scar pair
- * OD-547: Changed from issue-keyed to agent-keyed lookup
+ * Changed from issue-keyed to agent-keyed lookup
  */
 export async function getExistingAssignment(agentId, scarId) {
     if (!supabase.isConfigured()) {
@@ -60,15 +61,15 @@ export async function getExistingAssignment(agentId, scarId) {
 }
 /**
  * Create random variant assignment
- * OD-547: Agent-keyed with optional issue/session metadata
+ * Agent-keyed with optional issue/session metadata
  */
 export async function createVariantAssignment(agentId, scarId, variants, metadata) {
     if (!supabase.isConfigured() || variants.length === 0) {
         return null;
     }
     try {
-        // Random selection from active variants
-        const randomIndex = Math.floor(Math.random() * variants.length);
+        // Cryptographically secure random selection for blind A/B testing integrity
+        const randomIndex = randomInt(0, variants.length);
         const selectedVariant = variants[randomIndex];
         const result = await supabase.directUpsert("variant_assignments", {
             agent_id: agentId,
@@ -86,7 +87,7 @@ export async function createVariantAssignment(agentId, scarId, variants, metadat
             console.error(`[variant-assignment] Assignment already exists (race condition), fetching...`);
             return await getExistingAssignment(agentId, scarId);
         }
-        console.error(`[variant-assignment] Exception creating assignment:`, error);
+        console.error(`[variant-assignment] Failed to create assignment for scar ${scarId}`);
         return null;
     }
 }
@@ -94,7 +95,7 @@ export async function createVariantAssignment(agentId, scarId, variants, metadat
  * Get or create variant assignment for a scar
  * This is the main entry point for enforcement integration
  *
- * OD-547: Changed from issue-keyed to agent-keyed assignment.
+ * Changed from issue-keyed to agent-keyed assignment.
  * Agent identity is always available, so variants are always assigned.
  *
  * @param agentId - Agent identity (e.g., 'CLI', 'DAC', 'CODA-1')

package/dist/tools/analyze.d.ts

@@ -1,11 +1,11 @@
 /**
- * analyze Tool (OD-567)
+ * analyze Tool
  *
  * Session analytics and insights engine. Provides structured analysis
  * of session history, closing reflections, agent patterns, and more.
  *
  * Starts with "summary" lens; expanded with additional lenses in
- * OD-568 (Tier 1), OD-569 (Tier 2), OD-570 (Tier 3), OD-572 (Tier 4).
+ * (Tier 1).
  *
  * Performance target: 3000ms
  */

package/dist/tools/analyze.js

@@ -1,11 +1,11 @@
 /**
- * analyze Tool (OD-567)
+ * analyze Tool
  *
  * Session analytics and insights engine. Provides structured analysis
  * of session history, closing reflections, agent patterns, and more.
  *
  * Starts with "summary" lens; expanded with additional lenses in
- * OD-568 (Tier 1), OD-569 (Tier 2), OD-570 (Tier 3), OD-572 (Tier 4).
+ * (Tier 1).
  *
  * Performance target: 3000ms
  */

package/dist/tools/archive-learning.js

@@ -10,6 +10,7 @@
  */
 import { directPatch, isConfigured } from "../services/supabase-client.js";
 import { hasSupabase } from "../services/tier.js";
+import { getStorage } from "../services/storage.js";
 import { flushCache } from "../services/startup.js";
 import { Timer } from "../services/metrics.js";
 import { wrapDisplay } from "../services/display-protocol.js";
@@ -26,35 +27,48 @@ export async function archiveLearning(params) {
             performance_ms: timer.stop(),
         };
     }
-    if (!hasSupabase() || !isConfigured()) {
-        const msg = "archive_learning requires Supabase (pro/dev tier)";
-        return {
-            success: false,
-            id: params.id,
-            cache_flushed: false,
-            display: wrapDisplay(msg),
-            error: msg,
-            performance_ms: timer.stop(),
-        };
-    }
     try {
         const archivedAt = new Date().toISOString();
-        await directPatch("orchestra_learnings", { id: `eq.${params.id}` }, {
-            is_active: false,
-            archived_at: archivedAt,
-        });
-        // Flush local cache so archived scar is immediately excluded
         let cacheFlushed = false;
-        try {
-            await flushCache();
-            cacheFlushed = true;
+        if (hasSupabase() && isConfigured()) {
+            // Pro/dev: patch in Supabase
+            await directPatch("orchestra_learnings", { id: `eq.${params.id}` }, {
+                is_active: false,
+                archived_at: archivedAt,
+            });
+            try {
+                await flushCache();
+                cacheFlushed = true;
+            }
+            catch {
+                console.error("[archive-learning] Cache flush failed (non-fatal)");
+            }
         }
-        catch {
-            console.error("[archive-learning] Cache flush failed (non-fatal)");
+        else {
+            // Free tier: update in local JSON
+            const storage = getStorage();
+            const existing = await storage.get("learnings", params.id);
+            if (!existing) {
+                const msg = `Learning ${params.id} not found in local storage`;
+                return {
+                    success: false,
+                    id: params.id,
+                    cache_flushed: false,
+                    display: wrapDisplay(msg),
+                    error: msg,
+                    performance_ms: timer.stop(),
+                };
+            }
+            await storage.upsert("learnings", {
+                ...existing,
+                id: params.id,
+                is_active: false,
+                archived_at: archivedAt,
+            });
         }
         const latencyMs = timer.stop();
         const reasonText = params.reason ? ` Reason: ${params.reason}` : "";
-        const display = `Archived learning ${params.id}.${reasonText}\nCache ${cacheFlushed ? "flushed" : "flush failed"} (${latencyMs}ms)`;
+        const display = `Archived learning ${params.id}.${reasonText}\n(${latencyMs}ms)`;
         return {
             success: true,
             id: params.id,

package/dist/tools/confirm-scars.js

@@ -176,12 +176,16 @@ export async function confirmScars(params) {
                 errors.push(error);
             }
             else {
+                // Derive default relevance from decision if not provided
+                const relevance = conf.relevance ??
+                    (conf.decision === "APPLYING" ? "high" : conf.decision === "N_A" ? "low" : "low");
                 validConfirmations.push({
                     scar_id: conf.scar_id,
                     scar_title: scar.scar_title,
                     decision: conf.decision,
                     evidence: conf.evidence.trim(),
                     confirmed_at: new Date().toISOString(),
+                    relevance,
                 });
                 confirmedIds.add(conf.scar_id);
             }

package/dist/tools/create-decision.d.ts

@@ -5,7 +5,7 @@
  * Generates embeddings client-side and writes directly to Supabase REST API,
  * eliminating the ww-mcp Edge Function dependency.
  *
- * Performance target: <3000ms (OD-429)
+ * Performance target: <3000ms
  */
 import type { CreateDecisionParams, CreateDecisionResult } from "../types/index.js";
 /**

package/dist/tools/create-decision.js

@@ -5,7 +5,7 @@
  * Generates embeddings client-side and writes directly to Supabase REST API,
  * eliminating the ww-mcp Edge Function dependency.
  *
- * Performance target: <3000ms (OD-429)
+ * Performance target: <3000ms
  */
 import { v4 as uuidv4 } from "uuid";
 import * as supabase from "../services/supabase-client.js";
@@ -74,7 +74,7 @@ export async function createDecision(params) {
                 cache_status: "not_applicable",
                 network_call: true,
             };
-            // OD-466: Auto-create knowledge triples (tracked fire-and-forget)
+            // Auto-create knowledge triples (tracked fire-and-forget)
             getEffectTracker().track("triple_write", "decision", () => writeTriplesForDecision({
                 id: decisionId,
                 title: params.title,

package/dist/tools/create-learning.d.ts

@@ -5,7 +5,7 @@
  * Generates embeddings client-side and writes directly to Supabase REST API,
  * eliminating the ww-mcp Edge Function dependency.
  *
- * Performance target: <3000ms (OD-429)
+ * Performance target: <3000ms
  */
 import type { CreateLearningParams, CreateLearningResult } from "../types/index.js";
 /**

package/dist/tools/create-learning.js

@@ -5,7 +5,7 @@
  * Generates embeddings client-side and writes directly to Supabase REST API,
  * eliminating the ww-mcp Edge Function dependency.
  *
- * Performance target: <3000ms (OD-429)
+ * Performance target: <3000ms
  */
 import { v4 as uuidv4 } from "uuid";
 import * as supabase from "../services/supabase-client.js";
@@ -87,7 +87,7 @@ export async function createLearning(params) {
         created_at: new Date().toISOString(),
         persona_name: agentIdentity,
         source_date: new Date().toISOString().split("T")[0],
-        // OD-508: LLM-cooperative enforcement fields (optional)
+        // LLM-cooperative enforcement fields (optional)
         ...(params.why_this_matters && { why_this_matters: params.why_this_matters }),
         ...(params.action_protocol && { action_protocol: params.action_protocol }),
         ...(params.self_check_criteria && { self_check_criteria: params.self_check_criteria }),
@@ -151,14 +151,14 @@ export async function createLearning(params) {
                 cache_status: "not_applicable",
                 network_call: true,
             };
-            // OD-539: Defense in depth - verify write succeeded
+            // Defense in depth - verify write succeeded
             // directUpsert now throws on empty result, but explicit check documents expectation
             if (!writeResult || !writeResult.id) {
                 throw new Error(`Write verification failed: directUpsert returned ${writeResult ? 'record without id' : 'null/undefined'}. ` +
                     `Expected record with id field.`);
             }
             console.error(`[create_learning] directUpsert succeeded, verified ID: ${writeResult.id}`);
-            // OD-466: Auto-create knowledge triples (tracked fire-and-forget)
+            // Auto-create knowledge triples (tracked fire-and-forget)
             getEffectTracker().track("triple_write", "learning", () => writeTriplesForLearning({
                 id: learningId,
                 learning_type: params.learning_type,

package/dist/tools/create-linear-issue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * create_linear_issue Tool (OD-611)
+ *
+ * Proxy Linear issue creation via GraphQL API.
+ * Returns slim response (~50 tokens) instead of Linear MCP's ~1400 tokens.
+ *
+ * Pattern: File-based payload handoff (same as session_close).
+ * Agent writes description to .gitmem/issue-payload.json, then calls this
+ * tool with title + teamId inline. Tool reads, merges, calls Linear, deletes file.
+ *
+ * Performance target: <2000ms (one network call)
+ */
+import type { CreateLinearIssueParams, CreateLinearIssueResult } from "../types/index.js";
+/**
+ * Create a Linear issue via GraphQL API with slim response.
+ */
+export declare function createLinearIssue(params: CreateLinearIssueParams): Promise<CreateLinearIssueResult>;
+//# sourceMappingURL=create-linear-issue.d.ts.map

package/dist/tools/create-linear-issue.js

@@ -0,0 +1,197 @@
+/**
+ * create_linear_issue Tool (OD-611)
+ *
+ * Proxy Linear issue creation via GraphQL API.
+ * Returns slim response (~50 tokens) instead of Linear MCP's ~1400 tokens.
+ *
+ * Pattern: File-based payload handoff (same as session_close).
+ * Agent writes description to .gitmem/issue-payload.json, then calls this
+ * tool with title + teamId inline. Tool reads, merges, calls Linear, deletes file.
+ *
+ * Performance target: <2000ms (one network call)
+ */
+import * as fs from "fs";
+import { v4 as uuidv4 } from "uuid";
+import { getGitmemPath } from "../services/gitmem-dir.js";
+import { Timer, buildPerformanceData, recordMetrics, } from "../services/metrics.js";
+import { getEffectTracker } from "../services/effect-tracker.js";
+const LINEAR_API_URL = "https://api.linear.app/graphql";
+/** GraphQL mutation — request only the fields needed for the slim response */
+const ISSUE_CREATE_MUTATION = `
+  mutation IssueCreate($input: IssueCreateInput!) {
+    issueCreate(input: $input) {
+      success
+      issue {
+        id
+        identifier
+        url
+        state {
+          name
+        }
+      }
+    }
+  }
+`;
+/**
+ * Create a Linear issue via GraphQL API with slim response.
+ */
+export async function createLinearIssue(params) {
+    const timer = new Timer();
+    const metricsId = uuidv4();
+    // 1. Check LINEAR_API_KEY
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey) {
+        const latencyMs = timer.stop();
+        return {
+            success: false,
+            error: "LINEAR_API_KEY environment variable is not set. Add it to your MCP server configuration.",
+            performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+        };
+    }
+    // 2. Load file-based payload (same pattern as session_close)
+    const payloadPath = params.payload_path || getGitmemPath("issue-payload.json");
+    let filePayload = {};
+    try {
+        if (fs.existsSync(payloadPath)) {
+            filePayload = JSON.parse(fs.readFileSync(payloadPath, "utf-8"));
+            console.error(`[create_linear_issue] Loaded payload from ${payloadPath}`);
+            // Clean up payload file after reading
+            try {
+                fs.unlinkSync(payloadPath);
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+    }
+    catch (error) {
+        console.error("[create_linear_issue] Failed to read issue-payload.json:", error);
+    }
+    // 3. Merge: inline params override file payload
+    const teamId = params.teamId || filePayload.teamId;
+    const title = params.title || filePayload.title;
+    if (!teamId || !title) {
+        const latencyMs = timer.stop();
+        return {
+            success: false,
+            error: "teamId and title are required. Provide inline or in .gitmem/issue-payload.json.",
+            performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+        };
+    }
+    // 4. Build IssueCreateInput for GraphQL
+    const input = {
+        teamId,
+        title,
+    };
+    // Description only comes from file payload (the large field)
+    if (filePayload.description) {
+        input.description = filePayload.description;
+    }
+    // Merge optional fields — inline overrides file
+    if (params.priority !== undefined || filePayload.priority !== undefined) {
+        input.priority = params.priority ?? filePayload.priority;
+    }
+    if (params.labelIds?.length || filePayload.labelIds?.length) {
+        input.labelIds = params.labelIds || filePayload.labelIds;
+    }
+    if (params.projectId || filePayload.projectId) {
+        input.projectId = params.projectId || filePayload.projectId;
+    }
+    if (params.assigneeId || filePayload.assigneeId) {
+        input.assigneeId = params.assigneeId || filePayload.assigneeId;
+    }
+    if (params.parentId || filePayload.parentId) {
+        input.parentId = params.parentId || filePayload.parentId;
+    }
+    if (params.stateId || filePayload.stateId) {
+        input.stateId = params.stateId || filePayload.stateId;
+    }
+    if (params.estimate !== undefined || filePayload.estimate !== undefined) {
+        input.estimate = params.estimate ?? filePayload.estimate;
+    }
+    // 5. Call Linear GraphQL API
+    try {
+        const response = await fetch(LINEAR_API_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: apiKey,
+            },
+            body: JSON.stringify({
+                query: ISSUE_CREATE_MUTATION,
+                variables: { input },
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            const latencyMs = timer.stop();
+            return {
+                success: false,
+                error: `Linear API HTTP ${response.status}: ${text.slice(0, 200)}`,
+                performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+            };
+        }
+        const data = (await response.json());
+        // Handle GraphQL errors
+        if (data.errors?.length) {
+            const latencyMs = timer.stop();
+            return {
+                success: false,
+                error: `Linear GraphQL error: ${data.errors.map((e) => e.message).join("; ")}`,
+                performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+            };
+        }
+        const issueCreate = data.data?.issueCreate;
+        if (!issueCreate?.success || !issueCreate.issue) {
+            const latencyMs = timer.stop();
+            return {
+                success: false,
+                error: "Linear API returned unsuccessful issueCreate",
+                performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+            };
+        }
+        const issue = issueCreate.issue;
+        const latencyMs = timer.stop();
+        // 6. Fire-and-forget metrics recording
+        getEffectTracker().track("metrics", "create_linear_issue", () => recordMetrics({
+            id: metricsId,
+            tool_name: "create_linear_issue",
+            latency_ms: latencyMs,
+            result_count: 1,
+            metadata: {
+                identifier: issue.identifier,
+                teamId,
+                has_description: !!filePayload.description,
+            },
+        }));
+        // 7. Return slim response (~50 tokens vs ~1400)
+        return {
+            success: true,
+            identifier: issue.identifier,
+            url: issue.url,
+            id: issue.id,
+            state: issue.state?.name,
+            performance: buildPerformanceData("create_linear_issue", latencyMs, 1, {
+                breakdown: {
+                    upsert: {
+                        latency_ms: latencyMs,
+                        source: "supabase",
+                        cache_status: "not_applicable",
+                        network_call: true,
+                    },
+                },
+            }),
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("[create_linear_issue] Failed:", error);
+        const latencyMs = timer.stop();
+        return {
+            success: false,
+            error: `Linear API call failed: ${errorMessage}`,
+            performance: buildPerformanceData("create_linear_issue", latencyMs, 0),
+        };
+    }
+}
+//# sourceMappingURL=create-linear-issue.js.map

package/dist/tools/create-thread.d.ts

@@ -4,7 +4,7 @@
  * Create an open thread outside of session close. Threads track
  * unresolved work items that carry across sessions.
  *
- * OD-620: Writes to Supabase (source of truth) + local file (cache).
+ * Writes to Supabase (source of truth) + local file (cache).
  * Falls back to local-only if Supabase is unavailable.
  *
  * Phase 3: Semantic dedup gate — before creating, checks existing open

package/dist/tools/create-thread.js

@@ -4,7 +4,7 @@
  * Create an open thread outside of session close. Threads track
  * unresolved work items that carry across sessions.
  *
- * OD-620: Writes to Supabase (source of truth) + local file (cache).
+ * Writes to Supabase (source of truth) + local file (cache).
  * Falls back to local-only if Supabase is unavailable.
  *
  * Phase 3: Semantic dedup gate — before creating, checks existing open
@@ -123,7 +123,7 @@ export async function createThread(params) {
         created_at: new Date().toISOString(),
         ...(sessionId && { source_session: sessionId }),
     };
-    // OD-620: Write to Supabase (source of truth) with embedding — non-blocking on failure
+    // Write to Supabase (source of truth) with embedding — non-blocking on failure
     let supabaseSynced = false;
     const embeddingJson = newEmbedding ? JSON.stringify(newEmbedding) : null;
     const supabaseResult = await createThreadInSupabase(thread, project, embeddingJson);