feat(memory): auto-sync steering index on memory changes

The memory MCP now automatically generates and maintains a steering
file (team-memories-index.md) with an index of all active memories.

The index is synced on:
- Store load (MCP startup)
- add_memory
- archive_memory
- remove_memory

Editor detection is automatic — writes to .kiro/steering/ and/or
.cursor/rules/ based on which directories exist.

Bumps @arvoretech/memory-mcp to 1.3.0

Author: Joao208

packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvoretech/memory-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "MCP server for team memory — persistent knowledge base with semantic search for AI-assisted development",
   "main": "dist/index.js",
   "type": "module",

packages/memory/src/store.ts

@@ -1,5 +1,5 @@
 import { readFile, readdir, writeFile, mkdir, rm, stat } from "node:fs/promises";
-import { join, basename } from "node:path";
+import { join, basename, resolve, dirname } from "node:path";
 import { existsSync } from "node:fs";
 import { createHash } from "node:crypto";
 import * as lancedb from "@lancedb/lancedb";
@@ -15,6 +15,35 @@ import {
   MemoryMCPError,
 } from "./types.js";
 
+interface SteeringTarget {
+  dir: string;
+  buildContent: (body: string) => string;
+}
+
+function detectSteeringTargets(workspaceRoot: string): SteeringTarget[] {
+  const targets: SteeringTarget[] = [];
+
+  const kiroSteering = join(workspaceRoot, ".kiro", "steering");
+  if (existsSync(kiroSteering)) {
+    targets.push({
+      dir: kiroSteering,
+      buildContent: (body) =>
+        `---\ninclusion: always\nname: team-memories-index\n---\n\n${body}\n`,
+    });
+  }
+
+  const cursorRules = join(workspaceRoot, ".cursor", "rules");
+  if (existsSync(cursorRules)) {
+    targets.push({
+      dir: cursorRules,
+      buildContent: (body) =>
+        `---\ndescription: "Team memories index — active knowledge base"\nalwaysApply: true\n---\n\n${body}\n`,
+    });
+  }
+
+  return targets;
+}
+
 function vectorRecord(entry: MemoryEntry, vector: number[], contentHash: string): Record<string, unknown> {
   return {
     id: entry.id,
@@ -31,6 +60,7 @@ function vectorRecord(entry: MemoryEntry, vector: number[], contentHash: string)
 
 export class MemoryStore {
   private memoriesPath: string;
+  private workspaceRoot: string;
   private catalog: MemoryEntry[] = [];
   private embeddings: EmbeddingEngine;
   private db: lancedb.Connection | null = null;
@@ -40,9 +70,19 @@ export class MemoryStore {
 
   constructor(memoriesPath: string, embeddingModel?: string) {
     this.memoriesPath = memoriesPath;
+    this.workspaceRoot = this.resolveWorkspaceRoot(memoriesPath);
     this.embeddings = new EmbeddingEngine(embeddingModel);
   }
 
+  private resolveWorkspaceRoot(memoriesPath: string): string {
+    const abs = resolve(memoriesPath);
+    const parent = dirname(abs);
+    if (existsSync(join(parent, ".kiro")) || existsSync(join(parent, ".cursor")) || existsSync(join(parent, ".git"))) {
+      return parent;
+    }
+    return parent;
+  }
+
   async load(): Promise<void> {
     this.loadingPromise = this.doLoad();
     return this.loadingPromise;
@@ -93,6 +133,58 @@ export class MemoryStore {
     }
 
     this.loaded = true;
+
+    await this.syncSteeringIndex();
+  }
+
+  async syncSteeringIndex(): Promise<void> {
+    try {
+      const targets = detectSteeringTargets(this.workspaceRoot);
+      if (targets.length === 0) return;
+
+      const active = this.catalog.filter((m) => m.status === "active");
+      const grouped = new Map<string, MemoryEntry[]>();
+
+      for (const entry of active) {
+        const list = grouped.get(entry.category) || [];
+        list.push(entry);
+        grouped.set(entry.category, list);
+      }
+
+      const lines: string[] = [
+        "# Team Memories Index",
+        "",
+        `Total: ${active.length} active memories. Use \`get_memory(id)\` to read full content.`,
+        "",
+      ];
+
+      for (const category of VALID_CATEGORIES) {
+        const entries = grouped.get(category);
+        if (!entries || entries.length === 0) continue;
+
+        lines.push(`## ${category} (${entries.length})`);
+        lines.push("");
+
+        for (const entry of entries) {
+          const tags = entry.tags.length > 0 ? ` [${entry.tags.join(", ")}]` : "";
+          lines.push(`- **${entry.title}**${tags} → \`${entry.id}\``);
+        }
+
+        lines.push("");
+      }
+
+      const body = lines.join("\n");
+
+      for (const target of targets) {
+        const filePath = join(target.dir, "team-memories-index.md");
+        const content = target.buildContent(body);
+        await writeFile(filePath, content, "utf-8");
+      }
+
+      console.error(`Synced steering index (${active.length} memories, ${targets.length} target(s))`);
+    } catch (error) {
+      console.error(`Failed to sync steering index: ${error instanceof Error ? error.message : error}`);
+    }
   }
 
   private async syncVectorStore(): Promise<void> {
@@ -364,6 +456,8 @@ export class MemoryStore {
       }
     }
 
+    await this.syncSteeringIndex();
+
     return entry;
   }
 
@@ -385,6 +479,8 @@ export class MemoryStore {
       await this.table.update({ where: `id = '${id}'`, values: { status: "archived" } });
     }
 
+    await this.syncSteeringIndex();
+
     return entry;
   }
 
@@ -400,6 +496,8 @@ export class MemoryStore {
     if (this.table) {
       await this.table.delete(`id = '${id}'`);
     }
+
+    await this.syncSteeringIndex();
   }
 
   private toCatalogEntry(entry: MemoryEntry): MemoryCatalogEntry {