@danielblomma/cortex-mcp 2.0.3 → 2.0.5

package/bin/cortex.mjs

@@ -22,17 +22,20 @@ const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const SCAFFOLD_ROOT = path.join(PACKAGE_ROOT, "scaffold");
 const PACKAGE_JSON_PATH = path.join(PACKAGE_ROOT, "package.json");
 
+// v2.0.5: project layout moved mcp/ under .context/mcp/, and the
+// gitignore policy flipped to "ignore everything in .context/, whitelist
+// only the three editable config files". Generated artifacts (db,
+// embeddings, cache, hooks, mcp/, govern.local.json) never land in git.
+const MCP_PROJECT_REL = path.join(".context", "mcp");
+
 const GITIGNORE_LINES = [
   "",
   "# Cortex local storage",
-  ".context/db/",
-  ".context/embeddings/",
-  ".context/cache/",
-  ".context/hooks/",
-  ".npm-cache/",
-  "mcp/.npm-cache/",
-  "mcp/dist/",
-  "mcp/node_modules/"
+  ".context/",
+  "!.context/config.yaml",
+  "!.context/rules.yaml",
+  "!.context/ontology.cypher",
+  ".npm-cache/"
 ];
 
 function printBanner(title) {
@@ -199,7 +202,6 @@ const INIT_SKIP_DIRECTORIES = new Set([
   ".cache",
   ".context",
   "scripts",
-  "mcp",
   ".githooks",
   "bin",
   "obj"
@@ -439,11 +441,26 @@ function mergeGitignore(targetDir) {
   fs.writeFileSync(gitignorePath, merged, "utf8");
 }
 
+function migrateLegacyMcpLocation(targetDir) {
+  const legacyMcp = path.join(targetDir, "mcp");
+  const newMcp = path.join(targetDir, MCP_PROJECT_REL);
+  if (!fs.existsSync(legacyMcp)) return;
+  if (fs.existsSync(newMcp)) return;
+  fs.mkdirSync(path.join(targetDir, ".context"), { recursive: true });
+  fs.renameSync(legacyMcp, newMcp);
+  console.log(
+    "[cortex] migrated legacy mcp/ → .context/mcp/ to keep project root clean. " +
+      "Re-run 'cortex connect' if Claude/Codex MCP registrations need to be refreshed.",
+  );
+}
+
 function installScaffold(targetDir, force) {
+  migrateLegacyMcpLocation(targetDir);
+
   const copyMap = [
     [path.join(SCAFFOLD_ROOT, ".context"), path.join(targetDir, ".context")],
     [path.join(SCAFFOLD_ROOT, "scripts"), path.join(targetDir, "scripts")],
-    [path.join(SCAFFOLD_ROOT, "mcp"), path.join(targetDir, "mcp")],
+    [path.join(SCAFFOLD_ROOT, "mcp"), path.join(targetDir, MCP_PROJECT_REL)],
     [path.join(SCAFFOLD_ROOT, ".githooks"), path.join(targetDir, ".githooks")]
   ];
 
@@ -633,7 +650,7 @@ async function connectClaude(targetDir) {
   }
 
   const serverName = "cortex";
-  const projectServerEntry = path.join("mcp", "dist", "server.js");
+  const projectServerEntry = path.join(MCP_PROJECT_REL, "dist", "server.js");
   await runCommandResult("claude", ["mcp", "remove", "-s", "project", serverName], targetDir, "ignore");
   await runCommand(
     "claude",
@@ -646,7 +663,7 @@ async function connectClaude(targetDir) {
 
 async function connectMcpClients(targetDir, options = {}) {
   const { skipBuild = false } = options;
-  const mcpDir = path.join(targetDir, "mcp");
+  const mcpDir = path.join(targetDir, MCP_PROJECT_REL);
   const packageJson = path.join(mcpDir, "package.json");
   const nodeModules = path.join(mcpDir, "node_modules");
   const serverEntry = path.join(mcpDir, "dist", "server.js");
@@ -662,7 +679,7 @@ async function connectMcpClients(targetDir, options = {}) {
       console.log(`[cortex] MCP build failed, continuing with existing dist output: ${toErrorMessage(error)}`);
     }
   } else if (!skipBuild) {
-    console.log("[cortex] mcp/node_modules not found, skipping build (run cortex bootstrap first)");
+    console.log("[cortex] .context/mcp/node_modules not found, skipping build (run cortex bootstrap first)");
   }
 
   if (!fs.existsSync(serverEntry)) {
@@ -716,7 +733,7 @@ async function maybeInstallGitHooks(targetDir) {
 }
 
 function ensureProjectInitialized(targetDir) {
-  const mcpPackageJson = path.join(targetDir, "mcp", "package.json");
+  const mcpPackageJson = path.join(targetDir, MCP_PROJECT_REL, "package.json");
   if (!fs.existsSync(mcpPackageJson)) {
     throw new Error(`Missing ${mcpPackageJson}. Run 'cortex init --bootstrap' first.`);
   }
@@ -731,7 +748,9 @@ function isTruthyEnv(value) {
 }
 
 function canAutoInitialize(targetDir) {
-  const scaffoldPaths = [".context", "scripts", "mcp", ".githooks"].map((entry) => path.join(targetDir, entry));
+  // Legacy mcp/ at root no longer counted — pre-v2.0.5 projects are migrated
+  // by installScaffold rather than blocking auto-init.
+  const scaffoldPaths = [".context", "scripts", ".githooks"].map((entry) => path.join(targetDir, entry));
   return scaffoldPaths.every((entryPath) => !fs.existsSync(entryPath));
 }
 
@@ -744,7 +763,12 @@ function isScaffoldOutOfDate(targetDir) {
   if (!fs.existsSync(doctorScript)) {
     return true;
   }
-  const mcpPackage = path.join(targetDir, "mcp", "package.json");
+  // Treat legacy mcp/ at project root as out-of-date so existing installs
+  // get migrated into .context/mcp/ on the next bootstrap.
+  if (fs.existsSync(path.join(targetDir, "mcp", "package.json"))) {
+    return true;
+  }
+  const mcpPackage = path.join(targetDir, MCP_PROJECT_REL, "package.json");
   if (!fs.existsSync(mcpPackage)) {
     return true;
   }
@@ -780,7 +804,8 @@ async function maybeMigrateScaffold(targetDir, command) {
 
   console.error(
     `[cortex] scaffold in ${targetDir} is out of date ` +
-      `(missing scripts/doctor.sh, mcp/package.json, or doctor subcommand in context.sh).`
+      `(missing scripts/doctor.sh, .context/mcp/package.json, doctor subcommand in context.sh, ` +
+      `or carries a legacy mcp/ directory at the project root).`
   );
 
   let proceed = autoYes;
@@ -808,8 +833,8 @@ async function maybeMigrateScaffold(targetDir, command) {
 }
 
 async function ensureProjectInitializedForMcp(targetDir) {
-  const mcpPackageJson = path.join(targetDir, "mcp", "package.json");
-  const serverEntry = path.join(targetDir, "mcp", "dist", "server.js");
+  const mcpPackageJson = path.join(targetDir, MCP_PROJECT_REL, "package.json");
+  const serverEntry = path.join(targetDir, MCP_PROJECT_REL, "dist", "server.js");
 
   if (fs.existsSync(mcpPackageJson) && fs.existsSync(serverEntry)) {
     return;
@@ -947,7 +972,7 @@ async function run() {
     process.env.CORTEX_PROJECT_ROOT = target;
     await ensureProjectInitializedForMcp(target);
     ensureProjectInitialized(target);
-    const serverEntry = path.join(target, "mcp", "dist", "server.js");
+    const serverEntry = path.join(target, MCP_PROJECT_REL, "dist", "server.js");
     if (!fs.existsSync(serverEntry)) {
       throw new Error(`Missing ${serverEntry}. Run 'cortex bootstrap' in ${target} first.`);
     }
@@ -1038,12 +1063,12 @@ function isPidAlive(pid) {
 }
 
 function resolveProjectMcpDist() {
-  // v2.0.0: daemon/hooks/cli are built into the project's mcp/dist/
-  // (via 'cortex bootstrap'). PACKAGE_ROOT/scaffold/mcp/ is the source
-  // tree the scaffold is copied from. The actual built code lives in
-  // each project's <cwd>/mcp/dist/ after bootstrap.
+  // v2.0.5: project layout was moved from <cwd>/mcp/ to <cwd>/.context/mcp/.
+  // PACKAGE_ROOT/scaffold/mcp/ is still the source tree the scaffold is
+  // copied from; the actual built code lives in each project's
+  // <cwd>/.context/mcp/dist/ after bootstrap.
   const target = process.env.CORTEX_PROJECT_ROOT?.trim() || process.cwd();
-  return path.join(target, "mcp", "dist");
+  return path.join(target, MCP_PROJECT_REL, "dist");
 }
 
 function resolveDaemonEntry() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielblomma/cortex-mcp",
   "mcpName": "io.github.DanielBlomma/cortex",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Local, repo-scoped context platform for coding assistants. Semantic search, graph relationships, and architectural rule context.",
   "type": "module",
   "author": "Daniel Blomma",

package/scaffold/mcp/src/daemon/main.ts

@@ -27,6 +27,7 @@ import {
   emitTamperAudit,
 } from "./heartbeat-tracker.js";
 import { startSyncTimer } from "./sync-checker.js";
+import { startSkillSyncTimer } from "./skill-sync-checker.js";
 import { startHostEventsPusher } from "./host-events-pusher.js";
 import { startEgressProxy } from "./egress-proxy.js";
 import { startHeartbeatPusher } from "./heartbeat-pusher.js";
@@ -345,6 +346,16 @@ async function main(): Promise<void> {
   if (process.env.CORTEX_DISABLE_HOST_EVENTS_PUSH !== "1") {
     startHostEventsPusher(process.cwd(), pushIntervalMs);
   }
+  // Skills v3: poll cortex-web for org-authored skills, write SKILL.md
+  // files into per-CLI user-scope directories. Runs at the same cadence
+  // as the govern-config sync check by default but is independently
+  // configurable.
+  const skillSyncRaw = parseInt(process.env.CORTEX_SKILL_SYNC_MS ?? "", 10);
+  const skillSyncMs =
+    Number.isFinite(skillSyncRaw) && skillSyncRaw > 0 ? skillSyncRaw : syncIntervalMs;
+  if (process.env.CORTEX_DISABLE_SKILL_SYNC !== "1") {
+    startSkillSyncTimer(process.cwd(), skillSyncMs);
+  }
 
   // Govern host heartbeat — fills host_enrollment on cortex-web so the
   // dashboard at /dashboard/govern actually shows this host.

package/scaffold/mcp/src/daemon/skill-sync-checker.ts

@@ -0,0 +1,375 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+import { loadEnterpriseConfig } from "../core/config.js";
+import { writeHostAuditEvent } from "./ungoverned-scanner.js";
+import { daemonDir } from "./paths.js";
+
+/**
+ * Skills v3 sync flow — daemon side.
+ *
+ * The daemon polls cortex-web /api/v1/govern/skills/manifest each tick to
+ * learn what skills the org has authored. It diffs against a local state
+ * file, then for each new/changed skill it fetches the assembled SKILL.md
+ * and writes it to the appropriate per-CLI skills directory. Removed
+ * skills are unlinked. Unlike govern-config sync, this does NOT need
+ * root: SKILL.md files live in user-owned directories the daemon can
+ * write to directly.
+ *
+ * Three audit outcomes per tick:
+ *  - skills_unchanged   — manifest matches local state
+ *  - skills_synced      — at least one skill was written or removed
+ *                         (metadata: added/changed/removed counts)
+ *  - skills_sync_failed — network / auth / disk error
+ *
+ * When something changes, a notification file is written so
+ * 'cortex enterprise status' can prompt the user to restart Claude
+ * Code / Codex CLI to pick up the new skills.
+ */
+
+const STATE_FILENAME = "skills.local.json";
+const NOTIFICATION_FILENAME = ".skills-update-applied.json";
+
+const SUPPORTED_CLIS = ["claude", "codex"] as const;
+type SkillCli = (typeof SUPPORTED_CLIS)[number];
+
+type ManifestEntry = {
+  name: string;
+  scope: string;
+  updated_at: string;
+};
+
+type LocalSkillRecord = {
+  scope: string;
+  updated_at: string;
+  path: string;
+};
+
+type LocalSkillsState = {
+  skills: Record<string, LocalSkillRecord>;
+  last_synced_at?: string;
+};
+
+export type SkillSyncOutcome =
+  | {
+      kind: "unchanged";
+      cli: SkillCli;
+      count: number;
+    }
+  | {
+      kind: "synced";
+      cli: SkillCli;
+      added: string[];
+      changed: string[];
+      removed: string[];
+    }
+  | {
+      kind: "failed";
+      cli: SkillCli;
+      error: string;
+    };
+
+function stateFilePath(): string {
+  return join(daemonDir(), STATE_FILENAME);
+}
+
+function notificationFilePath(): string {
+  return join(daemonDir(), NOTIFICATION_FILENAME);
+}
+
+function readState(): LocalSkillsState {
+  const path = stateFilePath();
+  if (!existsSync(path)) return { skills: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as LocalSkillsState;
+    return { skills: parsed.skills ?? {}, last_synced_at: parsed.last_synced_at };
+  } catch {
+    return { skills: {} };
+  }
+}
+
+function writeState(state: LocalSkillsState): void {
+  writeFileSync(
+    stateFilePath(),
+    JSON.stringify(state, null, 2) + "\n",
+    "utf8",
+  );
+}
+
+/**
+ * Resolve the on-disk SKILL.md path for a skill. Global skills live under
+ * ~/.claude/skills (Claude Code's user-scope skills directory); cli:codex
+ * skills live under ~/.codex/skills. cli:claude scope is treated as
+ * Claude-only and lands in ~/.claude/skills.
+ */
+function skillFilePath(scope: string, name: string): string {
+  const root =
+    scope === "cli:codex"
+      ? join(homedir(), ".codex", "skills")
+      : join(homedir(), ".claude", "skills");
+  return join(root, name, "SKILL.md");
+}
+
+function shouldSyncForCli(scope: string, cli: SkillCli): boolean {
+  if (scope === "global") return true;
+  return scope === `cli:${cli}`;
+}
+
+async function fetchManifest(
+  baseUrl: string,
+  apiKey: string,
+  cli: SkillCli,
+): Promise<ManifestEntry[]> {
+  const url = new URL(
+    baseUrl.replace(/\/$/, "") + "/api/v1/govern/skills/manifest",
+  );
+  url.searchParams.set("cli", cli);
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  }
+  const body = (await res.json()) as { skills?: ManifestEntry[] };
+  return body.skills ?? [];
+}
+
+async function fetchSkillBody(
+  baseUrl: string,
+  apiKey: string,
+  name: string,
+): Promise<string> {
+  const url = new URL(
+    baseUrl.replace(/\/$/, "") +
+      "/api/v1/govern/skills/" +
+      encodeURIComponent(name),
+  );
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  }
+  return res.text();
+}
+
+function writeSkillFile(path: string, content: string): void {
+  const dir = path.replace(/\/SKILL\.md$/, "");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, content, "utf8");
+}
+
+function removeSkillFile(path: string): void {
+  if (!existsSync(path)) return;
+  // Remove the per-skill directory (parent of SKILL.md). The skills root
+  // is shared with non-Cortex skills so we never recurse beyond the
+  // skill's own directory.
+  const dir = path.replace(/\/SKILL\.md$/, "");
+  rmSync(dir, { recursive: true, force: true });
+}
+
+function writeNotification(data: {
+  added: number;
+  changed: number;
+  removed: number;
+  cli: SkillCli;
+  detected_at: string;
+}): void {
+  writeFileSync(
+    notificationFilePath(),
+    JSON.stringify(data, null, 2) + "\n",
+    "utf8",
+  );
+}
+
+export async function runSkillSyncForCli(
+  cwd: string,
+  cli: SkillCli,
+): Promise<SkillSyncOutcome> {
+  const config = loadEnterpriseConfig(join(cwd, ".context"));
+  const apiKey = config.enterprise.api_key.trim();
+  const baseUrl = (config.enterprise.base_url || config.enterprise.endpoint).trim();
+  if (!apiKey || !baseUrl) {
+    return { kind: "failed", cli, error: "enterprise not configured" };
+  }
+
+  let manifest: ManifestEntry[];
+  try {
+    manifest = await fetchManifest(baseUrl, apiKey, cli);
+  } catch (err) {
+    return {
+      kind: "failed",
+      cli,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+
+  const state = readState();
+  const relevantManifest = manifest.filter((entry) =>
+    shouldSyncForCli(entry.scope, cli),
+  );
+  const remoteByName = new Map(relevantManifest.map((e) => [e.name, e]));
+
+  const added: string[] = [];
+  const changed: string[] = [];
+  const removed: string[] = [];
+
+  // Detect adds + changes
+  for (const entry of relevantManifest) {
+    const local = state.skills[entry.name];
+    const isNew = !local;
+    const isChanged =
+      Boolean(local) &&
+      (local.updated_at !== entry.updated_at || local.scope !== entry.scope);
+    if (!isNew && !isChanged) continue;
+
+    let body: string;
+    try {
+      body = await fetchSkillBody(baseUrl, apiKey, entry.name);
+    } catch (err) {
+      return {
+        kind: "failed",
+        cli,
+        error:
+          err instanceof Error
+            ? `fetch ${entry.name}: ${err.message}`
+            : `fetch ${entry.name}: ${String(err)}`,
+      };
+    }
+
+    const path = skillFilePath(entry.scope, entry.name);
+    try {
+      writeSkillFile(path, body);
+    } catch (err) {
+      return {
+        kind: "failed",
+        cli,
+        error:
+          err instanceof Error
+            ? `write ${entry.name}: ${err.message}`
+            : `write ${entry.name}: ${String(err)}`,
+      };
+    }
+
+    state.skills[entry.name] = {
+      scope: entry.scope,
+      updated_at: entry.updated_at,
+      path,
+    };
+    (isNew ? added : changed).push(entry.name);
+  }
+
+  // Detect removes — entries we have locally for this cli but the manifest
+  // dropped (or disabled). We only consider state entries whose scope
+  // matches this cli, so we don't accidentally remove the other CLI's
+  // skills when running a per-cli tick.
+  for (const [name, record] of Object.entries(state.skills)) {
+    if (!shouldSyncForCli(record.scope, cli)) continue;
+    if (remoteByName.has(name)) continue;
+    try {
+      removeSkillFile(record.path);
+    } catch {
+      // best-effort; if unlink fails the next tick will retry
+    }
+    delete state.skills[name];
+    removed.push(name);
+  }
+
+  const totalChanged = added.length + changed.length + removed.length;
+  if (totalChanged === 0) {
+    return { kind: "unchanged", cli, count: relevantManifest.length };
+  }
+
+  state.last_synced_at = new Date().toISOString();
+  writeState(state);
+  return { kind: "synced", cli, added, changed, removed };
+}
+
+export async function runSkillSyncOnce(
+  cwd: string,
+  clis: ReadonlyArray<SkillCli> = SUPPORTED_CLIS,
+): Promise<SkillSyncOutcome[]> {
+  const outcomes: SkillSyncOutcome[] = [];
+  const now = new Date().toISOString();
+
+  for (const cli of clis) {
+    const outcome = await runSkillSyncForCli(cwd, cli);
+    outcomes.push(outcome);
+
+    const eventBase = {
+      timestamp: now,
+      host_id: hostname(),
+      cli,
+    };
+
+    if (outcome.kind === "unchanged") {
+      await writeHostAuditEvent(cwd, {
+        ...eventBase,
+        event_type: "skills_unchanged",
+        count: outcome.count,
+      }).catch(() => undefined);
+    } else if (outcome.kind === "synced") {
+      await writeHostAuditEvent(cwd, {
+        ...eventBase,
+        event_type: "skills_synced",
+        added: outcome.added,
+        changed: outcome.changed,
+        removed: outcome.removed,
+      }).catch(() => undefined);
+      writeNotification({
+        added: outcome.added.length,
+        changed: outcome.changed.length,
+        removed: outcome.removed.length,
+        cli,
+        detected_at: now,
+      });
+    } else {
+      await writeHostAuditEvent(cwd, {
+        ...eventBase,
+        event_type: "skills_sync_failed",
+        error: outcome.error,
+      }).catch(() => undefined);
+    }
+  }
+
+  // We deliberately leave the notification file in place when this tick
+  // had no changes — it represents "restart pending" from a prior sync,
+  // not current drift. `cortex enterprise status --acknowledge-skills`
+  // (future CLI) will be the explicit clear path.
+
+  return outcomes;
+}
+
+export type SkillSyncTimerHandle = {
+  stop(): void;
+};
+
+export function startSkillSyncTimer(
+  cwd: string,
+  intervalMs: number,
+): SkillSyncTimerHandle {
+  const tick = () => {
+    void runSkillSyncOnce(cwd).catch((err) => {
+      process.stderr.write(
+        `[cortex-daemon] skill sync failed: ${
+          err instanceof Error ? err.message : String(err)
+        }\n`,
+      );
+    });
+  };
+
+  void Promise.resolve().then(tick);
+  const handle = setInterval(tick, intervalMs);
+  if (typeof handle.unref === "function") handle.unref();
+  return {
+    stop() {
+      clearInterval(handle);
+    },
+  };
+}

package/scaffold/scripts/bootstrap.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-MCP_DIR="$REPO_ROOT/mcp"
+MCP_DIR="$REPO_ROOT/.context/mcp"
 TOTAL_STEPS=6
 STEP_INDEX=0
 

package/scaffold/scripts/doctor.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 CONTEXT_DIR="$REPO_ROOT/.context"
-MCP_DIR="$REPO_ROOT/mcp"
+MCP_DIR="$CONTEXT_DIR/mcp"
 
 PASS=0
 FAIL=0
@@ -165,15 +165,15 @@ echo ""
 echo "  MCP Server"
 
 if [[ -f "$MCP_DIR/dist/server.js" ]]; then
-  pass "mcp/dist/server.js exists"
+  pass ".context/mcp/dist/server.js exists"
 else
-  fail "mcp/dist/server.js missing — run: cd mcp && npm run build"
+  fail ".context/mcp/dist/server.js missing — run: cd .context/mcp && npm run build"
 fi
 
 if [[ -d "$MCP_DIR/node_modules" ]]; then
-  pass "mcp/node_modules present"
+  pass ".context/mcp/node_modules present"
 else
-  fail "mcp/node_modules missing — run: cd mcp && npm install"
+  fail ".context/mcp/node_modules missing — run: cd .context/mcp && npm install"
 fi
 
 # Quick MCP import check
@@ -181,7 +181,7 @@ if [[ -f "$MCP_DIR/dist/server.js" ]] && [[ -d "$MCP_DIR/node_modules" ]]; then
   MCP_CHECK=$(cd "$REPO_ROOT" && timeout 10 node -e '
     const start = Date.now();
     try {
-      require("./mcp/dist/graph.js");
+      require("./.context/mcp/dist/graph.js");
       console.log("ok " + (Date.now() - start));
     } catch(e) {
       console.log("fail " + e.message);

package/scaffold/scripts/embed.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-MCP_DIR="$REPO_ROOT/mcp"
+MCP_DIR="$REPO_ROOT/.context/mcp"
 
 if ! command -v npm >/dev/null 2>&1; then
   echo "[embed] npm is required but not found on PATH"
@@ -11,5 +11,5 @@ fi
 
 mkdir -p "$MCP_DIR/.npm-cache"
 
-echo "[embed] generating embeddings via mcp/embed"
+echo "[embed] generating embeddings via .context/mcp/embed"
 NPM_CONFIG_CACHE="$MCP_DIR/.npm-cache" npm --prefix "$MCP_DIR" run embed --silent -- "$@"

package/scaffold/scripts/load-ryu.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-MCP_DIR="$REPO_ROOT/mcp"
+MCP_DIR="$REPO_ROOT/.context/mcp"
 
 if [[ ! -f "$MCP_DIR/package.json" ]]; then
   echo "[graph-load] missing $MCP_DIR/package.json"
@@ -10,8 +10,8 @@ if [[ ! -f "$MCP_DIR/package.json" ]]; then
 fi
 
 if [[ ! -d "$MCP_DIR/node_modules" ]]; then
-  echo "[graph-load] node_modules missing in mcp/"
-  echo "[graph-load] run: cd mcp && NPM_CONFIG_CACHE=$MCP_DIR/.npm-cache npm install"
+  echo "[graph-load] node_modules missing in .context/mcp/"
+  echo "[graph-load] run: cd .context/mcp && NPM_CONFIG_CACHE=$MCP_DIR/.npm-cache npm install"
   exit 1
 fi
 

package/scaffold/scripts/memory-compile.mjs

@@ -2,7 +2,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseFrontmatter, parseStringList } from "../mcp/dist/frontmatter.js";
+import { parseFrontmatter, parseStringList } from "../.context/mcp/dist/frontmatter.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

package/scaffold/scripts/memory-lint.mjs

@@ -2,7 +2,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseFrontmatter, parseStringList } from "../mcp/dist/frontmatter.js";
+import { parseFrontmatter, parseStringList } from "../.context/mcp/dist/frontmatter.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

package/scaffold/scripts/watch.sh

@@ -146,11 +146,9 @@ status_digest() {
   fi
 
   # Fallback for non-git directories.
+  # .context/ excludes the relocated .context/mcp/ tree as well.
   find "$REPO_ROOT" -type f \
     ! -path "$REPO_ROOT/.context/*" \
-    ! -path "$REPO_ROOT/mcp/node_modules/*" \
-    ! -path "$REPO_ROOT/mcp/dist/*" \
-    ! -path "$REPO_ROOT/mcp/.npm-cache/*" \
     ! -path "$REPO_ROOT/scripts/parsers/node_modules/*" \
     ! -path "$REPO_ROOT/scripts/parsers/.npm-cache/*" \
     -print \
@@ -201,16 +199,13 @@ wait_for_change_event() {
     inotifywait)
       inotifywait -q -r \
         -e modify,create,delete,move \
-        --exclude '(^|/)\\.git(/|$)|(^|/)\\.context(/|$)|(^|/)mcp/(node_modules|dist|\\.npm-cache)(/|$)|(^|/)scripts/parsers/(node_modules|\\.npm-cache)(/|$)' \
+        --exclude '(^|/)\\.git(/|$)|(^|/)\\.context(/|$)|(^|/)scripts/parsers/(node_modules|\\.npm-cache)(/|$)' \
         "$REPO_ROOT" >/dev/null 2>&1 || true
       ;;
     fswatch)
       fswatch -1 -r \
         --exclude '(^|/)\\.git(/|$)' \
         --exclude '(^|/)\\.context(/|$)' \
-        --exclude '(^|/)mcp/node_modules(/|$)' \
-        --exclude '(^|/)mcp/dist(/|$)' \
-        --exclude '(^|/)mcp/\\.npm-cache(/|$)' \
         --exclude '(^|/)scripts/parsers/node_modules(/|$)' \
         --exclude '(^|/)scripts/parsers/\\.npm-cache(/|$)' \
         "$REPO_ROOT" >/dev/null 2>&1 || true